From 2ae0f7db9cc9fc5ac64a5b9931064ba8962e10d2 Mon Sep 17 00:00:00 2001
From: bzeiss <ben@zeiss.net>
Date: Tue, 18 Aug 2026 20:01:33 +0200
Subject: [PATCH 01/12] improved startup speed.

---
 apps/axkdeck/README.md                        |  51 ++
 apps/axkdeck/package.json                     |   3 +-
 apps/axkdeck/src-tauri/src/lib.rs             | 107 ++--
 .../src-tauri/src/local_directory_exports.rs  |  11 +-
 apps/axkdeck/src-tauri/src/local_packages.rs  |  22 +-
 .../axkdeck/src-tauri/src/local_workspaces.rs |  23 +-
 apps/axkdeck/src-tauri/src/remote_settings.rs | 204 +++++++-
 apps/axkdeck/src-tauri/src/server_sidecar.rs  |  57 ++-
 .../src-tauri/src/startup_diagnostics.rs      | 478 ++++++++++++++++++
 apps/axkdeck/src/App.svelte                   | 156 +++---
 apps/axkdeck/src/App.test.ts                  |  14 +-
 apps/axkdeck/src/StartupShell.svelte          | 198 ++++++++
 apps/axkdeck/src/StartupShell.test.ts         |  34 ++
 apps/axkdeck/src/appProps.ts                  |   7 +
 .../src/features/dialogs/visibility.ts        |  83 +++
 apps/axkdeck/src/features/workspace/tabs.ts   |  15 +
 apps/axkdeck/src/lib/diagnostics.ts           |  10 +
 .../src/lib/startupCoordinator.test.ts        |  42 ++
 apps/axkdeck/src/lib/startupCoordinator.ts    |  19 +
 .../src/lib/startupDiagnostics.test.ts        |  98 ++++
 apps/axkdeck/src/lib/startupDiagnostics.ts    | 130 +++++
 apps/axkdeck/src/main.ts                      | 145 +++++-
 apps/axkdeck/tools/check-startup-bundle.mjs   |  39 ++
 apps/server/CMakeLists.txt                    |  42 +-
 .../server/include/axklib/server/contract.hpp |  18 +-
 apps/server/src/contract.cpp                  | 123 +----
 apps/server/src/server_lifecycle.cpp          |  11 +-
 apps/server/src/validation_plan.cpp           | 252 +++++++++
 apps/server/src/validation_plan.hpp           | 110 ++++
 apps/server/src/validation_plan_generator.cpp | 387 ++++++++++++++
 apps/server/tests/contract_test_support.cpp   |  77 +++
 apps/server/tests/contract_test_support.hpp   |  32 ++
 apps/server/tests/server_contract_test.cpp    |  73 ++-
 vcpkg.json                                    |   6 +-
 34 files changed, 2740 insertions(+), 337 deletions(-)
 create mode 100644 apps/axkdeck/src-tauri/src/startup_diagnostics.rs
 create mode 100644 apps/axkdeck/src/StartupShell.svelte
 create mode 100644 apps/axkdeck/src/StartupShell.test.ts
 create mode 100644 apps/axkdeck/src/appProps.ts
 create mode 100644 apps/axkdeck/src/features/dialogs/visibility.ts
 create mode 100644 apps/axkdeck/src/features/workspace/tabs.ts
 create mode 100644 apps/axkdeck/src/lib/startupCoordinator.test.ts
 create mode 100644 apps/axkdeck/src/lib/startupCoordinator.ts
 create mode 100644 apps/axkdeck/src/lib/startupDiagnostics.test.ts
 create mode 100644 apps/axkdeck/src/lib/startupDiagnostics.ts
 create mode 100644 apps/axkdeck/tools/check-startup-bundle.mjs
 create mode 100644 apps/server/src/validation_plan.cpp
 create mode 100644 apps/server/src/validation_plan.hpp
 create mode 100644 apps/server/src/validation_plan_generator.cpp
 create mode 100644 apps/server/tests/contract_test_support.cpp
 create mode 100644 apps/server/tests/contract_test_support.hpp

diff --git a/apps/axkdeck/README.md b/apps/axkdeck/README.md
index aa751f6b..23c10b8a 100644
--- a/apps/axkdeck/README.md
+++ b/apps/axkdeck/README.md
@@ -346,6 +346,57 @@ Development runs also mirror `axklib-server` stdout and stderr to the terminal.
 Workspace setup failures remain visible in the Workspaces dialog and include
 the server request ID when one is available.
 
+### Startup profiling
+
+Every completed desktop launch writes one structured `desktop_startup_completed`
+event at the default `info` log level. It reports native setup, protected-settings
+lookup, local-server startup, WebView navigation, frontend initialization, mount,
+and first-painted-frame timings. Outcomes are categorical and the event never
+contains filesystem paths, server URLs, credentials, user names, host names, or
+raw errors. Set `AXKDECK_LOG_LEVEL=debug` to additionally record each fixed
+`desktop_startup_milestone` as it occurs. Explicit `warn`, `error`, and `off`
+settings continue to suppress the informational summary.
+
+The built-in timeline begins when Rust enters axkdeck. Use Windows Performance
+Recorder (WPR) when the delay may precede that point or involve process startup,
+storage, antivirus scanning, WebView2, or DLL loading. Profile a packaged build,
+not a Vite development session:
+
+1. Record the axkdeck version and source identity, machine model, CPU, memory,
+   storage type, Windows version, WebView2 version, and active security software.
+2. Collect at least five first-launch-after-reboot (cold) samples and five
+   subsequent (warm) samples with the normal local server.
+3. Repeat both sets after launching from PowerShell with
+   `$env:AXKDECK_HTTP_SERVER='0'`. This diagnostic comparison disables the local
+   sidecar for that process; it is not a normal operating configuration.
+4. Keep each startup trace separate and retain the corresponding
+   `desktop_startup_completed` log line.
+
+From an elevated PowerShell terminal, first confirm the available WPR profiles,
+then capture one launch:
+
+```powershell
+wpr -profiles
+wpr -start GeneralProfile -filemode
+# Launch axkdeck, wait for the workspace to finish its first paint, then:
+wpr -stop "$env:TEMP\axkdeck-startup.etl"
+```
+
+Run `wpr -cancel` if a capture must be abandoned. In Windows Performance
+Analyzer, inspect process lifetime, CPU usage, disk/file I/O, image/DLL loading,
+and wait analysis for `axkdeck.exe`, `axklib-server.exe`,
+`msedgewebview2.exe`, and the active antivirus process. Correlate those spans
+with the structured log milestones:
+
+- delay before `native_entry` is outside the built-in timeline and belongs to
+  OS process creation, loading, security scanning, or runtime initialization;
+- a long `credentialLookupMs` isolates protected-settings access;
+- a long `sidecarStartupMs` isolates local server spawn/readiness;
+- a gap between `pageLoadStartedMs` and `pageLoadFinishedMs` isolates WebView
+  navigation and asset loading;
+- large frontend module-to-mount or mount-to-first-frame intervals isolate
+  renderer initialization and painting.
+
 ## Verify and build
 
 ```bash
diff --git a/apps/axkdeck/package.json b/apps/axkdeck/package.json
index 55fed00b..3763b13a 100644
--- a/apps/axkdeck/package.json
+++ b/apps/axkdeck/package.json
@@ -9,7 +9,8 @@
   },
   "scripts": {
     "dev": "vite",
-    "build": "pnpm contract:check && svelte-check --tsconfig ./tsconfig.app.json && vite build",
+    "build": "pnpm contract:check && svelte-check --tsconfig ./tsconfig.app.json && vite build && pnpm bundle:check",
+    "bundle:check": "node tools/check-startup-bundle.mjs",
     "contract:check": "node tools/openapi-contract.mjs check",
     "contract:generate": "node tools/openapi-contract.mjs write",
     "version:check": "node tools/check-versions.mjs",
diff --git a/apps/axkdeck/src-tauri/src/lib.rs b/apps/axkdeck/src-tauri/src/lib.rs
index 2b6f9ee0..f41dd553 100644
--- a/apps/axkdeck/src-tauri/src/lib.rs
+++ b/apps/axkdeck/src-tauri/src/lib.rs
@@ -7,10 +7,12 @@ mod local_workspaces;
 mod remote_settings;
 mod retained_download;
 mod server_sidecar;
+mod startup_diagnostics;
 
 use std::sync::Mutex;
 
 use serde::Serialize;
+use tauri::webview::PageLoadEvent;
 use tauri::{Manager, State, WebviewWindow};
 use tauri_plugin_log::{RotationStrategy, Target, TargetKind};
 
@@ -26,6 +28,7 @@ use local_packages::{
     select_local_volume_packages,
 };
 use local_workspaces::{WorkspaceCandidateStore, commit_local_workspace, select_local_workspace};
+use startup_diagnostics::{StartupDiagnostics, StartupMilestone, complete_startup};
 
 const LOG_FILE_SIZE: u128 = 5 * 1024 * 1024;
 const RETAINED_LOG_FILES: usize = 3;
@@ -320,23 +323,23 @@ fn desktop_build_info() -> DesktopBuildInfo {
 }
 
 #[tauri::command]
-fn server_connection(
-    state: State<'_, Mutex<remote_settings::ServerConnectionManager>>,
+async fn server_connection(
+    state: State<'_, remote_settings::ServerConnectionState>,
 ) -> Result<Option<server_sidecar::FrontendConnection>, String> {
-    state
-        .lock()
-        .map_err(|_| "server connection settings are unavailable".to_owned())?
-        .connection()
+    let state = state.inner().clone();
+    tauri::async_runtime::spawn_blocking(move || state.connection())
+        .await
+        .map_err(|error| format!("wait for server connection: {error}"))?
 }
 
 #[tauri::command]
-fn remote_server_settings(
-    state: State<'_, Mutex<remote_settings::ServerConnectionManager>>,
+async fn remote_server_settings(
+    state: State<'_, remote_settings::ServerConnectionState>,
 ) -> Result<remote_settings::RemoteServerSettingsView, String> {
-    state
-        .lock()
-        .map_err(|_| "server connection settings are unavailable".to_owned())
-        .map(|manager| manager.settings())
+    let state = state.inner().clone();
+    tauri::async_runtime::spawn_blocking(move || state.settings())
+        .await
+        .map_err(|error| format!("wait for server settings: {error}"))
 }
 
 #[tauri::command]
@@ -347,24 +350,24 @@ fn validate_remote_server_settings(
 }
 
 #[tauri::command]
-fn configure_remote_server(
+async fn configure_remote_server(
     settings: remote_settings::RemoteServerSettingsInput,
-    state: State<'_, Mutex<remote_settings::ServerConnectionManager>>,
+    state: State<'_, remote_settings::ServerConnectionState>,
 ) -> Result<remote_settings::RemoteServerSettingsView, String> {
-    state
-        .lock()
-        .map_err(|_| "server connection settings are unavailable".to_owned())?
-        .configure_remote(settings)
+    let state = state.inner().clone();
+    tauri::async_runtime::spawn_blocking(move || state.configure_remote(settings))
+        .await
+        .map_err(|error| format!("configure remote server worker failed: {error}"))?
 }
 
 #[tauri::command]
-fn use_local_server(
-    state: State<'_, Mutex<remote_settings::ServerConnectionManager>>,
+async fn use_local_server(
+    state: State<'_, remote_settings::ServerConnectionState>,
 ) -> Result<remote_settings::RemoteServerSettingsView, String> {
-    state
-        .lock()
-        .map_err(|_| "server connection settings are unavailable".to_owned())?
-        .use_local()
+    let state = state.inner().clone();
+    tauri::async_runtime::spawn_blocking(move || state.use_local())
+        .await
+        .map_err(|error| format!("start local server worker failed: {error}"))?
 }
 
 #[cfg(target_os = "linux")]
@@ -386,8 +389,11 @@ fn configure_linux_webkit() {
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
+    let startup = StartupDiagnostics::new();
+    startup.record(StartupMilestone::NativeEntry);
     #[cfg(target_os = "linux")]
     configure_linux_webkit();
+    startup.record(StartupMilestone::PlatformConfigurationCompleted);
     let log_level = configured_log_level();
     let log_targets = vec![
         Target::new(TargetKind::LogDir {
@@ -396,21 +402,28 @@ pub fn run() {
         #[cfg(debug_assertions)]
         Target::new(TargetKind::Stdout),
     ];
+    startup.record(StartupMilestone::LogPluginBuildStarted);
     let log_plugin = tauri_plugin_log::Builder::new()
         .targets(log_targets)
         .level(log_level)
         .max_file_size(LOG_FILE_SIZE)
         .rotation_strategy(RotationStrategy::KeepSome(RETAINED_LOG_FILES))
         .build();
+    startup.record(StartupMilestone::LogPluginBuildCompleted);
 
-    tauri::Builder::default()
+    let setup_startup = startup.clone();
+    let page_load_startup = startup.clone();
+    let builder = tauri::Builder::default()
         .plugin(log_plugin)
         .plugin(tauri_plugin_dialog::init())
         .plugin(tauri_plugin_fs::init())
         .manage(Mutex::new(WorkspaceCandidateStore::default()))
         .manage(Mutex::new(PackageSaveCandidateStore::default()))
         .manage(Mutex::new(DirectorySaveCandidateStore::default()))
-        .setup(|app| {
+        .manage(startup.clone())
+        .setup(move |app| {
+            setup_startup.enable_logging();
+            setup_startup.record(StartupMilestone::TauriSetupStarted);
             let log_directory = app
                 .path()
                 .app_log_dir()
@@ -419,35 +432,47 @@ pub fn run() {
                 .path()
                 .app_local_data_dir()
                 .map_err(|error| format!("resolve application state directory: {error}"))?;
+            setup_startup.record(StartupMilestone::PathsResolved);
             let preferences_path = application_data_directory.join("desktop-preferences.json");
+            setup_startup.record(StartupMilestone::PreferencesLoadStarted);
             let preferences = DesktopPreferencesStore::load(preferences_path.clone()).unwrap_or_else(|error| {
                 log::warn!("desktop preferences are unavailable and will be reset on the next update: {error}");
                 DesktopPreferencesStore::empty(preferences_path)
             });
+            setup_startup.record(StartupMilestone::PreferencesLoadCompleted);
             app.manage(Mutex::new(preferences));
             let state_directory = application_data_directory.join("server-state");
-            let manager = remote_settings::ServerConnectionManager::initialize(
-                log_directory.clone(),
-                state_directory.clone(),
-            )
-            .unwrap_or_else(|error| {
-                log::error!("local axklib-server initialization failed: {error}");
-                remote_settings::ServerConnectionManager::unavailable(
-                    error,
-                    log_directory,
-                    state_directory,
-                )
-            });
-            app.manage(Mutex::new(manager));
+            let connections = remote_settings::ServerConnectionState::pending();
+            connections.initialize_in_background(
+                log_directory,
+                state_directory,
+                setup_startup.clone(),
+            );
+            app.manage(connections);
             let build = current_build_info();
             log::info!(
                 "axkdeck desktop shell initialized: version={} source={}",
                 build.semantic_version,
                 build.source_identity
             );
+            setup_startup.record(StartupMilestone::TauriSetupCompleted);
             Ok(())
         })
+        .on_page_load(move |webview, payload| {
+            if webview.label() != "main" {
+                return;
+            }
+            match payload.event() {
+                PageLoadEvent::Started => {
+                    page_load_startup.record(StartupMilestone::PageLoadStarted);
+                }
+                PageLoadEvent::Finished => {
+                    page_load_startup.record(StartupMilestone::PageLoadFinished);
+                }
+            }
+        })
         .invoke_handler(tauri::generate_handler![
+            complete_startup,
             server_connection,
             remote_server_settings,
             validate_remote_server_settings,
@@ -468,7 +493,9 @@ pub fn run() {
             desktop_build_info,
             open_allocation_inspector,
             save_allocation_map_json
-        ])
+        ]);
+    startup.record(StartupMilestone::TauriBuilderConfigured);
+    builder
         .run(tauri::generate_context!())
         .expect("failed to run axkdeck");
 }
diff --git a/apps/axkdeck/src-tauri/src/local_directory_exports.rs b/apps/axkdeck/src-tauri/src/local_directory_exports.rs
index 2dc94701..f212af8a 100644
--- a/apps/axkdeck/src-tauri/src/local_directory_exports.rs
+++ b/apps/axkdeck/src-tauri/src/local_directory_exports.rs
@@ -390,7 +390,7 @@ pub(crate) async fn save_retained_directory_export(
     content_path: String,
     expected_size: u64,
     candidates: State<'_, Mutex<DirectorySaveCandidateStore>>,
-    connections: State<'_, Mutex<remote_settings::ServerConnectionManager>>,
+    connections: State<'_, remote_settings::ServerConnectionState>,
 ) -> Result<(), String> {
     let destination = candidates
         .lock()
@@ -400,12 +400,11 @@ pub(crate) async fn save_retained_directory_export(
         .filter(|(_, created)| created.elapsed() < Duration::from_secs(300))
         .map(|(path, _)| path)
         .ok_or_else(|| "export destination expired; choose it again".to_owned())?;
-    let connection = connections
-        .lock()
-        .map_err(|_| "server connection settings are unavailable".to_owned())?
-        .connection()?
-        .ok_or_else(|| "axklib-server is unavailable".to_owned())?;
+    let connections = connections.inner().clone();
     tauri::async_runtime::spawn_blocking(move || {
+        let connection = connections
+            .connection()?
+            .ok_or_else(|| "axklib-server is unavailable".to_owned())?;
         download_retained_directory_export(connection, destination, content_path, expected_size)
     })
     .await
diff --git a/apps/axkdeck/src-tauri/src/local_packages.rs b/apps/axkdeck/src-tauri/src/local_packages.rs
index 276d8a56..78a0d3f1 100644
--- a/apps/axkdeck/src-tauri/src/local_packages.rs
+++ b/apps/axkdeck/src-tauri/src/local_packages.rs
@@ -459,7 +459,7 @@ pub(crate) async fn save_retained_package(
     content_path: String,
     expected_size: u64,
     candidates: State<'_, Mutex<PackageSaveCandidateStore>>,
-    connections: State<'_, Mutex<remote_settings::ServerConnectionManager>>,
+    connections: State<'_, remote_settings::ServerConnectionState>,
 ) -> Result<(), String> {
     let destination = candidates
         .lock()
@@ -469,12 +469,11 @@ pub(crate) async fn save_retained_package(
         .filter(|(_, created)| created.elapsed() < Duration::from_secs(300))
         .map(|(path, _)| path)
         .ok_or_else(|| "package destination expired; choose it again".to_owned())?;
-    let connection = connections
-        .lock()
-        .map_err(|_| "server connection settings are unavailable".to_owned())?
-        .connection()?
-        .ok_or_else(|| "axklib-server is unavailable".to_owned())?;
+    let connections = connections.inner().clone();
     tauri::async_runtime::spawn_blocking(move || {
+        let connection = connections
+            .connection()?
+            .ok_or_else(|| "axklib-server is unavailable".to_owned())?;
         download_retained_file(connection, destination, content_path, expected_size)
     })
     .await
@@ -487,7 +486,7 @@ pub(crate) async fn save_retained_media(
     content_path: String,
     expected_size: u64,
     candidates: State<'_, Mutex<PackageSaveCandidateStore>>,
-    connections: State<'_, Mutex<remote_settings::ServerConnectionManager>>,
+    connections: State<'_, remote_settings::ServerConnectionState>,
 ) -> Result<(), String> {
     let destination = candidates
         .lock()
@@ -497,12 +496,11 @@ pub(crate) async fn save_retained_media(
         .filter(|(_, created)| created.elapsed() < Duration::from_secs(300))
         .map(|(path, _)| path)
         .ok_or_else(|| "media destination expired; choose it again".to_owned())?;
-    let connection = connections
-        .lock()
-        .map_err(|_| "server connection settings are unavailable".to_owned())?
-        .connection()?
-        .ok_or_else(|| "axklib-server is unavailable".to_owned())?;
+    let connections = connections.inner().clone();
     tauri::async_runtime::spawn_blocking(move || {
+        let connection = connections
+            .connection()?
+            .ok_or_else(|| "axklib-server is unavailable".to_owned())?;
         download_retained_file(connection, destination, content_path, expected_size)
     })
     .await
diff --git a/apps/axkdeck/src-tauri/src/local_workspaces.rs b/apps/axkdeck/src-tauri/src/local_workspaces.rs
index 0a1d982b..40b3c19f 100644
--- a/apps/axkdeck/src-tauri/src/local_workspaces.rs
+++ b/apps/axkdeck/src-tauri/src/local_workspaces.rs
@@ -77,13 +77,13 @@ pub(crate) async fn select_local_workspace(
 }
 
 #[tauri::command]
-pub(crate) fn commit_local_workspace(
+pub(crate) async fn commit_local_workspace(
     candidate_id: String,
     display_name: String,
     writable: bool,
     revision: u64,
     candidates: State<'_, Mutex<WorkspaceCandidateStore>>,
-    connections: State<'_, Mutex<remote_settings::ServerConnectionManager>>,
+    connections: State<'_, remote_settings::ServerConnectionState>,
 ) -> Result<(), String> {
     if display_name.trim().is_empty() {
         return Err("enter a workspace name".to_owned());
@@ -96,12 +96,17 @@ pub(crate) fn commit_local_workspace(
         .filter(|(_, created)| created.elapsed() < Duration::from_secs(300))
         .map(|(path, _)| path)
         .ok_or_else(|| "workspace selection expired; choose the folder again".to_owned())?;
-    let connection = connections
-        .lock()
-        .map_err(|_| "server connection settings are unavailable".to_owned())?
-        .connection()?
-        .ok_or_else(|| "local axklib-server is unavailable".to_owned())?;
-    server_sidecar::create_workspace(&connection, &path, display_name.trim(), writable, revision)?;
-    log::info!("local workspace committed: {display_name}");
+    let display_name = display_name.trim().to_owned();
+    let connections = connections.inner().clone();
+    let logged_name = display_name.clone();
+    tauri::async_runtime::spawn_blocking(move || {
+        let connection = connections
+            .connection()?
+            .ok_or_else(|| "local axklib-server is unavailable".to_owned())?;
+        server_sidecar::create_workspace(&connection, &path, &display_name, writable, revision)
+    })
+    .await
+    .map_err(|error| format!("create workspace worker failed: {error}"))??;
+    log::info!("local workspace committed: {logged_name}");
     Ok(())
 }
diff --git a/apps/axkdeck/src-tauri/src/remote_settings.rs b/apps/axkdeck/src-tauri/src/remote_settings.rs
index 53e293c6..0efcf9a0 100644
--- a/apps/axkdeck/src-tauri/src/remote_settings.rs
+++ b/apps/axkdeck/src-tauri/src/remote_settings.rs
@@ -1,8 +1,12 @@
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
+use std::sync::{Arc, Condvar, Mutex};
 use url::{Host, Url};
 
 use crate::server_sidecar::{FrontendConnection, ServerSidecar};
+use crate::startup_diagnostics::{
+    CredentialOutcome, ServerOutcome, StartupDiagnostics, StartupMilestone,
+};
 
 const KEYRING_SERVICE: &str = "app.axkdeck.desktop.axklib-server";
 const KEYRING_USER: &str = "remote-server-v1";
@@ -40,18 +44,143 @@ pub struct ServerConnectionManager {
     state_directory: PathBuf,
 }
 
-impl ServerConnectionManager {
-    pub fn initialize(log_directory: PathBuf, state_directory: PathBuf) -> Result<Self, String> {
-        match load_remote_settings() {
-            Ok(Some(settings)) => Ok(Self {
-                sidecar: None,
-                connection: Some(frontend_connection(&settings)),
-                secure_storage_error: None,
+struct ServerConnectionStateInner {
+    manager: Mutex<Option<ServerConnectionManager>>,
+    ready: Condvar,
+}
+
+#[derive(Clone)]
+pub struct ServerConnectionState {
+    inner: Arc<ServerConnectionStateInner>,
+}
+
+impl ServerConnectionState {
+    pub fn pending() -> Self {
+        Self {
+            inner: Arc::new(ServerConnectionStateInner {
+                manager: Mutex::new(None),
+                ready: Condvar::new(),
+            }),
+        }
+    }
+
+    pub fn initialize_in_background(
+        &self,
+        log_directory: PathBuf,
+        state_directory: PathBuf,
+        startup: StartupDiagnostics,
+    ) {
+        let worker_state = self.clone();
+        let worker_log_directory = log_directory.clone();
+        let worker_state_directory = state_directory.clone();
+        let worker = std::thread::Builder::new()
+            .name("axkdeck-server-startup".to_owned())
+            .spawn(move || {
+                let manager = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+                    ServerConnectionManager::initialize(
+                        worker_log_directory.clone(),
+                        worker_state_directory.clone(),
+                        &startup,
+                    )
+                }))
+                .map_err(|_| "axklib-server initialization panicked".to_owned())
+                .and_then(|result| result)
+                .unwrap_or_else(|error| {
+                    log::error!("local axklib-server initialization failed: {error}");
+                    ServerConnectionManager::unavailable(
+                        error,
+                        worker_log_directory,
+                        worker_state_directory,
+                    )
+                });
+                worker_state.complete(manager);
+            });
+        if let Err(error) = worker {
+            let message = format!("start axklib-server initialization worker: {error}");
+            log::error!("{message}");
+            self.complete(ServerConnectionManager::unavailable(
+                message,
                 log_directory,
                 state_directory,
-            }),
-            Ok(None) => Self::local(log_directory, state_directory, None),
-            Err(error) => Self::local(log_directory, state_directory, Some(error)),
+            ));
+        }
+    }
+
+    pub fn connection(&self) -> Result<Option<FrontendConnection>, String> {
+        self.with_manager(ServerConnectionManager::connection)
+    }
+
+    pub fn settings(&self) -> RemoteServerSettingsView {
+        self.with_manager(|manager| manager.settings())
+    }
+
+    pub fn configure_remote(
+        &self,
+        input: RemoteServerSettingsInput,
+    ) -> Result<RemoteServerSettingsView, String> {
+        self.with_manager(|manager| manager.configure_remote(input))
+    }
+
+    pub fn use_local(&self) -> Result<RemoteServerSettingsView, String> {
+        self.with_manager(ServerConnectionManager::use_local)
+    }
+
+    fn complete(&self, manager: ServerConnectionManager) {
+        let mut current = self
+            .inner
+            .manager
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        if current.is_none() {
+            *current = Some(manager);
+            self.inner.ready.notify_all();
+        }
+    }
+
+    fn with_manager<T>(&self, operation: impl FnOnce(&mut ServerConnectionManager) -> T) -> T {
+        let mut current = self
+            .inner
+            .manager
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        while current.is_none() {
+            current = self
+                .inner
+                .ready
+                .wait(current)
+                .unwrap_or_else(std::sync::PoisonError::into_inner);
+        }
+        operation(current.as_mut().expect("server connection state completed"))
+    }
+}
+
+impl ServerConnectionManager {
+    pub fn initialize(
+        log_directory: PathBuf,
+        state_directory: PathBuf,
+        startup: &StartupDiagnostics,
+    ) -> Result<Self, String> {
+        startup.record(StartupMilestone::CredentialLookupStarted);
+        let settings = load_remote_settings();
+        startup.set_credential_outcome(match &settings {
+            Ok(Some(_)) => CredentialOutcome::Found,
+            Ok(None) => CredentialOutcome::Missing,
+            Err(_) => CredentialOutcome::Error,
+        });
+        startup.record(StartupMilestone::CredentialLookupCompleted);
+        match settings {
+            Ok(Some(settings)) => {
+                startup.set_server_outcome(ServerOutcome::RemoteReady);
+                Ok(Self {
+                    sidecar: None,
+                    connection: Some(frontend_connection(&settings)),
+                    secure_storage_error: None,
+                    log_directory,
+                    state_directory,
+                })
+            }
+            Ok(None) => Self::local(log_directory, state_directory, None, Some(startup)),
+            Err(error) => Self::local(log_directory, state_directory, Some(error), Some(startup)),
         }
     }
 
@@ -59,8 +188,14 @@ impl ServerConnectionManager {
         log_directory: PathBuf,
         state_directory: PathBuf,
         secure_storage_error: Option<String>,
+        startup: Option<&StartupDiagnostics>,
     ) -> Result<Self, String> {
-        let sidecar = ServerSidecar::launch_if_available(&log_directory, &state_directory)?;
+        let sidecar = match startup {
+            Some(startup) => {
+                ServerSidecar::launch_at_startup(&log_directory, &state_directory, startup)?
+            }
+            None => ServerSidecar::launch_if_available(&log_directory, &state_directory)?,
+        };
         let connection = sidecar.as_ref().map(|server| server.connection().clone());
         Ok(Self {
             sidecar,
@@ -228,7 +363,14 @@ fn delete_remote_settings() -> Result<(), String> {
 
 #[cfg(test)]
 mod tests {
-    use super::{RemoteServerSettingsInput, validate_remote_settings};
+    use std::path::PathBuf;
+    use std::sync::mpsc;
+    use std::time::Duration;
+
+    use super::{
+        RemoteServerSettingsInput, ServerConnectionManager, ServerConnectionState,
+        validate_remote_settings,
+    };
 
     fn settings(base_url: &str) -> RemoteServerSettingsInput {
         RemoteServerSettingsInput {
@@ -275,4 +417,42 @@ mod tests {
         whitespace.bearer_token = "0123456789abcdef 0123456789abcdef".to_owned();
         assert!(validate_remote_settings(whitespace).is_err());
     }
+
+    #[test]
+    fn pending_connection_state_releases_waiters_when_initialization_completes() {
+        let state = ServerConnectionState::pending();
+        let waiter_state = state.clone();
+        let (started_sender, started_receiver) = mpsc::channel();
+        let (result_sender, result_receiver) = mpsc::channel();
+        let waiter = std::thread::spawn(move || {
+            started_sender.send(()).expect("report waiter start");
+            result_sender
+                .send(waiter_state.settings())
+                .expect("report completed settings");
+        });
+
+        started_receiver
+            .recv_timeout(Duration::from_secs(1))
+            .expect("waiter started");
+        assert!(
+            result_receiver
+                .recv_timeout(Duration::from_millis(20))
+                .is_err()
+        );
+
+        state.complete(ServerConnectionManager::unavailable(
+            "sidecar unavailable".to_owned(),
+            PathBuf::from("logs"),
+            PathBuf::from("state"),
+        ));
+        let settings = result_receiver
+            .recv_timeout(Duration::from_secs(1))
+            .expect("waiter released");
+        assert_eq!(settings.mode, "local");
+        assert_eq!(
+            settings.secure_storage_error.as_deref(),
+            Some("sidecar unavailable")
+        );
+        waiter.join().expect("join waiter");
+    }
 }
diff --git a/apps/axkdeck/src-tauri/src/server_sidecar.rs b/apps/axkdeck/src-tauri/src/server_sidecar.rs
index 2e491989..e479ebe0 100644
--- a/apps/axkdeck/src-tauri/src/server_sidecar.rs
+++ b/apps/axkdeck/src-tauri/src/server_sidecar.rs
@@ -14,6 +14,7 @@ use url::{Host, Url};
 #[path = "server_sidecar_runtime.rs"]
 mod runtime;
 
+use crate::startup_diagnostics::{ServerOutcome, StartupDiagnostics, StartupMilestone};
 use runtime::PrivateRuntimeDirectory;
 
 const CONNECTION_SCHEMA_VERSION: u32 = 1;
@@ -115,23 +116,59 @@ impl ServerSidecar {
         log_directory: &Path,
         state_directory: &Path,
     ) -> Result<Option<Self>, String> {
+        Self::launch_if_available_inner(log_directory, state_directory, None)
+    }
+
+    pub fn launch_at_startup(
+        log_directory: &Path,
+        state_directory: &Path,
+        startup: &StartupDiagnostics,
+    ) -> Result<Option<Self>, String> {
+        Self::launch_if_available_inner(log_directory, state_directory, Some(startup))
+    }
+
+    fn launch_if_available_inner(
+        log_directory: &Path,
+        state_directory: &Path,
+        startup: Option<&StartupDiagnostics>,
+    ) -> Result<Option<Self>, String> {
+        if let Some(startup) = startup {
+            startup.record(StartupMilestone::SidecarStartupStarted);
+        }
         if std::env::var("AXKDECK_HTTP_SERVER").is_ok_and(|value| {
             matches!(
                 value.trim().to_ascii_lowercase().as_str(),
                 "0" | "false" | "no"
             )
         }) {
+            complete_sidecar_startup(startup, ServerOutcome::Disabled);
             return Ok(None);
         }
         let Some(binary) = server_binary() else {
+            complete_sidecar_startup(startup, ServerOutcome::BinaryUnavailable);
             return Ok(None);
         };
-        Self::launch(&binary, log_directory, state_directory).map(Some)
+        match Self::launch(&binary, log_directory, state_directory, startup) {
+            Ok(sidecar) => {
+                complete_sidecar_startup(startup, ServerOutcome::LocalReady);
+                Ok(Some(sidecar))
+            }
+            Err(error) => {
+                complete_sidecar_startup(startup, ServerOutcome::Failed);
+                Err(error)
+            }
+        }
     }
 
-    fn launch(binary: &Path, log_directory: &Path, state_directory: &Path) -> Result<Self, String> {
+    fn launch(
+        binary: &Path,
+        log_directory: &Path,
+        state_directory: &Path,
+        startup: Option<&StartupDiagnostics>,
+    ) -> Result<Self, String> {
         prepare_persistent_state_directory(state_directory)?;
         let runtime_directory = PrivateRuntimeDirectory::create(&std::env::temp_dir())?;
+        record_startup(startup, StartupMilestone::SidecarStatePrepared);
         let connection_path = runtime_directory.connection_path();
         let arguments = sidecar_arguments(state_directory, &connection_path);
         let mut command = Command::new(binary);
@@ -147,6 +184,7 @@ impl ServerSidecar {
         let mut child = command
             .spawn()
             .map_err(|error| format!("start axklib-server: {error}"))?;
+        record_startup(startup, StartupMilestone::SidecarSpawned);
         let log_threads = match capture_child_logs(&mut child, log_directory) {
             Ok(threads) => threads,
             Err(error) => {
@@ -166,6 +204,7 @@ impl ServerSidecar {
                     return Err(error);
                 }
             };
+        record_startup(startup, StartupMilestone::SidecarReadinessReceived);
         if let Err(error) = validate_connection(
             &metadata,
             child.id(),
@@ -179,6 +218,7 @@ impl ServerSidecar {
             join_log_threads(log_threads);
             return Err(error);
         }
+        record_startup(startup, StartupMilestone::SidecarConnectionValidated);
         let connection = FrontendConnection {
             base_url: metadata.base_url,
             bearer_token: metadata.bearer_token,
@@ -218,6 +258,19 @@ impl ServerSidecar {
     }
 }
 
+fn record_startup(startup: Option<&StartupDiagnostics>, milestone: StartupMilestone) {
+    if let Some(startup) = startup {
+        startup.record(milestone);
+    }
+}
+
+fn complete_sidecar_startup(startup: Option<&StartupDiagnostics>, outcome: ServerOutcome) {
+    if let Some(startup) = startup {
+        startup.set_server_outcome(outcome);
+        startup.record(StartupMilestone::SidecarStartupCompleted);
+    }
+}
+
 impl Drop for ServerSidecar {
     fn drop(&mut self) {
         if let Ok(mut child) = self.child.lock() {
diff --git a/apps/axkdeck/src-tauri/src/startup_diagnostics.rs b/apps/axkdeck/src-tauri/src/startup_diagnostics.rs
new file mode 100644
index 00000000..8b44518a
--- /dev/null
+++ b/apps/axkdeck/src-tauri/src/startup_diagnostics.rs
@@ -0,0 +1,478 @@
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant};
+
+use serde::{Deserialize, Serialize};
+use tauri::State;
+
+const FRONTEND_SCHEMA_VERSION: u32 = 2;
+const MAXIMUM_FRONTEND_MILLISECONDS: f64 = 60.0 * 60.0 * 1000.0;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum StartupMilestone {
+    NativeEntry,
+    PlatformConfigurationCompleted,
+    LogPluginBuildStarted,
+    LogPluginBuildCompleted,
+    TauriBuilderConfigured,
+    TauriSetupStarted,
+    PathsResolved,
+    PreferencesLoadStarted,
+    PreferencesLoadCompleted,
+    CredentialLookupStarted,
+    CredentialLookupCompleted,
+    SidecarStartupStarted,
+    SidecarStatePrepared,
+    SidecarSpawned,
+    SidecarReadinessReceived,
+    SidecarConnectionValidated,
+    SidecarStartupCompleted,
+    TauriSetupCompleted,
+    PageLoadStarted,
+    PageLoadFinished,
+}
+
+impl StartupMilestone {
+    fn name(self) -> &'static str {
+        match self {
+            Self::NativeEntry => "native_entry",
+            Self::PlatformConfigurationCompleted => "platform_configuration_completed",
+            Self::LogPluginBuildStarted => "log_plugin_build_started",
+            Self::LogPluginBuildCompleted => "log_plugin_build_completed",
+            Self::TauriBuilderConfigured => "tauri_builder_configured",
+            Self::TauriSetupStarted => "tauri_setup_started",
+            Self::PathsResolved => "paths_resolved",
+            Self::PreferencesLoadStarted => "preferences_load_started",
+            Self::PreferencesLoadCompleted => "preferences_load_completed",
+            Self::CredentialLookupStarted => "credential_lookup_started",
+            Self::CredentialLookupCompleted => "credential_lookup_completed",
+            Self::SidecarStartupStarted => "sidecar_startup_started",
+            Self::SidecarStatePrepared => "sidecar_state_prepared",
+            Self::SidecarSpawned => "sidecar_spawned",
+            Self::SidecarReadinessReceived => "sidecar_readiness_received",
+            Self::SidecarConnectionValidated => "sidecar_connection_validated",
+            Self::SidecarStartupCompleted => "sidecar_startup_completed",
+            Self::TauriSetupCompleted => "tauri_setup_completed",
+            Self::PageLoadStarted => "page_load_started",
+            Self::PageLoadFinished => "page_load_finished",
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum CredentialOutcome {
+    Found,
+    Missing,
+    Error,
+}
+
+#[derive(Clone, Copy, Debug, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ServerOutcome {
+    RemoteReady,
+    LocalReady,
+    Disabled,
+    BinaryUnavailable,
+    Failed,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FrontendStartupMetrics {
+    schema_version: u32,
+    view: StartupView,
+    module_evaluated_ms: f64,
+    diagnostics_installed_ms: f64,
+    interface_scale_complete_ms: f64,
+    shell_mounted_ms: f64,
+    shell_first_frame_ms: f64,
+    app_module_ready_ms: f64,
+    server_connection_complete_ms: Option<f64>,
+    app_mounted_ms: f64,
+    app_first_frame_ms: f64,
+    navigation_duration_ms: Option<f64>,
+    first_contentful_paint_ms: Option<f64>,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "snake_case")]
+enum StartupView {
+    Workspace,
+    Allocation,
+}
+
+#[derive(Clone, Copy, Debug)]
+struct MilestoneEntry {
+    milestone: StartupMilestone,
+    elapsed: Duration,
+}
+
+#[derive(Default)]
+struct StartupState {
+    milestones: Vec<MilestoneEntry>,
+    credential_outcome: Option<CredentialOutcome>,
+    server_outcome: Option<ServerOutcome>,
+    logging_enabled: bool,
+    completed: bool,
+}
+
+#[derive(Clone)]
+pub struct StartupDiagnostics {
+    origin: Instant,
+    state: Arc<Mutex<StartupState>>,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct StartupMilestoneEvent {
+    event: &'static str,
+    schema_version: u32,
+    milestone: &'static str,
+    elapsed_ms: u128,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct StartupSummary {
+    event: &'static str,
+    schema_version: u32,
+    total_duration_ms: u128,
+    platform_configuration_completed_ms: Option<u128>,
+    log_plugin_build_ms: Option<u128>,
+    tauri_builder_configured_ms: Option<u128>,
+    setup_duration_ms: Option<u128>,
+    preferences_load_ms: Option<u128>,
+    credential_lookup_ms: Option<u128>,
+    sidecar_startup_ms: Option<u128>,
+    page_load_started_ms: Option<u128>,
+    page_load_finished_ms: Option<u128>,
+    credential_outcome: Option<CredentialOutcome>,
+    server_outcome: Option<ServerOutcome>,
+    platform: &'static str,
+    architecture: &'static str,
+    build_profile: &'static str,
+    source_identity: &'static str,
+    frontend: FrontendStartupSummary,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct FrontendStartupSummary {
+    view: StartupView,
+    module_evaluated_ms: f64,
+    diagnostics_installed_ms: f64,
+    interface_scale_complete_ms: f64,
+    shell_mounted_ms: f64,
+    shell_first_frame_ms: f64,
+    app_module_ready_ms: f64,
+    server_connection_complete_ms: Option<f64>,
+    app_mounted_ms: f64,
+    app_first_frame_ms: f64,
+    navigation_duration_ms: Option<f64>,
+    first_contentful_paint_ms: Option<f64>,
+}
+
+impl StartupDiagnostics {
+    pub fn new() -> Self {
+        Self {
+            origin: Instant::now(),
+            state: Arc::new(Mutex::new(StartupState::default())),
+        }
+    }
+
+    pub fn record(&self, milestone: StartupMilestone) {
+        self.record_at(milestone, self.origin.elapsed());
+    }
+
+    fn record_at(&self, milestone: StartupMilestone, elapsed: Duration) {
+        let should_log = {
+            let Ok(mut state) = self.state.lock() else {
+                return;
+            };
+            if state
+                .milestones
+                .iter()
+                .any(|entry| entry.milestone == milestone)
+            {
+                return;
+            }
+            state.milestones.push(MilestoneEntry { milestone, elapsed });
+            state.logging_enabled
+        };
+        if should_log {
+            log_milestone(milestone, elapsed);
+        }
+    }
+
+    pub fn enable_logging(&self) {
+        let entries = {
+            let Ok(mut state) = self.state.lock() else {
+                return;
+            };
+            if state.logging_enabled {
+                return;
+            }
+            state.logging_enabled = true;
+            state.milestones.clone()
+        };
+        for entry in entries {
+            log_milestone(entry.milestone, entry.elapsed);
+        }
+    }
+
+    pub fn set_credential_outcome(&self, outcome: CredentialOutcome) {
+        if let Ok(mut state) = self.state.lock() {
+            state.credential_outcome = Some(outcome);
+        }
+    }
+
+    pub fn set_server_outcome(&self, outcome: ServerOutcome) {
+        if let Ok(mut state) = self.state.lock() {
+            state.server_outcome = Some(outcome);
+        }
+    }
+
+    fn complete(&self, metrics: FrontendStartupMetrics) -> Result<(), String> {
+        validate_frontend_metrics(&metrics)?;
+        let summary = self.summary(metrics, self.origin.elapsed())?;
+        let encoded = serde_json::to_string(&summary)
+            .map_err(|error| format!("encode desktop startup summary: {error}"))?;
+        log::info!("{encoded}");
+        Ok(())
+    }
+
+    fn summary(
+        &self,
+        metrics: FrontendStartupMetrics,
+        elapsed: Duration,
+    ) -> Result<StartupSummary, String> {
+        let mut state = self
+            .state
+            .lock()
+            .map_err(|_| "desktop startup diagnostics are unavailable".to_owned())?;
+        if state.completed {
+            return Err("desktop startup diagnostics were already completed".to_owned());
+        }
+        state.completed = true;
+        let duration = |start, end| milestone_duration(&state.milestones, start, end);
+        let milestone = |target| milestone_elapsed(&state.milestones, target);
+        Ok(StartupSummary {
+            event: "desktop_startup_completed",
+            schema_version: FRONTEND_SCHEMA_VERSION,
+            total_duration_ms: elapsed.as_millis(),
+            platform_configuration_completed_ms: milestone(
+                StartupMilestone::PlatformConfigurationCompleted,
+            ),
+            log_plugin_build_ms: duration(
+                StartupMilestone::LogPluginBuildStarted,
+                StartupMilestone::LogPluginBuildCompleted,
+            ),
+            tauri_builder_configured_ms: milestone(StartupMilestone::TauriBuilderConfigured),
+            setup_duration_ms: duration(
+                StartupMilestone::TauriSetupStarted,
+                StartupMilestone::TauriSetupCompleted,
+            ),
+            preferences_load_ms: duration(
+                StartupMilestone::PreferencesLoadStarted,
+                StartupMilestone::PreferencesLoadCompleted,
+            ),
+            credential_lookup_ms: duration(
+                StartupMilestone::CredentialLookupStarted,
+                StartupMilestone::CredentialLookupCompleted,
+            ),
+            sidecar_startup_ms: duration(
+                StartupMilestone::SidecarStartupStarted,
+                StartupMilestone::SidecarStartupCompleted,
+            ),
+            page_load_started_ms: milestone(StartupMilestone::PageLoadStarted),
+            page_load_finished_ms: milestone(StartupMilestone::PageLoadFinished),
+            credential_outcome: state.credential_outcome,
+            server_outcome: state.server_outcome,
+            platform: std::env::consts::OS,
+            architecture: std::env::consts::ARCH,
+            build_profile: if cfg!(debug_assertions) {
+                "debug"
+            } else {
+                "release"
+            },
+            source_identity: env!("AXKDECK_SOURCE_IDENTITY"),
+            frontend: FrontendStartupSummary {
+                view: metrics.view,
+                module_evaluated_ms: metrics.module_evaluated_ms,
+                diagnostics_installed_ms: metrics.diagnostics_installed_ms,
+                interface_scale_complete_ms: metrics.interface_scale_complete_ms,
+                shell_mounted_ms: metrics.shell_mounted_ms,
+                shell_first_frame_ms: metrics.shell_first_frame_ms,
+                app_module_ready_ms: metrics.app_module_ready_ms,
+                server_connection_complete_ms: metrics.server_connection_complete_ms,
+                app_mounted_ms: metrics.app_mounted_ms,
+                app_first_frame_ms: metrics.app_first_frame_ms,
+                navigation_duration_ms: metrics.navigation_duration_ms,
+                first_contentful_paint_ms: metrics.first_contentful_paint_ms,
+            },
+        })
+    }
+}
+
+fn milestone_elapsed(entries: &[MilestoneEntry], target: StartupMilestone) -> Option<u128> {
+    entries
+        .iter()
+        .find(|entry| entry.milestone == target)
+        .map(|entry| entry.elapsed.as_millis())
+}
+
+fn milestone_duration(
+    entries: &[MilestoneEntry],
+    start: StartupMilestone,
+    end: StartupMilestone,
+) -> Option<u128> {
+    let start = entries
+        .iter()
+        .find(|entry| entry.milestone == start)?
+        .elapsed;
+    let end = entries.iter().find(|entry| entry.milestone == end)?.elapsed;
+    end.checked_sub(start).map(|duration| duration.as_millis())
+}
+
+fn validate_frontend_metrics(metrics: &FrontendStartupMetrics) -> Result<(), String> {
+    if metrics.schema_version != FRONTEND_SCHEMA_VERSION {
+        return Err("unsupported desktop startup metrics schema".to_owned());
+    }
+    let ordered = [
+        metrics.module_evaluated_ms,
+        metrics.shell_mounted_ms,
+        metrics.shell_first_frame_ms,
+        metrics.app_module_ready_ms,
+        metrics.app_mounted_ms,
+        metrics.app_first_frame_ms,
+    ];
+    if ordered
+        .iter()
+        .any(|value| !value.is_finite() || *value < 0.0 || *value > MAXIMUM_FRONTEND_MILLISECONDS)
+        || ordered.windows(2).any(|pair| pair[0] > pair[1])
+    {
+        return Err("desktop startup metrics are invalid or unordered".to_owned());
+    }
+    for setup in [
+        metrics.diagnostics_installed_ms,
+        metrics.interface_scale_complete_ms,
+    ] {
+        if !setup.is_finite()
+            || !(metrics.module_evaluated_ms..=metrics.app_mounted_ms).contains(&setup)
+        {
+            return Err("desktop startup setup metric is invalid".to_owned());
+        }
+    }
+    if let Some(server) = metrics.server_connection_complete_ms {
+        if !server.is_finite()
+            || !(metrics.module_evaluated_ms..=metrics.app_mounted_ms).contains(&server)
+        {
+            return Err("desktop startup server metric is invalid".to_owned());
+        }
+    }
+    for optional in [
+        metrics.navigation_duration_ms,
+        metrics.first_contentful_paint_ms,
+    ]
+    .into_iter()
+    .flatten()
+    {
+        if !optional.is_finite() || !(0.0..=MAXIMUM_FRONTEND_MILLISECONDS).contains(&optional) {
+            return Err("desktop startup browser metrics are invalid".to_owned());
+        }
+    }
+    Ok(())
+}
+
+fn log_milestone(milestone: StartupMilestone, elapsed: Duration) {
+    let event = StartupMilestoneEvent {
+        event: "desktop_startup_milestone",
+        schema_version: FRONTEND_SCHEMA_VERSION,
+        milestone: milestone.name(),
+        elapsed_ms: elapsed.as_millis(),
+    };
+    if let Ok(encoded) = serde_json::to_string(&event) {
+        log::debug!("{encoded}");
+    }
+}
+
+#[tauri::command]
+pub fn complete_startup(
+    metrics: FrontendStartupMetrics,
+    diagnostics: State<'_, StartupDiagnostics>,
+) -> Result<(), String> {
+    diagnostics.complete(metrics)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn valid_metrics() -> FrontendStartupMetrics {
+        FrontendStartupMetrics {
+            schema_version: FRONTEND_SCHEMA_VERSION,
+            view: StartupView::Workspace,
+            module_evaluated_ms: 2.0,
+            diagnostics_installed_ms: 4.0,
+            interface_scale_complete_ms: 6.0,
+            shell_mounted_ms: 3.0,
+            shell_first_frame_ms: 8.0,
+            app_module_ready_ms: 9.0,
+            server_connection_complete_ms: Some(8.5),
+            app_mounted_ms: 10.0,
+            app_first_frame_ms: 12.0,
+            navigation_duration_ms: Some(10.0),
+            first_contentful_paint_ms: Some(11.0),
+        }
+    }
+
+    #[test]
+    fn validates_ordered_bounded_frontend_metrics() {
+        assert!(validate_frontend_metrics(&valid_metrics()).is_ok());
+        let mut unordered = valid_metrics();
+        unordered.app_mounted_ms = 3.0;
+        assert!(validate_frontend_metrics(&unordered).is_err());
+        let mut unsupported = valid_metrics();
+        unsupported.schema_version = 1;
+        assert!(validate_frontend_metrics(&unsupported).is_err());
+    }
+
+    #[test]
+    fn summarizes_each_startup_once_without_sensitive_values() {
+        let diagnostics = StartupDiagnostics::new();
+        diagnostics.record_at(
+            StartupMilestone::TauriSetupStarted,
+            Duration::from_millis(2),
+        );
+        diagnostics.record_at(
+            StartupMilestone::TauriSetupCompleted,
+            Duration::from_millis(7),
+        );
+        diagnostics.set_credential_outcome(CredentialOutcome::Missing);
+        diagnostics.set_server_outcome(ServerOutcome::LocalReady);
+        let summary = diagnostics
+            .summary(valid_metrics(), Duration::from_millis(20))
+            .expect("summarize startup");
+        let encoded = serde_json::to_string(&summary).expect("encode startup summary");
+        assert_eq!(summary.setup_duration_ms, Some(5));
+        assert!(encoded.contains("desktop_startup_completed"));
+        for forbidden in ["bearerToken", "baseUrl", "logDirectory", "stateDirectory"] {
+            assert!(!encoded.contains(forbidden));
+        }
+        assert!(
+            diagnostics
+                .summary(valid_metrics(), Duration::from_millis(21))
+                .is_err()
+        );
+    }
+
+    #[test]
+    fn records_each_fixed_milestone_only_once() {
+        let diagnostics = StartupDiagnostics::new();
+        diagnostics.record_at(StartupMilestone::NativeEntry, Duration::from_millis(1));
+        diagnostics.record_at(StartupMilestone::NativeEntry, Duration::from_millis(9));
+        let state = diagnostics.state.lock().expect("startup state");
+        assert_eq!(state.milestones.len(), 1);
+        assert_eq!(state.milestones[0].elapsed, Duration::from_millis(1));
+    }
+}
diff --git a/apps/axkdeck/src/App.svelte b/apps/axkdeck/src/App.svelte
index f1697303..9d7b4bfc 100644
--- a/apps/axkdeck/src/App.svelte
+++ b/apps/axkdeck/src/App.svelte
@@ -1,11 +1,12 @@
 <script lang="ts">
     import { onDestroy, onMount } from 'svelte';
+    import type { AppProps } from './appProps';
     import { AuditionWorkflow } from './features/audition/workflow.svelte';
     import { CatalogWorkflow } from './features/catalog/workflow.svelte';
     import { createConnectionActions } from './features/connection/actions';
     import { DeletionWorkflow } from './features/deletion/workflow.svelte';
     import { PickerController, type PickerRequest } from './features/dialogs/picker';
-    import AppDialogs from './features/dialogs/AppDialogs.svelte';
+    import { hasOpenAppDialog } from './features/dialogs/visibility';
     import { ExportWorkflow } from './features/export/workflow.svelte';
     import { MediaExportWorkflow } from './features/export/mediaWorkflow.svelte';
     import { VolumePackageExportWorkflow } from './features/export/volumePackageWorkflow.svelte';
@@ -23,19 +24,19 @@
     import { MutationWorkflow } from './features/mutation/workflow.svelte';
     import { ProgramGenerationWorkflow } from './features/program-generation/workflow.svelte';
     import WorkspaceShell from './features/workspace/WorkspaceShell.svelte';
+    import { workspaceTabs } from './features/workspace/tabs';
     import ExperimentalWarningDialog from './lib/components/ExperimentalWarningDialog.svelte';
     import ImageIntegrityDialog from './lib/components/ImageIntegrityDialog.svelte';
     import { createTransport } from './lib/createTransport';
     import { openAllocationInspector } from './lib/allocationInspector';
     import type { RemoteServerSettingsInput, RemoteServerSettingsView } from './lib/serverSettings';
-    import { diagnosticsEnabled, reportDiagnostic } from './lib/diagnostics';
+    import { reportMutationTiming } from './lib/diagnostics';
     import {
         emptyPackageExportSelection,
         maximumPackageExportRoots,
         type PackageExportSelectionState,
     } from './lib/objectSelection';
     import { userFacingMessage } from './lib/userFacingMessage';
-    import type { InterfaceScaleController } from './lib/interfaceScale';
     import { midiExtensions } from './lib/midiImport';
     import type {
         DiskTreeItem,
@@ -46,27 +47,16 @@
         WorkspaceView,
     } from './lib/types';
 
-    interface Props {
-        interfaceScaling?: InterfaceScaleController | null;
-    }
-
-    let { interfaceScaling = null }: Props = $props();
-
-    const workspaceTabs: {
-        id: WorkspaceView;
-        label: string;
-        icon: 'music' | 'layers' | 'archive' | 'waveform' | 'list';
-    }[] = [
-        { id: 'programs', label: 'Programs', icon: 'music' },
-        { id: 'sample-banks', label: 'Sample Banks', icon: 'layers' },
-        { id: 'samples', label: 'Samples', icon: 'archive' },
-        { id: 'wave-data', label: 'Wave Data', icon: 'waveform' },
-        { id: 'sequences', label: 'Sequences', icon: 'list' },
-    ];
+    let {
+        interfaceScaling = null,
+        initialExperimentalWarningOpen = true,
+        openConnectionSettingsOnStart = false,
+    }: AppProps = $props();
     const transport = createTransport();
     const isDesktop = '__TAURI_INTERNALS__' in window;
     let pickerRequest = $state<PickerRequest | null>(null);
-    let experimentalWarningOpen = $state(true);
+    let experimentalWarningAcknowledged = $state(false);
+    const experimentalWarningOpen = $derived(initialExperimentalWarningOpen && !experimentalWarningAcknowledged);
     let workspaceView = $state<WorkspaceView>('programs');
     let inspectorOpen = $state(true);
     let connectionSettings = $state<RemoteServerSettingsView | null>(null);
@@ -325,7 +315,9 @@
     });
 
     onMount(() => {
-        return mediaDropWorkflow.mountNativeDrops();
+        const unmountNativeDrops = mediaDropWorkflow.mountNativeDrops();
+        if (openConnectionSettingsOnStart) void openConnectionSettings();
+        return unmountNativeDrops;
     });
 
     const selectedProgram = $derived(programs.find((item) => item.objectId === catalog.selectedProgramId));
@@ -333,6 +325,27 @@
     const selectedSample = $derived(samples.find((item) => item.objectId === catalog.selectedSampleId));
     const auditionableSampleObjectIds = $derived(auditionWorkflow.auditionableSampleObjectIds);
     const auditionableSampleBankObjectIds = $derived(auditionWorkflow.auditionableSampleBankObjectIds);
+    const appDialogsOpen = $derived(
+        hasOpenAppDialog({
+            pickerRequest,
+            imageSession: imageSessionWorkflow,
+            workspaceManagerOpen,
+            connectionSettings,
+            mutation: mutationWorkflow,
+            packageImport: packageImportWorkflow,
+            packageBatchImport: packageBatchImportWorkflow,
+            exports: exportWorkflow,
+            volumePackages: volumePackageExportWorkflow,
+            volumeFloppies: volumeFloppyExportWorkflow,
+            mediaExports: mediaExportWorkflow,
+            deletion: deletionWorkflow,
+            programGeneration: programGenerationWorkflow,
+            audioImport: audioImportWorkflow,
+            sequenceImport: sequenceImportWorkflow,
+            tx16wImport: tx16wImportWorkflow,
+            mediaDrop: mediaDropWorkflow,
+        }),
+    );
     const bankMembers = $derived(selectedBank ? catalog.membersForBank(selectedBank.objectId) : []);
     const bankMemberWaveData = $derived(
         catalog.selectedBankMemberId ? catalog.waveDataForSample(catalog.selectedBankMemberId) : [],
@@ -511,16 +524,6 @@
         deletionWorkflow.requestCleanup();
     }
 
-    function reportMutationTiming(operation: string, started: number, itemCount: number): void {
-        if (!diagnosticsEnabled()) return;
-        reportDiagnostic('image_mutation_completed', {
-            operation,
-            itemCount,
-            durationMs: Math.round(performance.now() - started),
-            strategy: 'journaled-in-place',
-        });
-    }
-
     function suppressDesktopContextMenu(event: MouseEvent): void {
         if (isDesktop) event.preventDefault();
     }
@@ -630,7 +633,7 @@
 />
 
 {#if experimentalWarningOpen}
-    <ExperimentalWarningDialog onacknowledge={() => (experimentalWarningOpen = false)} />
+    <ExperimentalWarningDialog onacknowledge={() => (experimentalWarningAcknowledged = true)} />
 {/if}
 
 {#if imageSessionWorkflow.integrityDialogOpen}
@@ -647,44 +650,49 @@
     />
 {/if}
 
-<AppDialogs
-    {transport}
-    {isDesktop}
-    {pickerRequest}
-    finishPicker={(selection) => pickerController.finish(selection)}
-    manageLocations={() => (workspaceManagerOpen = true)}
-    companionRequest={imageSessionWorkflow.companionRequest}
-    addCompanion={() => void imageSessionWorkflow.addCompanionDiskSource()}
-    removeCompanion={(source) => imageSessionWorkflow.removeCompanionDiskSource(source)}
-    attachCompanions={(selection) => void imageSessionWorkflow.attachCompanionDisks(selection)}
-    cancelCompanions={() => imageSessionWorkflow.cancelCompanionDisks()}
-    hardDiskDirectory={imageSessionWorkflow.hardDiskDirectory}
-    finishHardDisk={(file) => imageSessionWorkflow.finishHardDiskCreation(file)}
-    cancelHardDisk={() => imageSessionWorkflow.cancelHardDiskCreation()}
-    {workspaceManagerOpen}
-    activeWorkspaceId={imageSessionWorkflow.location?.reference.rootId ?? null}
-    closeWorkspaceManager={() => (workspaceManagerOpen = false)}
-    {connectionSettings}
-    {saveRemoteConnection}
-    {switchToLocalConnection}
-    closeConnectionSettings={() => (connectionSettings = null)}
-    mutation={mutationWorkflow}
-    packageImport={packageImportWorkflow}
-    packageBatchImport={packageBatchImportWorkflow}
-    exports={exportWorkflow}
-    volumePackages={volumePackageExportWorkflow}
-    volumeFloppies={volumeFloppyExportWorkflow}
-    mediaExports={mediaExportWorkflow}
-    deletion={deletionWorkflow}
-    programGeneration={programGenerationWorkflow}
-    mediaDrop={mediaDropWorkflow}
-    tx16wImport={tx16wImportWorkflow}
-    audioImport={audioImportWorkflow}
-    {audioFileInput}
-    sequenceImport={sequenceImportWorkflow}
-    {sequenceFileInput}
-    sampleNames={samples.map((item) => item.name)}
-    sampleBankNames={sampleBanks.map((item) => item.name)}
-    waveDataNames={waveData.map((item) => item.name)}
-    sequenceNames={sequences.map((item) => item.name)}
-/>
+{#if appDialogsOpen}
+    {#await import('./features/dialogs/AppDialogs.svelte') then dialogs}
+        {@const AppDialogs = dialogs.default}
+        <AppDialogs
+            {transport}
+            {isDesktop}
+            {pickerRequest}
+            finishPicker={(selection) => pickerController.finish(selection)}
+            manageLocations={() => (workspaceManagerOpen = true)}
+            companionRequest={imageSessionWorkflow.companionRequest}
+            addCompanion={() => void imageSessionWorkflow.addCompanionDiskSource()}
+            removeCompanion={(source) => imageSessionWorkflow.removeCompanionDiskSource(source)}
+            attachCompanions={(selection) => void imageSessionWorkflow.attachCompanionDisks(selection)}
+            cancelCompanions={() => imageSessionWorkflow.cancelCompanionDisks()}
+            hardDiskDirectory={imageSessionWorkflow.hardDiskDirectory}
+            finishHardDisk={(file) => imageSessionWorkflow.finishHardDiskCreation(file)}
+            cancelHardDisk={() => imageSessionWorkflow.cancelHardDiskCreation()}
+            {workspaceManagerOpen}
+            activeWorkspaceId={imageSessionWorkflow.location?.reference.rootId ?? null}
+            closeWorkspaceManager={() => (workspaceManagerOpen = false)}
+            {connectionSettings}
+            {saveRemoteConnection}
+            {switchToLocalConnection}
+            closeConnectionSettings={() => (connectionSettings = null)}
+            mutation={mutationWorkflow}
+            packageImport={packageImportWorkflow}
+            packageBatchImport={packageBatchImportWorkflow}
+            exports={exportWorkflow}
+            volumePackages={volumePackageExportWorkflow}
+            volumeFloppies={volumeFloppyExportWorkflow}
+            mediaExports={mediaExportWorkflow}
+            deletion={deletionWorkflow}
+            programGeneration={programGenerationWorkflow}
+            mediaDrop={mediaDropWorkflow}
+            tx16wImport={tx16wImportWorkflow}
+            audioImport={audioImportWorkflow}
+            {audioFileInput}
+            sequenceImport={sequenceImportWorkflow}
+            {sequenceFileInput}
+            sampleNames={samples.map((item) => item.name)}
+            sampleBankNames={sampleBanks.map((item) => item.name)}
+            waveDataNames={waveData.map((item) => item.name)}
+            sequenceNames={sequences.map((item) => item.name)}
+        />
+    {/await}
+{/if}
diff --git a/apps/axkdeck/src/App.test.ts b/apps/axkdeck/src/App.test.ts
index e6a9012e..4dc052a8 100644
--- a/apps/axkdeck/src/App.test.ts
+++ b/apps/axkdeck/src/App.test.ts
@@ -80,7 +80,7 @@ function renderAcknowledgedApp() {
 
 async function chooseNestedImage(buttonName: 'Open image' | 'Open another image' = 'Open image'): Promise<void> {
     await fireEvent.click(screen.getByRole('button', { name: buttonName }));
-    const picker = await screen.findByRole('dialog', { name: 'Open image' });
+    const picker = await screen.findByRole('dialog', { name: 'Open image' }, { timeout: 5_000 });
     if (buttonName === 'Open image') {
         await fireEvent.click(await within(picker).findByText('Yamaha'));
         await fireEvent.click(await within(picker).findByText('images'));
@@ -1264,7 +1264,8 @@ describe('App panel layout', () => {
         });
         await fireEvent.contextMenu(screen.getByRole('button', { name: /My Volume/ }));
         await fireEvent.click(screen.getByRole('menuitem', { name: 'Import package…' }));
-        await fireEvent.click(screen.getByRole('button', { name: /Storage location/ }));
+        const importDialog = await screen.findByRole('dialog', { name: 'Import axklib package' });
+        await fireEvent.click(within(importDialog).getByRole('button', { name: /Storage location/ }));
         const picker = await screen.findByRole('dialog', { name: 'Choose axklib package' });
         expect(screen.queryByRole('dialog', { name: 'Import axklib package' })).toBeNull();
         expect(screen.getAllByRole('dialog')).toHaveLength(1);
@@ -1327,7 +1328,7 @@ describe('App panel layout', () => {
         await fireEvent.click(screen.getByRole('menuitem', { name: 'Import' }));
         await fireEvent.click(screen.getByRole('menuitem', { name: 'Import packages…' }));
 
-        const dialog = screen.getByRole('dialog', { name: 'Import volume packages' });
+        const dialog = await screen.findByRole('dialog', { name: 'Import volume packages' });
         expect(within(dialog).getByText('Create volumes in My Partition from selected .axkvol packages.')).toBeTruthy();
         expect(within(dialog).getByRole('button', { name: /Storage location/ })).toBeTruthy();
     });
@@ -1493,7 +1494,7 @@ describe('App panel layout', () => {
         expect(screen.getByRole('status').textContent).toContain('2 selected');
         await fireEvent.click(screen.getByRole('button', { name: 'Export 2 selected objects' }));
 
-        const dialog = screen.getByRole('dialog', { name: 'Export axklib package' });
+        const dialog = await screen.findByRole('dialog', { name: 'Export axklib package' });
         expect(within(dialog).getByText('Partition 0 · Piano')).toBeTruthy();
         expect(within(dialog).getByText('Partition 1 · Drums')).toBeTruthy();
         expect(within(dialog).getByText('1 Program · 1 Sample Bank')).toBeTruthy();
@@ -1550,7 +1551,7 @@ describe('App panel layout', () => {
         expect(screen.queryByRole('menuitem', { name: 'Import package…' })).toBeNull();
         await fireEvent.click(screen.getByRole('menuitem', { name: 'Export package…' }));
 
-        const dialog = screen.getByRole('dialog', { name: 'Export axklib package' });
+        const dialog = await screen.findByRole('dialog', { name: 'Export axklib package' });
         expect(within(dialog).getByText('Export “Object directory”')).toBeTruthy();
         expect(within(dialog).getByRole('button', { name: /Storage location/ })).toBeTruthy();
     });
@@ -1886,7 +1887,8 @@ describe('App panel layout', () => {
         await chooseNestedImage();
         await fireEvent.click(screen.getByRole('button', { name: 'Samples' }));
         await fireEvent.click(screen.getByRole('button', { name: 'Import audio' }));
-        await fireEvent.click(screen.getByRole('button', { name: /This computer/ }));
+        const sourceDialog = await screen.findByRole('dialog', { name: 'Import audio' });
+        await fireEvent.click(within(sourceDialog).getByRole('button', { name: /This computer/ }));
 
         const input = container.querySelector<HTMLInputElement>('input[type="file"]');
         expect(input).toBeTruthy();
diff --git a/apps/axkdeck/src/StartupShell.svelte b/apps/axkdeck/src/StartupShell.svelte
new file mode 100644
index 00000000..68f0a76b
--- /dev/null
+++ b/apps/axkdeck/src/StartupShell.svelte
@@ -0,0 +1,198 @@
+<script lang="ts">
+    import ExperimentalWarningDialog from './lib/components/ExperimentalWarningDialog.svelte';
+
+    interface Props {
+        status?: 'starting' | 'unavailable';
+        message?: string;
+        warningOpen?: boolean;
+        onacknowledge: () => void;
+        onretry: () => void;
+        onopensettings: () => void;
+    }
+
+    let {
+        status = 'starting',
+        message = '',
+        warningOpen = true,
+        onacknowledge,
+        onretry,
+        onopensettings,
+    }: Props = $props();
+</script>
+
+<div class="startup-shell" aria-busy={status === 'starting'}>
+    <header class="startup-header">
+        <div class="startup-brand"><span aria-hidden="true">~</span><strong>axkdeck</strong></div>
+        <nav aria-label="Object views">
+            <button type="button" disabled>Programs</button>
+            <button type="button" disabled>Sample Banks</button>
+            <button type="button" disabled>Samples</button>
+            <button type="button" disabled>Wave Data</button>
+            <button type="button" disabled>Sequences</button>
+        </nav>
+    </header>
+    <aside class="startup-library">
+        <p>IMAGE</p>
+        <div class="startup-placeholder">Open Image</div>
+        <p>CONTENTS</p>
+        <strong>Partitions, volumes and objects</strong>
+    </aside>
+    <main class="startup-workspace">
+        <header><strong>Programs</strong><span>0 items</span></header>
+        {#if status === 'unavailable'}
+            <section class="startup-error" role="alert">
+                <strong>axklib-server is unavailable</strong>
+                <p>{message || 'The application could not connect to its data service.'}</p>
+                <div>
+                    <button type="button" class="secondary-button" onclick={onretry}>Retry</button>
+                    <button type="button" class="secondary-button" onclick={onopensettings}>Connection settings</button>
+                </div>
+            </section>
+        {:else}
+            <p class="startup-empty">Starting services...</p>
+        {/if}
+    </main>
+    <aside class="startup-inspector">
+        <p>INSPECTOR</p>
+        <strong>Object details</strong>
+    </aside>
+    <footer>
+        <span class:startup-failed={status === 'unavailable'}></span>{status === 'starting'
+            ? 'Starting services...'
+            : 'Service unavailable'}
+    </footer>
+</div>
+
+{#if warningOpen}
+    <ExperimentalWarningDialog {onacknowledge} />
+{/if}
+
+<style>
+    .startup-shell {
+        display: grid;
+        grid-template-columns: 248px minmax(520px, 1fr) 268px;
+        grid-template-rows: 40px minmax(0, 1fr) 18px;
+        width: 100%;
+        height: 100%;
+        min-width: 760px;
+        background: var(--color-bg);
+        color: var(--color-text);
+    }
+    .startup-header {
+        grid-column: 1 / -1;
+        display: grid;
+        grid-template-columns: 248px minmax(0, 1fr);
+        align-items: stretch;
+        border-bottom: 1px solid var(--color-border);
+        background: #1c1f21;
+    }
+    .startup-brand {
+        display: flex;
+        align-items: center;
+        gap: 10px;
+        padding: 0 10px;
+        color: var(--color-text-strong);
+    }
+    .startup-brand span {
+        display: grid;
+        width: 28px;
+        height: 28px;
+        place-items: center;
+        border: 1px solid rgb(204 120 50 / 55%);
+        border-radius: 7px;
+        background: #8e5428;
+        font-weight: 700;
+    }
+    nav {
+        display: flex;
+    }
+    nav button {
+        padding: 0 14px;
+        border: 0;
+        background: transparent;
+        color: var(--color-text-muted);
+    }
+    .startup-library,
+    .startup-inspector {
+        padding: 12px 10px;
+        border-right: 1px solid var(--color-border);
+    }
+    .startup-inspector {
+        border-right: 0;
+        border-left: 1px solid var(--color-border);
+    }
+    .startup-library p,
+    .startup-inspector p {
+        margin: 0 0 5px;
+        color: var(--color-text-muted);
+        font-size: 9px;
+        font-weight: 700;
+        letter-spacing: 0.12em;
+    }
+    .startup-placeholder {
+        height: 44px;
+        margin: 8px 0 18px;
+        padding: 13px;
+        border: 1px solid var(--color-border);
+        border-radius: 6px;
+        color: var(--color-text-muted);
+    }
+    .startup-workspace {
+        min-width: 0;
+    }
+    .startup-workspace > header {
+        display: flex;
+        align-items: center;
+        gap: 5px;
+        height: 34px;
+        padding: 0 8px;
+        border-bottom: 1px solid var(--color-border);
+    }
+    .startup-workspace > header span {
+        color: var(--color-text-muted);
+        font-size: 9px;
+    }
+    .startup-empty {
+        display: grid;
+        height: calc(100% - 34px);
+        margin: 0;
+        place-items: center;
+        color: var(--color-text-muted);
+    }
+    .startup-error {
+        width: min(460px, calc(100% - 40px));
+        margin: 64px auto;
+        padding: 16px;
+        border: 1px solid var(--color-border);
+        border-radius: 6px;
+        background: var(--color-panel);
+    }
+    .startup-error strong {
+        color: var(--color-danger);
+    }
+    .startup-error p {
+        line-height: 1.45;
+    }
+    .startup-error div {
+        display: flex;
+        gap: 8px;
+    }
+    footer {
+        grid-column: 1 / -1;
+        display: flex;
+        align-items: center;
+        gap: 6px;
+        padding: 0 10px;
+        border-top: 1px solid var(--color-border);
+        font-size: 9px;
+    }
+    footer span {
+        width: 5px;
+        height: 5px;
+        border-radius: 50%;
+        background: var(--color-success);
+    }
+    footer span.startup-failed {
+        background: var(--color-danger);
+    }
+</style>
diff --git a/apps/axkdeck/src/StartupShell.test.ts b/apps/axkdeck/src/StartupShell.test.ts
new file mode 100644
index 00000000..704d353b
--- /dev/null
+++ b/apps/axkdeck/src/StartupShell.test.ts
@@ -0,0 +1,34 @@
+import { fireEvent, render, screen } from '@testing-library/svelte';
+import { describe, expect, it, vi } from 'vitest';
+
+import StartupShell from './StartupShell.svelte';
+
+describe('StartupShell', () => {
+    it('paints a stable starting state while retaining the startup warning', () => {
+        render(StartupShell, {
+            props: { onacknowledge: vi.fn(), onretry: vi.fn(), onopensettings: vi.fn() },
+        });
+        expect(screen.getAllByText('Starting services...')).toHaveLength(2);
+        expect(screen.getByRole('dialog', { name: 'Experimental software' })).toBeTruthy();
+    });
+
+    it('offers recovery without leaving a blank window', async () => {
+        const onretry = vi.fn();
+        const onopensettings = vi.fn();
+        render(StartupShell, {
+            props: {
+                status: 'unavailable',
+                message: 'Connection timed out',
+                warningOpen: false,
+                onacknowledge: vi.fn(),
+                onretry,
+                onopensettings,
+            },
+        });
+        expect(screen.getByRole('alert').textContent).toContain('Connection timed out');
+        await fireEvent.click(screen.getByRole('button', { name: 'Retry' }));
+        await fireEvent.click(screen.getByRole('button', { name: 'Connection settings' }));
+        expect(onretry).toHaveBeenCalledOnce();
+        expect(onopensettings).toHaveBeenCalledOnce();
+    });
+});
diff --git a/apps/axkdeck/src/appProps.ts b/apps/axkdeck/src/appProps.ts
new file mode 100644
index 00000000..e704fe91
--- /dev/null
+++ b/apps/axkdeck/src/appProps.ts
@@ -0,0 +1,7 @@
+import type { InterfaceScaleController } from './lib/interfaceScale';
+
+export interface AppProps {
+    interfaceScaling?: InterfaceScaleController | null;
+    initialExperimentalWarningOpen?: boolean;
+    openConnectionSettingsOnStart?: boolean;
+}
diff --git a/apps/axkdeck/src/features/dialogs/visibility.ts b/apps/axkdeck/src/features/dialogs/visibility.ts
new file mode 100644
index 00000000..7e470e16
--- /dev/null
+++ b/apps/axkdeck/src/features/dialogs/visibility.ts
@@ -0,0 +1,83 @@
+interface ImageSessionDialogState {
+    companionRequest: unknown;
+    hardDiskDirectory: unknown;
+}
+
+interface MutationDialogState {
+    volumeAction: unknown;
+    placementRepairRequest: unknown;
+    objectRenameRequest: unknown;
+    sampleBankCreationRequest: unknown;
+    sampleBankAssignmentRequest: unknown;
+}
+
+interface DeletionDialogState {
+    objectRequest: unknown;
+    cleanupRequest: unknown;
+}
+
+interface MediaDropDialogState {
+    notice: unknown;
+    dragActive: boolean;
+}
+
+interface RequestDialogState {
+    request: unknown;
+}
+
+interface ExportDialogState {
+    packageRequest: unknown;
+    audioRequest: unknown;
+    sequenceRequest: unknown;
+}
+
+interface AppDialogState {
+    pickerRequest: unknown;
+    imageSession: ImageSessionDialogState;
+    workspaceManagerOpen: boolean;
+    connectionSettings: unknown;
+    mutation: MutationDialogState;
+    packageImport: RequestDialogState;
+    packageBatchImport: RequestDialogState;
+    exports: ExportDialogState;
+    volumePackages: RequestDialogState;
+    volumeFloppies: RequestDialogState;
+    mediaExports: RequestDialogState;
+    deletion: DeletionDialogState;
+    programGeneration: RequestDialogState;
+    audioImport: RequestDialogState;
+    sequenceImport: RequestDialogState;
+    tx16wImport: RequestDialogState;
+    mediaDrop: MediaDropDialogState;
+}
+
+export function hasOpenAppDialog(state: AppDialogState): boolean {
+    return [
+        state.pickerRequest,
+        state.imageSession.companionRequest,
+        state.imageSession.hardDiskDirectory,
+        state.workspaceManagerOpen,
+        state.connectionSettings,
+        state.mutation.volumeAction,
+        state.mutation.placementRepairRequest,
+        state.mutation.objectRenameRequest,
+        state.mutation.sampleBankCreationRequest,
+        state.mutation.sampleBankAssignmentRequest,
+        state.packageImport.request,
+        state.packageBatchImport.request,
+        state.exports.packageRequest,
+        state.volumePackages.request,
+        state.volumeFloppies.request,
+        state.exports.audioRequest,
+        state.exports.sequenceRequest,
+        state.mediaExports.request,
+        state.deletion.objectRequest,
+        state.deletion.cleanupRequest,
+        state.programGeneration.request,
+        state.audioImport.request,
+        state.sequenceImport.request,
+        state.tx16wImport.request,
+        state.mediaDrop.notice,
+        state.mediaDrop.dragActive,
+    ].some(Boolean);
+}
diff --git a/apps/axkdeck/src/features/workspace/tabs.ts b/apps/axkdeck/src/features/workspace/tabs.ts
new file mode 100644
index 00000000..347be5cc
--- /dev/null
+++ b/apps/axkdeck/src/features/workspace/tabs.ts
@@ -0,0 +1,15 @@
+import type { WorkspaceView } from '../../lib/types';
+
+export interface WorkspaceTab {
+    id: WorkspaceView;
+    label: string;
+    icon: 'music' | 'layers' | 'archive' | 'waveform' | 'list';
+}
+
+export const workspaceTabs: WorkspaceTab[] = [
+    { id: 'programs', label: 'Programs', icon: 'music' },
+    { id: 'sample-banks', label: 'Sample Banks', icon: 'layers' },
+    { id: 'samples', label: 'Samples', icon: 'archive' },
+    { id: 'wave-data', label: 'Wave Data', icon: 'waveform' },
+    { id: 'sequences', label: 'Sequences', icon: 'list' },
+];
diff --git a/apps/axkdeck/src/lib/diagnostics.ts b/apps/axkdeck/src/lib/diagnostics.ts
index be978122..57d024f2 100644
--- a/apps/axkdeck/src/lib/diagnostics.ts
+++ b/apps/axkdeck/src/lib/diagnostics.ts
@@ -62,6 +62,16 @@ export function reportDiagnostic(
     }
 }
 
+export function reportMutationTiming(operation: string, started: number, itemCount: number): void {
+    if (!diagnosticsEnabled()) return;
+    reportDiagnostic('image_mutation_completed', {
+        operation,
+        itemCount,
+        durationMs: Math.round(performance.now() - started),
+        strategy: 'journaled-in-place',
+    });
+}
+
 export async function installDiagnostics(): Promise<void> {
     window.addEventListener('error', (event) => {
         reportError('Unhandled frontend error', event.error ?? event.message);
diff --git a/apps/axkdeck/src/lib/startupCoordinator.test.ts b/apps/axkdeck/src/lib/startupCoordinator.test.ts
new file mode 100644
index 00000000..11da47a1
--- /dev/null
+++ b/apps/axkdeck/src/lib/startupCoordinator.test.ts
@@ -0,0 +1,42 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { prepareServerConnection, prepareStartup } from './startupCoordinator';
+
+describe('startup coordinator', () => {
+    it('starts the connection before paint and defers the application module until after paint', async () => {
+        let finishPaint!: () => void;
+        const paint = new Promise<void>((resolve) => (finishPaint = resolve));
+        const connection = Promise.resolve('connected');
+        const loadModule = vi.fn().mockResolvedValue('module');
+
+        const prepared = prepareStartup(connection, () => paint, loadModule);
+        expect(loadModule).not.toHaveBeenCalled();
+
+        finishPaint();
+        await Promise.resolve();
+        expect(loadModule).toHaveBeenCalledOnce();
+        await expect(prepared).resolves.toEqual({ connection: 'connected', module: 'module' });
+    });
+
+    it('restarts a failed local server before retrying its connection', async () => {
+        const calls: string[] = [];
+        const useLocalServer = vi.fn(async () => {
+            calls.push('restart');
+        });
+        const loadConnection = vi.fn(async () => {
+            calls.push('connect');
+            return 'connected';
+        });
+
+        await expect(prepareServerConnection(true, useLocalServer, loadConnection)).resolves.toBe('connected');
+        expect(calls).toEqual(['restart', 'connect']);
+    });
+
+    it('does not alter local server configuration during normal startup', async () => {
+        const useLocalServer = vi.fn();
+        const loadConnection = vi.fn().mockResolvedValue('connected');
+
+        await expect(prepareServerConnection(false, useLocalServer, loadConnection)).resolves.toBe('connected');
+        expect(useLocalServer).not.toHaveBeenCalled();
+    });
+});
diff --git a/apps/axkdeck/src/lib/startupCoordinator.ts b/apps/axkdeck/src/lib/startupCoordinator.ts
new file mode 100644
index 00000000..c0029cd4
--- /dev/null
+++ b/apps/axkdeck/src/lib/startupCoordinator.ts
@@ -0,0 +1,19 @@
+export async function prepareStartup<TConnection, TModule>(
+    connection: Promise<TConnection>,
+    waitForShellPaint: () => Promise<void>,
+    loadModule: () => Promise<TModule>,
+): Promise<{ connection: TConnection; module: TModule }> {
+    await waitForShellPaint();
+    const modulePromise = loadModule();
+    const [connectionResult, moduleResult] = await Promise.all([connection, modulePromise]);
+    return { connection: connectionResult, module: moduleResult };
+}
+
+export async function prepareServerConnection<TConnection>(
+    restartLocal: boolean,
+    useLocalServer: () => Promise<unknown>,
+    loadConnection: () => Promise<TConnection>,
+): Promise<TConnection> {
+    if (restartLocal) await useLocalServer();
+    return loadConnection();
+}
diff --git a/apps/axkdeck/src/lib/startupDiagnostics.test.ts b/apps/axkdeck/src/lib/startupDiagnostics.test.ts
new file mode 100644
index 00000000..89b124f0
--- /dev/null
+++ b/apps/axkdeck/src/lib/startupDiagnostics.test.ts
@@ -0,0 +1,98 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { FrontendStartupRecorder } from './startupDiagnostics';
+
+describe('frontend startup diagnostics', () => {
+    it('distinguishes the shell paint from application readiness', async () => {
+        let now = 4;
+        const recorder = new FrontendStartupRecorder({
+            now: () => now,
+            getEntriesByType: () => [],
+        });
+        const frames: FrameRequestCallback[] = [];
+        const requestFrame = vi.fn((callback: FrameRequestCallback) => {
+            frames.push(callback);
+            return frames.length;
+        });
+        const submit = vi.fn().mockResolvedValue(undefined);
+
+        now = 9;
+        recorder.markShellMounted();
+        now = 12;
+        recorder.markDiagnosticsInstalled();
+        now = 14;
+        recorder.markInterfaceScaleComplete();
+
+        const shellPaint = recorder.waitForShellFirstFrame(requestFrame);
+        now = 20;
+        frames.shift()?.(now);
+        await Promise.resolve();
+        now = 24;
+        frames.shift()?.(now);
+        await shellPaint;
+
+        now = 29;
+        recorder.markServerConnectionComplete();
+        now = 34;
+        recorder.markAppModuleReady();
+        now = 38;
+        recorder.markAppMounted();
+
+        const reporting = recorder.reportAfterAppFirstFrame('workspace', submit, requestFrame);
+        now = 42;
+        frames.shift()?.(now);
+        await Promise.resolve();
+        now = 47;
+        frames.shift()?.(now);
+        await reporting;
+
+        expect(submit).toHaveBeenCalledWith({
+            schemaVersion: 2,
+            view: 'workspace',
+            moduleEvaluatedMs: 4,
+            diagnosticsInstalledMs: 12,
+            interfaceScaleCompleteMs: 14,
+            shellMountedMs: 9,
+            shellFirstFrameMs: 24,
+            appModuleReadyMs: 34,
+            serverConnectionCompleteMs: 29,
+            appMountedMs: 38,
+            appFirstFrameMs: 47,
+            navigationDurationMs: null,
+            firstContentfulPaintMs: null,
+        });
+    });
+
+    it('allows views that do not require a server connection', async () => {
+        const recorder = new FrontendStartupRecorder({
+            now: () => 20,
+            getEntriesByType: (type) => {
+                if (type === 'navigation') return [{ duration: 18 }] as PerformanceEntry[];
+                if (type === 'paint') {
+                    return [{ name: 'first-contentful-paint', startTime: 12 }] as PerformanceEntry[];
+                }
+                return [];
+            },
+        });
+        recorder.markShellMounted();
+        recorder.markDiagnosticsInstalled();
+        recorder.markInterfaceScaleComplete();
+        const requestFrame = (callback: FrameRequestCallback) => {
+            callback(20);
+            return 1;
+        };
+        await recorder.waitForShellFirstFrame(requestFrame);
+        recorder.markAppModuleReady();
+        recorder.markAppMounted();
+        const submit = vi.fn().mockResolvedValue(undefined);
+
+        await recorder.reportAfterAppFirstFrame('allocation', submit, requestFrame);
+
+        expect(submit.mock.calls[0]?.[0]).toMatchObject({
+            view: 'allocation',
+            serverConnectionCompleteMs: null,
+            navigationDurationMs: 18,
+            firstContentfulPaintMs: 12,
+        });
+    });
+});
diff --git a/apps/axkdeck/src/lib/startupDiagnostics.ts b/apps/axkdeck/src/lib/startupDiagnostics.ts
new file mode 100644
index 00000000..7f915b90
--- /dev/null
+++ b/apps/axkdeck/src/lib/startupDiagnostics.ts
@@ -0,0 +1,130 @@
+import { invoke } from '@tauri-apps/api/core';
+
+export type StartupView = 'workspace' | 'allocation';
+
+export interface FrontendStartupMetrics {
+    schemaVersion: 2;
+    view: StartupView;
+    moduleEvaluatedMs: number;
+    diagnosticsInstalledMs: number;
+    interfaceScaleCompleteMs: number;
+    shellMountedMs: number;
+    shellFirstFrameMs: number;
+    appModuleReadyMs: number;
+    serverConnectionCompleteMs: number | null;
+    appMountedMs: number;
+    appFirstFrameMs: number;
+    navigationDurationMs: number | null;
+    firstContentfulPaintMs: number | null;
+}
+
+interface StartupPerformance {
+    now(): number;
+    getEntriesByType(type: string): PerformanceEntry[];
+}
+
+type StartupSubmitter = (metrics: FrontendStartupMetrics) => Promise<unknown>;
+type FrameRequester = (callback: FrameRequestCallback) => number;
+
+function finiteTiming(value: unknown): number | null {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : null;
+}
+
+function entryTiming(entries: PerformanceEntry[], name: string, property: 'duration' | 'startTime'): number | null {
+    const entry = entries.find((candidate) => candidate.name === name) ?? entries[0];
+    return finiteTiming(entry?.[property]);
+}
+
+function afterTwoFrames(requestFrame: FrameRequester): Promise<void> {
+    return new Promise<void>((resolve) => requestFrame(() => requestFrame(() => resolve())));
+}
+
+export class FrontendStartupRecorder {
+    private readonly moduleEvaluatedMs: number;
+    private diagnosticsInstalledMs: number | null = null;
+    private interfaceScaleCompleteMs: number | null = null;
+    private shellMountedMs: number | null = null;
+    private shellFirstFrameMs: number | null = null;
+    private appModuleReadyMs: number | null = null;
+    private serverConnectionCompleteMs: number | null = null;
+    private appMountedMs: number | null = null;
+    private shellPaint: Promise<void> | null = null;
+    private reporting: Promise<void> | null = null;
+
+    constructor(private readonly performanceSource: StartupPerformance) {
+        this.moduleEvaluatedMs = this.performanceSource.now();
+    }
+
+    markDiagnosticsInstalled(): void {
+        this.diagnosticsInstalledMs ??= this.performanceSource.now();
+    }
+
+    markInterfaceScaleComplete(): void {
+        this.interfaceScaleCompleteMs ??= this.performanceSource.now();
+    }
+
+    markShellMounted(): void {
+        this.shellMountedMs ??= this.performanceSource.now();
+    }
+
+    waitForShellFirstFrame(requestFrame: FrameRequester = window.requestAnimationFrame.bind(window)): Promise<void> {
+        if (!this.shellPaint) {
+            this.shellPaint = afterTwoFrames(requestFrame).then(() => {
+                this.shellFirstFrameMs ??= this.performanceSource.now();
+            });
+        }
+        return this.shellPaint;
+    }
+
+    markAppModuleReady(): void {
+        this.appModuleReadyMs ??= this.performanceSource.now();
+    }
+
+    markServerConnectionComplete(): void {
+        this.serverConnectionCompleteMs ??= this.performanceSource.now();
+    }
+
+    markAppMounted(): void {
+        this.appMountedMs ??= this.performanceSource.now();
+    }
+
+    reportAfterAppFirstFrame(
+        view: StartupView,
+        submit: StartupSubmitter = (metrics) => invoke('complete_startup', { metrics }),
+        requestFrame: FrameRequester = window.requestAnimationFrame.bind(window),
+    ): Promise<void> {
+        if (!this.reporting) this.reporting = this.report(view, submit, requestFrame);
+        return this.reporting;
+    }
+
+    private async report(view: StartupView, submit: StartupSubmitter, requestFrame: FrameRequester): Promise<void> {
+        await afterTwoFrames(requestFrame);
+        const appFirstFrameMs = this.performanceSource.now();
+        const fallback = appFirstFrameMs;
+        await submit({
+            schemaVersion: 2,
+            view,
+            moduleEvaluatedMs: this.moduleEvaluatedMs,
+            diagnosticsInstalledMs: this.diagnosticsInstalledMs ?? fallback,
+            interfaceScaleCompleteMs: this.interfaceScaleCompleteMs ?? fallback,
+            shellMountedMs: this.shellMountedMs ?? fallback,
+            shellFirstFrameMs: this.shellFirstFrameMs ?? fallback,
+            appModuleReadyMs: this.appModuleReadyMs ?? fallback,
+            serverConnectionCompleteMs: this.serverConnectionCompleteMs,
+            appMountedMs: this.appMountedMs ?? fallback,
+            appFirstFrameMs,
+            navigationDurationMs: entryTiming(
+                this.performanceSource.getEntriesByType('navigation'),
+                'navigation',
+                'duration',
+            ),
+            firstContentfulPaintMs: entryTiming(
+                this.performanceSource.getEntriesByType('paint'),
+                'first-contentful-paint',
+                'startTime',
+            ),
+        });
+    }
+}
+
+export const frontendStartup = new FrontendStartupRecorder(window.performance);
diff --git a/apps/axkdeck/src/main.ts b/apps/axkdeck/src/main.ts
index 6f5b5647..f293584d 100644
--- a/apps/axkdeck/src/main.ts
+++ b/apps/axkdeck/src/main.ts
@@ -1,23 +1,73 @@
 import './app.css';
-import { mount } from 'svelte';
-import App from './App.svelte';
-import AllocationInspector from './AllocationInspector.svelte';
 import { invoke } from '@tauri-apps/api/core';
+import { mount, unmount } from 'svelte';
+import StartupShell from './StartupShell.svelte';
 import { installDiagnostics, reportDiagnostic, reportError, reportInfo } from './lib/diagnostics';
 import { createInterfaceScaleController, type InterfaceScaleController } from './lib/interfaceScale';
+import { prepareServerConnection, prepareStartup } from './lib/startupCoordinator';
+import { frontendStartup, type StartupView } from './lib/startupDiagnostics';
 import { createTauriInterfaceScaleAdapter } from './lib/tauriInterfaceScale';
 
+type ServerConnection = NonNullable<Window['__AXKLIB_SERVER__']>;
+type AppModule = typeof import('./App.svelte');
+
 const target = document.getElementById('app');
+if (!target) throw new Error('Unable to find the application mount point.');
 
-if (!target) {
-    throw new Error('Unable to find the application mount point.');
+async function connectServer(restartLocal: boolean): Promise<ServerConnection | null> {
+    try {
+        const connection = await prepareServerConnection(
+            restartLocal,
+            () => invoke('use_local_server'),
+            async () => (await invoke<Window['__AXKLIB_SERVER__'] | null>('server_connection')) ?? null,
+        );
+        window.__AXKLIB_SERVER__ = connection ?? undefined;
+        frontendStartup.markServerConnectionComplete();
+        reportInfo(
+            connection ? `Connected to ${connection.mode} axklib-server.` : 'No axklib-server connection is available.',
+        );
+        return connection;
+    } catch (error) {
+        window.__AXKLIB_SERVER__ = undefined;
+        frontendStartup.markServerConnectionComplete();
+        reportError('axklib-server is unavailable', error);
+        return null;
+    }
 }
 
 async function bootstrap(mountTarget: HTMLElement): Promise<void> {
-    await installDiagnostics();
     const isDesktop = '__TAURI_INTERNALS__' in window;
     let interfaceScaling: InterfaceScaleController | null = null;
-    if (isDesktop) {
+    let warningOpen = true;
+    let shellStatus: 'starting' | 'unavailable' = 'starting';
+    let shellMessage = '';
+    let shell: ReturnType<typeof mount> | null = null;
+    const renderShell = () => {
+        shell = mount(StartupShell, {
+            target: mountTarget,
+            props: {
+                status: shellStatus,
+                message: shellMessage,
+                warningOpen,
+                onacknowledge: () => {
+                    warningOpen = false;
+                    void replaceShell();
+                },
+                onretry: () => void startWorkspace(false, true),
+                onopensettings: () => void startWorkspace(true),
+            },
+        });
+    };
+    const replaceShell = async () => {
+        if (shell) await unmount(shell);
+        renderShell();
+    };
+    renderShell();
+    frontendStartup.markShellMounted();
+    const shellFirstFrame = frontendStartup.waitForShellFirstFrame();
+    const diagnosticsReady = installDiagnostics().finally(() => frontendStartup.markDiagnosticsInstalled());
+    const interfaceScalingReady = (async () => {
+        if (!isDesktop) return;
         try {
             interfaceScaling = await createInterfaceScaleController(
                 createTauriInterfaceScaleAdapter(),
@@ -27,27 +77,78 @@ async function bootstrap(mountTarget: HTMLElement): Promise<void> {
         } catch (error) {
             reportDiagnostic('interface_scale_initialization_failed', { message: String(error) }, 'warn');
         }
-    }
-    if (isDesktop) {
+    })().finally(() => frontendStartup.markInterfaceScaleComplete());
+
+    const view: StartupView =
+        new URLSearchParams(window.location.search).get('view') === 'allocation' ? 'allocation' : 'workspace';
+    if (view === 'allocation') {
         try {
-            window.__AXKLIB_SERVER__ =
-                (await invoke<Window['__AXKLIB_SERVER__'] | null>('server_connection')) ?? undefined;
-            reportInfo(
-                window.__AXKLIB_SERVER__
-                    ? `Connected to ${window.__AXKLIB_SERVER__.mode} axklib-server.`
-                    : 'No axklib-server connection is available.',
+            const moduleReady = shellFirstFrame.then(() =>
+                import('./AllocationInspector.svelte').then((module) => {
+                    frontendStartup.markAppModuleReady();
+                    return module;
+                }),
             );
+            const [module] = await Promise.all([moduleReady, diagnosticsReady, interfaceScalingReady]);
+            if (shell) await unmount(shell);
+            mount(module.default, { target: mountTarget });
+            frontendStartup.markAppMounted();
         } catch (error) {
-            window.__AXKLIB_SERVER__ = undefined;
-            reportError('axklib-server is unavailable', error);
+            shellStatus = 'unavailable';
+            shellMessage = `The allocation inspector could not be loaded: ${String(error)}`;
+            await replaceShell();
         }
+        return;
     }
-    const view = new URLSearchParams(window.location.search).get('view');
-    if (view === 'allocation') {
-        mount(AllocationInspector, { target: mountTarget });
-    } else {
-        mount(App, { target: mountTarget, props: { interfaceScaling } });
+
+    async function startWorkspace(openSettings: boolean, restartLocal = false): Promise<void> {
+        const refreshShell = shellStatus !== 'starting' || shellMessage.length > 0;
+        shellStatus = 'starting';
+        shellMessage = '';
+        if (refreshShell) await replaceShell();
+        const connectionPromise = isDesktop ? connectServer(restartLocal) : Promise.resolve(null);
+        let prepared: { connection: ServerConnection | null; module: AppModule };
+        try {
+            const workspaceReady = prepareStartup(
+                connectionPromise,
+                () => shellFirstFrame,
+                () =>
+                    import('./App.svelte').then((module) => {
+                        frontendStartup.markAppModuleReady();
+                        return module;
+                    }),
+            );
+            [prepared] = await Promise.all([workspaceReady, diagnosticsReady, interfaceScalingReady]);
+        } catch (error) {
+            shellStatus = 'unavailable';
+            shellMessage = `The application workspace could not be loaded: ${String(error)}`;
+            await replaceShell();
+            return;
+        }
+        if (isDesktop && !prepared.connection && !openSettings) {
+            shellStatus = 'unavailable';
+            shellMessage = 'Check the local service or configure a remote axklib-server connection.';
+            await replaceShell();
+            return;
+        }
+        if (shell) await unmount(shell);
+        mount(prepared.module.default, {
+            target: mountTarget,
+            props: {
+                interfaceScaling,
+                initialExperimentalWarningOpen: warningOpen,
+                openConnectionSettingsOnStart: openSettings,
+            },
+        });
+        frontendStartup.markAppMounted();
+        if (isDesktop) {
+            void frontendStartup.reportAfterAppFirstFrame('workspace').catch((error) => {
+                reportDiagnostic('desktop_startup_report_failed', { message: String(error) }, 'warn');
+            });
+        }
     }
+
+    await startWorkspace(false);
 }
 
 void bootstrap(target);
diff --git a/apps/axkdeck/tools/check-startup-bundle.mjs b/apps/axkdeck/tools/check-startup-bundle.mjs
new file mode 100644
index 00000000..fe158471
--- /dev/null
+++ b/apps/axkdeck/tools/check-startup-bundle.mjs
@@ -0,0 +1,39 @@
+import { readFile, stat } from 'node:fs/promises';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import path from 'node:path';
+
+const MAXIMUM_STARTUP_BYTES = 150 * 1024;
+
+function localAssetPath(directory, asset) {
+    return path.join(directory, asset.replace(/^\//, ''));
+}
+
+export async function checkStartupBundle(directory) {
+    const indexPath = path.join(directory, 'index.html');
+    const html = await readFile(indexPath, 'utf8');
+    const entry = html.match(/<script[^>]+src="([^"]+)"/)?.[1];
+    if (!entry) throw new Error(`No JavaScript entry was found in ${indexPath}`);
+    const entryPath = localAssetPath(directory, entry);
+    const entryBytes = (await stat(entryPath)).size;
+    const preloads = [...html.matchAll(/<link[^>]+rel="modulepreload"[^>]+href="([^"]+)"/g)].map((match) => match[1]);
+    const preloadBytes = await Promise.all(
+        preloads.map(async (asset) => (await stat(localAssetPath(directory, asset))).size),
+    );
+    const startupBytes = entryBytes + preloadBytes.reduce((total, bytes) => total + bytes, 0);
+    if (startupBytes > MAXIMUM_STARTUP_BYTES) {
+        throw new Error(
+            `Startup JavaScript is ${startupBytes} bytes; the ${MAXIMUM_STARTUP_BYTES}-byte budget requires the workspace to remain dynamically loaded.`,
+        );
+    }
+    const source = await readFile(entryPath, 'utf8');
+    if (!source.includes('App-') || !source.includes('import(')) {
+        throw new Error('The generated startup entry does not dynamically load the workspace application.');
+    }
+    process.stdout.write(
+        `Startup bundle check passed: ${startupBytes} bytes (${path.basename(entryPath)} plus ${preloads.length} preload${preloads.length === 1 ? '' : 's'})\n`,
+    );
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
+    await checkStartupBundle(fileURLToPath(new URL('../dist', import.meta.url)));
+}
diff --git a/apps/server/CMakeLists.txt b/apps/server/CMakeLists.txt
index b62ce376..be3ed549 100644
--- a/apps/server/CMakeLists.txt
+++ b/apps/server/CMakeLists.txt
@@ -4,11 +4,12 @@ get_filename_component(AXK_REPOSITORY_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/../.." A
 
 find_package(Crow CONFIG REQUIRED)
 find_package(nlohmann_json CONFIG REQUIRED)
-find_package(nlohmann_json_schema_validator CONFIG REQUIRED)
 
 set(AXK_SERVER_OPENAPI_BASE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/contracts/openapi-v1.base.json")
 set(AXK_SERVER_OPENAPI_PATH "${CMAKE_CURRENT_SOURCE_DIR}/contracts/openapi-v1.json")
 set(AXK_SERVER_GENERATED_OPENAPI_PATH "${CMAKE_CURRENT_BINARY_DIR}/generated/openapi-v1.json")
+set(AXK_SERVER_GENERATED_VALIDATION_PLAN_PATH
+    "${CMAKE_CURRENT_BINARY_DIR}/generated/validation_plan.cpp")
 set_property(
   DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${AXK_SERVER_OPENAPI_BASE_PATH}"
                                       "${AXK_SERVER_OPENAPI_PATH}"
@@ -37,13 +38,40 @@ while(AXK_SERVER_OPENAPI_HEX_OFFSET LESS AXK_SERVER_OPENAPI_HEX_LENGTH)
 endwhile()
 configure_file(src/embedded_contract.cpp.in "${CMAKE_CURRENT_BINARY_DIR}/generated/embedded_contract.cpp" @ONLY)
 
-add_library(axk_server_contract STATIC src/contract.cpp)
+add_executable(axk_server_validation_plan_generator EXCLUDE_FROM_ALL src/validation_plan_generator.cpp)
+target_compile_features(axk_server_validation_plan_generator PRIVATE cxx_std_23)
+target_include_directories(axk_server_validation_plan_generator PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/src")
+target_link_libraries(axk_server_validation_plan_generator PRIVATE nlohmann_json::nlohmann_json)
+axk_set_project_warnings(axk_server_validation_plan_generator)
+axk_enable_sanitizers(axk_server_validation_plan_generator)
+axk_enable_coverage(axk_server_validation_plan_generator)
+add_custom_command(
+  OUTPUT "${AXK_SERVER_GENERATED_VALIDATION_PLAN_PATH}"
+  COMMAND "${CMAKE_COMMAND}" -E make_directory "${CMAKE_CURRENT_BINARY_DIR}/generated"
+  COMMAND "$<TARGET_FILE:axk_server_validation_plan_generator>" "${AXK_SERVER_OPENAPI_PATH}"
+          "${AXK_SERVER_GENERATED_VALIDATION_PLAN_PATH}"
+  DEPENDS axk_server_validation_plan_generator "${AXK_SERVER_OPENAPI_PATH}"
+          "${CMAKE_CURRENT_SOURCE_DIR}/src/validation_plan.hpp"
+  COMMENT "Compiling the axklib-server OpenAPI validation plan"
+  VERBATIM
+)
+
+add_library(
+  axk_server_contract
+  STATIC
+  src/contract.cpp
+  src/validation_plan.cpp
+  "${AXK_SERVER_GENERATED_VALIDATION_PLAN_PATH}"
+)
 target_compile_features(axk_server_contract PUBLIC cxx_std_23)
-target_include_directories(axk_server_contract PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include")
+target_include_directories(
+  axk_server_contract
+  PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include"
+  PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/src"
+)
 target_link_libraries(
   axk_server_contract
   PUBLIC axklib::application nlohmann_json::nlohmann_json
-  PRIVATE nlohmann_json_schema_validator::validator
 )
 axk_set_project_warnings(axk_server_contract)
 axk_enable_sanitizers(axk_server_contract)
@@ -189,12 +217,14 @@ if(BUILD_TESTING)
   endfunction()
 
   find_package(GTest CONFIG REQUIRED)
+  find_package(nlohmann_json_schema_validator CONFIG REQUIRED)
   find_package(Python3 COMPONENTS Interpreter REQUIRED)
   include(GoogleTest)
   add_executable(
     axk_server_tests
     tests/archive_download_budget_test.cpp
     tests/config_test.cpp
+    tests/contract_test_support.cpp
     tests/download_reader_test.cpp
     tests/event_delivery_budget_test.cpp
     tests/event_dispatcher_test.cpp
@@ -212,7 +242,7 @@ if(BUILD_TESTING)
   target_compile_definitions(axk_server_tests PRIVATE AXK_SOURCE_ROOT="${AXK_REPOSITORY_ROOT}")
   target_link_libraries(
     axk_server_tests
-    PRIVATE axk_server_adapter GTest::gtest_main
+    PRIVATE axk_server_adapter GTest::gtest_main nlohmann_json_schema_validator::validator
   )
   target_include_directories(axk_server_tests PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/src")
   axk_set_project_warnings(axk_server_tests)
@@ -279,7 +309,7 @@ endif()
 install(TARGETS axklib_server RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" COMPONENT server)
 install(FILES "${AXK_REPOSITORY_ROOT}/LICENSE"
         DESTINATION "${CMAKE_INSTALL_DATADIR}/licenses/axklib" COMPONENT server)
-foreach(package crow asio json-schema-validator hash-library openssl nlohmann-json libsndfile soxr utfcpp
+foreach(package crow asio hash-library openssl nlohmann-json libsndfile soxr utfcpp
                 libflac libogg libvorbis opus fatfs)
   install(
     FILES "${VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}/share/${package}/copyright"
diff --git a/apps/server/include/axklib/server/contract.hpp b/apps/server/include/axklib/server/contract.hpp
index 90009569..ce192ca5 100644
--- a/apps/server/include/axklib/server/contract.hpp
+++ b/apps/server/include/axklib/server/contract.hpp
@@ -1,6 +1,5 @@
 #pragma once
 
-#include <memory>
 #include <string>
 #include <string_view>
 
@@ -12,30 +11,15 @@ namespace axk::server {
 
 class OpenApiValidator {
   public:
-    explicit OpenApiValidator(nlohmann::json document);
-    ~OpenApiValidator();
-
-    OpenApiValidator(const OpenApiValidator &) = delete;
-    OpenApiValidator &operator=(const OpenApiValidator &) = delete;
-    OpenApiValidator(OpenApiValidator &&) noexcept;
-    OpenApiValidator &operator=(OpenApiValidator &&) noexcept;
+    OpenApiValidator() = default;
 
     [[nodiscard]] app::Result<void> validate(std::string_view schema_name, const nlohmann::json &value) const;
     [[nodiscard]] nlohmann::json application_value(std::string_view schema_name,
                                                    const nlohmann::json &wire_value) const;
     [[nodiscard]] nlohmann::json wire_value(std::string_view schema_name,
                                             const nlohmann::json &application_value) const;
-
-  private:
-    struct Impl;
-    std::unique_ptr<Impl> impl_;
 };
 
 [[nodiscard]] nlohmann::json build_openapi_document(std::string_view base_document,
                                                     const app::OperationRegistry &registry);
-[[nodiscard]] app::Result<void> validate_openapi_value(const nlohmann::json &document, std::string_view schema_name,
-                                                       const nlohmann::json &value);
-[[nodiscard]] app::Result<void> validate_openapi_schema(const nlohmann::json &document, const nlohmann::json &schema,
-                                                        const nlohmann::json &value);
-
 } // namespace axk::server
diff --git a/apps/server/src/contract.cpp b/apps/server/src/contract.cpp
index 1c18f67a..5c9b9126 100644
--- a/apps/server/src/contract.cpp
+++ b/apps/server/src/contract.cpp
@@ -3,14 +3,13 @@
 #include <algorithm>
 #include <cctype>
 #include <map>
-#include <memory>
 #include <ranges>
 #include <stdexcept>
 #include <string>
 #include <string_view>
 #include <vector>
 
-#include <nlohmann/json-schema.hpp>
+#include "validation_plan.hpp"
 
 namespace {
 
@@ -155,68 +154,6 @@ Json schema_example(const Json &document, const Json &schema, std::size_t depth
     return result;
 }
 
-Json validation_root(const Json &document, const Json &schema) {
-    auto root = schema;
-    root["$schema"] = "http://json-schema.org/draft-07/schema#";
-    root["components"] = document.at("components");
-    return root;
-}
-
-axk::app::Result<void> validate_value(const Json &document, const Json &schema, const Json &value) {
-    try {
-        nlohmann::json_schema::json_validator validator;
-        validator.set_root_schema(validation_root(document, schema));
-        static_cast<void>(validator.validate(value));
-    } catch (const std::exception &) {
-        return std::unexpected(
-            axk::app::Error{"invalid_request", "request body does not match the declared OpenAPI schema"});
-    }
-    return {};
-}
-
-Json translate_value(const Json &document, const Json &schema, const Json &value, bool to_application) {
-    const auto &resolved = resolve_schema_reference(document, schema);
-    if (const auto mapping = resolved.find("x-axklib-application-enum");
-        mapping != resolved.end() && mapping->is_object() && value.is_string()) {
-        const auto text = value.get<std::string>();
-        if (to_application) {
-            if (const auto found = mapping->find(text); found != mapping->end() && found->is_string())
-                return *found;
-        } else {
-            for (const auto &[wire, application] : mapping->items()) {
-                if (application.is_string() && application.get_ref<const std::string &>() == text)
-                    return wire;
-            }
-        }
-        return value;
-    }
-
-    auto result = value;
-    for (const auto keyword : {"allOf", "oneOf", "anyOf"}) {
-        const auto variants = resolved.find(keyword);
-        if (variants == resolved.end() || !variants->is_array())
-            continue;
-        for (const auto &variant : *variants)
-            result = translate_value(document, variant, result, to_application);
-    }
-    if (result.is_object()) {
-        const auto properties = resolved.find("properties");
-        if (properties != resolved.end() && properties->is_object()) {
-            for (const auto &[name, property_schema] : properties->items()) {
-                if (result.contains(name))
-                    result[name] = translate_value(document, property_schema, result.at(name), to_application);
-            }
-        }
-    } else if (result.is_array()) {
-        const auto items = resolved.find("items");
-        if (items != resolved.end()) {
-            for (auto &item : result)
-                item = translate_value(document, *items, item, to_application);
-        }
-    }
-    return result;
-}
-
 void require_schema(const Json &document, std::string_view name) {
     auto &schemas = document["components"]["schemas"];
     if (!schemas.contains(name))
@@ -358,49 +295,33 @@ void add_infrastructure_error_responses(Json &document) {
 
 } // namespace
 
-struct axk::server::OpenApiValidator::Impl {
-    explicit Impl(Json value) : document(std::move(value)) {
-        for (const auto &[name, schema] : document.at("components").at("schemas").items()) {
-            auto validator = std::make_unique<nlohmann::json_schema::json_validator>();
-            validator->set_root_schema(validation_root(document, schema));
-            validators.emplace(name, std::move(validator));
-        }
-    }
-
-    Json document;
-    std::map<std::string, std::unique_ptr<nlohmann::json_schema::json_validator>, std::less<>> validators;
-};
-
-axk::server::OpenApiValidator::OpenApiValidator(nlohmann::json document)
-    : impl_(std::make_unique<Impl>(std::move(document))) {}
-
-axk::server::OpenApiValidator::~OpenApiValidator() = default;
-axk::server::OpenApiValidator::OpenApiValidator(OpenApiValidator &&) noexcept = default;
-axk::server::OpenApiValidator &axk::server::OpenApiValidator::operator=(OpenApiValidator &&) noexcept = default;
-
 axk::app::Result<void> axk::server::OpenApiValidator::validate(std::string_view schema_name,
                                                                const nlohmann::json &value) const {
-    const auto found = impl_->validators.find(schema_name);
-    if (found == impl_->validators.end())
+    const auto &plan = detail::generated_validation_plan();
+    const auto *schema = detail::find_schema(plan, schema_name);
+    if (schema == nullptr)
         return std::unexpected(app::Error{"contract_error", "OpenAPI schema is not available"});
-    try {
-        static_cast<void>(found->second->validate(value));
-    } catch (const std::exception &) {
+    if (!detail::validate(plan, *schema, value))
         return std::unexpected(app::Error{"invalid_request", "request body does not match its declared schema"});
-    }
     return {};
 }
 
 nlohmann::json axk::server::OpenApiValidator::application_value(std::string_view schema_name,
                                                                 const nlohmann::json &wire_value) const {
-    const auto &schema = impl_->document.at("components").at("schemas").at(schema_name);
-    return translate_value(impl_->document, schema, wire_value, true);
+    const auto &plan = detail::generated_validation_plan();
+    const auto *schema = detail::find_schema(plan, schema_name);
+    if (schema == nullptr)
+        throw std::out_of_range{"OpenAPI schema is not available"};
+    return detail::translate(plan, *schema, wire_value, true);
 }
 
 nlohmann::json axk::server::OpenApiValidator::wire_value(std::string_view schema_name,
                                                          const nlohmann::json &application_value) const {
-    const auto &schema = impl_->document.at("components").at("schemas").at(schema_name);
-    return translate_value(impl_->document, schema, application_value, false);
+    const auto &plan = detail::generated_validation_plan();
+    const auto *schema = detail::find_schema(plan, schema_name);
+    if (schema == nullptr)
+        throw std::out_of_range{"OpenAPI schema is not available"};
+    return detail::translate(plan, *schema, application_value, false);
 }
 
 nlohmann::json axk::server::build_openapi_document(std::string_view base_document,
@@ -472,17 +393,3 @@ nlohmann::json axk::server::build_openapi_document(std::string_view base_documen
     add_request_id_headers(document);
     return document;
 }
-
-axk::app::Result<void> axk::server::validate_openapi_value(const nlohmann::json &document, std::string_view schema_name,
-                                                           const nlohmann::json &value) {
-    try {
-        return validate_value(document, schema_reference(schema_name), value);
-    } catch (const std::exception &) {
-        return std::unexpected(app::Error{"contract_error", "OpenAPI schema is not available"});
-    }
-}
-
-axk::app::Result<void> axk::server::validate_openapi_schema(const nlohmann::json &document,
-                                                            const nlohmann::json &schema, const nlohmann::json &value) {
-    return validate_value(document, schema, value);
-}
diff --git a/apps/server/src/server_lifecycle.cpp b/apps/server/src/server_lifecycle.cpp
index 1b904ded..c723c55b 100644
--- a/apps/server/src/server_lifecycle.cpp
+++ b/apps/server/src/server_lifecycle.cpp
@@ -244,12 +244,11 @@ ServerApplication::ServerApplication(axk::server::Config config, axk::app::Opera
                                  {config_.maximum_media_build_object_bytes, config_.maximum_media_build_payload_bytes,
                                   config_.maximum_media_build_output_bytes})),
       openapi_document_(axk::server::build_openapi_document(axk::server::embedded_openapi(), registry_)),
-      openapi_validator_(openapi_document_),
-      jobs_(
-          registry_, config_.job_worker_threads, config_.write_job_worker_threads, config_.maximum_queued_jobs,
-          config_.replay_events_per_job, config_.maximum_retained_jobs,
-          std::chrono::seconds{config_.job_retention_seconds}, [] { return axk::app::JobManager::Clock::now(); },
-          &uploads_, &path_reservations_),
+      openapi_validator_(), jobs_(
+                                registry_, config_.job_worker_threads, config_.write_job_worker_threads,
+                                config_.maximum_queued_jobs, config_.replay_events_per_job,
+                                config_.maximum_retained_jobs, std::chrono::seconds{config_.job_retention_seconds},
+                                [] { return axk::app::JobManager::Clock::now(); }, &uploads_, &path_reservations_),
       event_tickets_(std::chrono::seconds{config_.event_ticket_ttl_seconds}, config_.maximum_event_tickets),
       event_dispatcher_(config_.maximum_websocket_delivery_events,
                         [this](const axk::app::JobEvent &event) { broadcast(event); }) {
diff --git a/apps/server/src/validation_plan.cpp b/apps/server/src/validation_plan.cpp
new file mode 100644
index 00000000..d8e247e9
--- /dev/null
+++ b/apps/server/src/validation_plan.cpp
@@ -0,0 +1,252 @@
+#include "validation_plan.hpp"
+
+#include <algorithm>
+#include <cctype>
+#include <iterator>
+#include <limits>
+#include <ranges>
+
+namespace axk::server::detail {
+namespace {
+
+constexpr bool has_type(const SchemaNode &schema, JsonType type) {
+    return (schema.types & static_cast<std::uint8_t>(type)) != 0U;
+}
+
+const SchemaNode &resolved(const ValidationPlan &plan, const SchemaNode &schema) {
+    const SchemaNode *current = &schema;
+    for (std::size_t depth = 0U; depth < 64U && current->reference != no_schema; ++depth)
+        current = &plan.nodes[current->reference];
+    return *current;
+}
+
+bool ascii_range(std::string_view value, unsigned char low, unsigned char high) {
+    return std::ranges::all_of(value, [=](unsigned char character) { return character >= low && character <= high; });
+}
+
+bool digits_01_16(std::string_view value) {
+    return value.size() == 2U && ((value[0] == '0' && value[1] >= '1' && value[1] <= '9') ||
+                                  (value[0] == '1' && value[1] >= '0' && value[1] <= '6'));
+}
+
+std::size_t utf8_length(std::string_view value) {
+    return static_cast<std::size_t>(
+        std::ranges::count_if(value, [](unsigned char character) { return (character & 0xc0U) != 0x80U; }));
+}
+
+bool matches_pattern(Pattern pattern, std::string_view value) {
+    switch (pattern) {
+    case Pattern::none:
+        return true;
+    case Pattern::lowercase_sha256:
+        return value.size() == 64U && std::ranges::all_of(value, [](unsigned char character) {
+                   return std::isdigit(character) != 0 || (character >= 'a' && character <= 'f');
+               });
+    case Pattern::sampler_name:
+        return (value.size() == 1U && ascii_range(value, '!', '~')) ||
+               (value.size() >= 2U && value.size() <= 8U &&
+                static_cast<unsigned char>(value.front()) >= static_cast<unsigned char>('!') &&
+                static_cast<unsigned char>(value.front()) <= static_cast<unsigned char>('~') &&
+                static_cast<unsigned char>(value.back()) >= static_cast<unsigned char>('!') &&
+                static_cast<unsigned char>(value.back()) <= static_cast<unsigned char>('~') &&
+                ascii_range(value, ' ', '~'));
+    case Pattern::printable_text:
+        return !value.empty() && ascii_range(value, ' ', '~');
+    case Pattern::media_extension:
+        return value == ".iso" || value == ".ima" || value == ".zip";
+    case Pattern::package_extension:
+        return value.size() > 4U && value.starts_with(".axk") &&
+               std::ranges::all_of(value.substr(4U),
+                                   [](unsigned char character) { return std::islower(character) != 0; });
+    case Pattern::identifier:
+        return !value.empty() && std::ranges::all_of(value, [](unsigned char character) {
+            return std::isalnum(character) != 0 || character == '_' || character == '.' || character == '-';
+        });
+    case Pattern::midi_manufacturer_id: {
+        const auto hexadecimal = [](unsigned char character) {
+            return std::isdigit(character) != 0 || (character >= 'A' && character <= 'F');
+        };
+        return (value.size() == 2U && std::ranges::all_of(value, hexadecimal)) ||
+               (value.size() == 8U && value.starts_with("00-") && value[5] == '-' &&
+                hexadecimal(static_cast<unsigned char>(value[3])) &&
+                hexadecimal(static_cast<unsigned char>(value[4])) &&
+                hexadecimal(static_cast<unsigned char>(value[6])) && hexadecimal(static_cast<unsigned char>(value[7])));
+    }
+    case Pattern::receive_channel:
+        return digits_01_16(value) ||
+               (value.size() == 3U && (value.front() == 'A' || value.front() == 'B') && digits_01_16(value.substr(1U)));
+    case Pattern::api_path:
+        return value.starts_with("/api/v1/");
+    case Pattern::archive_content_path: {
+        constexpr std::string_view prefix{"/api/v1/download-archives/"};
+        constexpr std::string_view suffix{"/content"};
+        if (!value.starts_with(prefix) || !value.ends_with(suffix))
+            return false;
+        const auto identifier = value.substr(prefix.size(), value.size() - prefix.size() - suffix.size());
+        return !identifier.empty() &&
+               std::ranges::all_of(identifier, [](unsigned char character) { return std::isalnum(character) != 0; });
+    }
+    }
+    return false;
+}
+
+bool matches_literal(const Literal &literal, const nlohmann::json &value) {
+    switch (literal.kind) {
+    case LiteralKind::null:
+        return value.is_null();
+    case LiteralKind::boolean:
+        return value.is_boolean() && value.get<bool>() == literal.boolean;
+    case LiteralKind::integer:
+        if (value.is_number_unsigned()) {
+            return literal.integer >= 0 && value.get<std::uint64_t>() == static_cast<std::uint64_t>(literal.integer);
+        }
+        return value.is_number_integer() && value.get<std::int64_t>() == literal.integer;
+    case LiteralKind::string:
+        return value.is_string() && value.get_ref<const std::string &>() == literal.text;
+    }
+    return false;
+}
+
+bool matches_type(const SchemaNode &schema, const nlohmann::json &value) {
+    if (schema.types == 0U)
+        return true;
+    return (has_type(schema, JsonType::null) && value.is_null()) ||
+           (has_type(schema, JsonType::boolean) && value.is_boolean()) ||
+           (has_type(schema, JsonType::integer) && (value.is_number_integer() || value.is_number_unsigned())) ||
+           (has_type(schema, JsonType::number) && value.is_number()) ||
+           (has_type(schema, JsonType::string) && value.is_string()) ||
+           (has_type(schema, JsonType::array) && value.is_array()) ||
+           (has_type(schema, JsonType::object) && value.is_object());
+}
+
+bool validate_node(const ValidationPlan &plan, const SchemaNode &input_schema, const nlohmann::json &value,
+                   std::size_t depth) {
+    if (depth > 128U)
+        return false;
+    const auto &schema = resolved(plan, input_schema);
+    if (!matches_type(schema, value))
+        return false;
+    if (schema.literals_count != 0U) {
+        const auto literals = plan.literals.subspan(schema.literals_begin, schema.literals_count);
+        if (std::ranges::none_of(literals, [&](const Literal &literal) { return matches_literal(literal, value); }))
+            return false;
+    }
+    if (schema.variants_count != 0U) {
+        const auto variants = plan.variants.subspan(schema.variants_begin, schema.variants_count);
+        const auto matches = std::ranges::count_if(variants, [&](std::uint32_t variant) {
+            return validate_node(plan, plan.nodes[variant], value, depth + 1U);
+        });
+        if (matches != 1)
+            return false;
+    }
+    if (value.is_string()) {
+        const auto &text = value.get_ref<const std::string &>();
+        const auto length = utf8_length(text);
+        if ((schema.has_minimum_length && length < schema.minimum_length) ||
+            (schema.has_maximum_length && length > schema.maximum_length) || !matches_pattern(schema.pattern, text))
+            return false;
+    }
+    if (value.is_number_unsigned()) {
+        const auto number = value.get<std::uint64_t>();
+        const auto below_minimum =
+            schema.has_minimum && schema.minimum >= 0 && number < static_cast<std::uint64_t>(schema.minimum);
+        const auto above_maximum =
+            schema.has_maximum && (schema.maximum < 0 || number > static_cast<std::uint64_t>(schema.maximum));
+        if (below_minimum || above_maximum)
+            return false;
+    } else if (value.is_number_integer()) {
+        const auto number = value.get<std::int64_t>();
+        if ((schema.has_minimum && number < schema.minimum) || (schema.has_maximum && number > schema.maximum))
+            return false;
+    } else if (value.is_number_float()) {
+        const auto number = value.get<double>();
+        if ((schema.has_minimum && number < static_cast<double>(schema.minimum)) ||
+            (schema.has_maximum && number > static_cast<double>(schema.maximum)))
+            return false;
+    }
+    if (value.is_array()) {
+        if ((schema.has_minimum_items && value.size() < schema.minimum_items) ||
+            (schema.has_maximum_items && value.size() > schema.maximum_items))
+            return false;
+        if (schema.unique_items) {
+            for (auto left = value.begin(); left != value.end(); ++left)
+                if (std::find(std::next(left), value.end(), *left) != value.end())
+                    return false;
+        }
+        if (schema.items != no_schema && std::ranges::any_of(value, [&](const auto &item) {
+                return !validate_node(plan, plan.nodes[schema.items], item, depth + 1U);
+            }))
+            return false;
+    }
+    if (value.is_object()) {
+        if (schema.has_maximum_properties && value.size() > schema.maximum_properties)
+            return false;
+        const auto properties = plan.properties.subspan(schema.properties_begin, schema.properties_count);
+        for (const auto &property : properties) {
+            const auto found = value.find(property.name);
+            if (found == value.end()) {
+                if (property.required)
+                    return false;
+            } else if (property.schema != no_schema &&
+                       !validate_node(plan, plan.nodes[property.schema], *found, depth + 1U)) {
+                return false;
+            }
+        }
+        for (const auto &[name, child] : value.items()) {
+            if (std::ranges::any_of(properties, [&](const Property &property) { return property.name == name; }))
+                continue;
+            if (!schema.additional_properties_allowed ||
+                (schema.additional_properties != no_schema &&
+                 !validate_node(plan, plan.nodes[schema.additional_properties], child, depth + 1U)))
+                return false;
+        }
+    }
+    return true;
+}
+
+nlohmann::json translate_node(const ValidationPlan &plan, const SchemaNode &input_schema, const nlohmann::json &value,
+                              bool to_application, std::size_t depth) {
+    if (depth > 128U)
+        return value;
+    const auto &schema = resolved(plan, input_schema);
+    if (value.is_string() && schema.mappings_count != 0U) {
+        const auto mappings = plan.mappings.subspan(schema.mappings_begin, schema.mappings_count);
+        const auto text = value.get_ref<const std::string &>();
+        const auto found = std::ranges::find_if(mappings, [&](const EnumMapping &mapping) {
+            return (to_application ? mapping.wire : mapping.application) == text;
+        });
+        return found == mappings.end() ? value
+                                       : nlohmann::json(std::string{to_application ? found->application : found->wire});
+    }
+    auto result = value;
+    for (const auto variant : plan.variants.subspan(schema.variants_begin, schema.variants_count))
+        result = translate_node(plan, plan.nodes[variant], result, to_application, depth + 1U);
+    if (result.is_object()) {
+        for (const auto &property : plan.properties.subspan(schema.properties_begin, schema.properties_count))
+            if (property.schema != no_schema && result.contains(property.name))
+                result[property.name] = translate_node(plan, plan.nodes[property.schema], result.at(property.name),
+                                                       to_application, depth + 1U);
+    } else if (result.is_array() && schema.items != no_schema) {
+        for (auto &item : result)
+            item = translate_node(plan, plan.nodes[schema.items], item, to_application, depth + 1U);
+    }
+    return result;
+}
+
+} // namespace
+
+const SchemaNode *find_schema(const ValidationPlan &plan, std::string_view name) {
+    const auto found = std::ranges::lower_bound(plan.schemas, name, {}, &NamedSchema::name);
+    return found != plan.schemas.end() && found->name == name ? &plan.nodes[found->schema] : nullptr;
+}
+
+bool validate(const ValidationPlan &plan, const SchemaNode &schema, const nlohmann::json &value) {
+    return validate_node(plan, schema, value, 0U);
+}
+
+nlohmann::json translate(const ValidationPlan &plan, const SchemaNode &schema, const nlohmann::json &value,
+                         bool to_application) {
+    return translate_node(plan, schema, value, to_application, 0U);
+}
+
+} // namespace axk::server::detail
diff --git a/apps/server/src/validation_plan.hpp b/apps/server/src/validation_plan.hpp
new file mode 100644
index 00000000..46517fa8
--- /dev/null
+++ b/apps/server/src/validation_plan.hpp
@@ -0,0 +1,110 @@
+#pragma once
+
+#include <cstdint>
+#include <limits>
+#include <span>
+#include <string_view>
+
+#include <nlohmann/json.hpp>
+
+namespace axk::server::detail {
+
+constexpr std::uint32_t no_schema = std::numeric_limits<std::uint32_t>::max();
+
+enum class JsonType : std::uint8_t {
+    null = 1U << 0U,
+    boolean = 1U << 1U,
+    integer = 1U << 2U,
+    number = 1U << 3U,
+    string = 1U << 4U,
+    array = 1U << 5U,
+    object = 1U << 6U,
+};
+
+enum class Pattern : std::uint8_t {
+    none,
+    lowercase_sha256,
+    sampler_name,
+    printable_text,
+    media_extension,
+    package_extension,
+    identifier,
+    midi_manufacturer_id,
+    receive_channel,
+    api_path,
+    archive_content_path,
+};
+
+enum class LiteralKind : std::uint8_t { null, boolean, integer, string };
+
+struct Literal {
+    LiteralKind kind;
+    std::string_view text;
+    std::int64_t integer;
+    bool boolean;
+};
+
+struct Property {
+    std::string_view name;
+    std::uint32_t schema;
+    bool required;
+};
+
+struct EnumMapping {
+    std::string_view wire;
+    std::string_view application;
+};
+
+struct SchemaNode {
+    std::uint8_t types;
+    Pattern pattern;
+    std::uint32_t reference;
+    std::uint32_t items;
+    std::uint32_t additional_properties;
+    std::uint32_t properties_begin;
+    std::uint32_t properties_count;
+    std::uint32_t variants_begin;
+    std::uint32_t variants_count;
+    std::uint32_t literals_begin;
+    std::uint32_t literals_count;
+    std::uint32_t mappings_begin;
+    std::uint32_t mappings_count;
+    std::uint64_t minimum_length;
+    std::uint64_t maximum_length;
+    std::uint64_t minimum_items;
+    std::uint64_t maximum_items;
+    std::uint64_t maximum_properties;
+    std::int64_t minimum;
+    std::int64_t maximum;
+    bool additional_properties_allowed;
+    bool unique_items;
+    bool has_minimum_length;
+    bool has_maximum_length;
+    bool has_minimum_items;
+    bool has_maximum_items;
+    bool has_maximum_properties;
+    bool has_minimum;
+    bool has_maximum;
+};
+
+struct NamedSchema {
+    std::string_view name;
+    std::uint32_t schema;
+};
+
+struct ValidationPlan {
+    std::span<const SchemaNode> nodes;
+    std::span<const Property> properties;
+    std::span<const std::uint32_t> variants;
+    std::span<const Literal> literals;
+    std::span<const EnumMapping> mappings;
+    std::span<const NamedSchema> schemas;
+};
+
+[[nodiscard]] const ValidationPlan &generated_validation_plan();
+[[nodiscard]] const SchemaNode *find_schema(const ValidationPlan &plan, std::string_view name);
+[[nodiscard]] bool validate(const ValidationPlan &plan, const SchemaNode &schema, const nlohmann::json &value);
+[[nodiscard]] nlohmann::json translate(const ValidationPlan &plan, const SchemaNode &schema,
+                                       const nlohmann::json &value, bool to_application);
+
+} // namespace axk::server::detail
diff --git a/apps/server/src/validation_plan_generator.cpp b/apps/server/src/validation_plan_generator.cpp
new file mode 100644
index 00000000..c3b39dec
--- /dev/null
+++ b/apps/server/src/validation_plan_generator.cpp
@@ -0,0 +1,387 @@
+#include <algorithm>
+#include <cstdint>
+#include <deque>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <iterator>
+#include <map>
+#include <ranges>
+#include <set>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include <nlohmann/json.hpp>
+
+#include "validation_plan.hpp"
+
+namespace {
+
+using Json = nlohmann::json;
+using axk::server::detail::EnumMapping;
+using axk::server::detail::Literal;
+using axk::server::detail::LiteralKind;
+using axk::server::detail::NamedSchema;
+using axk::server::detail::Pattern;
+using axk::server::detail::Property;
+using axk::server::detail::SchemaNode;
+constexpr auto no_schema = axk::server::detail::no_schema;
+constexpr std::string_view reference_prefix{"#/components/schemas/"};
+
+std::string quote(std::string_view value) { return Json(std::string{value}).dump(); }
+
+std::string pattern_name(std::string_view value) {
+    static const std::map<std::string_view, std::string_view> patterns{
+        {"", "none"},
+        {"^[0-9a-f]{64}$", "lowercase_sha256"},
+        {"^(?:[!-~]|[!-~][ -~]{0,6}[!-~])$", "sampler_name"},
+        {"^[ -~]+$", "printable_text"},
+        {"^\\.(iso|ima|zip)$", "media_extension"},
+        {"^\\.axk[a-z]+$", "package_extension"},
+        {"^[A-Za-z0-9_.-]+$", "identifier"},
+        {"^(?:[0-9A-F]{2}|00-[0-9A-F]{2}-[0-9A-F]{2})$", "midi_manufacturer_id"},
+        {"^(A|B)?(0[1-9]|1[0-6])$", "receive_channel"},
+        {"^/api/v1/", "api_path"},
+        {"^/api/v1/download-archives/[A-Za-z0-9]+/content$", "archive_content_path"},
+    };
+    const auto found = patterns.find(value);
+    if (found == patterns.end())
+        throw std::runtime_error{"unsupported OpenAPI pattern: " + std::string{value}};
+    return "Pattern::" + std::string{found->second};
+}
+
+std::uint8_t type_bit(std::string_view type) {
+    static const std::map<std::string_view, std::uint8_t> types{
+        {"null", 1U << 0U},   {"boolean", 1U << 1U}, {"integer", 1U << 2U}, {"number", 1U << 3U},
+        {"string", 1U << 4U}, {"array", 1U << 5U},   {"object", 1U << 6U},
+    };
+    const auto found = types.find(type);
+    if (found == types.end())
+        throw std::runtime_error{"unsupported OpenAPI type: " + std::string{type}};
+    return found->second;
+}
+
+struct Compiler {
+    explicit Compiler(const Json &document) : document(document) {
+        for (const auto &[name, schema] : document.at("components").at("schemas").items()) {
+            static_cast<void>(schema);
+            names.emplace(name, static_cast<std::uint32_t>(nodes.size()));
+            named.push_back({intern(name), static_cast<std::uint32_t>(nodes.size())});
+            nodes.emplace_back();
+        }
+        for (const auto &[name, schema] : document.at("components").at("schemas").items())
+            compile_at(names.at(name), schema, name);
+        std::ranges::sort(named, {}, &NamedSchema::name);
+    }
+
+    std::uint32_t compile(const Json &schema, std::string_view path) {
+        const auto index = static_cast<std::uint32_t>(nodes.size());
+        nodes.emplace_back();
+        compile_at(index, schema, path);
+        return index;
+    }
+
+    void compile_at(std::uint32_t index, const Json &schema, std::string_view path) {
+        if (!schema.is_object())
+            throw std::runtime_error{"schema is not an object at " + std::string{path}};
+        static const std::set<std::string_view> supported{
+            "$ref",
+            "type",
+            "properties",
+            "required",
+            "additionalProperties",
+            "items",
+            "enum",
+            "const",
+            "minimum",
+            "maximum",
+            "minLength",
+            "maxLength",
+            "minItems",
+            "maxItems",
+            "maxProperties",
+            "uniqueItems",
+            "oneOf",
+            "pattern",
+            "default",
+            "description",
+            "example",
+            "x-axklib-application-enum",
+        };
+        for (const auto &[keyword, value] : schema.items()) {
+            static_cast<void>(value);
+            if (!supported.contains(keyword))
+                throw std::runtime_error{"unsupported OpenAPI schema keyword at " + std::string{path} + ": " + keyword};
+        }
+
+        SchemaNode node{};
+        node.reference = no_schema;
+        node.items = no_schema;
+        node.additional_properties = no_schema;
+        node.additional_properties_allowed = true;
+        if (const auto reference = schema.find("$ref"); reference != schema.end()) {
+            if (!reference->is_string() || !reference->get_ref<const std::string &>().starts_with(reference_prefix))
+                throw std::runtime_error{"unsupported OpenAPI reference at " + std::string{path}};
+            node.reference = compile_reference(reference->get_ref<const std::string &>());
+            nodes[index] = node;
+            return;
+        }
+        if (const auto type = schema.find("type"); type != schema.end()) {
+            if (type->is_string()) {
+                node.types = type_bit(type->get_ref<const std::string &>());
+            } else if (type->is_array()) {
+                for (const auto &candidate : *type) {
+                    if (!candidate.is_string())
+                        throw std::runtime_error{"non-string OpenAPI type at " + std::string{path}};
+                    node.types |= type_bit(candidate.get_ref<const std::string &>());
+                }
+            } else {
+                throw std::runtime_error{"invalid OpenAPI type at " + std::string{path}};
+            }
+        }
+        node.pattern = pattern_from(schema.value("pattern", std::string{}));
+        if (const auto items = schema.find("items"); items != schema.end())
+            node.items = compile(*items, std::string{path} + "[]");
+
+        std::set<std::string> required;
+        if (const auto values = schema.find("required"); values != schema.end()) {
+            if (!values->is_array())
+                throw std::runtime_error{"required is not an array at " + std::string{path}};
+            for (const auto &value : *values)
+                required.insert(value.get<std::string>());
+        }
+        std::vector<Property> local_properties;
+        if (const auto values = schema.find("properties"); values != schema.end()) {
+            if (!values->is_object())
+                throw std::runtime_error{"properties is not an object at " + std::string{path}};
+            for (const auto &[name, child] : values->items())
+                local_properties.push_back(
+                    {intern(name), compile(child, std::string{path} + '/' + name), required.contains(name)});
+        }
+        for (const auto &name : required)
+            if (std::ranges::none_of(local_properties, [&](const Property &property) { return property.name == name; }))
+                local_properties.push_back({intern(name), no_schema, true});
+        node.properties_begin = append(properties, local_properties);
+        node.properties_count = static_cast<std::uint32_t>(local_properties.size());
+
+        if (const auto additional = schema.find("additionalProperties"); additional != schema.end()) {
+            if (additional->is_boolean()) {
+                node.additional_properties_allowed = additional->get<bool>();
+            } else if (additional->is_object()) {
+                node.additional_properties = compile(*additional, std::string{path} + "/additionalProperties");
+            } else {
+                throw std::runtime_error{"invalid additionalProperties at " + std::string{path}};
+            }
+        }
+        std::vector<std::uint32_t> local_variants;
+        if (const auto values = schema.find("oneOf"); values != schema.end()) {
+            if (!values->is_array())
+                throw std::runtime_error{"oneOf is not an array at " + std::string{path}};
+            for (std::size_t variant = 0U; variant < values->size(); ++variant)
+                local_variants.push_back(compile(values->at(variant), std::string{path} + "/oneOf"));
+        }
+        node.variants_begin = append(variants, local_variants);
+        node.variants_count = static_cast<std::uint32_t>(local_variants.size());
+
+        std::vector<Literal> local_literals;
+        if (const auto enumeration = schema.find("enum"); enumeration != schema.end()) {
+            if (!enumeration->is_array())
+                throw std::runtime_error{"enum is not an array at " + std::string{path}};
+            for (const auto &value : *enumeration)
+                local_literals.push_back(literal(value, path));
+        }
+        if (const auto constant = schema.find("const"); constant != schema.end())
+            local_literals.push_back(literal(*constant, path));
+        node.literals_begin = append(literals, local_literals);
+        node.literals_count = static_cast<std::uint32_t>(local_literals.size());
+
+        std::vector<EnumMapping> local_mappings;
+        if (const auto mapping = schema.find("x-axklib-application-enum"); mapping != schema.end()) {
+            if (!mapping->is_object())
+                throw std::runtime_error{"application enum mapping is not an object at " + std::string{path}};
+            for (const auto &[wire, application] : mapping->items()) {
+                if (!application.is_string())
+                    throw std::runtime_error{"application enum value is not a string at " + std::string{path}};
+                local_mappings.push_back({intern(wire), intern(application.get_ref<const std::string &>())});
+            }
+        }
+        node.mappings_begin = append(mappings, local_mappings);
+        node.mappings_count = static_cast<std::uint32_t>(local_mappings.size());
+        bounded(schema, "minLength", node.minimum_length, node.has_minimum_length);
+        bounded(schema, "maxLength", node.maximum_length, node.has_maximum_length);
+        bounded(schema, "minItems", node.minimum_items, node.has_minimum_items);
+        bounded(schema, "maxItems", node.maximum_items, node.has_maximum_items);
+        bounded(schema, "maxProperties", node.maximum_properties, node.has_maximum_properties);
+        signed_bound(schema, "minimum", node.minimum, node.has_minimum);
+        signed_bound(schema, "maximum", node.maximum, node.has_maximum);
+        node.unique_items = schema.value("uniqueItems", false);
+        nodes[index] = node;
+    }
+
+    static Pattern pattern_from(std::string_view value) {
+        const auto generated = pattern_name(value);
+        static const std::map<std::string_view, Pattern> values{
+            {"Pattern::none", Pattern::none},
+            {"Pattern::lowercase_sha256", Pattern::lowercase_sha256},
+            {"Pattern::sampler_name", Pattern::sampler_name},
+            {"Pattern::printable_text", Pattern::printable_text},
+            {"Pattern::media_extension", Pattern::media_extension},
+            {"Pattern::package_extension", Pattern::package_extension},
+            {"Pattern::identifier", Pattern::identifier},
+            {"Pattern::midi_manufacturer_id", Pattern::midi_manufacturer_id},
+            {"Pattern::receive_channel", Pattern::receive_channel},
+            {"Pattern::api_path", Pattern::api_path},
+            {"Pattern::archive_content_path", Pattern::archive_content_path},
+        };
+        return values.at(generated);
+    }
+
+    std::uint32_t compile_reference(const std::string &reference) {
+        const auto name = reference.substr(reference_prefix.size());
+        if (!name.contains('/')) {
+            const auto found = names.find(name);
+            if (found == names.end())
+                throw std::runtime_error{"unknown OpenAPI schema reference: " + name};
+            return found->second;
+        }
+
+        const auto existing = reference_nodes.find(reference);
+        if (existing != reference_nodes.end())
+            return existing->second;
+
+        const auto index = static_cast<std::uint32_t>(nodes.size());
+        reference_nodes.emplace(reference, index);
+        nodes.emplace_back();
+        try {
+            compile_at(index, document.at(Json::json_pointer{reference.substr(1U)}), reference);
+        } catch (const Json::exception &error) {
+            throw std::runtime_error{"unknown OpenAPI schema reference " + reference + ": " + error.what()};
+        }
+        return index;
+    }
+
+    Literal literal(const Json &value, std::string_view path) {
+        if (value.is_null())
+            return {LiteralKind::null, {}, 0, false};
+        if (value.is_boolean())
+            return {LiteralKind::boolean, {}, 0, value.get<bool>()};
+        if (value.is_number_integer() || value.is_number_unsigned())
+            return {LiteralKind::integer, {}, value.get<std::int64_t>(), false};
+        if (value.is_string())
+            return {LiteralKind::string, intern(value.get_ref<const std::string &>()), 0, false};
+        throw std::runtime_error{"unsupported enum or const literal at " + std::string{path}};
+    }
+
+    template <typename T> static std::uint32_t append(std::vector<T> &target, const std::vector<T> &values) {
+        const auto begin = static_cast<std::uint32_t>(target.size());
+        target.insert(target.end(), values.begin(), values.end());
+        return begin;
+    }
+
+    static void bounded(const Json &schema, std::string_view keyword, std::uint64_t &value, bool &present) {
+        if (const auto found = schema.find(keyword); found != schema.end()) {
+            value = found->get<std::uint64_t>();
+            present = true;
+        }
+    }
+
+    static void signed_bound(const Json &schema, std::string_view keyword, std::int64_t &value, bool &present) {
+        if (const auto found = schema.find(keyword); found != schema.end()) {
+            value = found->get<std::int64_t>();
+            present = true;
+        }
+    }
+
+    std::string_view intern(std::string_view value) {
+        strings.emplace_back(value);
+        return strings.back();
+    }
+
+    const Json &document;
+    std::map<std::string, std::uint32_t, std::less<>> names;
+    std::map<std::string, std::uint32_t, std::less<>> reference_nodes;
+    std::vector<SchemaNode> nodes;
+    std::vector<Property> properties;
+    std::vector<std::uint32_t> variants;
+    std::vector<Literal> literals;
+    std::vector<EnumMapping> mappings;
+    std::vector<NamedSchema> named;
+    std::deque<std::string> strings;
+};
+
+std::string bool_text(bool value) { return value ? "true" : "false"; }
+
+void write_output(std::ostream &out, const Compiler &value) {
+    out << "#include \"validation_plan.hpp\"\n\n#include <array>\n\nnamespace axk::server::detail {\nnamespace {\n";
+    out << "constexpr std::array<SchemaNode," << value.nodes.size() << "> nodes{\n";
+    for (const auto &node : value.nodes) {
+        out << "SchemaNode{" << unsigned{node.types} << ", Pattern::";
+        const auto pattern = static_cast<unsigned>(node.pattern);
+        static constexpr std::string_view names[]{"none",           "lowercase_sha256",     "sampler_name",
+                                                  "printable_text", "media_extension",      "package_extension",
+                                                  "identifier",     "midi_manufacturer_id", "receive_channel",
+                                                  "api_path",       "archive_content_path"};
+        out << names[pattern] << "," << node.reference << 'U' << ',' << node.items << 'U' << ','
+            << node.additional_properties << 'U' << ',' << node.properties_begin << 'U' << ',' << node.properties_count
+            << 'U' << ',' << node.variants_begin << 'U' << ',' << node.variants_count << 'U' << ','
+            << node.literals_begin << 'U' << ',' << node.literals_count << 'U' << ',' << node.mappings_begin << 'U'
+            << ',' << node.mappings_count << 'U' << ',' << node.minimum_length << "ULL," << node.maximum_length
+            << "ULL," << node.minimum_items << "ULL," << node.maximum_items << "ULL," << node.maximum_properties
+            << "ULL," << node.minimum << "LL," << node.maximum << "LL," << bool_text(node.additional_properties_allowed)
+            << ',' << bool_text(node.unique_items) << ',' << bool_text(node.has_minimum_length) << ','
+            << bool_text(node.has_maximum_length) << ',' << bool_text(node.has_minimum_items) << ','
+            << bool_text(node.has_maximum_items) << ',' << bool_text(node.has_maximum_properties) << ','
+            << bool_text(node.has_minimum) << ',' << bool_text(node.has_maximum) << "},\n";
+    }
+    out << "};\nconstexpr std::array<Property," << value.properties.size() << "> properties{\n";
+    for (const auto &property : value.properties)
+        out << "Property{" << quote(property.name) << ',' << property.schema << "U," << bool_text(property.required)
+            << "},\n";
+    out << "};\nconstexpr std::array<std::uint32_t," << value.variants.size() << "> variants{";
+    for (const auto variant : value.variants)
+        out << variant << "U,";
+    out << "};\nconstexpr std::array<Literal," << value.literals.size() << "> literals{\n";
+    for (const auto &literal : value.literals) {
+        static constexpr std::string_view kinds[]{"null", "boolean", "integer", "string"};
+        out << "Literal{LiteralKind::" << kinds[static_cast<unsigned>(literal.kind)] << ',' << quote(literal.text)
+            << ',' << literal.integer << "LL," << bool_text(literal.boolean) << "},\n";
+    }
+    out << "};\nconstexpr std::array<EnumMapping," << value.mappings.size() << "> mappings{\n";
+    for (const auto &mapping : value.mappings)
+        out << "EnumMapping{" << quote(mapping.wire) << ',' << quote(mapping.application) << "},\n";
+    out << "};\nconstexpr std::array<NamedSchema," << value.named.size() << "> schemas{\n";
+    for (const auto &schema : value.named)
+        out << "NamedSchema{" << quote(schema.name) << ',' << schema.schema << "U},\n";
+    out << "};\nconstexpr ValidationPlan plan{nodes,properties,variants,literals,mappings,schemas};\n"
+           "} // namespace\nconst ValidationPlan &generated_validation_plan() { return plan; }\n"
+           "} // namespace axk::server::detail\n";
+}
+
+} // namespace
+
+int main(int argc, char **argv) {
+    if (argc != 3) {
+        std::cerr << "usage: axk-server-validation-plan-generator OPENAPI OUTPUT\n";
+        return 2;
+    }
+    try {
+        std::ifstream input{std::filesystem::path{argv[1]}, std::ios::binary};
+        if (!input)
+            throw std::runtime_error{"could not open OpenAPI document"};
+        const Json document = Json::parse(input);
+        const Compiler compiler{document};
+        std::ostringstream generated;
+        write_output(generated, compiler);
+        std::ofstream output{std::filesystem::path{argv[2]}, std::ios::binary | std::ios::trunc};
+        output << generated.str();
+        if (!output)
+            throw std::runtime_error{"could not write validation plan"};
+        return 0;
+    } catch (const std::exception &error) {
+        std::cerr << "OpenAPI validation-plan generation failed: " << error.what() << '\n';
+        return 1;
+    }
+}
diff --git a/apps/server/tests/contract_test_support.cpp b/apps/server/tests/contract_test_support.cpp
new file mode 100644
index 00000000..14826cbe
--- /dev/null
+++ b/apps/server/tests/contract_test_support.cpp
@@ -0,0 +1,77 @@
+#include "contract_test_support.hpp"
+
+#include <exception>
+#include <map>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include <nlohmann/json-schema.hpp>
+
+namespace {
+
+nlohmann::json validation_root(const nlohmann::json &document, const nlohmann::json &schema) {
+    auto root = schema;
+    root["$schema"] = "http://json-schema.org/draft-07/schema#";
+    root["components"] = document.at("components");
+    return root;
+}
+
+axk::app::Result<void> validate_value(const nlohmann::json &document, const nlohmann::json &schema,
+                                      const nlohmann::json &value) {
+    try {
+        nlohmann::json_schema::json_validator validator;
+        validator.set_root_schema(validation_root(document, schema));
+        static_cast<void>(validator.validate(value));
+    } catch (const std::exception &) {
+        return std::unexpected(
+            axk::app::Error{"invalid_request", "request body does not match the declared OpenAPI schema"});
+    }
+    return {};
+}
+
+} // namespace
+
+struct axk::server::OracleOpenApiValidator::Impl {
+    explicit Impl(nlohmann::json value) : document(std::move(value)) {
+        for (const auto &[name, schema] : document.at("components").at("schemas").items()) {
+            auto validator = std::make_unique<nlohmann::json_schema::json_validator>();
+            validator->set_root_schema(validation_root(document, schema));
+            validators.emplace(name, std::move(validator));
+        }
+    }
+
+    nlohmann::json document;
+    std::map<std::string, std::unique_ptr<nlohmann::json_schema::json_validator>, std::less<>> validators;
+};
+
+axk::server::OracleOpenApiValidator::OracleOpenApiValidator(nlohmann::json document)
+    : impl_(std::make_unique<Impl>(std::move(document))) {}
+
+axk::server::OracleOpenApiValidator::~OracleOpenApiValidator() = default;
+
+bool axk::server::OracleOpenApiValidator::validate(std::string_view schema_name, const nlohmann::json &value) const {
+    const auto found = impl_->validators.find(schema_name);
+    if (found == impl_->validators.end())
+        return false;
+    try {
+        static_cast<void>(found->second->validate(value));
+        return true;
+    } catch (const std::exception &) {
+        return false;
+    }
+}
+
+axk::app::Result<void> axk::server::validate_openapi_value(const nlohmann::json &document, std::string_view schema_name,
+                                                           const nlohmann::json &value) {
+    try {
+        return validate_value(document, {{"$ref", "#/components/schemas/" + std::string{schema_name}}}, value);
+    } catch (const std::exception &) {
+        return std::unexpected(app::Error{"contract_error", "OpenAPI schema is not available"});
+    }
+}
+
+axk::app::Result<void> axk::server::validate_openapi_schema(const nlohmann::json &document,
+                                                            const nlohmann::json &schema, const nlohmann::json &value) {
+    return validate_value(document, schema, value);
+}
diff --git a/apps/server/tests/contract_test_support.hpp b/apps/server/tests/contract_test_support.hpp
new file mode 100644
index 00000000..14b96c29
--- /dev/null
+++ b/apps/server/tests/contract_test_support.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <memory>
+#include <string_view>
+
+#include <nlohmann/json.hpp>
+
+#include "axklib/application/contracts.hpp"
+
+namespace axk::server {
+
+class OracleOpenApiValidator {
+  public:
+    explicit OracleOpenApiValidator(nlohmann::json document);
+    ~OracleOpenApiValidator();
+
+    OracleOpenApiValidator(const OracleOpenApiValidator &) = delete;
+    OracleOpenApiValidator &operator=(const OracleOpenApiValidator &) = delete;
+
+    [[nodiscard]] bool validate(std::string_view schema_name, const nlohmann::json &value) const;
+
+  private:
+    struct Impl;
+    std::unique_ptr<Impl> impl_;
+};
+
+[[nodiscard]] app::Result<void> validate_openapi_value(const nlohmann::json &document, std::string_view schema_name,
+                                                       const nlohmann::json &value);
+[[nodiscard]] app::Result<void> validate_openapi_schema(const nlohmann::json &document, const nlohmann::json &schema,
+                                                        const nlohmann::json &value);
+
+} // namespace axk::server
diff --git a/apps/server/tests/server_contract_test.cpp b/apps/server/tests/server_contract_test.cpp
index ff2c59fa..127f78c3 100644
--- a/apps/server/tests/server_contract_test.cpp
+++ b/apps/server/tests/server_contract_test.cpp
@@ -14,6 +14,7 @@
 #include "axklib/application/operation_registry.hpp"
 #include "axklib/server/contract.hpp"
 #include "axklib/server/server.hpp"
+#include "contract_test_support.hpp"
 
 namespace {
 
@@ -89,6 +90,58 @@ TEST(ServerContract, EmbedsValidOpenApi31WithSandboxReferences) {
     EXPECT_TRUE(headers.contains("XRequestId"));
 }
 
+TEST(ServerContract, GeneratedValidationPlanMatchesTheSchemaCompilerForRepresentativeValues) {
+    const auto document =
+        axk::server::build_openapi_document(axk::server::embedded_openapi(), axk::app::make_operation_registry());
+    const axk::server::OpenApiValidator generated;
+    const axk::server::OracleOpenApiValidator oracle{document};
+    const auto representatives = std::to_array<nlohmann::json>({
+        nullptr,
+        false,
+        true,
+        -1,
+        0,
+        1,
+        1.5,
+        "",
+        "x",
+        "é",
+        "A01",
+        "A16",
+        "A00",
+        "A17",
+        "B01",
+        "B16",
+        "Bch",
+        "01",
+        "16",
+        "00",
+        "17",
+        ".iso",
+        ".axkvol",
+        ".AXKVOL",
+        "/api/v1/",
+        "/api/v1/system/version",
+        "/api/v2/system/version",
+        "/api/v1/download-archives/archive1/content",
+        "/api/v1/download-archives/archive-1/content",
+        "00-43-10",
+        "0A",
+        "0a",
+        "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
+        nlohmann::json::array(),
+        nlohmann::json::object(),
+        nlohmann::json{{"unexpected", true}},
+    });
+    for (const auto &[name, schema] : document.at("components").at("schemas").items()) {
+        static_cast<void>(schema);
+        for (const auto &value : representatives) {
+            EXPECT_EQ(static_cast<bool>(generated.validate(name, value)), oracle.validate(name, value))
+                << name << ": " << value.dump();
+        }
+    }
+}
+
 TEST(ServerContract, ImageObjectScopeUsesAnOpaqueContentNodeIdentifier) {
     const auto document =
         axk::server::build_openapi_document(axk::server::embedded_openapi(), axk::app::make_operation_registry());
@@ -147,7 +200,7 @@ TEST(ServerContract, DirectoryListingsSeparateMediaSourceInspection) {
 TEST(ServerContract, AlterationJobReportsIncludeTx16wDiskSetImports) {
     const auto document =
         axk::server::build_openapi_document(axk::server::embedded_openapi(), axk::app::make_operation_registry());
-    axk::server::OpenApiValidator validator{document};
+    axk::server::OpenApiValidator validator;
     const auto &type =
         document.at("components").at("schemas").at("AlterationOperationReport").at("properties").at("type");
     EXPECT_TRUE(std::ranges::contains(type.at("enum"), "IMPORT_TX16W_DISK_SET"));
@@ -417,7 +470,7 @@ TEST(ServerContract, EveryHttpResponseCarriesRequestIdAndPaginationIsBounded) {
 TEST(ServerContract, RelationshipDiagnosticsValidateForInspectionAndTerminalExtractionResults) {
     const auto document =
         axk::server::build_openapi_document(axk::server::embedded_openapi(), axk::app::make_operation_registry());
-    axk::server::OpenApiValidator validator{document};
+    axk::server::OpenApiValidator validator;
     const auto diagnostic = nlohmann::json{
         {"code", "unconfirmed_relationship_excluded"},
         {"message", "Unconfirmed relationship excluded from exact export"},
@@ -479,7 +532,7 @@ TEST(ServerContract, RelationshipDiagnosticsValidateForInspectionAndTerminalExtr
 TEST(ServerContract, ProgramAssignmentAdjustmentsValidateForPlansAndImportResults) {
     const auto document =
         axk::server::build_openapi_document(axk::server::embedded_openapi(), axk::app::make_operation_registry());
-    axk::server::OpenApiValidator validator{document};
+    axk::server::OpenApiValidator validator;
     const auto adjustment = nlohmann::json{
         {"adjustmentId", "adjustment-1"},
         {"origin", "existing-program"},
@@ -821,9 +874,7 @@ TEST(ServerContract, ProgramGenerationInspectionAndJobUseReviewedSelections) {
 }
 
 TEST(ServerContract, WorkspaceCreateRequestRejectsUnknownFields) {
-    const auto document =
-        axk::server::build_openapi_document(axk::server::embedded_openapi(), axk::app::make_operation_registry());
-    axk::server::OpenApiValidator validator{document};
+    axk::server::OpenApiValidator validator;
     const auto request =
         nlohmann::json{{"displayName", "Samples"}, {"path", "/samples"}, {"writable", false}, {"revision", 0U}};
     EXPECT_TRUE(validator.validate("WorkspaceCreateRequest", request));
@@ -835,9 +886,7 @@ TEST(ServerContract, WorkspaceCreateRequestRejectsUnknownFields) {
 }
 
 TEST(ServerContract, MediaConversionRequestsAndTerminalResultsMatchTheirSchemas) {
-    const auto document =
-        axk::server::build_openapi_document(axk::server::embedded_openapi(), axk::app::make_operation_registry());
-    axk::server::OpenApiValidator validator{document};
+    axk::server::OpenApiValidator validator;
     const auto inspection_request = nlohmann::json{{"imageId", "image-one"},
                                                    {"expectedRevision", 3U},
                                                    {"format", "FAT12_FLOPPY"},
@@ -886,7 +935,7 @@ TEST(ServerContract, WireEnumsAreUpperSnakeAndTranslateOnlyAtTheApplicationBound
     const auto document =
         axk::server::build_openapi_document(axk::server::embedded_openapi(), axk::app::make_operation_registry());
     expect_upper_snake_enums(document.at("components").at("schemas"));
-    axk::server::OpenApiValidator validator{document};
+    axk::server::OpenApiValidator validator;
 
     const auto wire_request =
         nlohmann::json{{"source", file_ref()},
@@ -933,9 +982,7 @@ TEST(ServerContract, WireEnumsAreUpperSnakeAndTranslateOnlyAtTheApplicationBound
 }
 
 TEST(ServerContract, ImageSessionVolumeSelectorsUseExactContentIdentity) {
-    const auto document =
-        axk::server::build_openapi_document(axk::server::embedded_openapi(), axk::app::make_operation_registry());
-    axk::server::OpenApiValidator validator{document};
+    axk::server::OpenApiValidator validator;
     const auto exact = nlohmann::json{{"kind", "VOLUME"}, {"contentId", "content-volume-1"}};
     EXPECT_TRUE(validator.validate("ImageSessionExportRoot", exact));
     EXPECT_FALSE(
diff --git a/vcpkg.json b/vcpkg.json
index ed745f5b..06a6c7db 100644
--- a/vcpkg.json
+++ b/vcpkg.json
@@ -32,14 +32,14 @@
     "server": {
       "description": "Dependencies used only by the Crow REST and WebSocket server",
       "dependencies": [
-        "crow",
-        "json-schema-validator"
+        "crow"
       ]
     },
     "tests": {
       "description": "Dependencies used only by native test targets",
       "dependencies": [
-        "gtest"
+        "gtest",
+        "json-schema-validator"
       ]
     }
   }

From 2f41750b7c947a32a626d1c19e6eb3fd210530dc Mon Sep 17 00:00:00 2001
From: bzeiss <ben@zeiss.net>
Date: Tue, 18 Aug 2026 21:26:25 +0200
Subject: [PATCH 02/12] - hidpi mode read and applied before displaying
 anything - added 115% scaling

---
 apps/axkdeck/README.md                        |  6 ++---
 apps/axkdeck/index.html                       |  6 ++++-
 .../src/lib/components/LayoutControls.svelte  |  1 +
 .../src/lib/components/LayoutControls.test.ts |  4 +--
 apps/axkdeck/src/lib/interfaceScale.test.ts   | 13 ++++++++--
 apps/axkdeck/src/lib/interfaceScale.ts        |  4 +--
 .../axkdeck/src/lib/startupVisibility.test.ts | 25 +++++++++++++++++++
 apps/axkdeck/src/lib/startupVisibility.ts     |  9 +++++++
 apps/axkdeck/src/main.ts                      |  5 +++-
 9 files changed, 62 insertions(+), 11 deletions(-)
 create mode 100644 apps/axkdeck/src/lib/startupVisibility.test.ts
 create mode 100644 apps/axkdeck/src/lib/startupVisibility.ts

diff --git a/apps/axkdeck/README.md b/apps/axkdeck/README.md
index 23c10b8a..d765e2d3 100644
--- a/apps/axkdeck/README.md
+++ b/apps/axkdeck/README.md
@@ -217,7 +217,7 @@ target before launching the desktop shell.
 
 ### Interface scale
 
-Desktop builds adjust the webview scale before mounting the interface. Auto
+Desktop builds adjust the webview scale before revealing the interface. Auto
 mode uses the active monitor's physical resolution together with its operating
 system scale factor, so a 4K display at 100% receives a larger interface while
 a display that is already scaled by the operating system is not enlarged
@@ -225,8 +225,8 @@ twice. The scale is recalculated when the window moves to another monitor or
 the monitor scale changes.
 
 Use the sliders menu beside the panel layout controls to select Auto, 100%,
-125%, or 150%. The selected mode is stored locally and restored on the next
-launch. Manual modes remain fixed when the window moves between displays.
+115%, 125%, or 150%. The selected mode is stored locally and restored on the
+next launch. Manual modes remain fixed when the window moves between displays.
 
 ### Local workspaces
 
diff --git a/apps/axkdeck/index.html b/apps/axkdeck/index.html
index b35a9fe4..05fd32f5 100644
--- a/apps/axkdeck/index.html
+++ b/apps/axkdeck/index.html
@@ -1,5 +1,5 @@
 <!doctype html>
-<html lang="en">
+<html lang="en" data-interface-scale-pending>
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
@@ -30,6 +30,10 @@
         font: 12px/1.4 Inter, ui-sans-serif, system-ui, -apple-system,
           BlinkMacSystemFont, "Segoe UI", sans-serif;
       }
+
+      html[data-interface-scale-pending] #app {
+        visibility: hidden;
+      }
     </style>
     <title>axkdeck</title>
   </head>
diff --git a/apps/axkdeck/src/lib/components/LayoutControls.svelte b/apps/axkdeck/src/lib/components/LayoutControls.svelte
index af59651f..585bf8fb 100644
--- a/apps/axkdeck/src/lib/components/LayoutControls.svelte
+++ b/apps/axkdeck/src/lib/components/LayoutControls.svelte
@@ -31,6 +31,7 @@
     let scaleTrigger: HTMLButtonElement | undefined = $state();
     const scaleOptions: readonly { mode: InterfaceScaleMode; label: string }[] = [
         { mode: '1', label: '100%' },
+        { mode: '1.15', label: '115%' },
         { mode: '1.25', label: '125%' },
         { mode: '1.5', label: '150%' },
     ];
diff --git a/apps/axkdeck/src/lib/components/LayoutControls.test.ts b/apps/axkdeck/src/lib/components/LayoutControls.test.ts
index 3c21fbcd..01fe235e 100644
--- a/apps/axkdeck/src/lib/components/LayoutControls.test.ts
+++ b/apps/axkdeck/src/lib/components/LayoutControls.test.ts
@@ -85,9 +85,9 @@ describe('LayoutControls', () => {
         expect(document.activeElement).toBe(trigger);
 
         await fireEvent.click(trigger);
-        await fireEvent.click(screen.getByRole('menuitemradio', { name: '125%' }));
+        await fireEvent.click(screen.getByRole('menuitemradio', { name: '115%' }));
 
-        expect(oninterfacescalechange).toHaveBeenCalledWith('1.25');
+        expect(oninterfacescalechange).toHaveBeenCalledWith('1.15');
         expect(screen.queryByRole('menu', { name: 'Interface scale' })).toBeNull();
     });
 
diff --git a/apps/axkdeck/src/lib/interfaceScale.test.ts b/apps/axkdeck/src/lib/interfaceScale.test.ts
index 2fc7c773..13db8f0b 100644
--- a/apps/axkdeck/src/lib/interfaceScale.test.ts
+++ b/apps/axkdeck/src/lib/interfaceScale.test.ts
@@ -174,6 +174,15 @@ describe('InterfaceScaleController', () => {
         await controller.dispose();
     });
 
+    it('restores and applies the fixed 115% mode', async () => {
+        const { adapter } = adapterFor(monitor(1920, 1080));
+        const controller = await createInterfaceScaleController(adapter, storageWith('1.15'));
+
+        expect(controller.state()).toEqual({ mode: '1.15', appliedZoom: 1.15 });
+        expect(adapter.setZoom).toHaveBeenCalledWith(1.15);
+        await controller.dispose();
+    });
+
     it.each(['', '125%', '2', 'invalid'])('falls back to Auto for an invalid stored mode %j', async (stored) => {
         const { adapter } = adapterFor(monitor(2560, 1440));
 
@@ -241,7 +250,7 @@ describe('InterfaceScaleController', () => {
         await controller.dispose();
     });
 
-    it.each<InterfaceScaleMode>(['auto', '1', '1.25', '1.5'])(
+    it.each<InterfaceScaleMode>(['auto', '1', '1.15', '1.25', '1.5'])(
         'does not mutate the native window when maximizing in %s mode',
         async (mode) => {
             const { adapter, emitMoved, emitResized, setMaximized } = adapterFor(monitor(1920, 1080));
@@ -341,7 +350,7 @@ describe('InterfaceScaleController', () => {
     it('accepts every declared fixed mode', async () => {
         const { adapter } = adapterFor();
         const controller = await createInterfaceScaleController(adapter, storageWith());
-        const modes: InterfaceScaleMode[] = ['1', '1.25', '1.5', 'auto'];
+        const modes: InterfaceScaleMode[] = ['1', '1.15', '1.25', '1.5', 'auto'];
 
         for (const mode of modes) await controller.setMode(mode);
 
diff --git a/apps/axkdeck/src/lib/interfaceScale.ts b/apps/axkdeck/src/lib/interfaceScale.ts
index a38f3dc7..bb509817 100644
--- a/apps/axkdeck/src/lib/interfaceScale.ts
+++ b/apps/axkdeck/src/lib/interfaceScale.ts
@@ -1,4 +1,4 @@
-export type InterfaceScaleMode = 'auto' | '1' | '1.25' | '1.5';
+export type InterfaceScaleMode = 'auto' | '1' | '1.15' | '1.25' | '1.5';
 
 export interface InterfaceScaleState {
     mode: InterfaceScaleMode;
@@ -49,7 +49,7 @@ const storageKey = 'axkdeck.interface-scale.v1';
 const minimumWindowWidth = 800;
 const minimumWindowHeight = 600;
 const windowEventDebounceMs = 150;
-const fixedModes = new Set<InterfaceScaleMode>(['1', '1.25', '1.5']);
+const fixedModes = new Set<InterfaceScaleMode>(['1', '1.15', '1.25', '1.5']);
 
 function finitePositive(value: number): boolean {
     return Number.isFinite(value) && value > 0;
diff --git a/apps/axkdeck/src/lib/startupVisibility.test.ts b/apps/axkdeck/src/lib/startupVisibility.test.ts
new file mode 100644
index 00000000..af404443
--- /dev/null
+++ b/apps/axkdeck/src/lib/startupVisibility.test.ts
@@ -0,0 +1,25 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { revealAfterInterfaceScale } from './startupVisibility';
+
+describe('startup visibility', () => {
+    it('reveals the mounted shell before measuring its first visible frame', async () => {
+        document.documentElement.setAttribute('data-interface-scale-pending', '');
+        let finishScale: (() => void) | undefined;
+        const scaleReady = new Promise<void>((resolve) => {
+            finishScale = resolve;
+        });
+        const waitForFirstFrame = vi.fn(async () => undefined);
+
+        const ready = revealAfterInterfaceScale(scaleReady, waitForFirstFrame);
+
+        expect(document.documentElement.hasAttribute('data-interface-scale-pending')).toBe(true);
+        expect(waitForFirstFrame).not.toHaveBeenCalled();
+
+        finishScale?.();
+        await ready;
+
+        expect(document.documentElement.hasAttribute('data-interface-scale-pending')).toBe(false);
+        expect(waitForFirstFrame).toHaveBeenCalledOnce();
+    });
+});
diff --git a/apps/axkdeck/src/lib/startupVisibility.ts b/apps/axkdeck/src/lib/startupVisibility.ts
new file mode 100644
index 00000000..22f83e70
--- /dev/null
+++ b/apps/axkdeck/src/lib/startupVisibility.ts
@@ -0,0 +1,9 @@
+export async function revealAfterInterfaceScale(
+    interfaceScaleReady: Promise<unknown>,
+    waitForFirstFrame: () => Promise<void>,
+    root: HTMLElement = document.documentElement,
+): Promise<void> {
+    await interfaceScaleReady;
+    root.removeAttribute('data-interface-scale-pending');
+    await waitForFirstFrame();
+}
diff --git a/apps/axkdeck/src/main.ts b/apps/axkdeck/src/main.ts
index f293584d..f8498544 100644
--- a/apps/axkdeck/src/main.ts
+++ b/apps/axkdeck/src/main.ts
@@ -6,6 +6,7 @@ import { installDiagnostics, reportDiagnostic, reportError, reportInfo } from '.
 import { createInterfaceScaleController, type InterfaceScaleController } from './lib/interfaceScale';
 import { prepareServerConnection, prepareStartup } from './lib/startupCoordinator';
 import { frontendStartup, type StartupView } from './lib/startupDiagnostics';
+import { revealAfterInterfaceScale } from './lib/startupVisibility';
 import { createTauriInterfaceScaleAdapter } from './lib/tauriInterfaceScale';
 
 type ServerConnection = NonNullable<Window['__AXKLIB_SERVER__']>;
@@ -64,7 +65,6 @@ async function bootstrap(mountTarget: HTMLElement): Promise<void> {
     };
     renderShell();
     frontendStartup.markShellMounted();
-    const shellFirstFrame = frontendStartup.waitForShellFirstFrame();
     const diagnosticsReady = installDiagnostics().finally(() => frontendStartup.markDiagnosticsInstalled());
     const interfaceScalingReady = (async () => {
         if (!isDesktop) return;
@@ -78,6 +78,9 @@ async function bootstrap(mountTarget: HTMLElement): Promise<void> {
             reportDiagnostic('interface_scale_initialization_failed', { message: String(error) }, 'warn');
         }
     })().finally(() => frontendStartup.markInterfaceScaleComplete());
+    const shellFirstFrame = revealAfterInterfaceScale(interfaceScalingReady, () =>
+        frontendStartup.waitForShellFirstFrame(),
+    );
 
     const view: StartupView =
         new URLSearchParams(window.location.search).get('view') === 'allocation' ? 'allocation' : 'workspace';

From 7ec07e1550aff645bbd64fb914ea2d07908a6b6d Mon Sep 17 00:00:00 2001
From: bzeiss <ben@zeiss.net>
Date: Wed, 19 Aug 2026 08:04:42 +0200
Subject: [PATCH 03/12] visual improvements.

---
 .../lib/components/ServerStoragePicker.svelte | 20 ++++-----
 .../components/ServerStoragePicker.test.ts    |  7 ++--
 .../lib/components/WorkspaceManager.svelte    | 35 ++++++++++------
 .../lib/components/WorkspaceManager.test.ts   | 41 +++++++++++++++++++
 4 files changed, 78 insertions(+), 25 deletions(-)

diff --git a/apps/axkdeck/src/lib/components/ServerStoragePicker.svelte b/apps/axkdeck/src/lib/components/ServerStoragePicker.svelte
index 277fd3fc..8e4ff761 100644
--- a/apps/axkdeck/src/lib/components/ServerStoragePicker.svelte
+++ b/apps/axkdeck/src/lib/components/ServerStoragePicker.svelte
@@ -450,6 +450,16 @@
         </header>
 
         <nav class="storage-picker-location" aria-label="Storage location">
+            <button
+                class="icon-button"
+                type="button"
+                aria-label="Go to all workspaces"
+                title="All workspaces"
+                disabled={!activeRoot || loading}
+                onclick={goHome}
+            >
+                <Icon name="home" size={15} />
+            </button>
             <button
                 class="icon-button"
                 type="button"
@@ -499,16 +509,6 @@
                         New folder
                     </button>
                 {/if}
-                <button
-                    class="icon-button"
-                    type="button"
-                    aria-label="Go to all workspaces"
-                    title="All workspaces"
-                    disabled={!activeRoot || loading}
-                    onclick={goHome}
-                >
-                    <Icon name="home" size={15} />
-                </button>
             </div>
         </nav>
 
diff --git a/apps/axkdeck/src/lib/components/ServerStoragePicker.test.ts b/apps/axkdeck/src/lib/components/ServerStoragePicker.test.ts
index 3a56b5af..b658374d 100644
--- a/apps/axkdeck/src/lib/components/ServerStoragePicker.test.ts
+++ b/apps/axkdeck/src/lib/components/ServerStoragePicker.test.ts
@@ -305,7 +305,7 @@ describe('ServerStoragePicker', () => {
         });
     });
 
-    it('keeps a persistent location bar with the path before the right-aligned home action', async () => {
+    it('keeps a persistent location bar ordered home, parent, then path', async () => {
         render(ServerStoragePicker, {
             props: {
                 transport: transport(),
@@ -330,8 +330,9 @@ describe('ServerStoragePicker', () => {
         const home = within(location).getByRole('button', { name: 'Go to all workspaces' });
         expect(parent.hasAttribute('disabled')).toBe(false);
         expect(home.hasAttribute('disabled')).toBe(false);
-        expect(path.compareDocumentPosition(home) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy();
-        expect(location.lastElementChild?.contains(home)).toBe(true);
+        expect(location.firstElementChild).toBe(home);
+        expect(home.compareDocumentPosition(parent) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy();
+        expect(parent.compareDocumentPosition(path) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy();
     });
 
     it('uses parent navigation to return from a workspace root to the workspace list', async () => {
diff --git a/apps/axkdeck/src/lib/components/WorkspaceManager.svelte b/apps/axkdeck/src/lib/components/WorkspaceManager.svelte
index dd3f7fe8..51bf4678 100644
--- a/apps/axkdeck/src/lib/components/WorkspaceManager.svelte
+++ b/apps/axkdeck/src/lib/components/WorkspaceManager.svelte
@@ -379,37 +379,48 @@
         border-color: rgb(190 80 80 / 35%);
         background: rgb(120 35 35 / 20%);
     }
-    .workspace-list,
+    .workspace-list {
+        display: grid;
+        gap: 2px;
+        max-height: 200px;
+        overflow: auto;
+        padding: 6px 12px;
+    }
     .host-browser {
         min-height: 72px;
         overflow: auto;
         padding: 6px 12px;
     }
-    .workspace-list {
-        max-height: 200px;
-    }
-    .workspace-row,
-    .host-row {
-        min-height: 36px;
+    .workspace-row {
+        min-height: 32px;
         display: grid;
         grid-template-columns: 20px 1fr auto;
         align-items: center;
         gap: 8px;
-        border-bottom: 1px solid var(--color-border);
+        padding: 3px 0;
     }
-    .workspace-row span,
-    .workspace-row small {
-        display: block;
+    .workspace-row span {
+        min-width: 0;
+        display: grid;
+        gap: 0;
     }
     .workspace-row strong {
         font-size: 10px;
+        line-height: 11px;
     }
     .workspace-row small {
-        margin-top: 1px;
+        display: block;
+        margin: 0;
         color: var(--color-text-muted);
         font-size: 8px;
+        line-height: 9px;
     }
     .host-row {
+        min-height: 36px;
+        display: grid;
+        grid-template-columns: 20px 1fr auto;
+        align-items: center;
+        gap: 8px;
         width: 100%;
         color: inherit;
         text-align: left;
diff --git a/apps/axkdeck/src/lib/components/WorkspaceManager.test.ts b/apps/axkdeck/src/lib/components/WorkspaceManager.test.ts
index c4653d16..b23026e6 100644
--- a/apps/axkdeck/src/lib/components/WorkspaceManager.test.ts
+++ b/apps/axkdeck/src/lib/components/WorkspaceManager.test.ts
@@ -1,5 +1,6 @@
 import { fireEvent, render, screen, waitFor } from '@testing-library/svelte';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+import workspaceManagerSource from './WorkspaceManager.svelte?raw';
 
 const mocks = vi.hoisted(() => ({ invoke: vi.fn() }));
 vi.mock('@tauri-apps/api/core', () => ({ invoke: mocks.invoke }));
@@ -76,6 +77,46 @@ describe('WorkspaceManager', () => {
         expect(screen.queryByText('Server storage')).toBeNull();
     });
 
+    it('renders configured storage locations as a compact undivided list', async () => {
+        vi.mocked(fetch).mockResolvedValue(activeWorkspaceResponse());
+        render(WorkspaceManager, { props: { open: true, onclose: vi.fn() } });
+
+        const list = await screen.findByRole('list', { name: 'Configured storage locations' });
+        const rows = list.querySelectorAll<HTMLElement>('.workspace-row');
+        expect(rows).toHaveLength(2);
+
+        const listGeometry = workspaceManagerSource.match(/\.workspace-list\s*\{[^}]+\}/)?.[0];
+        const rowGeometry = workspaceManagerSource.match(/\.workspace-row\s*\{[^}]+\}/)?.[0];
+        const nameGeometry = workspaceManagerSource.match(/\.workspace-row strong\s*\{[^}]+\}/)?.[0];
+        const statusGeometry = workspaceManagerSource.match(/\.workspace-row small\s*\{[^}]+\}/)?.[0];
+        expect(listGeometry).toBeDefined();
+        expect(rowGeometry).toBeDefined();
+        expect(nameGeometry).toBeDefined();
+        expect(statusGeometry).toBeDefined();
+        const style = document.createElement('style');
+        style.textContent = `${listGeometry}\n${rowGeometry}\n${nameGeometry}\n${statusGeometry}`;
+        document.head.append(style);
+
+        const listStyle = getComputedStyle(list);
+        expect(listStyle.minHeight).toBe('auto');
+        expect(listStyle.paddingTop).toBe('6px');
+        expect(listStyle.paddingBottom).toBe('6px');
+        expect(listStyle.gap).toBe('2px');
+
+        const rowStyle = getComputedStyle(rows[0]);
+        expect(rowStyle.minHeight).toBe('32px');
+        expect(rowStyle.borderBottomStyle).toBe('none');
+
+        const name = screen.getByText('Open image location');
+        const status = rows[0].querySelector('small');
+        expect(status).not.toBeNull();
+        expect(getComputedStyle(name).lineHeight).toBe('11px');
+        expect(getComputedStyle(status!).lineHeight).toBe('9px');
+        expect(getComputedStyle(status!).marginTop).toBe('0px');
+
+        style.remove();
+    });
+
     it('opens the native picker and presents the selected directory for confirmation', async () => {
         mocks.invoke.mockResolvedValue({ candidateId: 'candidate-1', suggestedName: 'Samples' });
         render(WorkspaceManager, { props: { open: false, onclose: vi.fn() } });

From 847f14feeb6e5cf5b83ec73a4b2d93ebda0e6503 Mon Sep 17 00:00:00 2001
From: bzeiss <ben@zeiss.net>
Date: Wed, 19 Aug 2026 20:03:05 +0200
Subject: [PATCH 04/12] webview minimum version, allow cancellation before
 webview is installed.

---
 README.md                                     |  6 +++
 apps/axkdeck/README.md                        | 12 ++++-
 apps/axkdeck/src-tauri/tauri.conf.json        |  8 ++-
 .../src-tauri/windows/webview2-consent.nsh    | 53 +++++++++++++++++++
 apps/axkdeck/vite.config.ts                   |  2 +-
 docs/index.md                                 |  7 +++
 tools/python/tests/test_release_tools.py      | 32 ++++++++++-
 7 files changed, 116 insertions(+), 4 deletions(-)
 create mode 100644 apps/axkdeck/src-tauri/windows/webview2-consent.nsh

diff --git a/README.md b/README.md
index 683dd6d1..62515f09 100644
--- a/README.md
+++ b/README.md
@@ -79,6 +79,12 @@ the source tree and its CMake package, keeping the compiler, standard library,
 and dependency choices under their own control. The local `axklib-server` is an
 axkdeck sidecar and is not published as a standalone download.
 
+Windows installers require Microsoft Edge WebView2 Evergreen Runtime version
+111 or newer. An interactive installation asks before downloading or updating
+an insufficient runtime from Microsoft; silent `/S` installations perform that
+prerequisite step without a prompt. The installer does not bundle a fixed
+WebView2 runtime and does not replace a newer installed version.
+
 ## Command Line
 
 The CLI exposes the same image and object operations for scripts and batch
diff --git a/apps/axkdeck/README.md b/apps/axkdeck/README.md
index d765e2d3..80f1abe5 100644
--- a/apps/axkdeck/README.md
+++ b/apps/axkdeck/README.md
@@ -166,7 +166,8 @@ WebView2:
    and select the **Desktop development with C++** workload.
 2. Ensure the
    [WebView2 Evergreen Runtime](https://developer.microsoft.com/microsoft-edge/webview2/#download-section)
-   is installed. It is already included with Windows 10 version 1803 and newer.
+   version 111 or newer is installed. WebView2 is already included with current
+   Windows releases.
 3. Install Rust with the MSVC host toolchain and use Node.js LTS.
 
 Open a new PowerShell terminal and verify the toolchain:
@@ -184,6 +185,15 @@ See the official
 [Tauri Windows prerequisites](https://v2.tauri.app/start/prerequisites/#windows)
 for installer details and troubleshooting.
 
+The packaged NSIS installer checks for WebView2 version `111.0.0.0` or newer.
+When an interactive installation finds no runtime or an older runtime, axkdeck
+discloses the installed and required versions and asks before continuing. If
+accepted, the installer downloads Microsoft's current Evergreen bootstrapper;
+the runtime is not bundled in the installer. An unattended `/S` installation
+performs the same check and installation without a prompt. A newer installed
+runtime is retained, and the shared Evergreen Runtime continues to receive its
+normal Microsoft updates.
+
 Tauri desktop packages are native to the build host. The native CI matrix builds
 the C++ targets once per platform and then reuses the resulting server for the
 matching axkdeck build. Release packaging produces a universal macOS DMG,
diff --git a/apps/axkdeck/src-tauri/tauri.conf.json b/apps/axkdeck/src-tauri/tauri.conf.json
index 91628bbd..260a7851 100644
--- a/apps/axkdeck/src-tauri/tauri.conf.json
+++ b/apps/axkdeck/src-tauri/tauri.conf.json
@@ -49,9 +49,15 @@
       "resources/axkdeck.spdx.json": "licenses/axkdeck.spdx.json"
     },
     "windows": {
+      "minimumWebview2Version": "111.0.0.0",
+      "webviewInstallMode": {
+        "type": "downloadBootstrapper",
+        "silent": true
+      },
       "nsis": {
         "installerIcon": "icons/icon.ico",
-        "uninstallerIcon": "icons/icon.ico"
+        "uninstallerIcon": "icons/icon.ico",
+        "installerHooks": "windows/webview2-consent.nsh"
       }
     },
     "macOS": {
diff --git a/apps/axkdeck/src-tauri/windows/webview2-consent.nsh b/apps/axkdeck/src-tauri/windows/webview2-consent.nsh
new file mode 100644
index 00000000..1809cf21
--- /dev/null
+++ b/apps/axkdeck/src-tauri/windows/webview2-consent.nsh
@@ -0,0 +1,53 @@
+!define AXKDECK_WEBVIEW2_APP_GUID "{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}"
+!define AXKDECK_MINIMUM_WEBVIEW2_VERSION "111.0.0.0"
+
+; Tauri's WebView2 section runs before NSIS_HOOK_PREINSTALL. Use the GUI
+; callback so an interactive user can decline before any runtime is changed.
+Function .onGUIInit
+  IfSilent axkdeck_webview2_consent_done 0
+
+  StrCpy $0 ""
+  StrCpy $1 ""
+  ${If} ${RunningX64}
+    ReadRegStr $0 HKLM "SOFTWARE\WOW6432Node\Microsoft\EdgeUpdate\Clients\${AXKDECK_WEBVIEW2_APP_GUID}" "pv"
+  ${Else}
+    ReadRegStr $0 HKLM "SOFTWARE\Microsoft\EdgeUpdate\Clients\${AXKDECK_WEBVIEW2_APP_GUID}" "pv"
+  ${EndIf}
+  ReadRegStr $1 HKCU "SOFTWARE\Microsoft\EdgeUpdate\Clients\${AXKDECK_WEBVIEW2_APP_GUID}" "pv"
+
+  ; Use the newest visible machine- or user-scoped Evergreen Runtime.
+  StrCpy $2 $0
+  ${If} $2 == ""
+  ${OrIf} $2 == "0.0.0.0"
+    StrCpy $2 $1
+  ${Else}
+    ${If} $1 != ""
+      ${If} $1 != "0.0.0.0"
+        ${VersionCompare} "$1" "$2" $3
+        ${If} $3 == 1
+          StrCpy $2 $1
+        ${EndIf}
+      ${EndIf}
+    ${EndIf}
+  ${EndIf}
+
+  ${If} $2 == ""
+  ${OrIf} $2 == "0.0.0.0"
+    StrCpy $4 "Not installed"
+    Goto axkdeck_webview2_consent_prompt
+  ${EndIf}
+
+  ${VersionCompare} "${AXKDECK_MINIMUM_WEBVIEW2_VERSION}" "$2" $3
+  ${If} $3 != 1
+    Goto axkdeck_webview2_consent_done
+  ${EndIf}
+  StrCpy $4 $2
+
+  axkdeck_webview2_consent_prompt:
+    MessageBox MB_OKCANCEL|MB_ICONEXCLAMATION \
+      "axkdeck requires the Microsoft Edge WebView2 Evergreen Runtime.$\r$\n$\r$\nInstalled version: $4$\r$\nMinimum required version: ${AXKDECK_MINIMUM_WEBVIEW2_VERSION}$\r$\n$\r$\nContinue to let setup download and install or update the shared runtime from Microsoft? WebView2 updates automatically after installation." \
+      IDOK axkdeck_webview2_consent_done
+    Quit
+
+  axkdeck_webview2_consent_done:
+FunctionEnd
diff --git a/apps/axkdeck/vite.config.ts b/apps/axkdeck/vite.config.ts
index 5e5b1619..3fb56086 100644
--- a/apps/axkdeck/vite.config.ts
+++ b/apps/axkdeck/vite.config.ts
@@ -32,7 +32,7 @@ export default defineConfig({
     },
     envPrefix: ['VITE_', 'TAURI_ENV_*'],
     build: {
-        target: process.env.TAURI_ENV_PLATFORM === 'windows' ? 'chrome105' : 'safari13',
+        target: process.env.TAURI_ENV_PLATFORM === 'windows' ? 'chrome111' : 'safari16.4',
         minify: process.env.TAURI_ENV_DEBUG ? false : 'oxc',
         sourcemap: Boolean(process.env.TAURI_ENV_DEBUG),
     },
diff --git a/docs/index.md b/docs/index.md
index 572ca559..887ac54f 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -22,6 +22,13 @@ a separately validated repaired copy without changing the source image.
 
 [Download axkdeck](https://github.com/tphzz/axklib/releases)
 
+On Windows, axkdeck requires Microsoft Edge WebView2 Evergreen Runtime version
+111 or newer. The interactive NSIS installer reports a missing or outdated
+runtime and asks before downloading or updating it from Microsoft. Silent `/S`
+installations perform the prerequisite step without a prompt. The installer
+uses the online Evergreen bootstrapper rather than bundling a fixed runtime and
+leaves newer installed versions in place.
+
 ## Other Interfaces
 
 - The [CLI reference](axklib/cli.md) covers scripted and batch workflows.
diff --git a/tools/python/tests/test_release_tools.py b/tools/python/tests/test_release_tools.py
index abf670d8..1bb78b9a 100644
--- a/tools/python/tests/test_release_tools.py
+++ b/tools/python/tests/test_release_tools.py
@@ -862,12 +862,42 @@ def test_windows_desktop_bundle_uses_branded_gui_startup() -> None:
     configuration = json.loads(
         (desktop / "src-tauri/tauri.conf.json").read_text(encoding="utf-8")
     )
-    nsis = configuration["bundle"]["windows"]["nsis"]
+    windows = configuration["bundle"]["windows"]
+    nsis = windows["nsis"]
 
     assert nsis["installerIcon"] == "icons/icon.ico"
     assert nsis["uninstallerIcon"] == "icons/icon.ico"
     assert (desktop / "src-tauri" / nsis["installerIcon"]).is_file()
 
+    minimum_webview2_version = "111.0.0.0"
+    assert windows["minimumWebview2Version"] == minimum_webview2_version
+    assert windows["webviewInstallMode"] == {
+        "type": "downloadBootstrapper",
+        "silent": True,
+    }
+    assert nsis["installerHooks"] == "windows/webview2-consent.nsh"
+
+    installer_hook = (desktop / "src-tauri" / nsis["installerHooks"]).read_text(
+        encoding="utf-8"
+    )
+    assert "Function .onGUIInit" in installer_hook
+    assert "IfSilent" in installer_hook
+    assert minimum_webview2_version in installer_hook
+    assert "{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}" in installer_hook
+    assert "Microsoft" in installer_hook
+    assert "EdgeUpdate" in installer_hook
+    assert "Clients" in installer_hook
+    assert '"pv"' in installer_hook
+    assert "Installed version:" in installer_hook
+    assert "Minimum required version:" in installer_hook
+    assert "download and install or update" in installer_hook
+    assert "MessageBox MB_OKCANCEL|MB_ICONEXCLAMATION" in installer_hook
+    assert "Quit" in installer_hook
+
+    vite = (desktop / "vite.config.ts").read_text(encoding="utf-8")
+    assert "'chrome111'" in vite
+    assert "'safari16.4'" in vite
+
     main = (desktop / "src-tauri/src/main.rs").read_text(encoding="utf-8")
     assert '#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]' in main
     sidecar = (desktop / "src-tauri/src/server_sidecar.rs").read_text(encoding="utf-8")

From 3851ddec779d9c8c3b81fdf72acda5be9a4ab7b4 Mon Sep 17 00:00:00 2001
From: bzeiss <ben@zeiss.net>
Date: Thu, 20 Aug 2026 08:13:32 +0200
Subject: [PATCH 05/12] overall drag & drop improvements.

---
 .../src/package_operations_support.cpp        |  28 +-
 apps/application/src/package_plan_store.cpp   |  13 +-
 .../src/session_package_import_plan.cpp       |  17 +
 apps/application/src/uploads.cpp              |   4 +-
 .../tests/package_operations_test.cpp         |  38 +++
 apps/application/tests/uploads_test.cpp       |  10 +-
 apps/axkdeck/src-tauri/src/lib.rs             |   2 +-
 apps/axkdeck/src-tauri/src/local_packages.rs  |   9 +-
 apps/axkdeck/src/App.svelte                   |  11 +-
 apps/axkdeck/src/App.test.ts                  |   6 +-
 apps/axkdeck/src/StartupShell.svelte          |   2 +-
 apps/axkdeck/src/app.css                      | 104 +++++-
 apps/axkdeck/src/features/catalog/hooks.ts    |  13 +
 .../src/features/dialogs/AppDialogs.svelte    |  18 +-
 .../import/mediaDropWorkflow.svelte.ts        |  97 ++++--
 .../features/import/mediaDropWorkflow.test.ts |   5 +
 .../import/packageDestinations.test.ts        |  27 ++
 .../features/import/packageDestinations.ts    |  97 ++++++
 .../features/import/packageWorkflow.svelte.ts | 273 ++++++++++++++-
 .../features/import/packageWorkflow.test.ts   | 189 +++++++++++
 .../components/AssignSampleBankDialog.svelte  |  46 +--
 .../components/AssignSampleBankDialog.test.ts |   6 +-
 .../lib/components/AudioImportDialog.test.ts  |   1 +
 .../src/lib/components/AudioImportRows.svelte |  18 +-
 .../components/AudioSamplerSettings.svelte    |  23 +-
 .../lib/components/CollectionToolbar.svelte   |   1 +
 .../lib/components/CollectionToolbar.test.ts  |  46 +++
 .../src/lib/components/ImageNavigator.svelte  |   2 +-
 .../PackageImportDestination.svelte           | 321 ++++++++++++++++++
 .../PackageImportDestination.test.ts          | 116 +++++++
 .../lib/components/PackageImportDialog.svelte |  69 +++-
 .../components/PackageImportDialog.test.ts    |  39 +++
 .../src/lib/components/TreeNode.svelte        |   6 +-
 .../lib/components/Tx16wImportDialog.svelte   |   7 +-
 .../lib/components/VolumeActionDialog.svelte  |   1 +
 apps/axkdeck/src/lib/generated/axklibApiV1.ts |   8 +-
 apps/axkdeck/src/lib/nativeMediaDrop.test.ts  |  21 ++
 apps/axkdeck/src/lib/nativeMediaDrop.ts       |   8 +-
 apps/axkdeck/src/lib/packageImportMedia.ts    |  22 ++
 apps/server/contracts/openapi-v1.base.json    |  12 +-
 apps/server/contracts/openapi-v1.json         |  28 +-
 41 files changed, 1629 insertions(+), 135 deletions(-)
 create mode 100644 apps/axkdeck/src/features/catalog/hooks.ts
 create mode 100644 apps/axkdeck/src/features/import/packageDestinations.test.ts
 create mode 100644 apps/axkdeck/src/features/import/packageDestinations.ts
 create mode 100644 apps/axkdeck/src/lib/components/PackageImportDestination.svelte
 create mode 100644 apps/axkdeck/src/lib/components/PackageImportDestination.test.ts
 create mode 100644 apps/axkdeck/src/lib/packageImportMedia.ts

diff --git a/apps/application/src/package_operations_support.cpp b/apps/application/src/package_operations_support.cpp
index b1fb448f..75ccc4f3 100644
--- a/apps/application/src/package_operations_support.cpp
+++ b/apps/application/src/package_operations_support.cpp
@@ -1,6 +1,8 @@
 #include "package_operations_internal.hpp"
 
 #include <algorithm>
+#include <array>
+#include <cctype>
 #include <cstdint>
 #include <format>
 #include <fstream>
@@ -108,8 +110,13 @@ axk::app::Result<ResolvedPackage> resolve_package(const PackageInput &input, std
     auto snapshot = uploads.inspect(upload, owner_id);
     if (!snapshot)
         return std::unexpected(snapshot.error());
-    if (snapshot->kind != axk::app::UploadKind::package) {
-        return std::unexpected(operation_error("upload_kind_mismatch", "upload is not a portable package"));
+    auto extension = std::filesystem::path{snapshot->filename}.extension().string();
+    std::ranges::transform(extension, extension.begin(),
+                           [](unsigned char character) { return static_cast<char>(std::tolower(character)); });
+    if (snapshot->kind != axk::app::UploadKind::package &&
+        !(snapshot->kind == axk::app::UploadKind::disk_image && extension == ".a3k")) {
+        return std::unexpected(
+            operation_error("upload_kind_mismatch", "upload is not a portable package or A3K archive"));
     }
     auto lease = uploads.lease(upload, owner_id);
     if (!lease)
@@ -122,6 +129,23 @@ axk::app::Result<ResolvedPackage> resolve_package(const PackageInput &input, std
 
 axk::app::Result<axk::PortablePackage> read_package(const ResolvedPackage &resolved, bool verify,
                                                     const axk::app::OperationContext &context) {
+    auto extension = std::filesystem::path{resolved.filename}.extension().string();
+    std::ranges::transform(extension, extension.begin(),
+                           [](unsigned char character) { return static_cast<char>(std::tolower(character)); });
+    if (extension == ".a3k") {
+        auto media = axk::open_media(resolved.reader, std::filesystem::path{resolved.filename}, context.cancellation);
+        if (!media)
+            return std::unexpected(core_error(media.error()));
+        if (media->kind() != axk::MediaKind::a3k_archive)
+            return std::unexpected(operation_error("package_read_failed", "source is not an A3K volume archive"));
+        axk::PackageRootSelector root;
+        root.kind = axk::PackageRootKind::volume;
+        const std::array roots{std::move(root)};
+        auto package = axk::build_portable_package(*media, roots, context.cancellation);
+        if (!package)
+            return std::unexpected(core_error(package.error()));
+        return std::move(package->package);
+    }
     auto package = verify ? axk::open_portable_package(*resolved.reader, resolved.filename, context.cancellation)
                           : axk::inspect_portable_package(*resolved.reader, resolved.filename, context.cancellation);
     if (!package)
diff --git a/apps/application/src/package_plan_store.cpp b/apps/application/src/package_plan_store.cpp
index 4c8b074b..417182a6 100644
--- a/apps/application/src/package_plan_store.cpp
+++ b/apps/application/src/package_plan_store.cpp
@@ -1,5 +1,7 @@
 #include "package_plan_store.hpp"
 
+#include <algorithm>
+#include <cctype>
 #include <limits>
 #include <optional>
 #include <set>
@@ -160,8 +162,15 @@ axk::app::package_plan_internal::retain_sources(std::span<const PackageInput> in
             auto snapshot = uploads.inspect(upload, owner_id);
             if (!snapshot)
                 return std::unexpected(snapshot.error());
-            if (snapshot->state != UploadState::ready || snapshot->kind != UploadKind::package)
-                return std::unexpected(plan_error("upload_kind_mismatch", "upload is not a ready portable package"));
+            auto extension = std::filesystem::path{snapshot->filename}.extension().string();
+            std::ranges::transform(extension, extension.begin(),
+                                   [](unsigned char character) { return static_cast<char>(std::tolower(character)); });
+            const auto supported_kind = snapshot->kind == UploadKind::package ||
+                                        (snapshot->kind == UploadKind::disk_image && extension == ".a3k");
+            if (snapshot->state != UploadState::ready || !supported_kind) {
+                return std::unexpected(
+                    plan_error("upload_kind_mismatch", "upload is not a ready portable package or A3K archive"));
+            }
             auto lease = uploads.lease(upload, owner_id);
             if (!lease)
                 return std::unexpected(lease.error());
diff --git a/apps/application/src/session_package_import_plan.cpp b/apps/application/src/session_package_import_plan.cpp
index 9cbbecb8..4395591a 100644
--- a/apps/application/src/session_package_import_plan.cpp
+++ b/apps/application/src/session_package_import_plan.cpp
@@ -107,6 +107,23 @@ prepare_session_import(const Json &input, std::span<const axk::PortablePackage>
                         {package_index, root_index, *partition, {}, volume_name, {}, {}, false});
                 }
             }
+        } else if (kind == "CREATE_VOLUME") {
+            if (packages.size() != 1U)
+                return std::unexpected(
+                    operation_error("invalid_request", "CREATE_VOLUME requires exactly one import source"));
+            const auto volume_name = destination.at("volumeName").get<std::string>();
+            if (!valid_volume_name(volume_name))
+                return std::unexpected(operation_error("invalid_request", "destination volume name is invalid"));
+            if (std::ranges::any_of(volume_scopes_by_id, [&](const auto &entry) {
+                    return entry.second.partition_index == *partition && entry.second.display_name == volume_name;
+                })) {
+                return std::unexpected(
+                    operation_error("package_destination_conflict", "destination volume name already exists"));
+            }
+            result.destination_volume_names.assign(1U, volume_name);
+            for (std::size_t root_index = 0U; root_index < packages.front().roots.size(); ++root_index) {
+                result.request.root_destinations.push_back({0U, root_index, *partition, {}, volume_name, {}, {}, true});
+            }
         } else if (kind == "CREATE_VOLUMES_FROM_HINTS") {
             std::map<std::size_t, std::string> overrides;
             for (const auto &override_value : destination.value("volumeNameOverrides", Json::array())) {
diff --git a/apps/application/src/uploads.cpp b/apps/application/src/uploads.cpp
index 63b702a0..76e11046 100644
--- a/apps/application/src/uploads.cpp
+++ b/apps/application/src/uploads.cpp
@@ -62,7 +62,7 @@ bool admitted_extension(axk::app::UploadKind kind, const std::filesystem::path &
     case axk::app::UploadKind::manifest:
         return extension == ".json";
     case axk::app::UploadKind::disk_image:
-        return extension == ".img" || extension == ".ima";
+        return extension == ".img" || extension == ".ima" || extension == ".a3k";
     }
     return false;
 }
@@ -96,7 +96,7 @@ std::string_view disallowed_upload_message(axk::app::UploadKind kind) {
     case axk::app::UploadKind::manifest:
         return "manifest uploads require a JSON file";
     case axk::app::UploadKind::disk_image:
-        return "disk image uploads require an IMG or IMA file";
+        return "media uploads require an IMG, IMA, or A3K file";
     }
     return "upload type is not allowed";
 }
diff --git a/apps/application/tests/package_operations_test.cpp b/apps/application/tests/package_operations_test.cpp
index 37f50027..7c9a81ef 100644
--- a/apps/application/tests/package_operations_test.cpp
+++ b/apps/application/tests/package_operations_test.cpp
@@ -709,6 +709,44 @@ TEST_F(PackageOperationsTest, SessionExportsA3kArchiveVolumeAsDirectPackage) {
     EXPECT_EQ(package->source_media_kind, "a3k-archive");
 }
 
+TEST_F(PackageOperationsTest, InspectsA3kArchiveAsAnImportableVolumePackage) {
+    const auto inspected = registry_.invoke(
+        "package.inspect", {{"package", {{"fileRef", {{"rootId", "workspace"}, {"relativePath", "archive.a3k"}}}}}},
+        context());
+    ASSERT_TRUE(inspected) << inspected.error().message;
+    EXPECT_EQ(inspected->at("packageKind"), "volume");
+    EXPECT_EQ(inspected->at("requiredExtension"), ".axkvol");
+    EXPECT_EQ(inspected->at("sourceMediaKind"), "a3k-archive");
+    ASSERT_EQ(inspected->at("roots").size(), 1U);
+    EXPECT_EQ(inspected->at("roots").front().at("displayName"), "Archive Volume");
+}
+
+TEST_F(PackageOperationsTest, SessionImportCreatesOneExplicitlyNamedVolumeForA3kArchive) {
+    const auto opened = images_->open({"workspace", "target.hds"}, "owner");
+    ASSERT_TRUE(opened) << opened.error().message;
+    const auto request = nlohmann::json{
+        {"imageId", opened->image_id},
+        {"expectedRevision", opened->revision},
+        {"packages", {{{"fileRef", {{"rootId", "workspace"}, {"relativePath", "archive.a3k"}}}}}},
+        {"destination", {{"kind", "CREATE_VOLUME"}, {"partitionIndex", 0U}, {"volumeName", "Imported A3K"}}},
+        {"renames", nlohmann::json::array()},
+        {"programSlotAssignments", nlohmann::json::array()},
+        {"opaqueSequenceDecisions", nlohmann::json::array()},
+    };
+    const auto planned = registry_.invoke("images.package_import.plan", request, context());
+    ASSERT_TRUE(planned) << planned.error().message;
+    ASSERT_TRUE(planned->at("valid").get<bool>());
+    ASSERT_EQ(planned->at("packages").size(), 1U);
+    EXPECT_EQ(planned->at("packages").front().at("destinationVolumeName"), "Imported A3K");
+
+    const auto applied = registry_.invoke("images.package_import",
+                                          {{"planToken", planned->at("planToken").get<std::string>()}}, context());
+    ASSERT_TRUE(applied) << applied.error().message;
+    const auto refreshed = images_->inspect(opened->image_id, "owner");
+    ASSERT_TRUE(refreshed) << refreshed.error().message;
+    EXPECT_FALSE(volume_content_id(*refreshed, "Imported A3K").empty());
+}
+
 TEST_F(PackageOperationsTest, SessionInspectsAndExportsImmediateVolumePackagesWithReport) {
     const auto opened = images_->open({"workspace", "batch-volumes.hds"}, "owner");
     ASSERT_TRUE(opened) << opened.error().message;
diff --git a/apps/application/tests/uploads_test.cpp b/apps/application/tests/uploads_test.cpp
index 7b0b270c..c4809d68 100644
--- a/apps/application/tests/uploads_test.cpp
+++ b/apps/application/tests/uploads_test.cpp
@@ -113,6 +113,14 @@ TEST_F(UploadStoreTest, RejectsDiskImagesWrongOwnersOffsetsAndOversizedChunks) {
                                           .sha256 = std::nullopt});
     ASSERT_TRUE(tx16w_disk) << tx16w_disk.error().message;
     ASSERT_TRUE(value.remove(tx16w_disk->reference, "owner"));
+    const auto a3k_archive = value.create({.owner_id = "owner",
+                                           .filename = "JupiterPad.a3k",
+                                           .kind = axk::app::UploadKind::disk_image,
+                                           .media_type = "application/octet-stream",
+                                           .declared_size = 1U,
+                                           .sha256 = std::nullopt});
+    ASSERT_TRUE(a3k_archive) << a3k_archive.error().message;
+    ASSERT_TRUE(value.remove(a3k_archive->reference, "owner"));
     const auto wrong_disk_extension = value.create({.owner_id = "owner",
                                                     .filename = "tx16w.iso",
                                                     .kind = axk::app::UploadKind::disk_image,
@@ -120,7 +128,7 @@ TEST_F(UploadStoreTest, RejectsDiskImagesWrongOwnersOffsetsAndOversizedChunks) {
                                                     .declared_size = 1U,
                                                     .sha256 = std::nullopt});
     ASSERT_FALSE(wrong_disk_extension);
-    EXPECT_EQ(wrong_disk_extension.error().message, "disk image uploads require an IMG or IMA file");
+    EXPECT_EQ(wrong_disk_extension.error().message, "media uploads require an IMG, IMA, or A3K file");
 
     const auto mislabeled_audio = value.create({.owner_id = "owner",
                                                 .filename = "sample.wav",
diff --git a/apps/axkdeck/src-tauri/src/lib.rs b/apps/axkdeck/src-tauri/src/lib.rs
index f41dd553..5f80007e 100644
--- a/apps/axkdeck/src-tauri/src/lib.rs
+++ b/apps/axkdeck/src-tauri/src/lib.rs
@@ -158,7 +158,7 @@ mod tests {
     #[test]
     fn package_picker_accepts_every_current_package_extension() {
         for extension in [
-            "axkvol", "axkprg", "axksbac", "axksbnk", "axksmpl", "axkseq", "axkpkg",
+            "a3k", "axkvol", "axkprg", "axksbac", "axksbnk", "axksmpl", "axkseq", "axkpkg",
         ] {
             assert_eq!(
                 supported_package_extension(&format!("Package.{extension}")),
diff --git a/apps/axkdeck/src-tauri/src/local_packages.rs b/apps/axkdeck/src-tauri/src/local_packages.rs
index 78a0d3f1..39e005d1 100644
--- a/apps/axkdeck/src-tauri/src/local_packages.rs
+++ b/apps/axkdeck/src-tauri/src/local_packages.rs
@@ -14,8 +14,8 @@ use crate::desktop_preferences::DesktopPreferencesStore;
 use crate::{file_publication, remote_settings, retained_download, server_sidecar};
 
 const MAX_RETAINED_PACKAGE_BYTES: u64 = 4 * 1024 * 1024 * 1024;
-const SUPPORTED_PACKAGE_EXTENSIONS: [&str; 7] = [
-    "axkvol", "axkprg", "axksbac", "axksbnk", "axksmpl", "axkseq", "axkpkg",
+const SUPPORTED_PACKAGE_EXTENSIONS: [&str; 8] = [
+    "a3k", "axkvol", "axkprg", "axksbac", "axksbnk", "axksmpl", "axkseq", "axkpkg",
 ];
 const SUPPORTED_MEDIA_EXTENSIONS: [&str; 3] = ["iso", "ima", "zip"];
 
@@ -118,7 +118,10 @@ pub(crate) async fn select_local_package(
             .dialog()
             .file()
             .set_title("Choose axklib package")
-            .add_filter("axklib packages", &SUPPORTED_PACKAGE_EXTENSIONS)
+            .add_filter(
+                "axklib packages and A3K archives",
+                &SUPPORTED_PACKAGE_EXTENSIONS,
+            )
             .set_parent(&window);
         if let Some(directory) = starting_directory {
             dialog = dialog.set_directory(directory);
diff --git a/apps/axkdeck/src/App.svelte b/apps/axkdeck/src/App.svelte
index 9d7b4bfc..8f587f70 100644
--- a/apps/axkdeck/src/App.svelte
+++ b/apps/axkdeck/src/App.svelte
@@ -2,6 +2,7 @@
     import { onDestroy, onMount } from 'svelte';
     import type { AppProps } from './appProps';
     import { AuditionWorkflow } from './features/audition/workflow.svelte';
+    import { createCatalogHooks } from './features/catalog/hooks';
     import { CatalogWorkflow } from './features/catalog/workflow.svelte';
     import { createConnectionActions } from './features/connection/actions';
     import { DeletionWorkflow } from './features/deletion/workflow.svelte';
@@ -115,11 +116,7 @@
         sessionId: () => imageSessionWorkflow.sessionId,
         setStatus: (status) => imageSessionWorkflow.setStatus(status),
     });
-    const catalogHooks = {
-        stopPlayback: () => Promise.resolve(),
-        resetPreviews: () => {},
-        resetCleanup: () => {},
-    };
+    const catalogHooks = createCatalogHooks();
     const catalog = new CatalogWorkflow({
         transport,
         sessionId: () => imageSessionWorkflow.sessionId,
@@ -164,6 +161,9 @@
         refreshSession: (preferred) => imageSessionWorkflow.refresh(preferred),
         setStatus: (status) => imageSessionWorkflow.setStatus(status),
         pickerHistory: packagePickerHistory,
+        mutationsAvailable: () => imageSessionWorkflow.packageImportAvailable,
+        selectedSource: () => imageSessionWorkflow.selectedSource,
+        sourceItems: () => imageSessionWorkflow.sourceItems,
     });
     const packageBatchImportWorkflow = new PackageBatchImportWorkflow({
         transport,
@@ -273,6 +273,7 @@
         audioImport: audioImportWorkflow,
         sequenceImport: sequenceImportWorkflow,
         tx16wImport: tx16wImportWorkflow,
+        packageImport: packageImportWorkflow,
         setStatus: (status) => imageSessionWorkflow.setStatus(status),
     });
     imageSessionWorkflow.connect({
diff --git a/apps/axkdeck/src/App.test.ts b/apps/axkdeck/src/App.test.ts
index 4dc052a8..1652a70c 100644
--- a/apps/axkdeck/src/App.test.ts
+++ b/apps/axkdeck/src/App.test.ts
@@ -623,7 +623,7 @@ describe('App panel layout', () => {
         expect(screen.getByRole('button', { name: 'Create image' }).closest('aside')).toBe(navigator);
         expect(screen.queryByRole('textbox', { name: 'Disk image path' })).toBeNull();
         expect(screen.queryByRole('button', { name: 'Eject image' })).toBeNull();
-        expect(screen.getByText('Partitions, volumes and objects')).toBeTruthy();
+        expect(screen.getByText('Partitions and volumes')).toBeTruthy();
     });
 
     it('closes the active image and returns to the initial empty state', async () => {
@@ -1727,7 +1727,9 @@ describe('App panel layout', () => {
         Object.defineProperty(mixedDrop, 'dataTransfer', { value: mixedTransfer });
         window.dispatchEvent(mixedDrop);
         unavailable = await screen.findByRole('dialog', { name: 'Import unavailable' });
-        expect(within(unavailable).getByText('Drop audio, MIDI, and TX16W disks separately.')).toBeTruthy();
+        expect(
+            within(unavailable).getByText('Drop packages, A3K archives, audio, MIDI, and TX16W disks separately.'),
+        ).toBeTruthy();
         expect(screen.queryByRole('dialog', { name: 'Import MIDI' })).toBeNull();
         expect(screen.queryByRole('dialog', { name: 'Import audio' })).toBeNull();
     });
diff --git a/apps/axkdeck/src/StartupShell.svelte b/apps/axkdeck/src/StartupShell.svelte
index 68f0a76b..5141f7d2 100644
--- a/apps/axkdeck/src/StartupShell.svelte
+++ b/apps/axkdeck/src/StartupShell.svelte
@@ -35,7 +35,7 @@
         <p>IMAGE</p>
         <div class="startup-placeholder">Open Image</div>
         <p>CONTENTS</p>
-        <strong>Partitions, volumes and objects</strong>
+        <strong>Partitions and volumes</strong>
     </aside>
     <main class="startup-workspace">
         <header><strong>Programs</strong><span>0 items</span></header>
diff --git a/apps/axkdeck/src/app.css b/apps/axkdeck/src/app.css
index 9b31935a..75046b12 100644
--- a/apps/axkdeck/src/app.css
+++ b/apps/axkdeck/src/app.css
@@ -29,6 +29,9 @@
   --density-table-header: 20px;
   --density-metadata-row: 22px;
   --density-gap: 4px;
+  --dialog-control-font-size: 11px;
+  --dialog-label-font-size: 10px;
+  --dialog-option-metadata-font-size: 10px;
   --overlay-scrollbar-clearance: 16px;
   --contained-playback-clearance: 10px;
   font-family: var(--font-sans);
@@ -70,7 +73,9 @@ textarea,
 }
 
 button,
-input {
+input,
+select,
+textarea {
   font: inherit;
 }
 
@@ -2123,13 +2128,71 @@ input:focus-visible {
   font-size: 10px;
 }
 
-.volume-action-content input {
+.dialog-field-control {
+  min-width: 0;
   height: var(--density-control);
   padding: 0 8px;
   color: var(--color-text-strong);
   border: 1px solid var(--color-border);
   border-radius: 5px;
+  outline: none;
   background: var(--color-bg-deep);
+  color-scheme: dark;
+  font-family: inherit;
+  font-size: var(--dialog-control-font-size);
+  line-height: 1.2;
+}
+
+.dialog-field-control:focus {
+  border-color: var(--color-accent);
+}
+
+.dialog-autocomplete-list {
+  display: grid;
+  max-height: 220px;
+  overflow-y: auto;
+  color: var(--color-text-strong);
+  border: 1px solid var(--color-border);
+  background: var(--color-bg-deep);
+  box-shadow: 0 10px 24px rgb(0 0 0 / 36%);
+}
+
+.dialog-autocomplete-option {
+  min-height: 28px;
+  padding: 0 8px;
+  color: var(--color-text-strong);
+  border: 0;
+  border-bottom: 1px solid var(--color-border);
+  border-radius: 0;
+  background: transparent;
+  font-family: inherit;
+  font-size: var(--dialog-control-font-size);
+  line-height: 1.25;
+  text-align: left;
+}
+
+.dialog-autocomplete-option:last-of-type {
+  border-bottom: 0;
+}
+
+.dialog-autocomplete-option:hover:not(:disabled),
+.dialog-autocomplete-option.active:not(:disabled) {
+  background: rgb(104 151 187 / 14%);
+}
+
+.dialog-autocomplete-option:disabled {
+  color: var(--color-text-muted);
+  cursor: not-allowed;
+}
+
+.dialog-autocomplete-option small,
+.dialog-autocomplete-empty {
+  color: var(--color-text-muted);
+  font-size: var(--dialog-option-metadata-font-size);
+}
+
+.volume-action-content input {
+  width: 100%;
 }
 
 .volume-action-content strong {
@@ -2781,11 +2844,44 @@ input:focus-visible {
   white-space: nowrap;
 }
 
-.collection-filter input {
+.compact-checkbox {
+  display: grid;
   width: 12px;
   height: 12px;
+  flex: none;
   margin: 0;
-  accent-color: var(--color-accent);
+  padding: 0;
+  overflow: hidden;
+  appearance: none;
+  place-content: center;
+  color: #fff;
+  border: 1px solid var(--color-border);
+  border-radius: 2px;
+  background: var(--color-bg-deep);
+  cursor: pointer;
+}
+
+.compact-checkbox::before {
+  width: 3px;
+  height: 6px;
+  content: '';
+  border: solid currentcolor;
+  border-width: 0 1.5px 1.5px 0;
+  transform: translateY(-0.5px) rotate(45deg) scale(0);
+}
+
+.compact-checkbox:checked {
+  border-color: var(--color-accent);
+  background: var(--color-accent);
+}
+
+.compact-checkbox:checked::before {
+  transform: translateY(-0.5px) rotate(45deg) scale(1);
+}
+
+.compact-checkbox:disabled {
+  cursor: default;
+  opacity: 0.5;
 }
 
 .collection-actions .collection-search {
diff --git a/apps/axkdeck/src/features/catalog/hooks.ts b/apps/axkdeck/src/features/catalog/hooks.ts
new file mode 100644
index 00000000..7180d5ac
--- /dev/null
+++ b/apps/axkdeck/src/features/catalog/hooks.ts
@@ -0,0 +1,13 @@
+export interface CatalogHooks {
+    stopPlayback: () => Promise<void>;
+    resetPreviews: () => void;
+    resetCleanup: () => void;
+}
+
+export function createCatalogHooks(): CatalogHooks {
+    return {
+        stopPlayback: () => Promise.resolve(),
+        resetPreviews: () => {},
+        resetCleanup: () => {},
+    };
+}
diff --git a/apps/axkdeck/src/features/dialogs/AppDialogs.svelte b/apps/axkdeck/src/features/dialogs/AppDialogs.svelte
index 7c09b21f..e92877f9 100644
--- a/apps/axkdeck/src/features/dialogs/AppDialogs.svelte
+++ b/apps/axkdeck/src/features/dialogs/AppDialogs.svelte
@@ -255,8 +255,14 @@
 {/if}
 {#if packageImport.request && pickerRequest?.parentDialog !== 'package-import'}
     <PackageImportDialog
-        targetName={packageImport.request.item.name}
+        targetName={packageImport.targetName()}
+        destinationMode={packageImport.request.destinationMode}
+        destinationPartitionIndex={packageImport.request.destinationPartitionIndex}
+        destinationVolumeName={packageImport.request.destinationVolumeName}
+        partitionOptions={packageImport.partitionOptions()}
+        volumeOptions={packageImport.volumeOptions()}
         desktop={isDesktop}
+        canChangeSource={packageImport.request.canChangeSource}
         sourceName={packageImport.request.sourceName}
         inspection={packageImport.request.inspection}
         plan={packageImport.request.plan}
@@ -270,6 +276,11 @@
         onchooseworkspace={() => void packageImport.chooseWorkspace()}
         onchooselocal={() => void packageImport.chooseLocal()}
         onchange={() => void packageImport.resetSource()}
+        ondestinationmode={(mode) => packageImport.setDestinationMode(mode)}
+        ondestinationvolume={(partitionIndex, volumeName) =>
+            packageImport.setExistingVolume(partitionIndex, volumeName)}
+        ondestinationpartition={(partitionIndex) => packageImport.setDestinationPartition(partitionIndex)}
+        ondestinationname={(name) => packageImport.setDestinationVolumeName(name)}
         onrename={(nodeId, name) => packageImport.rename(nodeId, name)}
         onprogramslot={(nodeId, slot) => packageImport.programSlot(nodeId, slot)}
         onprogramstart={(placementId, start) => packageImport.programStart(placementId, start)}
@@ -472,7 +483,7 @@
         onclose={() => mediaDrop.closeNotice()}
     />
 {/if}
-{#if mediaDrop.dragActive && !audioImport.request && !sequenceImport.request && !tx16wImport.request}
+{#if mediaDrop.dragActive && !audioImport.request && !sequenceImport.request && !tx16wImport.request && !packageImport.request}
     <div class="media-drop-overlay" aria-hidden="true">
         <Icon name="upload" size={24} />
         {#if mediaDrop.dragKind === 'mixed'}
@@ -492,6 +503,9 @@
                     : 'Select a writable volume'}</strong
             >
             <span>Standard MIDI Files (.mid, .midi)</span>
+        {:else if mediaDrop.dragKind === 'package'}
+            <strong>Import package or A3K archive</strong>
+            <span>Choose an existing volume or create a new one after dropping</span>
         {:else}
             <strong
                 >{mediaDrop.dragTarget
diff --git a/apps/axkdeck/src/features/import/mediaDropWorkflow.svelte.ts b/apps/axkdeck/src/features/import/mediaDropWorkflow.svelte.ts
index 8aef4115..fe9d329b 100644
--- a/apps/axkdeck/src/features/import/mediaDropWorkflow.svelte.ts
+++ b/apps/axkdeck/src/features/import/mediaDropWorkflow.svelte.ts
@@ -3,15 +3,18 @@ import { browserUploadSource, type ClientUploadSource } from '../../lib/clientUp
 import { reportDiagnostic, reportError } from '../../lib/diagnostics';
 import { midiMediaType } from '../../lib/midiImport';
 import { listenForNativeMediaDrops, type NativeDropPosition } from '../../lib/nativeMediaDrop';
+import { packageImportUploadKind } from '../../lib/packageImportMedia';
 import type { AudioImportTarget } from '../../lib/transport';
 import { tx16wDiskMediaType } from '../../lib/tx16wImport';
-import type { WorkspaceView } from '../../lib/types';
+import type { DiskTreeItem, WorkspaceView } from '../../lib/types';
 import type { AudioImportWorkflow } from './audioWorkflow.svelte';
+import type { PackageImportWorkflow } from './packageWorkflow.svelte';
 import type { SequenceImportWorkflow } from './sequenceWorkflow.svelte';
 import type { Tx16wImportWorkflow } from './tx16wWorkflow.svelte';
 
-export type MediaDropKind = 'audio' | 'midi' | 'tx16w' | 'mixed';
+export type MediaDropKind = 'audio' | 'midi' | 'tx16w' | 'package' | 'mixed';
 type ClassifiedMedia = MediaDropKind | 'none';
+type DropTarget = AudioImportTarget | DiskTreeItem;
 
 export interface MediaDropNotice {
     title: string;
@@ -24,6 +27,7 @@ interface MediaDropDependencies {
     audioImport: AudioImportWorkflow;
     sequenceImport: SequenceImportWorkflow;
     tx16wImport: Tx16wImportWorkflow;
+    packageImport: PackageImportWorkflow;
     setStatus: (status: string) => void;
 }
 
@@ -53,7 +57,9 @@ export class MediaDropWorkflow {
                     mediaKind: kind,
                 });
                 if (droppedPathCount > 0 && files.length === 0) {
-                    this.dependencies.setStatus('No supported audio, MIDI, or TX16W disk files were dropped');
+                    this.dependencies.setStatus(
+                        'No supported package, A3K, audio, MIDI, or TX16W disk files were dropped',
+                    );
                     return;
                 }
                 void this.route(files, position ? this.nativeDroppedTarget(position, kind) : null);
@@ -93,9 +99,11 @@ export class MediaDropWorkflow {
             return;
         }
         this.dragKind = kind;
-        this.dragTarget = kind === 'mixed' ? null : this.targetForElement(event.target, kind);
+        const target = kind === 'mixed' ? null : this.targetForElement(event.target, kind);
+        this.dragTarget = target && !('kind' in target) ? target : null;
         this.dragActive = true;
-        dataTransfer.dropEffect = kind === 'mixed' || (kind !== 'tx16w' && this.dragTarget === null) ? 'none' : 'copy';
+        const dropAvailable = kind === 'package' ? this.dependencies.packageImport.dropAvailable() : target !== null;
+        dataTransfer.dropEffect = kind === 'mixed' || !dropAvailable ? 'none' : 'copy';
     }
 
     leave(event: DragEvent): void {
@@ -113,20 +121,49 @@ export class MediaDropWorkflow {
         if (files.length > 0) void this.route(files, target);
     }
 
-    private async route(files: ClientUploadSource[], target: AudioImportTarget | null): Promise<void> {
+    private async route(files: ClientUploadSource[], target: DropTarget | null): Promise<void> {
         if (this.importDialogOpen() || files.length === 0) return;
         const kind = classifyDroppedNames(files.map((file) => file.name));
         if (kind === 'mixed') {
             this.dependencies.setStatus('Drop one media type at a time');
-            this.notice = { title: 'Import unavailable', message: 'Drop audio, MIDI, and TX16W disks separately.' };
+            this.notice = {
+                title: 'Import unavailable',
+                message: 'Drop packages, A3K archives, audio, MIDI, and TX16W disks separately.',
+            };
             return;
         }
         const selectedKind = kind === 'none' ? this.defaultKind() : kind;
         if (kind === 'none') {
-            if (selectedKind === 'midi') await this.dependencies.sequenceImport.requestDroppedFiles(files, target);
-            else await this.dependencies.audioImport.requestDroppedFiles(files, target);
+            const volumeTarget = target && !('kind' in target) ? target : null;
+            if (selectedKind === 'midi')
+                await this.dependencies.sequenceImport.requestDroppedFiles(files, volumeTarget);
+            else await this.dependencies.audioImport.requestDroppedFiles(files, volumeTarget);
             return;
         }
+        if (selectedKind === 'package') {
+            if (files.length !== 1) {
+                this.dependencies.setStatus('Drop one package or A3K archive at a time');
+                this.notice = {
+                    title: 'Import unavailable',
+                    message: 'Choose one portable package or A3K archive for each import.',
+                };
+                return;
+            }
+            if (!this.dependencies.packageImport.dropAvailable()) {
+                this.dependencies.setStatus('Package import requires a writable SFS hard-disk image');
+                this.notice = {
+                    title: 'Package import unavailable',
+                    message: 'Open a writable SFS hard-disk image, then drop the package again.',
+                };
+                return;
+            }
+            await this.dependencies.packageImport.requestDroppedFile(
+                files[0],
+                target && 'kind' in target ? target : null,
+            );
+            return;
+        }
+        const volumeTarget = target && !('kind' in target) ? target : null;
         if (selectedKind === 'tx16w') {
             if (!this.dependencies.tx16wImport.dropAvailable()) {
                 this.dependencies.setStatus('TX16W import requires a writable SFS hard-disk image');
@@ -136,7 +173,7 @@ export class MediaDropWorkflow {
                 };
                 return;
             }
-            await this.dependencies.tx16wImport.requestDroppedFiles(files, target);
+            await this.dependencies.tx16wImport.requestDroppedFiles(files, volumeTarget);
             return;
         }
         if (selectedKind === 'midi') {
@@ -148,7 +185,7 @@ export class MediaDropWorkflow {
                 };
                 return;
             }
-            if (!target) {
+            if (!volumeTarget) {
                 this.dependencies.setStatus('Select a writable volume first');
                 this.notice = {
                     title: 'MIDI import unavailable',
@@ -156,10 +193,10 @@ export class MediaDropWorkflow {
                 };
                 return;
             }
-            await this.dependencies.sequenceImport.requestDroppedFiles(files, target);
+            await this.dependencies.sequenceImport.requestDroppedFiles(files, volumeTarget);
             return;
         }
-        if (!target) {
+        if (!volumeTarget) {
             this.dependencies.setStatus('Select a writable volume first');
             this.notice = {
                 title: 'Audio import unavailable',
@@ -167,7 +204,7 @@ export class MediaDropWorkflow {
             };
             return;
         }
-        await this.dependencies.audioImport.requestDroppedFiles(files, target);
+        await this.dependencies.audioImport.requestDroppedFiles(files, volumeTarget);
     }
 
     private updateHover(paths: readonly string[], position?: NativeDropPosition): void {
@@ -181,7 +218,8 @@ export class MediaDropWorkflow {
             return;
         }
         this.dragKind = kind;
-        this.dragTarget = kind === 'mixed' || !position ? null : this.nativeDroppedTarget(position, kind);
+        const target = kind === 'mixed' || !position ? null : this.nativeDroppedTarget(position, kind);
+        this.dragTarget = target && !('kind' in target) ? target : null;
         this.dragActive = true;
     }
 
@@ -189,8 +227,25 @@ export class MediaDropWorkflow {
         return this.dependencies.workspaceView() === 'sequences' ? 'midi' : 'audio';
     }
 
-    private targetForElement(target: EventTarget | null, kind: ClassifiedMedia): AudioImportTarget | null {
+    private targetForElement(target: EventTarget | null, kind: ClassifiedMedia): DropTarget | null {
         if (kind === 'mixed' || kind === 'none') return null;
+        if (kind === 'package') {
+            if (!this.dependencies.packageImport.dropAvailable()) return null;
+            const element = target instanceof Element ? target.closest<HTMLElement>('[data-import-drop-kind]') : null;
+            const partition = element?.dataset.importDropPartition;
+            const itemKind = element?.dataset.importDropKind;
+            const name = element?.dataset.importDropName;
+            if ((itemKind === 'partition' || itemKind === 'volume') && partition !== undefined && name) {
+                return {
+                    id: `drop-${itemKind}-${partition}-${name}`,
+                    name,
+                    kind: itemKind,
+                    partitionIndex: Number(partition),
+                    childCount: 0,
+                };
+            }
+            return null;
+        }
         const workflow =
             kind === 'midi'
                 ? this.dependencies.sequenceImport
@@ -206,7 +261,7 @@ export class MediaDropWorkflow {
         return workflow.activeTarget();
     }
 
-    private nativeDroppedTarget(position: NativeDropPosition, kind: ClassifiedMedia): AudioImportTarget | null {
+    private nativeDroppedTarget(position: NativeDropPosition, kind: ClassifiedMedia): DropTarget | null {
         const scale = window.devicePixelRatio > 0 ? window.devicePixelRatio : 1;
         return this.targetForElement(document.elementFromPoint?.(position.x / scale, position.y / scale) ?? null, kind);
     }
@@ -216,7 +271,8 @@ export class MediaDropWorkflow {
             this.notice !== null ||
             this.dependencies.audioImport.request !== null ||
             this.dependencies.sequenceImport.request !== null ||
-            this.dependencies.tx16wImport.request !== null
+            this.dependencies.tx16wImport.request !== null ||
+            this.dependencies.packageImport.request !== null
         );
     }
 
@@ -231,15 +287,18 @@ export function classifyDroppedNames(names: readonly string[]): ClassifiedMedia
     let audio = false;
     let midi = false;
     let tx16w = false;
+    let packageMedia = false;
     for (const name of names) {
         audio ||= audioMediaType(name) !== null;
         midi ||= midiMediaType(name) !== null;
         tx16w ||= tx16wDiskMediaType(name) !== null;
+        packageMedia ||= packageImportUploadKind(name) !== null;
     }
-    if (Number(audio) + Number(midi) + Number(tx16w) > 1) return 'mixed';
+    if (Number(audio) + Number(midi) + Number(tx16w) + Number(packageMedia) > 1) return 'mixed';
     if (audio) return 'audio';
     if (midi) return 'midi';
     if (tx16w) return 'tx16w';
+    if (packageMedia) return 'package';
     return 'none';
 }
 
diff --git a/apps/axkdeck/src/features/import/mediaDropWorkflow.test.ts b/apps/axkdeck/src/features/import/mediaDropWorkflow.test.ts
index 9f14b739..8d3c9ad4 100644
--- a/apps/axkdeck/src/features/import/mediaDropWorkflow.test.ts
+++ b/apps/axkdeck/src/features/import/mediaDropWorkflow.test.ts
@@ -9,8 +9,13 @@ describe('media drop classification', () => {
         [['song.MIDI', 'notes.txt'], 'midi'],
         [['sounds.ima'], 'tx16w'],
         [['sounds.IMG'], 'tx16w'],
+        [['archive.a3k'], 'package'],
+        [['volume.axkvol'], 'package'],
+        [['program.AXKPRG'], 'package'],
         [['take.aiff', 'song.mid'], 'mixed'],
         [['take.wav', 'sounds.ima'], 'mixed'],
+        [['archive.a3k', 'volume.axkvol'], 'package'],
+        [['archive.a3k', 'take.wav'], 'mixed'],
         [['notes.txt'], 'none'],
         [[], 'none'],
     ] as const)('classifies %j as %s', (names, expected) => {
diff --git a/apps/axkdeck/src/features/import/packageDestinations.test.ts b/apps/axkdeck/src/features/import/packageDestinations.test.ts
new file mode 100644
index 00000000..cc866fe3
--- /dev/null
+++ b/apps/axkdeck/src/features/import/packageDestinations.test.ts
@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest';
+import { packageImportDestination } from './packageDestinations';
+
+describe('packageImportDestination', () => {
+    it('preserves the exact name of an existing sampler volume', () => {
+        expect(packageImportDestination('existing', 2, '  Existing Volume  ')).toEqual({
+            kind: 'EXISTING_VOLUME',
+            partitionIndex: 2,
+            volumeName: '  Existing Volume  ',
+        });
+    });
+
+    it('accepts a valid new sampler volume name without rewriting it', () => {
+        expect(packageImportDestination('create', 0, 'New Volume')).toEqual({
+            kind: 'CREATE_VOLUME',
+            partitionIndex: 0,
+            volumeName: 'New Volume',
+        });
+    });
+
+    it.each([' New Volume', 'New Volume ', '12345678901234567', 'New\nVolume'])(
+        'rejects the invalid new sampler volume name %j',
+        (volumeName) => {
+            expect(packageImportDestination('create', 0, volumeName)).toBeNull();
+        },
+    );
+});
diff --git a/apps/axkdeck/src/features/import/packageDestinations.ts b/apps/axkdeck/src/features/import/packageDestinations.ts
new file mode 100644
index 00000000..a7e5748f
--- /dev/null
+++ b/apps/axkdeck/src/features/import/packageDestinations.ts
@@ -0,0 +1,97 @@
+import type { DiskTreeItem } from '../../lib/types';
+import type { PackageInspection } from '../../lib/transport';
+
+export type PackageImportDestinationMode = 'existing' | 'create';
+
+export interface PackageImportPartitionOption {
+    partitionIndex: number;
+    name: string;
+}
+
+export interface PackageImportVolumeOption extends PackageImportPartitionOption {
+    volumeName: string;
+    label: string;
+}
+
+export interface PackageImportDestinations {
+    partitions: PackageImportPartitionOption[];
+    volumes: PackageImportVolumeOption[];
+    partitionItems: DiskTreeItem[];
+    volumeItems: DiskTreeItem[];
+}
+
+export type PackageImportDestination =
+    | { kind: 'EXISTING_VOLUME'; partitionIndex: number; volumeName: string }
+    | { kind: 'CREATE_VOLUME'; partitionIndex: number; volumeName: string };
+
+export function collectPackageImportDestinations(sourceItems: readonly DiskTreeItem[]): PackageImportDestinations {
+    const partitionItems: DiskTreeItem[] = [];
+    const volumeItems: DiskTreeItem[] = [];
+    const visit = (item: DiskTreeItem): void => {
+        if (item.kind === 'partition' && item.partitionIndex !== undefined) partitionItems.push(item);
+        if (item.kind === 'volume' && item.partitionIndex !== undefined) volumeItems.push(item);
+        item.children?.forEach(visit);
+    };
+    sourceItems.forEach(visit);
+    const partitionNames = new Map(partitionItems.map((item) => [item.partitionIndex!, item.name]));
+    return {
+        partitionItems,
+        volumeItems,
+        partitions: partitionItems.map((item) => ({ partitionIndex: item.partitionIndex!, name: item.name })),
+        volumes: volumeItems.map((item) => {
+            const partitionIndex = item.partitionIndex!;
+            const name = partitionNames.get(partitionIndex) ?? `Partition ${partitionIndex + 1}`;
+            return {
+                partitionIndex,
+                name,
+                volumeName: item.name,
+                label: `${name} / ${item.name}`,
+            };
+        }),
+    };
+}
+
+export function initialPackageImportDestination(item: DiskTreeItem): {
+    mode: PackageImportDestinationMode;
+    partitionIndex: number | null;
+    volumeName: string;
+} | null {
+    if (item.kind === 'volume' && item.partitionIndex !== undefined) {
+        return { mode: 'existing', partitionIndex: item.partitionIndex, volumeName: item.name };
+    }
+    if (item.kind === 'partition' && item.partitionIndex !== undefined) {
+        return { mode: 'create', partitionIndex: item.partitionIndex, volumeName: '' };
+    }
+    return null;
+}
+
+export function packageImportDestination(
+    mode: PackageImportDestinationMode,
+    partitionIndex: number | null,
+    rawVolumeName: string,
+): PackageImportDestination | null {
+    if (partitionIndex === null || rawVolumeName.length === 0) return null;
+    if (
+        mode === 'create' &&
+        (rawVolumeName.length > 16 ||
+            rawVolumeName.startsWith(' ') ||
+            rawVolumeName.endsWith(' ') ||
+            Array.from(rawVolumeName).some((character) => {
+                const code = character.charCodeAt(0);
+                return code < 0x20 || code > 0x7e;
+            }))
+    ) {
+        return null;
+    }
+    return {
+        kind: mode === 'create' ? 'CREATE_VOLUME' : 'EXISTING_VOLUME',
+        partitionIndex,
+        volumeName: rawVolumeName,
+    };
+}
+
+export function suggestedPackageVolumeName(sourceName: string, inspection: PackageInspection | null): string {
+    const extension = sourceName.split('.').pop()?.toLowerCase() ?? '';
+    if (!inspection || (extension !== 'a3k' && extension !== 'axkvol')) return '';
+    return (inspection.roots[0]?.displayName ?? '').trim().slice(0, 16);
+}
diff --git a/apps/axkdeck/src/features/import/packageWorkflow.svelte.ts b/apps/axkdeck/src/features/import/packageWorkflow.svelte.ts
index e3fe09f0..48e984db 100644
--- a/apps/axkdeck/src/features/import/packageWorkflow.svelte.ts
+++ b/apps/axkdeck/src/features/import/packageWorkflow.svelte.ts
@@ -1,6 +1,12 @@
 import { nativeFileSource } from '../../lib/nativeFileSource';
 import { selectLocalPackage } from '../../lib/nativePackages';
+import type { ClientUploadSource } from '../../lib/clientUploadSource';
 import type { ClientUploadLocation, InputFileLocation } from '../../lib/storageLocations';
+import {
+    packageImportExtensions,
+    packageImportExtensionSetCopy,
+    packageImportUploadKind,
+} from '../../lib/packageImportMedia';
 import type {
     ImageSessionPackageImportPlan,
     ImageTransport,
@@ -12,17 +18,29 @@ import { userFacingMessage } from '../../lib/userFacingMessage';
 import { reportError } from '../../lib/diagnostics';
 import type { PickerController } from '../dialogs/picker';
 import type { JobController } from '../jobs/actions';
+import {
+    collectPackageImportDestinations,
+    initialPackageImportDestination,
+    packageImportDestination,
+    suggestedPackageVolumeName,
+    type PackageImportDestinationMode,
+    type PackageImportPartitionOption,
+    type PackageImportVolumeOption,
+} from './packageDestinations';
 import { PackagePickerHistory } from './packagePickerHistory';
 
-const packageExtensions = ['axkvol', 'axkprg', 'axksbac', 'axksbnk', 'axksmpl', 'axkseq', 'axkpkg'];
-const packageExtensionSet = new Set(packageExtensions);
+const packageExtensionSet = packageImportExtensionSetCopy();
 
 export interface PackageImportRequest {
     item: DiskTreeItem;
+    canChangeSource: boolean;
     source: InputFileLocation | null;
     upload: ClientUploadLocation | null;
     localSourcePath: string | null;
     sourceName: string;
+    destinationMode: PackageImportDestinationMode;
+    destinationPartitionIndex: number | null;
+    destinationVolumeName: string;
     inspection: PackageInspection | null;
     plan: ImageSessionPackageImportPlan | null;
     renames: Record<string, string>;
@@ -44,6 +62,9 @@ interface PackageImportDependencies {
     refreshSession: (preferred: { partitionIndex: number; volumeName?: string }) => Promise<void>;
     setStatus: (status: string) => void;
     pickerHistory?: PackagePickerHistory;
+    mutationsAvailable?: () => boolean;
+    selectedSource?: () => DiskTreeItem;
+    sourceItems?: () => DiskTreeItem[];
 }
 
 export class PackageImportWorkflow {
@@ -60,12 +81,21 @@ export class PackageImportWorkflow {
         ++this.generation;
         this.abortController?.abort();
         this.abortController = null;
+        const destination = initialPackageImportDestination(item) ?? {
+            mode: 'create' as const,
+            partitionIndex: null,
+            volumeName: '',
+        };
         this.request = {
             item,
+            canChangeSource: true,
             source: null,
             upload: null,
             localSourcePath: null,
             sourceName: '',
+            destinationMode: destination.mode,
+            destinationPartitionIndex: destination.partitionIndex,
+            destinationVolumeName: destination.volumeName,
             inspection: null,
             plan: null,
             renames: {},
@@ -78,6 +108,86 @@ export class PackageImportWorkflow {
         };
     }
 
+    dropAvailable(): boolean {
+        return this.dependencies.mutationsAvailable?.() ?? false;
+    }
+
+    partitionOptions(): PackageImportPartitionOption[] {
+        return this.destinations().partitions;
+    }
+
+    volumeOptions(): PackageImportVolumeOption[] {
+        return this.destinations().volumes;
+    }
+
+    targetName(): string {
+        const request = this.request;
+        if (!request) return '';
+        return request.destinationMode === 'create'
+            ? request.destinationVolumeName.trim() || 'new volume'
+            : request.destinationVolumeName;
+    }
+
+    setDestinationMode(mode: PackageImportDestinationMode): void {
+        const request = this.request;
+        if (!request || request.status === 'applying' || request.destinationMode === mode) return;
+        const destinations = this.destinations();
+        const currentVolume = destinations.volumes.find(
+            (option) =>
+                option.partitionIndex === request.destinationPartitionIndex &&
+                option.volumeName === request.destinationVolumeName,
+        );
+        const partitionIndex =
+            mode === 'existing'
+                ? (currentVolume?.partitionIndex ?? null)
+                : (request.destinationPartitionIndex ?? destinations.partitions[0]?.partitionIndex ?? null);
+        const volumeName =
+            mode === 'existing'
+                ? (currentVolume?.volumeName ?? '')
+                : suggestedPackageVolumeName(request.sourceName, request.inspection);
+        this.updateDestination(
+            {
+                destinationMode: mode,
+                destinationPartitionIndex: partitionIndex,
+                destinationVolumeName: volumeName,
+            },
+            true,
+        );
+    }
+
+    setExistingVolume(partitionIndex: number | null, volumeName: string): void {
+        const request = this.request;
+        if (
+            !request ||
+            request.status === 'applying' ||
+            (request.destinationMode === 'existing' &&
+                request.destinationPartitionIndex === partitionIndex &&
+                request.destinationVolumeName === volumeName)
+        ) {
+            return;
+        }
+        this.updateDestination(
+            {
+                destinationMode: 'existing',
+                destinationPartitionIndex: partitionIndex,
+                destinationVolumeName: volumeName,
+            },
+            partitionIndex !== null,
+        );
+    }
+
+    setDestinationPartition(partitionIndex: number): void {
+        const request = this.request;
+        if (!request || request.status === 'applying' || request.destinationPartitionIndex === partitionIndex) return;
+        this.updateDestination({ destinationPartitionIndex: partitionIndex }, true);
+    }
+
+    setDestinationVolumeName(volumeName: string): void {
+        const request = this.request;
+        if (!request || request.status === 'applying' || request.destinationVolumeName === volumeName) return;
+        this.updateDestination({ destinationVolumeName: volumeName.slice(0, 16) }, false);
+    }
+
     rename(nodeId: string, name: string): void {
         if (!this.request || this.request.status !== 'ready' || this.request.renames[nodeId] === name) return;
         this.request = {
@@ -149,7 +259,7 @@ export class PackageImportWorkflow {
     }
 
     async resetSource(): Promise<void> {
-        if (!this.request || this.request.status === 'applying') return;
+        if (!this.request || !this.request.canChangeSource || this.request.status === 'applying') return;
         const request = this.request;
         ++this.generation;
         this.abortController?.abort();
@@ -173,12 +283,62 @@ export class PackageImportWorkflow {
         };
     }
 
+    async requestDroppedFile(file: ClientUploadSource, target?: DiskTreeItem | null): Promise<void> {
+        if (this.request || !this.dropAvailable()) return;
+        const selected = this.dependencies.selectedSource?.();
+        const item =
+            target ??
+            (selected && (selected.kind === 'partition' || selected.kind === 'volume') ? selected : null) ??
+            this.fallbackDestinationItem();
+        if (!item || (item.kind !== 'partition' && item.kind !== 'volume')) {
+            this.dependencies.setStatus('Choose an import destination first');
+            return;
+        }
+        const uploadKind = packageImportUploadKind(file.name);
+        if (!uploadKind) return;
+        this.open(item);
+        const controller = new AbortController();
+        this.abortController = controller;
+        const generation = ++this.generation;
+        this.request = {
+            ...this.request!,
+            canChangeSource: false,
+            sourceName: file.name,
+            status: 'loading',
+            progress: 0,
+            error: '',
+        };
+        try {
+            const upload = await this.dependencies.transport.uploadClientFile(
+                file,
+                uploadKind,
+                (sent, total) => {
+                    if (generation === this.generation && this.request) {
+                        this.request = { ...this.request, progress: total === 0 ? 0 : sent / total };
+                    }
+                },
+                controller.signal,
+            );
+            if (this.abortController === controller) this.abortController = null;
+            if (generation !== this.generation || !this.request) {
+                await this.dependencies.transport.releaseClientUpload(upload).catch(() => undefined);
+                return;
+            }
+            await this.inspect(upload, file.name, upload);
+        } catch (error) {
+            if (this.abortController === controller) this.abortController = null;
+            if (generation !== this.generation || !this.request) return;
+            reportError('Import dropped package failed', error);
+            this.request = { ...this.request, status: 'choosing', error: userFacingMessage(error) };
+        }
+    }
+
     async chooseWorkspace(): Promise<void> {
         if (!this.request) return;
         const selection = await this.dependencies.picker.chooseLocation(
             'file',
             'Choose axklib package',
-            packageExtensions,
+            [...packageImportExtensions],
             '',
             {
                 parentDialog: 'package-import',
@@ -221,7 +381,7 @@ export class PackageImportWorkflow {
             };
             const upload = await this.dependencies.transport.uploadClientFile(
                 file,
-                'PACKAGE',
+                packageImportUploadKind(file.name) ?? 'PACKAGE',
                 (sent, total) => {
                     if (generation === this.generation && this.request) {
                         this.request = { ...this.request, progress: total === 0 ? 0 : sent / total };
@@ -262,19 +422,26 @@ export class PackageImportWorkflow {
     async apply(): Promise<void> {
         const request = this.request;
         const sessionId = this.dependencies.sessionId();
+        const destination = request
+            ? packageImportDestination(
+                  request.destinationMode,
+                  request.destinationPartitionIndex,
+                  request.destinationVolumeName,
+              )
+            : null;
         if (
             !request?.source ||
             !request.plan?.valid ||
             request.hasUnvalidatedChanges ||
             sessionId === null ||
-            request.item.partitionIndex === undefined
+            !destination
         ) {
             return;
         }
         const importedSource = request.source;
         const generation = ++this.generation;
         this.request = { ...request, status: 'applying', error: '' };
-        this.dependencies.setStatus(`Importing package into ${request.item.name}`);
+        this.dependencies.setStatus(`Importing package into ${destination.volumeName}`);
         try {
             await this.dependencies.invalidateSession(sessionId);
             const completed = await this.dependencies.jobs.run(
@@ -294,10 +461,10 @@ export class PackageImportWorkflow {
             }
             this.request = null;
             await this.dependencies.refreshSession({
-                partitionIndex: request.item.partitionIndex,
-                volumeName: request.item.name,
+                partitionIndex: destination.partitionIndex,
+                volumeName: destination.volumeName,
             });
-            this.dependencies.setStatus(`Imported package into ${request.item.name}`);
+            this.dependencies.setStatus(`Imported package into ${destination.volumeName}`);
         } catch (error) {
             const message = userFacingMessage(error);
             this.dependencies.setStatus(message);
@@ -318,6 +485,50 @@ export class PackageImportWorkflow {
         }
     }
 
+    private updateDestination(
+        update: Partial<
+            Pick<PackageImportRequest, 'destinationMode' | 'destinationPartitionIndex' | 'destinationVolumeName'>
+        >,
+        automaticallyPlan: boolean,
+    ): void {
+        const request = this.request;
+        if (!request || request.status === 'applying') return;
+        const previousPlan = request.plan;
+        const next = {
+            ...request,
+            ...update,
+            plan: null,
+            renames: {},
+            programSlots: {},
+            hasUnvalidatedChanges: true,
+            status: request.source ? ('ready' as const) : request.status,
+            error: '',
+        };
+        const destination = packageImportDestination(
+            next.destinationMode,
+            next.destinationPartitionIndex,
+            next.destinationVolumeName,
+        );
+        const shouldPlan = automaticallyPlan && next.source !== null && destination !== null;
+        const generation = ++this.generation;
+        this.request = { ...next, status: shouldPlan ? 'planning' : next.status };
+        void (async () => {
+            if (previousPlan) {
+                await this.dependencies.transport
+                    .releaseImagePackageImportPlan(previousPlan.planToken)
+                    .catch(() => undefined);
+            }
+            if (!shouldPlan || generation !== this.generation || !this.request) return;
+            try {
+                await this.plan(generation);
+            } catch (error) {
+                if (generation === this.generation && this.request) {
+                    this.request = { ...this.request, status: 'ready', error: userFacingMessage(error) };
+                }
+            }
+        })();
+    }
+
     private async inspect(
         source: InputFileLocation,
         sourceName: string,
@@ -348,7 +559,16 @@ export class PackageImportWorkflow {
                 if (upload) await this.dependencies.transport.releaseClientUpload(upload).catch(() => undefined);
                 return;
             }
-            this.request = { ...this.request, inspection, status: 'planning' };
+            const suggestedName = suggestedPackageVolumeName(sourceName, inspection);
+            this.request = {
+                ...this.request,
+                inspection,
+                destinationVolumeName:
+                    this.request.destinationMode === 'create' && !this.request.destinationVolumeName.trim()
+                        ? suggestedName
+                        : this.request.destinationVolumeName,
+                status: 'planning',
+            };
             await this.plan(generation);
         } catch (error) {
             if (generation !== this.generation || !this.request) {
@@ -378,7 +598,19 @@ export class PackageImportWorkflow {
     ): Promise<string | null> {
         const request = this.request;
         const sessionId = this.dependencies.sessionId();
-        if (!request?.source || sessionId === null || request.item.partitionIndex === undefined) return null;
+        const destination = request
+            ? packageImportDestination(
+                  request.destinationMode,
+                  request.destinationPartitionIndex,
+                  request.destinationVolumeName,
+              )
+            : null;
+        if (!request?.source || sessionId === null || !destination) {
+            if (request && generation === this.generation) {
+                this.request = { ...request, status: 'ready', hasUnvalidatedChanges: true };
+            }
+            return null;
+        }
         if (generation !== this.generation) return null;
         this.request = {
             ...request,
@@ -401,11 +633,7 @@ export class PackageImportWorkflow {
         const plan = await this.dependencies.transport.planImagePackageImport(
             sessionId,
             [request.source],
-            {
-                kind: 'EXISTING_VOLUME',
-                partitionIndex: request.item.partitionIndex,
-                volumeName: request.item.name,
-            },
+            destination,
             renames,
             programSlotAssignments,
             replacePlanToken,
@@ -457,4 +685,15 @@ export class PackageImportWorkflow {
         };
         return checkSuggestedProgramSlots ? plan.planToken : null;
     }
+
+    private fallbackDestinationItem(): DiskTreeItem | null {
+        const selected = this.dependencies.selectedSource?.();
+        if (selected && (selected.kind === 'partition' || selected.kind === 'volume')) return selected;
+        const destinations = this.destinations();
+        return destinations.partitionItems[0] ?? destinations.volumeItems[0] ?? null;
+    }
+
+    private destinations() {
+        return collectPackageImportDestinations(this.dependencies.sourceItems?.() ?? []);
+    }
 }
diff --git a/apps/axkdeck/src/features/import/packageWorkflow.test.ts b/apps/axkdeck/src/features/import/packageWorkflow.test.ts
index 5d15a2fe..976f3f71 100644
--- a/apps/axkdeck/src/features/import/packageWorkflow.test.ts
+++ b/apps/axkdeck/src/features/import/packageWorkflow.test.ts
@@ -165,6 +165,7 @@ describe('PackageImportWorkflow', () => {
         };
 
         workflow.open(target);
+        expect(workflow.request?.canChangeSource).toBe(true);
         const choosing = workflow.chooseWorkspace();
         picker.finish(source);
         await choosing;
@@ -663,4 +664,192 @@ describe('PackageImportWorkflow', () => {
         expect(nativeMocks.selectLocalPackage).toHaveBeenNthCalledWith(1, null);
         expect(nativeMocks.selectLocalPackage).toHaveBeenNthCalledWith(2, localPath);
     });
+
+    it('plans a dropped A3K archive into a new volume named from its archive root', async () => {
+        const dropped: ClientUploadSource = {
+            name: 'archive.a3k',
+            type: 'application/octet-stream',
+            size: 2048,
+            readChunk: vi.fn(),
+        };
+        const upload = clientUploadLocation({ uploadId: 'upload-a3k' }, 'DISK_IMAGE', 'archive.a3k');
+        const a3kInspection: PackageInspection = {
+            ...inspection,
+            packageKind: 'VOLUME',
+            requiredExtension: '.axkvol',
+            roots: [{ kind: 'VOLUME', displayName: 'Archive Volume', nodeIds: [] }],
+        };
+        const releaseImagePackageImportPlan = vi.fn().mockResolvedValue(undefined);
+        const transport = {
+            uploadClientFile: vi.fn().mockResolvedValue(upload),
+            inspectPackage: vi.fn().mockResolvedValue(a3kInspection),
+            planImagePackageImport: vi.fn().mockResolvedValue(programPlan(true)),
+            releaseImagePackageImportPlan,
+            releaseClientUpload: vi.fn().mockResolvedValue(undefined),
+        } as unknown as ImageTransport;
+        const partition: DiskTreeItem = {
+            id: 'partition-0',
+            name: 'Partition 1',
+            kind: 'partition',
+            childCount: 1,
+            partitionIndex: 0,
+        };
+        partition.children = [
+            {
+                id: 'volume-existing',
+                name: 'Existing',
+                kind: 'volume',
+                childCount: 0,
+                partitionIndex: 0,
+            },
+        ];
+        const workflow = new PackageImportWorkflow({
+            transport,
+            jobs: { run: vi.fn() } as unknown as JobController,
+            picker: new PickerController(() => undefined),
+            isDesktop: true,
+            sessionId: () => 17,
+            mutationsAvailable: () => true,
+            selectedSource: () => partition,
+            sourceItems: () => [partition],
+            invalidateSession: vi.fn(),
+            refreshSession: vi.fn(),
+            setStatus: vi.fn(),
+        });
+
+        await workflow.requestDroppedFile(dropped, partition);
+
+        expect(workflow.request?.canChangeSource).toBe(false);
+        expect(transport.uploadClientFile).toHaveBeenCalledWith(
+            dropped,
+            'DISK_IMAGE',
+            expect.any(Function),
+            expect.any(AbortSignal),
+        );
+        expect(workflow.request?.destinationMode).toBe('create');
+        expect(workflow.request?.destinationVolumeName).toBe('Archive Volume');
+        expect(transport.planImagePackageImport).toHaveBeenCalledWith(
+            17,
+            [upload],
+            { kind: 'CREATE_VOLUME', partitionIndex: 0, volumeName: 'Archive Volume' },
+            [],
+            [],
+            undefined,
+            [],
+        );
+
+        workflow.setExistingVolume(0, 'Existing');
+
+        await vi.waitFor(() => expect(transport.planImagePackageImport).toHaveBeenCalledTimes(2));
+        expect(releaseImagePackageImportPlan).toHaveBeenCalledWith('checked-plan');
+        expect(transport.planImagePackageImport).toHaveBeenNthCalledWith(
+            2,
+            17,
+            [upload],
+            { kind: 'EXISTING_VOLUME', partitionIndex: 0, volumeName: 'Existing' },
+            [],
+            [],
+            undefined,
+            [],
+        );
+
+        workflow.setDestinationMode('create');
+
+        await vi.waitFor(() => expect(transport.planImagePackageImport).toHaveBeenCalledTimes(3));
+        expect(workflow.request?.destinationVolumeName).toBe('Archive Volume');
+        expect(transport.planImagePackageImport).toHaveBeenNthCalledWith(
+            3,
+            17,
+            [upload],
+            { kind: 'CREATE_VOLUME', partitionIndex: 0, volumeName: 'Archive Volume' },
+            [],
+            [],
+            undefined,
+            [],
+        );
+
+        workflow.setExistingVolume(null, 'Not a volume');
+
+        await vi.waitFor(() => expect(releaseImagePackageImportPlan).toHaveBeenCalledTimes(3));
+        expect(workflow.request?.plan).toBeNull();
+        expect(workflow.request?.hasUnvalidatedChanges).toBe(true);
+        expect(transport.planImagePackageImport).toHaveBeenCalledTimes(3);
+    });
+
+    it('requires an explicit destination when a non-volume package is dropped without a selected volume', async () => {
+        const dropped: ClientUploadSource = {
+            name: 'Programs.axkprg',
+            type: 'application/octet-stream',
+            size: 1024,
+            readChunk: vi.fn(),
+        };
+        const upload = clientUploadLocation({ uploadId: 'upload-programs' }, 'PACKAGE', 'Programs.axkprg');
+        const partition: DiskTreeItem = {
+            id: 'partition-0',
+            name: 'Partition 1',
+            kind: 'partition',
+            childCount: 1,
+            partitionIndex: 0,
+            children: [
+                {
+                    id: 'volume-existing',
+                    name: 'Existing',
+                    kind: 'volume',
+                    childCount: 0,
+                    partitionIndex: 0,
+                },
+            ],
+        };
+        const planImagePackageImport = vi.fn().mockResolvedValue(programPlan(true));
+        const transport = {
+            uploadClientFile: vi.fn().mockResolvedValue(upload),
+            inspectPackage: vi.fn().mockResolvedValue(inspection),
+            planImagePackageImport,
+            releaseClientUpload: vi.fn().mockResolvedValue(undefined),
+        } as unknown as ImageTransport;
+        const workflow = new PackageImportWorkflow({
+            transport,
+            jobs: { run: vi.fn() } as unknown as JobController,
+            picker: new PickerController(() => undefined),
+            isDesktop: true,
+            sessionId: () => 17,
+            mutationsAvailable: () => true,
+            sourceItems: () => [partition],
+            invalidateSession: vi.fn(),
+            refreshSession: vi.fn(),
+            setStatus: vi.fn(),
+        });
+
+        await workflow.requestDroppedFile(dropped);
+
+        expect(workflow.request?.destinationMode).toBe('create');
+        expect(workflow.request?.destinationPartitionIndex).toBe(0);
+        expect(workflow.request?.destinationVolumeName).toBe('');
+        expect(workflow.request?.plan).toBeNull();
+        expect(workflow.request?.hasUnvalidatedChanges).toBe(true);
+        expect(planImagePackageImport).not.toHaveBeenCalled();
+
+        workflow.setDestinationMode('existing');
+
+        expect(workflow.request?.destinationMode).toBe('existing');
+        expect(workflow.request?.destinationPartitionIndex).toBeNull();
+        expect(workflow.request?.destinationVolumeName).toBe('');
+        expect(planImagePackageImport).not.toHaveBeenCalled();
+
+        workflow.setDestinationMode('create');
+        expect(workflow.request?.destinationPartitionIndex).toBe(0);
+
+        workflow.setDestinationVolumeName('Imported Programs');
+        await workflow.replan();
+
+        expect(planImagePackageImport).toHaveBeenCalledWith(
+            17,
+            [upload],
+            { kind: 'CREATE_VOLUME', partitionIndex: 0, volumeName: 'Imported Program' },
+            [],
+            [],
+            undefined,
+            [],
+        );
+    });
 });
diff --git a/apps/axkdeck/src/lib/components/AssignSampleBankDialog.svelte b/apps/axkdeck/src/lib/components/AssignSampleBankDialog.svelte
index ea357c08..492cf2a3 100644
--- a/apps/axkdeck/src/lib/components/AssignSampleBankDialog.svelte
+++ b/apps/axkdeck/src/lib/components/AssignSampleBankDialog.svelte
@@ -107,6 +107,7 @@
                 <div class="sample-bank-combobox">
                     <input
                         id="sample-bank-search"
+                        class="dialog-field-control"
                         value={query}
                         role="combobox"
                         aria-autocomplete="list"
@@ -125,7 +126,7 @@
                     {#if listOpen}
                         <div
                             id="sample-bank-options"
-                            class="sample-bank-options"
+                            class="sample-bank-options dialog-autocomplete-list"
                             role="listbox"
                             aria-label="Sample Banks"
                         >
@@ -133,6 +134,7 @@
                                 <button
                                     id={`sample-bank-option-${option.objectId}`}
                                     type="button"
+                                    class="dialog-autocomplete-option"
                                     role="option"
                                     aria-selected={selectedObjectId === option.objectId}
                                     aria-disabled={option.finalMemberCount > 127}
@@ -151,7 +153,7 @@
                                     </small>
                                 </button>
                             {:else}
-                                <p class="empty-copy">No matching Sample Banks</p>
+                                <p class="empty-copy dialog-autocomplete-empty">No matching Sample Banks</p>
                             {/each}
                         </div>
                     {/if}
@@ -224,8 +226,8 @@
     }
 
     .assign-sample-bank-content > label {
-        color: var(--text-muted);
-        font-size: 13px;
+        color: var(--color-text-muted);
+        font-size: var(--dialog-label-font-size);
     }
 
     .sample-bank-combobox {
@@ -237,45 +239,17 @@
     }
 
     .sample-bank-options {
-        display: grid;
-        max-height: 220px;
         margin-top: 4px;
-        overflow-y: auto;
-        border: 1px solid var(--color-border);
-        background: var(--color-panel);
     }
 
-    .sample-bank-options button {
+    .sample-bank-options :global(.dialog-autocomplete-option) {
         display: grid;
         grid-template-columns: minmax(0, 1fr) auto;
         gap: 12px;
         align-items: center;
-        min-height: 42px;
-        padding: 7px 10px;
-        border: 0;
-        border-bottom: 1px solid rgb(61 68 72 / 72%);
-        border-radius: 0;
-        color: var(--color-text-strong);
-        text-align: left;
-        background: transparent;
-    }
-
-    .sample-bank-options button:last-of-type {
-        border-bottom: 0;
-    }
-
-    .sample-bank-options button:hover:not(:disabled),
-    .sample-bank-options button.active:not(:disabled) {
-        background: rgb(104 151 187 / 14%);
-    }
-
-    .sample-bank-options button:disabled {
-        color: var(--text-muted);
-        cursor: not-allowed;
-    }
-
-    .sample-bank-options small {
-        color: var(--text-muted);
+        min-height: 38px;
+        padding-top: 4px;
+        padding-bottom: 4px;
     }
 
     .assignment-blockers,
diff --git a/apps/axkdeck/src/lib/components/AssignSampleBankDialog.test.ts b/apps/axkdeck/src/lib/components/AssignSampleBankDialog.test.ts
index 1183f326..dfa7546c 100644
--- a/apps/axkdeck/src/lib/components/AssignSampleBankDialog.test.ts
+++ b/apps/axkdeck/src/lib/components/AssignSampleBankDialog.test.ts
@@ -42,8 +42,12 @@ describe('AssignSampleBankDialog', () => {
 
         const input = screen.getByRole('combobox', { name: 'Sample Bank' });
         await waitFor(() => expect(document.activeElement).toBe(input));
+        expect(input.classList).toContain('dialog-field-control');
         await fireEvent.input(input, { target: { value: 'bank 2' } });
-        await fireEvent.click(screen.getByRole('option', { name: /Bank 2.*12 members/ }));
+        const option = screen.getByRole('option', { name: /Bank 2.*12 members/ });
+        expect(screen.getByRole('listbox', { name: 'Sample Banks' }).classList).toContain('dialog-autocomplete-list');
+        expect(option.classList).toContain('dialog-autocomplete-option');
+        await fireEvent.click(option);
 
         expect(
             screen.getByText('1 selected Sample is already in this Sample Bank and will remain in place.'),
diff --git a/apps/axkdeck/src/lib/components/AudioImportDialog.test.ts b/apps/axkdeck/src/lib/components/AudioImportDialog.test.ts
index 794d8e8a..0f42586b 100644
--- a/apps/axkdeck/src/lib/components/AudioImportDialog.test.ts
+++ b/apps/axkdeck/src/lib/components/AudioImportDialog.test.ts
@@ -616,6 +616,7 @@ describe('AudioImportDialog', () => {
         const selector = await screen.findByRole('combobox', {
             name: `Target sample rate for ${file.name}`,
         });
+        expect(selector.classList).toContain('dialog-field-control');
         expect((selector as HTMLSelectElement).value).toBe('44100');
 
         await fireEvent.change(selector, { target: { value: '22050' } });
diff --git a/apps/axkdeck/src/lib/components/AudioImportRows.svelte b/apps/axkdeck/src/lib/components/AudioImportRows.svelte
index 2be05993..c0851ffb 100644
--- a/apps/axkdeck/src/lib/components/AudioImportRows.svelte
+++ b/apps/axkdeck/src/lib/components/AudioImportRows.svelte
@@ -173,6 +173,7 @@
                     <label>
                         <span>Target rate</span>
                         <select
+                            class="dialog-field-control"
                             aria-label={`Target sample rate for ${row.fileName}`}
                             value={row.targetSampleRate}
                             disabled={busy || row.status === 'checking'}
@@ -186,6 +187,7 @@
                     <label>
                         <span>Sample name</span>
                         <input
+                            class="dialog-field-control"
                             aria-label={`Sample name for ${row.fileName}`}
                             data-dialog-initial-focus={index === 0 ? 'select' : undefined}
                             value={row.sampleName}
@@ -200,6 +202,7 @@
                     <label>
                         <span>Wave Data (mono/left)</span>
                         <input
+                            class="dialog-field-control"
                             aria-label={`Wave data (mono/left) for ${row.fileName}`}
                             value={row.waveformNames[0]}
                             maxlength="16"
@@ -211,6 +214,7 @@
                         <label>
                             <span>Wave Data (right)</span>
                             <input
+                                class="dialog-field-control"
                                 aria-label={`Wave data (right) for ${row.fileName}`}
                                 value={row.waveformNames[1]}
                                 maxlength="16"
@@ -317,28 +321,16 @@
         min-width: 0;
         gap: 4px;
         color: var(--color-text-muted);
-        font-size: 11px;
+        font-size: var(--dialog-label-font-size);
     }
     input,
     select {
         width: 100%;
         min-width: 0;
-        height: var(--density-control);
-        padding: 0 8px;
-        color: var(--color-text-strong);
-        border: 1px solid var(--color-border);
-        border-radius: 5px;
-        outline: none;
-        background: var(--color-bg-deep);
-        font-size: 12px;
     }
     select {
         appearance: auto;
     }
-    input:focus,
-    select:focus {
-        border-color: var(--color-accent);
-    }
     .status-message {
         display: flex;
         align-items: flex-start;
diff --git a/apps/axkdeck/src/lib/components/AudioSamplerSettings.svelte b/apps/axkdeck/src/lib/components/AudioSamplerSettings.svelte
index 07e266a6..0a3a87fb 100644
--- a/apps/axkdeck/src/lib/components/AudioSamplerSettings.svelte
+++ b/apps/axkdeck/src/lib/components/AudioSamplerSettings.svelte
@@ -21,6 +21,7 @@
             <span>Root key</span>
             <span class="note-input">
                 <input
+                    class="dialog-field-control"
                     aria-label={`Root key for ${row.fileName}`}
                     type="number"
                     min="0"
@@ -36,6 +37,7 @@
             <span>Fine tune</span>
             <span class="unit-input">
                 <input
+                    class="dialog-field-control"
                     aria-label={`Fine tune for ${row.fileName}`}
                     type="number"
                     min="-63"
@@ -51,6 +53,7 @@
             <span>Key range</span>
             <span class="range-inputs">
                 <input
+                    class="dialog-field-control"
                     aria-label={`Lowest key for ${row.fileName}`}
                     type="number"
                     min="0"
@@ -61,6 +64,7 @@
                 />
                 <span>to</span>
                 <input
+                    class="dialog-field-control"
                     aria-label={`Highest key for ${row.fileName}`}
                     type="number"
                     min="0"
@@ -75,6 +79,7 @@
             <span>Velocity range</span>
             <span class="range-inputs">
                 <input
+                    class="dialog-field-control"
                     aria-label={`Lowest velocity for ${row.fileName}`}
                     type="number"
                     min="0"
@@ -85,6 +90,7 @@
                 />
                 <span>to</span>
                 <input
+                    class="dialog-field-control"
                     aria-label={`Highest velocity for ${row.fileName}`}
                     type="number"
                     min="0"
@@ -98,6 +104,7 @@
         <label>
             <span>Playback</span>
             <select
+                class="dialog-field-control"
                 aria-label={`Playback mode for ${row.fileName}`}
                 value={row.loopMode}
                 {disabled}
@@ -117,6 +124,7 @@
             <label>
                 <span>Loop start</span>
                 <input
+                    class="dialog-field-control"
                     aria-label={`Loop start for ${row.fileName}`}
                     type="number"
                     min="0"
@@ -129,6 +137,7 @@
             <label>
                 <span>Loop length</span>
                 <input
+                    class="dialog-field-control"
                     aria-label={`Loop length for ${row.fileName}`}
                     type="number"
                     min="1"
@@ -156,24 +165,12 @@
         display: grid;
         gap: 4px;
         color: var(--color-text-muted);
-        font-size: 11px;
+        font-size: var(--dialog-label-font-size);
     }
     input,
     select {
         width: 100%;
         min-width: 0;
-        height: var(--density-control);
-        padding: 0 8px;
-        color: var(--color-text-strong);
-        border: 1px solid var(--color-border);
-        border-radius: 5px;
-        outline: none;
-        background: var(--color-bg-deep);
-        font-size: 12px;
-    }
-    input:focus,
-    select:focus {
-        border-color: var(--color-accent);
     }
     .note-input,
     .unit-input,
diff --git a/apps/axkdeck/src/lib/components/CollectionToolbar.svelte b/apps/axkdeck/src/lib/components/CollectionToolbar.svelte
index 9ea9af14..b74001af 100644
--- a/apps/axkdeck/src/lib/components/CollectionToolbar.svelte
+++ b/apps/axkdeck/src/lib/components/CollectionToolbar.svelte
@@ -52,6 +52,7 @@
         {#if filterLabel}
             <label class="collection-filter">
                 <input
+                    class="compact-checkbox"
                     type="checkbox"
                     checked={filterChecked}
                     onchange={(event) => onfilterchange(event.currentTarget.checked)}
diff --git a/apps/axkdeck/src/lib/components/CollectionToolbar.test.ts b/apps/axkdeck/src/lib/components/CollectionToolbar.test.ts
index 6796e107..28db3b64 100644
--- a/apps/axkdeck/src/lib/components/CollectionToolbar.test.ts
+++ b/apps/axkdeck/src/lib/components/CollectionToolbar.test.ts
@@ -1,9 +1,16 @@
+/// <reference types="node" />
+
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
 import { render, screen } from '@testing-library/svelte';
 import { createRawSnippet } from 'svelte';
 import { describe, expect, it, vi } from 'vitest';
 
 import CollectionToolbar from './CollectionToolbar.svelte';
 
+const appStyles = readFileSync(resolve(process.cwd(), 'src/app.css'), 'utf8');
+
 describe('CollectionToolbar', () => {
     it('keeps search as the rightmost collection action', () => {
         render(CollectionToolbar, {
@@ -90,4 +97,43 @@ describe('CollectionToolbar', () => {
             title?.children.item(2)?.contains(screen.getByRole('button', { name: 'Saved System File details' })),
         ).toBe(true);
     });
+
+    it('keeps the compact filter checkmark centered inside its box', () => {
+        render(CollectionToolbar, {
+            props: {
+                title: 'Samples',
+                count: 4,
+                query: '',
+                onquerychange: vi.fn(),
+                filterLabel: 'Show only standalone',
+                filterChecked: true,
+                onfilterchange: vi.fn(),
+            },
+        });
+
+        const checkbox = screen.getByRole('checkbox', { name: 'Show only standalone' });
+        expect(checkbox.classList).toContain('compact-checkbox');
+
+        const controlRule = appStyles.match(/\.compact-checkbox\s*\{[^}]+\}/)?.[0];
+        const glyphRule = appStyles.match(/\.compact-checkbox::before\s*\{[^}]+\}/)?.[0];
+        expect(controlRule).toContain('width: 12px');
+        expect(controlRule).toContain('height: 12px');
+        expect(controlRule).toContain('appearance: none');
+        expect(controlRule).toContain('place-content: center');
+        expect(controlRule).toContain('overflow: hidden');
+        expect(glyphRule).toContain('width: 3px');
+        expect(glyphRule).toContain('height: 6px');
+
+        const style = document.createElement('style');
+        style.textContent = controlRule ?? '';
+        document.head.append(style);
+
+        const checkboxStyle = getComputedStyle(checkbox);
+        expect(checkboxStyle.width).toBe('12px');
+        expect(checkboxStyle.height).toBe('12px');
+        expect(checkboxStyle.display).toBe('grid');
+        expect(checkboxStyle.overflow).toBe('hidden');
+
+        style.remove();
+    });
 });
diff --git a/apps/axkdeck/src/lib/components/ImageNavigator.svelte b/apps/axkdeck/src/lib/components/ImageNavigator.svelte
index a1b2c9ec..26844337 100644
--- a/apps/axkdeck/src/lib/components/ImageNavigator.svelte
+++ b/apps/axkdeck/src/lib/components/ImageNavigator.svelte
@@ -245,7 +245,7 @@
         <div class="panel-heading">
             <div>
                 <p class="eyebrow">Contents</p>
-                <h2>Partitions, volumes and objects</h2>
+                <h2>Partitions and volumes</h2>
             </div>
         </div>
 
diff --git a/apps/axkdeck/src/lib/components/PackageImportDestination.svelte b/apps/axkdeck/src/lib/components/PackageImportDestination.svelte
new file mode 100644
index 00000000..5104f183
--- /dev/null
+++ b/apps/axkdeck/src/lib/components/PackageImportDestination.svelte
@@ -0,0 +1,321 @@
+<script lang="ts">
+    import type {
+        PackageImportDestinationMode,
+        PackageImportPartitionOption,
+        PackageImportVolumeOption,
+    } from '../../features/import/packageDestinations';
+
+    interface Props {
+        mode: PackageImportDestinationMode;
+        partitionIndex: number | null;
+        volumeName: string;
+        partitions: PackageImportPartitionOption[];
+        volumes: PackageImportVolumeOption[];
+        disabled: boolean;
+        onmode: (mode: PackageImportDestinationMode) => void;
+        onvolume: (partitionIndex: number | null, volumeName: string) => void;
+        onpartition: (partitionIndex: number) => void;
+        onname: (name: string) => void;
+    }
+
+    let {
+        mode,
+        partitionIndex,
+        volumeName,
+        partitions,
+        volumes,
+        disabled,
+        onmode,
+        onvolume,
+        onpartition,
+        onname,
+    }: Props = $props();
+
+    let query = $state('');
+    let activeIndex = $state(-1);
+    let listOpen = $state(false);
+    let filtering = $state(false);
+    let synchronizedSelection = $state('');
+    const normalizedQuery = $derived(query.trim().toLocaleLowerCase());
+    const filteredVolumes = $derived(
+        filtering ? volumes.filter((option) => option.label.toLocaleLowerCase().includes(normalizedQuery)) : volumes,
+    );
+    const selectedVolume = $derived(
+        volumes.find((option) => option.partitionIndex === partitionIndex && option.volumeName === volumeName),
+    );
+
+    $effect(() => {
+        const nextSelection = selectedVolume ? volumeKey(selectedVolume) : '';
+        if (nextSelection && nextSelection !== synchronizedSelection && selectedVolume) {
+            query = selectedVolume.label;
+            filtering = false;
+            activeIndex = Math.max(0, volumes.indexOf(selectedVolume));
+        }
+        synchronizedSelection = nextSelection;
+    });
+
+    function volumeKey(option: PackageImportVolumeOption): string {
+        return `${option.partitionIndex}:${option.volumeName}`;
+    }
+
+    function optionId(option: PackageImportVolumeOption): string {
+        return `package-volume-option-${option.partitionIndex}-${volumes.indexOf(option)}`;
+    }
+
+    function selectVolume(option: PackageImportVolumeOption): void {
+        if (disabled) return;
+        query = option.label;
+        filtering = false;
+        synchronizedSelection = volumeKey(option);
+        listOpen = false;
+        onvolume(option.partitionIndex, option.volumeName);
+    }
+
+    function updateQuery(value: string): void {
+        query = value;
+        filtering = true;
+        activeIndex = -1;
+        listOpen = true;
+        onvolume(null, '');
+    }
+
+    function openList(): void {
+        if (disabled || volumes.length === 0) return;
+        if (selectedVolume) filtering = false;
+        listOpen = true;
+        activeIndex = selectedVolume ? filteredVolumes.indexOf(selectedVolume) : -1;
+    }
+
+    function handleKey(event: KeyboardEvent): void {
+        if (event.key === 'ArrowDown' || event.key === 'ArrowUp') {
+            event.preventDefault();
+            listOpen = true;
+            const direction = event.key === 'ArrowDown' ? 1 : -1;
+            const startingIndex = activeIndex < 0 ? (direction > 0 ? -1 : filteredVolumes.length) : activeIndex;
+            activeIndex = Math.max(0, Math.min(filteredVolumes.length - 1, startingIndex + direction));
+        } else if (event.key === 'Home' || event.key === 'End') {
+            event.preventDefault();
+            listOpen = true;
+            activeIndex = event.key === 'Home' ? 0 : Math.max(0, filteredVolumes.length - 1);
+        } else if (event.key === 'Enter' && listOpen && filteredVolumes[activeIndex]) {
+            event.preventDefault();
+            selectVolume(filteredVolumes[activeIndex]);
+        } else if (event.key === 'Escape' && listOpen) {
+            event.preventDefault();
+            event.stopPropagation();
+            listOpen = false;
+        }
+    }
+</script>
+
+<section class="package-import-destination" aria-label="Import destination">
+    <div class="package-destination-heading">
+        <strong>Destination</strong>
+        <div class="package-destination-mode" role="group" aria-label="Destination type">
+            <button
+                type="button"
+                class:active={mode === 'existing'}
+                aria-pressed={mode === 'existing'}
+                disabled={disabled || volumes.length === 0}
+                onclick={() => onmode('existing')}>Existing volume</button
+            >
+            <button
+                type="button"
+                class:active={mode === 'create'}
+                aria-pressed={mode === 'create'}
+                {disabled}
+                onclick={() => onmode('create')}>New volume</button
+            >
+        </div>
+    </div>
+
+    {#if mode === 'existing'}
+        <label class="target-field" for="package-volume-search">Volume</label>
+        <div class="package-volume-combobox">
+            <input
+                id="package-volume-search"
+                class="dialog-field-control"
+                type="text"
+                role="combobox"
+                aria-autocomplete="list"
+                aria-expanded={listOpen}
+                aria-controls="package-volume-options"
+                aria-activedescendant={listOpen && filteredVolumes[activeIndex]
+                    ? optionId(filteredVolumes[activeIndex])
+                    : undefined}
+                placeholder="Select a volume"
+                value={query}
+                disabled={disabled || volumes.length === 0}
+                autocomplete="off"
+                oninput={(event) => updateQuery(event.currentTarget.value)}
+                onfocus={openList}
+                onclick={openList}
+                onkeydown={handleKey}
+            />
+            {#if listOpen}
+                <div
+                    id="package-volume-options"
+                    class="package-volume-options dialog-autocomplete-list"
+                    role="listbox"
+                    aria-label="Volumes"
+                >
+                    {#each filteredVolumes as option, index (volumeKey(option))}
+                        <button
+                            id={optionId(option)}
+                            type="button"
+                            role="option"
+                            class="dialog-autocomplete-option"
+                            aria-selected={selectedVolume === option}
+                            class:active={index === activeIndex}
+                            onpointermove={() => (activeIndex = index)}
+                            onclick={() => selectVolume(option)}
+                        >
+                            {option.label}
+                        </button>
+                    {:else}
+                        <p class="dialog-autocomplete-empty">No matching volumes</p>
+                    {/each}
+                </div>
+            {/if}
+        </div>
+    {:else}
+        <div class="package-new-volume-fields">
+            <label class="target-field">
+                <span>Partition</span>
+                <select
+                    class="dialog-field-control"
+                    value={partitionIndex ?? ''}
+                    disabled={disabled || partitions.length === 0}
+                    onchange={(event) => onpartition(Number(event.currentTarget.value))}
+                >
+                    {#each partitions as option (option.partitionIndex)}
+                        <option value={option.partitionIndex}>{option.name}</option>
+                    {/each}
+                </select>
+            </label>
+            <label class="target-field">
+                <span>Volume name</span>
+                <input
+                    class="dialog-field-control"
+                    type="text"
+                    minlength="1"
+                    maxlength="16"
+                    value={volumeName}
+                    placeholder="Enter a volume name"
+                    {disabled}
+                    autocomplete="off"
+                    oninput={(event) => onname(event.currentTarget.value)}
+                />
+            </label>
+        </div>
+    {/if}
+</section>
+
+<style>
+    .package-import-destination {
+        display: grid;
+        gap: 9px;
+        margin-bottom: 12px;
+        padding: 10px;
+        border: 1px solid var(--color-border);
+        border-radius: 5px;
+        background: rgb(255 255 255 / 2%);
+    }
+
+    .package-destination-heading {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        gap: 12px;
+    }
+
+    .package-destination-heading > strong {
+        color: var(--color-text-strong);
+        font-size: 11px;
+    }
+
+    .package-destination-mode {
+        display: grid;
+        grid-template-columns: repeat(2, minmax(0, 1fr));
+        overflow: hidden;
+        border: 1px solid var(--color-border);
+        border-radius: 4px;
+        background: var(--color-bg-deep);
+    }
+
+    .package-destination-mode button {
+        min-height: 27px;
+        padding: 0 10px;
+        color: var(--color-text-muted);
+        border: 0;
+        border-right: 1px solid var(--color-border);
+        background: transparent;
+        cursor: pointer;
+        font-size: 10px;
+    }
+
+    .package-destination-mode button:last-child {
+        border-right: 0;
+    }
+
+    .package-destination-mode button.active {
+        color: #fff;
+        background: var(--color-accent-strong);
+    }
+
+    .package-destination-mode button:disabled {
+        cursor: default;
+        opacity: 0.45;
+    }
+
+    .package-volume-combobox {
+        position: relative;
+    }
+
+    .package-volume-combobox > input {
+        width: 100%;
+    }
+
+    .package-volume-options {
+        position: absolute;
+        z-index: 4;
+        top: calc(100% + 4px);
+        right: 0;
+        left: 0;
+    }
+
+    .package-volume-options p {
+        margin: 0;
+        padding: 9px;
+    }
+
+    .package-new-volume-fields {
+        display: grid;
+        grid-template-columns: minmax(140px, 0.7fr) minmax(180px, 1fr);
+        gap: 10px;
+    }
+
+    .target-field {
+        display: grid;
+        min-width: 0;
+        gap: 4px;
+        color: var(--color-text-muted);
+        font-size: var(--dialog-label-font-size);
+    }
+
+    .package-new-volume-fields :global(.dialog-field-control) {
+        min-width: 0;
+        width: 100%;
+    }
+
+    @media (max-width: 640px) {
+        .package-destination-heading,
+        .package-new-volume-fields {
+            grid-template-columns: 1fr;
+        }
+
+        .package-destination-heading {
+            display: grid;
+        }
+    }
+</style>
diff --git a/apps/axkdeck/src/lib/components/PackageImportDestination.test.ts b/apps/axkdeck/src/lib/components/PackageImportDestination.test.ts
new file mode 100644
index 00000000..b014b1ac
--- /dev/null
+++ b/apps/axkdeck/src/lib/components/PackageImportDestination.test.ts
@@ -0,0 +1,116 @@
+/// <reference types="node" />
+
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+import { fireEvent, render, screen } from '@testing-library/svelte';
+import { describe, expect, it, vi } from 'vitest';
+
+import PackageImportDestination from './PackageImportDestination.svelte';
+
+const appStyles = readFileSync(resolve(process.cwd(), 'src/app.css'), 'utf8');
+
+const partitions = [
+    { partitionIndex: 0, name: 'SOUNDS 01' },
+    { partitionIndex: 1, name: 'SOUNDS 02' },
+];
+
+const volumes = [
+    { partitionIndex: 0, name: 'SOUNDS 01', volumeName: 'Pianos', label: 'SOUNDS 01 / Pianos' },
+    { partitionIndex: 0, name: 'SOUNDS 01', volumeName: 'Strings', label: 'SOUNDS 01 / Strings' },
+    { partitionIndex: 1, name: 'SOUNDS 02', volumeName: 'Pianos', label: 'SOUNDS 02 / Pianos' },
+];
+
+function props(overrides: Record<string, unknown> = {}) {
+    return {
+        mode: 'existing' as const,
+        partitionIndex: 0,
+        volumeName: 'Strings',
+        partitions,
+        volumes,
+        disabled: false,
+        onmode: vi.fn(),
+        onvolume: vi.fn(),
+        onpartition: vi.fn(),
+        onname: vi.fn(),
+        ...overrides,
+    };
+}
+
+describe('PackageImportDestination', () => {
+    it('preselects the exact volume and exposes every partition volume through an autocomplete', async () => {
+        render(PackageImportDestination, { props: props() });
+
+        const combobox = screen.getByRole('combobox', { name: 'Volume' }) as HTMLInputElement;
+        expect(combobox.value).toBe('SOUNDS 01 / Strings');
+        await fireEvent.focus(combobox);
+
+        expect(screen.getByRole('listbox', { name: 'Volumes' })).toBeTruthy();
+        expect(screen.getAllByRole('option')).toHaveLength(3);
+        expect(screen.getByRole('option', { name: /SOUNDS 02.*Pianos/ })).toBeTruthy();
+    });
+
+    it('filters volumes and selects an exact destination with the keyboard', async () => {
+        const onvolume = vi.fn();
+        render(PackageImportDestination, { props: props({ partitionIndex: null, volumeName: '', onvolume }) });
+
+        const combobox = screen.getByRole('combobox', { name: 'Volume' });
+        await fireEvent.input(combobox, { target: { value: 'sounds 02' } });
+        expect(onvolume).toHaveBeenLastCalledWith(null, '');
+        expect(screen.getAllByRole('option')).toHaveLength(1);
+        await fireEvent.keyDown(combobox, { key: 'ArrowDown' });
+        await fireEvent.keyDown(combobox, { key: 'Enter' });
+
+        expect(onvolume).toHaveBeenLastCalledWith(1, 'Pianos');
+    });
+
+    it('uses the same dark dialog control treatment for a new volume name', async () => {
+        render(PackageImportDestination, {
+            props: props({ mode: 'create', partitionIndex: 0, volumeName: '' }),
+        });
+
+        expect(screen.getByRole('textbox', { name: 'Volume name' }).classList).toContain('dialog-field-control');
+        expect(screen.getByRole('combobox', { name: 'Partition' }).classList).toContain('dialog-field-control');
+    });
+
+    it('uses the shared compact dialog typography and dark autocomplete palette', async () => {
+        render(PackageImportDestination, { props: props() });
+
+        const combobox = screen.getByRole('combobox', { name: 'Volume' });
+        await fireEvent.focus(combobox);
+        const listbox = screen.getByRole('listbox', { name: 'Volumes' });
+        const option = screen.getAllByRole('option')[0];
+
+        expect(combobox.classList).toContain('dialog-field-control');
+        expect(listbox.classList).toContain('dialog-autocomplete-list');
+        expect(option.classList).toContain('dialog-autocomplete-option');
+
+        const controlRule = appStyles.match(/\.dialog-field-control\s*\{[^}]+\}/)?.[0];
+        const listRule = appStyles.match(/\.dialog-autocomplete-list\s*\{[^}]+\}/)?.[0];
+        const optionRule = appStyles.match(/\.dialog-autocomplete-option\s*\{[^}]+\}/)?.[0];
+        expect(controlRule).toContain('font-size: var(--dialog-control-font-size)');
+        expect(listRule).toContain('background: var(--color-bg-deep)');
+        expect(optionRule).toContain('font-size: var(--dialog-control-font-size)');
+        expect(appStyles).toContain('--density-control: 26px');
+        expect(appStyles).toContain('--dialog-control-font-size: 11px');
+        expect(appStyles).toContain('--color-bg-deep: #0b0d0f');
+
+        const style = document.createElement('style');
+        style.textContent = `${controlRule}\n${listRule}\n${optionRule}`
+            .replaceAll('var(--density-control)', '26px')
+            .replaceAll('var(--dialog-control-font-size)', '11px')
+            .replaceAll('var(--color-bg-deep)', '#0b0d0f');
+        document.head.append(style);
+
+        const controlStyle = getComputedStyle(combobox);
+        const listStyle = getComputedStyle(listbox);
+        const optionStyle = getComputedStyle(option);
+        expect(controlStyle.height).toBe('26px');
+        expect(controlStyle.fontSize).toBe('11px');
+        expect(listStyle.backgroundColor).toBe('rgb(11, 13, 15)');
+        expect(optionStyle.minHeight).toBe('28px');
+        expect(optionStyle.fontSize).toBe('11px');
+
+        style.remove();
+    });
+});
diff --git a/apps/axkdeck/src/lib/components/PackageImportDialog.svelte b/apps/axkdeck/src/lib/components/PackageImportDialog.svelte
index 16c822ec..01d7cb62 100644
--- a/apps/axkdeck/src/lib/components/PackageImportDialog.svelte
+++ b/apps/axkdeck/src/lib/components/PackageImportDialog.svelte
@@ -1,13 +1,26 @@
 <script lang="ts">
     import { formatStoredSize } from '../formatBytes';
     import { modal } from '../modal';
+    import {
+        packageImportDestination,
+        type PackageImportDestinationMode,
+        type PackageImportPartitionOption,
+        type PackageImportVolumeOption,
+    } from '../../features/import/packageDestinations';
     import type { ImageSessionPackageImportPlan, PackageInspection, PackageOpaqueSequenceDecision } from '../transport';
     import Icon from './Icon.svelte';
     import ImportSourceChoice from './ImportSourceChoice.svelte';
+    import PackageImportDestination from './PackageImportDestination.svelte';
 
     interface Props {
         targetName: string;
+        destinationMode: PackageImportDestinationMode;
+        destinationPartitionIndex: number | null;
+        destinationVolumeName: string;
+        partitionOptions: PackageImportPartitionOption[];
+        volumeOptions: PackageImportVolumeOption[];
         desktop: boolean;
+        canChangeSource: boolean;
         sourceName: string;
         inspection: PackageInspection | null;
         plan: ImageSessionPackageImportPlan | null;
@@ -21,6 +34,10 @@
         onchooseworkspace: () => void;
         onchooselocal: () => void;
         onchange: () => void;
+        ondestinationmode: (mode: PackageImportDestinationMode) => void;
+        ondestinationvolume: (partitionIndex: number | null, volumeName: string) => void;
+        ondestinationpartition: (partitionIndex: number) => void;
+        ondestinationname: (name: string) => void;
         onrename: (nodeId: string, name: string) => void;
         onprogramslot: (nodeId: string, slot: number) => void;
         onprogramstart: (placementId: string, start: number) => void;
@@ -48,7 +65,13 @@
 
     let {
         targetName,
+        destinationMode,
+        destinationPartitionIndex,
+        destinationVolumeName,
+        partitionOptions,
+        volumeOptions,
         desktop,
+        canChangeSource,
         sourceName,
         inspection,
         plan,
@@ -62,6 +85,10 @@
         onchooseworkspace,
         onchooselocal,
         onchange,
+        ondestinationmode,
+        ondestinationvolume,
+        ondestinationpartition,
+        ondestinationname,
         onrename,
         onprogramslot,
         onprogramstart,
@@ -146,7 +173,12 @@
     const visibleConflictCount = $derived(
         placementIssues.length + renameActions.length + nonRenameConflicts.length + undecidedOpaqueSequences.length,
     );
-    const showConflictCheck = $derived(renameActions.length > 0 || editableProgramPlacements.length > 0);
+    const showConflictCheck = $derived(
+        hasUnvalidatedChanges || renameActions.length > 0 || editableProgramPlacements.length > 0,
+    );
+    const destinationReady = $derived(
+        packageImportDestination(destinationMode, destinationPartitionIndex, destinationVolumeName) !== null,
+    );
     const canCheckConflicts = $derived(
         status === 'ready' &&
             (hasUnvalidatedChanges ||
@@ -268,9 +300,26 @@
                         <small>Package</small>
                         <strong>{sourceName}</strong>
                     </div>
-                    <button class="secondary-button" type="button" disabled={locked} onclick={onchange}>Change</button>
+                    {#if canChangeSource}
+                        <button class="secondary-button" type="button" disabled={locked} onclick={onchange}
+                            >Change</button
+                        >
+                    {/if}
                 </section>
 
+                <PackageImportDestination
+                    mode={destinationMode}
+                    partitionIndex={destinationPartitionIndex}
+                    volumeName={destinationVolumeName}
+                    partitions={partitionOptions}
+                    volumes={volumeOptions}
+                    disabled={locked || status === 'loading' || status === 'planning'}
+                    onmode={ondestinationmode}
+                    onvolume={ondestinationvolume}
+                    onpartition={ondestinationpartition}
+                    onname={ondestinationname}
+                />
+
                 {#if status === 'loading'}
                     <p class="dialog-progress" role="status">
                         {progress > 0 ? `Uploading package · ${Math.round(progress * 100)}%` : 'Verifying package…'}
@@ -539,8 +588,22 @@
                                             : warning.message}
                                     </p>
                                 {/each}
-                            {:else}
+                            {:else if !destinationReady}
+                                <p class="dialog-progress" role="status">Choose a valid import destination.</p>
+                                <div class="package-conflict-actions">
+                                    <button class="secondary-button" type="button" disabled>Check conflicts</button>
+                                </div>
+                            {:else if status === 'planning'}
                                 <p class="dialog-progress" role="status">Planning import…</p>
+                            {:else}
+                                <p class="dialog-progress" role="status">
+                                    Check the selected destination for conflicts and available image space.
+                                </p>
+                                <div class="package-conflict-actions">
+                                    <button class="secondary-button" type="button" disabled={busy} onclick={onreplan}
+                                        >Check conflicts</button
+                                    >
+                                </div>
                             {/if}
                         </section>
                     </div>
diff --git a/apps/axkdeck/src/lib/components/PackageImportDialog.test.ts b/apps/axkdeck/src/lib/components/PackageImportDialog.test.ts
index f0558ba8..bc5920ae 100644
--- a/apps/axkdeck/src/lib/components/PackageImportDialog.test.ts
+++ b/apps/axkdeck/src/lib/components/PackageImportDialog.test.ts
@@ -193,9 +193,26 @@ function programSlotPlan(
 }
 
 const callbacks = {
+    canChangeSource: true,
+    destinationMode: 'existing' as const,
+    destinationPartitionIndex: 0,
+    destinationVolumeName: 'TARGET',
+    partitionOptions: [{ partitionIndex: 0, name: 'PARTITION 1' }],
+    volumeOptions: [
+        {
+            partitionIndex: 0,
+            name: 'PARTITION 1',
+            volumeName: 'TARGET',
+            label: 'PARTITION 1 / TARGET',
+        },
+    ],
     onchooseworkspace: vi.fn(),
     onchooselocal: vi.fn(),
     onchange: vi.fn(),
+    ondestinationmode: vi.fn(),
+    ondestinationvolume: vi.fn(),
+    ondestinationpartition: vi.fn(),
+    ondestinationname: vi.fn(),
     onrename: vi.fn(),
     onprogramslot: vi.fn(),
     onprogramstart: vi.fn(),
@@ -206,6 +223,28 @@ const callbacks = {
 };
 
 describe('PackageImportDialog', () => {
+    it('does not offer to replace a package that was explicitly dropped', () => {
+        render(PackageImportDialog, {
+            props: {
+                targetName: 'TARGET',
+                desktop: true,
+                sourceName: 'drums.axkvol',
+                inspection,
+                plan: plan(),
+                renames: {},
+                programSlots: {},
+                status: 'ready',
+                progress: 1,
+                error: '',
+                ...callbacks,
+                canChangeSource: false,
+            },
+        });
+
+        expect(screen.getByText('drums.axkvol')).toBeTruthy();
+        expect(screen.queryByRole('button', { name: 'Change' })).toBeNull();
+    });
+
     it('presents local and workspace sources before a package is selected', async () => {
         render(PackageImportDialog, {
             props: {
diff --git a/apps/axkdeck/src/lib/components/TreeNode.svelte b/apps/axkdeck/src/lib/components/TreeNode.svelte
index 310082bd..499dc212 100644
--- a/apps/axkdeck/src/lib/components/TreeNode.svelte
+++ b/apps/axkdeck/src/lib/components/TreeNode.svelte
@@ -195,7 +195,11 @@
         class="tree-row group"
         style:--tree-depth={depth}
         data-import-drop-volume={item.kind === 'volume' ? item.name : undefined}
-        data-import-drop-partition={item.kind === 'volume' ? item.partitionIndex : undefined}
+        data-import-drop-partition={item.kind === 'volume' || item.kind === 'partition'
+            ? item.partitionIndex
+            : undefined}
+        data-import-drop-kind={item.kind === 'volume' || item.kind === 'partition' ? item.kind : undefined}
+        data-import-drop-name={item.kind === 'volume' || item.kind === 'partition' ? item.name : undefined}
     >
         {#if hasChildren}
             <button
diff --git a/apps/axkdeck/src/lib/components/Tx16wImportDialog.svelte b/apps/axkdeck/src/lib/components/Tx16wImportDialog.svelte
index fa685efd..e41bb08c 100644
--- a/apps/axkdeck/src/lib/components/Tx16wImportDialog.svelte
+++ b/apps/axkdeck/src/lib/components/Tx16wImportDialog.svelte
@@ -155,6 +155,7 @@
             <label class="target-field">
                 <span>Target volume</span>
                 <input
+                    class="dialog-field-control"
                     type="text"
                     list="tx16w-volume-options"
                     placeholder="Select a volume"
@@ -382,13 +383,17 @@
 
     small,
     .disk-set > small,
-    .target-field > span,
     summary span,
     .tx16w-footer > span {
         color: var(--color-text-muted);
         font-size: 12px;
     }
 
+    .target-field > span {
+        color: var(--color-text-muted);
+        font-size: var(--dialog-label-font-size);
+    }
+
     .target-field input {
         width: 100%;
     }
diff --git a/apps/axkdeck/src/lib/components/VolumeActionDialog.svelte b/apps/axkdeck/src/lib/components/VolumeActionDialog.svelte
index 5b044656..6088363e 100644
--- a/apps/axkdeck/src/lib/components/VolumeActionDialog.svelte
+++ b/apps/axkdeck/src/lib/components/VolumeActionDialog.svelte
@@ -95,6 +95,7 @@
                     <label>
                         <span>{subject} name</span>
                         <input
+                            class="dialog-field-control"
                             bind:value
                             data-dialog-initial-focus={action.startsWith('rename-') ? 'select' : 'caret'}
                             disabled={busy}
diff --git a/apps/axkdeck/src/lib/generated/axklibApiV1.ts b/apps/axkdeck/src/lib/generated/axklibApiV1.ts
index 86e6067e..d240f031 100644
--- a/apps/axkdeck/src/lib/generated/axklibApiV1.ts
+++ b/apps/axkdeck/src/lib/generated/axklibApiV1.ts
@@ -2754,8 +2754,14 @@ export interface components {
             totalPayloadBytes: number;
             valid: boolean;
         };
-        /** @description Either one existing SFS volume shared by every package root or one new SFS volume per volume package, named from its placement hint with optional indexed overrides. */
+        /** @description One existing SFS volume, one explicitly named new SFS volume, or one new SFS volume per volume package placement hint. */
         ImageSessionPackageImportDestination:
+            | {
+                  /** @constant */
+                  kind: 'CREATE_VOLUME';
+                  partitionIndex: number;
+                  volumeName: string;
+              }
             | {
                   /** @constant */
                   kind: 'EXISTING_VOLUME';
diff --git a/apps/axkdeck/src/lib/nativeMediaDrop.test.ts b/apps/axkdeck/src/lib/nativeMediaDrop.test.ts
index 9c79fc78..551705f8 100644
--- a/apps/axkdeck/src/lib/nativeMediaDrop.test.ts
+++ b/apps/axkdeck/src/lib/nativeMediaDrop.test.ts
@@ -162,4 +162,25 @@ describe('native media drops', () => {
         ]);
         expect(mocks.open).not.toHaveBeenCalled();
     });
+
+    it('admits portable packages and A3K archives without reading them eagerly', async () => {
+        const onDrop = vi.fn();
+
+        await listenForNativeMediaDrops({ onHover: vi.fn(), onDrop, onError: vi.fn() });
+        mocks.dragHandler!({
+            payload: {
+                type: 'drop',
+                paths: ['/packages/Program.axkprg', '/packages/Archive.A3K'],
+                position: { x: 15, y: 25 },
+            },
+        });
+
+        await vi.waitFor(() => expect(onDrop).toHaveBeenCalledOnce());
+        const files = onDrop.mock.calls[0][0] as { name: string; type: string }[];
+        expect(files.map((file) => ({ name: file.name, type: file.type }))).toEqual([
+            { name: 'Program.axkprg', type: 'application/octet-stream' },
+            { name: 'Archive.A3K', type: 'application/octet-stream' },
+        ]);
+        expect(mocks.open).not.toHaveBeenCalled();
+    });
 });
diff --git a/apps/axkdeck/src/lib/nativeMediaDrop.ts b/apps/axkdeck/src/lib/nativeMediaDrop.ts
index 95a30afc..579bdef6 100644
--- a/apps/axkdeck/src/lib/nativeMediaDrop.ts
+++ b/apps/axkdeck/src/lib/nativeMediaDrop.ts
@@ -4,6 +4,7 @@ import { audioExtensions, audioMediaType } from './audioImport';
 import type { ClientUploadSource } from './clientUploadSource';
 import { midiExtensions, midiMediaType } from './midiImport';
 import { nativeExtension, nativeFileSource } from './nativeFileSource';
+import { packageImportExtensions } from './packageImportMedia';
 import { tx16wDiskExtensions, tx16wDiskMediaType } from './tx16wImport';
 
 export interface NativeDropPosition {
@@ -21,7 +22,12 @@ interface NativeMediaDropCallbacks {
     onError: (reason: unknown) => void;
 }
 
-const supportedExtensions = new Set<string>([...audioExtensions, ...midiExtensions, ...tx16wDiskExtensions]);
+const supportedExtensions = new Set<string>([
+    ...audioExtensions,
+    ...midiExtensions,
+    ...tx16wDiskExtensions,
+    ...packageImportExtensions,
+]);
 const maximumNativeDropFileBytes = 4 * 1024 * 1024 * 1024;
 const maximumNativeDropTotalBytes = 8 * 1024 * 1024 * 1024;
 
diff --git a/apps/axkdeck/src/lib/packageImportMedia.ts b/apps/axkdeck/src/lib/packageImportMedia.ts
new file mode 100644
index 00000000..19c53ece
--- /dev/null
+++ b/apps/axkdeck/src/lib/packageImportMedia.ts
@@ -0,0 +1,22 @@
+export const packageImportExtensions = [
+    'a3k',
+    'axkvol',
+    'axkprg',
+    'axksbac',
+    'axksbnk',
+    'axksmpl',
+    'axkseq',
+    'axkpkg',
+] as const;
+
+const packageImportExtensionSet = new Set<string>(packageImportExtensions);
+
+export function packageImportUploadKind(filename: string): 'PACKAGE' | 'DISK_IMAGE' | null {
+    const extension = filename.split('.').pop()?.toLowerCase() ?? '';
+    if (!packageImportExtensionSet.has(extension)) return null;
+    return extension === 'a3k' ? 'DISK_IMAGE' : 'PACKAGE';
+}
+
+export function packageImportExtensionSetCopy(): Set<string> {
+    return new Set(packageImportExtensions);
+}
diff --git a/apps/server/contracts/openapi-v1.base.json b/apps/server/contracts/openapi-v1.base.json
index 768a306c..804482fa 100644
--- a/apps/server/contracts/openapi-v1.base.json
+++ b/apps/server/contracts/openapi-v1.base.json
@@ -2586,8 +2586,18 @@
         }
       },
       "ImageSessionPackageImportDestination": {
-        "description": "Either one existing SFS volume shared by every package root or one new SFS volume per volume package, named from its placement hint with optional indexed overrides.",
+        "description": "One existing SFS volume, one explicitly named new SFS volume, or one new SFS volume per volume package placement hint.",
         "oneOf": [
+          {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["kind", "partitionIndex", "volumeName"],
+            "properties": {
+              "kind": {"const": "CREATE_VOLUME"},
+              "partitionIndex": {"type": "integer", "minimum": 0, "maximum": 255},
+              "volumeName": {"type": "string", "minLength": 1, "maxLength": 16}
+            }
+          },
           {
             "type": "object",
             "additionalProperties": false,
diff --git a/apps/server/contracts/openapi-v1.json b/apps/server/contracts/openapi-v1.json
index c48c07e8..b34f31a4 100644
--- a/apps/server/contracts/openapi-v1.json
+++ b/apps/server/contracts/openapi-v1.json
@@ -5478,8 +5478,32 @@
         "type": "object"
       },
       "ImageSessionPackageImportDestination": {
-        "description": "Either one existing SFS volume shared by every package root or one new SFS volume per volume package, named from its placement hint with optional indexed overrides.",
+        "description": "One existing SFS volume, one explicitly named new SFS volume, or one new SFS volume per volume package placement hint.",
         "oneOf": [
+          {
+            "additionalProperties": false,
+            "properties": {
+              "kind": {
+                "const": "CREATE_VOLUME"
+              },
+              "partitionIndex": {
+                "maximum": 255,
+                "minimum": 0,
+                "type": "integer"
+              },
+              "volumeName": {
+                "maxLength": 16,
+                "minLength": 1,
+                "type": "string"
+              }
+            },
+            "required": [
+              "kind",
+              "partitionIndex",
+              "volumeName"
+            ],
+            "type": "object"
+          },
           {
             "additionalProperties": false,
             "properties": {
@@ -22969,7 +22993,7 @@
                 "default": {
                   "value": {
                     "destination": {
-                      "kind": "EXISTING_VOLUME",
+                      "kind": "CREATE_VOLUME",
                       "partitionIndex": 0,
                       "volumeName": "x"
                     },

From 65a90eba38fef2522e1241dcb317110cd8919dcd Mon Sep 17 00:00:00 2001
From: bzeiss <ben@zeiss.net>
Date: Thu, 20 Aug 2026 15:48:13 +0200
Subject: [PATCH 06/12] drag & drop improvements.

---
 apps/axkdeck/src/App.svelte                   |   9 +-
 apps/axkdeck/src/App.test.ts                  |  38 ++++-
 .../src/features/dialogs/AppDialogs.svelte    |  20 ++-
 .../features/image-session/workflow.svelte.ts |   3 +
 .../features/import/audioWorkflow.svelte.ts   | 150 ++++++++++++++----
 .../import/mediaDropWorkflow.svelte.ts        | 128 ++++++++-------
 .../features/import/mediaDropWorkflow.test.ts |  26 ++-
 .../import/packageDestinations.test.ts        |  14 +-
 .../features/import/packageDestinations.ts    |  30 ++--
 .../features/import/packageWorkflow.svelte.ts |  53 +++----
 .../features/import/packageWorkflow.test.ts   |  11 +-
 .../src/lib/audio/auditionController.test.ts  |  59 +++----
 .../src/lib/audio/auditionController.ts       |  90 +++++------
 .../lib/components/AudioImportDialog.svelte   |  53 +++++--
 .../lib/components/AudioImportDialog.test.ts  |  49 ++++--
 ...svelte => ImportDestinationChooser.svelte} | 122 +++++++++-----
 ...st.ts => ImportDestinationChooser.test.ts} |  25 ++-
 .../lib/components/PackageImportDialog.svelte |  22 +--
 apps/axkdeck/src/lib/httpImageSessions.ts     |   1 +
 .../src/lib/httpImportOperations.test.ts      |  49 ++++++
 apps/axkdeck/src/lib/httpImportOperations.ts  |  13 +-
 apps/axkdeck/src/lib/httpTransport.test.ts    |   2 +-
 apps/axkdeck/src/lib/httpTransport.ts         |   3 +-
 .../src/lib/testing/inMemoryTransport.ts      |   3 +-
 apps/axkdeck/src/lib/transport.ts             |   7 +-
 25 files changed, 642 insertions(+), 338 deletions(-)
 rename apps/axkdeck/src/lib/components/{PackageImportDestination.svelte => ImportDestinationChooser.svelte} (74%)
 rename apps/axkdeck/src/lib/components/{PackageImportDestination.test.ts => ImportDestinationChooser.test.ts} (83%)

diff --git a/apps/axkdeck/src/App.svelte b/apps/axkdeck/src/App.svelte
index 8f587f70..22cbe192 100644
--- a/apps/axkdeck/src/App.svelte
+++ b/apps/axkdeck/src/App.svelte
@@ -213,6 +213,7 @@
         picker: pickerController,
         sessionId: () => imageSessionWorkflow.sessionId,
         imageLocation: () => imageSessionWorkflow.location,
+        imageFormat: () => imageSessionWorkflow.imageFormat,
         mutationsAvailable: () => mutationWorkflow.volumeAvailable,
         selectedSource: () => imageSessionWorkflow.selectedSource,
         setSelectedSource: (item) => (imageSessionWorkflow.selectedSource = item),
@@ -274,6 +275,10 @@
         sequenceImport: sequenceImportWorkflow,
         tx16wImport: tx16wImportWorkflow,
         packageImport: packageImportWorkflow,
+        sessionId: () => imageSessionWorkflow.sessionId,
+        imageFormat: () => imageSessionWorkflow.imageFormat,
+        mutationsAvailable: () => mutationWorkflow.volumeAvailable,
+        selectedSource: () => imageSessionWorkflow.selectedSource,
         setStatus: (status) => imageSessionWorkflow.setStatus(status),
     });
     imageSessionWorkflow.connect({
@@ -498,7 +503,6 @@
     function clearPackageExportSelection(): void {
         packageExportSelection = emptyPackageExportSelection();
     }
-
     function reportPackageExportSelectionLimit(): void {
         imageSessionWorkflow.setStatus(
             `Package export supports at most ${maximumPackageExportRoots.toLocaleString()} selected objects`,
@@ -509,7 +513,6 @@
         if (!imageSessionWorkflow.audioExportAvailable) return;
         await exportWorkflow.requestAudio(items);
     }
-
     function requestSequenceExport(items: PackageExportObject[]): void {
         if (!imageSessionWorkflow.sequenceExportAvailable) return;
         exportWorkflow.requestSequence(items);
@@ -519,7 +522,6 @@
         if (!imageSessionWorkflow.objectDeletionAvailable) return;
         deletionWorkflow.requestObjects(targets);
     }
-
     function requestWaveDataCleanup(): void {
         if (!imageSessionWorkflow.waveDataCleanupAvailable) return;
         deletionWorkflow.requestCleanup();
@@ -528,7 +530,6 @@
     function suppressDesktopContextMenu(event: MouseEvent): void {
         if (isDesktop) event.preventDefault();
     }
-
     async function openConnectionSettings(): Promise<void> {
         try {
             connectionSettings = await connectionActions.load();
diff --git a/apps/axkdeck/src/App.test.ts b/apps/axkdeck/src/App.test.ts
index 1652a70c..f4cd9e25 100644
--- a/apps/axkdeck/src/App.test.ts
+++ b/apps/axkdeck/src/App.test.ts
@@ -112,6 +112,7 @@ describe('App panel layout', () => {
         ]);
         mocks.openImage.mockReset().mockResolvedValue({
             sessionId: 17,
+            format: 'sfs',
             revision: 1,
             companionSources: [],
             floppySet: null,
@@ -1590,9 +1591,9 @@ describe('App panel layout', () => {
         Object.defineProperty(drop, 'dataTransfer', { value: dataTransfer });
         window.dispatchEvent(drop);
         expect(drop.defaultPrevented).toBe(true);
-        const dialog = await screen.findByRole('dialog', { name: 'Audio import unavailable' });
+        const dialog = await screen.findByRole('dialog', { name: 'Open a hard-disk image' });
         expect(
-            within(dialog).getByText('Select a writable volume in Contents, then drop the audio files again.'),
+            within(dialog).getByText('Open a writable SFS hard-disk image before importing dropped files.'),
         ).toBeTruthy();
     });
 
@@ -1605,9 +1606,9 @@ describe('App panel layout', () => {
         const callbacks = mocks.listenForNativeMediaDrops.mock.calls[0][0];
         callbacks.onDrop([new File(['audio'], 'take.wav', { type: 'audio/wav' })], { x: 20, y: 30 }, 1);
 
-        const dialog = await screen.findByRole('dialog', { name: 'Audio import unavailable' });
+        const dialog = await screen.findByRole('dialog', { name: 'Open a hard-disk image' });
         expect(
-            within(dialog).getByText('Select a writable volume in Contents, then drop the audio files again.'),
+            within(dialog).getByText('Open a writable SFS hard-disk image before importing dropped files.'),
         ).toBeTruthy();
         delete runtime.__TAURI_INTERNALS__;
     });
@@ -1695,7 +1696,17 @@ describe('App panel layout', () => {
     });
 
     it('requires the Sequences tab for MIDI drops and rejects mixed media drops', async () => {
+        const volume = {
+            id: 'volume-1',
+            name: 'My Volume',
+            kind: 'volume' as const,
+            childCount: 0,
+            partitionIndex: 0,
+        };
+        mocks.openImage.mockResolvedValueOnce(openedImageWithVolumes([volume], volume));
         renderAcknowledgedApp();
+        await chooseNestedImage();
+        await screen.findByText('My Volume');
 
         const midiTransfer = {
             types: ['Files'],
@@ -1734,7 +1745,7 @@ describe('App panel layout', () => {
         expect(screen.queryByRole('dialog', { name: 'Import audio' })).toBeNull();
     });
 
-    it('switches to a dropped-on volume before opening MIDI import review', async () => {
+    it('keeps the explicitly selected volume when a MIDI file is dropped over another volume', async () => {
         const firstVolume = {
             id: 'volume-1',
             name: 'First Volume',
@@ -1770,8 +1781,8 @@ describe('App panel layout', () => {
         screen.getByText('Second Volume').dispatchEvent(drop);
 
         const dialog = await screen.findByRole('dialog', { name: 'Import MIDI' });
-        expect(within(dialog).getByText('Volume Second Volume')).toBeTruthy();
-        expect(mocks.objectPage).toHaveBeenCalledWith(17, 0, 256, { scopeId: 'volume-2' });
+        expect(within(dialog).getByText('Volume First Volume')).toBeTruthy();
+        expect(mocks.objectPage).not.toHaveBeenCalledWith(17, 0, 256, { scopeId: 'volume-2' });
     });
 
     it('selects several workspace audio files and inspects them without uploading', async () => {
@@ -1784,6 +1795,7 @@ describe('App panel layout', () => {
         };
         mocks.openImage.mockResolvedValueOnce({
             sessionId: 17,
+            format: 'sfs',
             tree: [{ id: 'disk-17', name: 'nested.hds', kind: 'disk', childCount: 1, children: [volume] }],
             validation: {
                 valid: true,
@@ -1861,6 +1873,7 @@ describe('App panel layout', () => {
         };
         mocks.openImage.mockResolvedValueOnce({
             sessionId: 17,
+            format: 'sfs',
             tree: [{ id: 'disk-17', name: 'nested.hds', kind: 'disk', childCount: 1, children: [volume] }],
             validation: {
                 valid: true,
@@ -1905,7 +1918,17 @@ describe('App panel layout', () => {
     });
 
     it('consumes unsupported and empty file drops without opening the import dialog', async () => {
+        const volume = {
+            id: 'volume-1',
+            name: 'My Volume',
+            kind: 'volume' as const,
+            childCount: 0,
+            partitionIndex: 0,
+        };
+        mocks.openImage.mockResolvedValueOnce(openedImageWithVolumes([volume], volume));
         renderAcknowledgedApp();
+        await chooseNestedImage();
+        await screen.findByText('My Volume');
 
         const unsupportedTransfer = {
             types: ['text/uri-list'],
@@ -1970,6 +1993,7 @@ function openedImageWithVolumes(
 ) {
     return {
         sessionId: 17,
+        format: 'sfs',
         companionSources: [],
         floppySet: null,
         tree: [
diff --git a/apps/axkdeck/src/features/dialogs/AppDialogs.svelte b/apps/axkdeck/src/features/dialogs/AppDialogs.svelte
index e92877f9..f67389bf 100644
--- a/apps/axkdeck/src/features/dialogs/AppDialogs.svelte
+++ b/apps/axkdeck/src/features/dialogs/AppDialogs.svelte
@@ -438,14 +438,24 @@
     <AudioImportDialog
         {transport}
         files={audioImport.request.files}
-        target={audioImport.request.target}
-        existingSampleNames={sampleNames}
-        existingSampleBankNames={sampleBankNames}
-        existingWaveformNames={waveDataNames}
+        target={audioImport.destination()}
+        destinationMode={audioImport.request.destinationMode}
+        destinationPartitionIndex={audioImport.request.destinationPartitionIndex}
+        destinationVolumeName={audioImport.request.destinationVolumeName}
+        partitionOptions={audioImport.partitionOptions()}
+        volumeOptions={audioImport.volumeOptions()}
+        existingSampleNames={audioImport.request.destinationMode === 'existing' ? sampleNames : []}
+        existingSampleBankNames={audioImport.request.destinationMode === 'existing' ? sampleBankNames : []}
+        existingWaveformNames={audioImport.request.destinationMode === 'existing' ? waveDataNames : []}
         onchooseworkspace={() => void audioImport.chooseWorkspace()}
         onchooselocal={transport.supportsClientUploads && audioFileInput
             ? () => audioImport.chooseLocal(audioFileInput)
             : undefined}
+        ondestinationmode={(mode) => audioImport.setDestinationMode(mode)}
+        ondestinationvolume={(partitionIndex, volumeName) =>
+            void audioImport.setExistingVolume(partitionIndex, volumeName)}
+        ondestinationpartition={(partitionIndex) => audioImport.setDestinationPartition(partitionIndex)}
+        ondestinationname={(volumeName) => audioImport.setDestinationVolumeName(volumeName)}
         oncommit={(items, grouping) => audioImport.commit(items, grouping)}
         oncancel={() => (audioImport.request = null)}
     />
@@ -510,7 +520,7 @@
             <strong
                 >{mediaDrop.dragTarget
                     ? `Import audio into ${mediaDrop.dragTarget.volumeName}`
-                    : 'Select a writable volume'}</strong
+                    : 'Choose a target volume after dropping'}</strong
             >
             <span>WAV, FLAC, and AIFF</span>
         {/if}
diff --git a/apps/axkdeck/src/features/image-session/workflow.svelte.ts b/apps/axkdeck/src/features/image-session/workflow.svelte.ts
index 50b58a90..26f571fe 100644
--- a/apps/axkdeck/src/features/image-session/workflow.svelte.ts
+++ b/apps/axkdeck/src/features/image-session/workflow.svelte.ts
@@ -88,6 +88,7 @@ export class ImageSessionWorkflow {
     mediaConversionAvailable = $state(false);
     extentLayoutRepairAvailable = $state(false);
     allocationInspectionAvailable = $state(false);
+    imageFormat = $state<string | null>(null);
     integrityDialogOpen = $state(false);
     integrityIssues = $state<ImageValidationIssue[]>([]);
     integrityLoading = $state(false);
@@ -355,6 +356,7 @@ export class ImageSessionWorkflow {
         this.mediaConversionAvailable = opened.mediaConversionAvailable;
         this.extentLayoutRepairAvailable = opened.extentLayoutRepairAvailable;
         this.allocationInspectionAvailable = opened.allocationInspectionAvailable;
+        this.imageFormat = opened.format ?? null;
         this.sourceItems = opened.tree;
         const preferredItem = preferred
             ? findSourceItem(opened.tree, preferred.partitionIndex, preferred.volumeName)
@@ -443,6 +445,7 @@ export class ImageSessionWorkflow {
         this.mediaConversionAvailable = false;
         this.extentLayoutRepairAvailable = false;
         this.allocationInspectionAvailable = false;
+        this.imageFormat = null;
         collaborators.deletion.dispose();
         collaborators.programGeneration.dispose();
         this.programGenerationAvailable = false;
diff --git a/apps/axkdeck/src/features/import/audioWorkflow.svelte.ts b/apps/axkdeck/src/features/import/audioWorkflow.svelte.ts
index 941ae60a..834fdf08 100644
--- a/apps/axkdeck/src/features/import/audioWorkflow.svelte.ts
+++ b/apps/axkdeck/src/features/import/audioWorkflow.svelte.ts
@@ -1,16 +1,30 @@
 import { audioExtensions, audioMediaType } from '../../lib/audioImport';
 import { browserUploadSource, type ClientUploadSource } from '../../lib/clientUploadSource';
 import type { DirectoryRef, FileLocation, ImageLocation } from '../../lib/storageLocations';
-import type { AudioImportGrouping, AudioImportItem, AudioImportTarget, ImageTransport } from '../../lib/transport';
+import type {
+    AudioImportDestination,
+    AudioImportGrouping,
+    AudioImportItem,
+    AudioImportTarget,
+    ImageTransport,
+} from '../../lib/transport';
 import type { DiskTreeItem, SampleStructureItem, WorkspaceView } from '../../lib/types';
 import { userFacingMessage } from '../../lib/userFacingMessage';
 import type { PickerController } from '../dialogs/picker';
 import type { JobController } from '../jobs/actions';
+import {
+    collectImportDestinations,
+    importDestination,
+    initialImportDestination,
+    type ImportDestinationMode,
+} from './packageDestinations';
 import { findVolumeSourceItem, sameVolumeTarget } from './volumeTarget';
 
 export interface AudioImportRequest {
     files: (ClientUploadSource | FileLocation)[];
-    target: AudioImportTarget;
+    destinationMode: ImportDestinationMode;
+    destinationPartitionIndex: number | null;
+    destinationVolumeName: string;
 }
 
 interface AudioImportDependencies {
@@ -19,6 +33,7 @@ interface AudioImportDependencies {
     picker: PickerController;
     sessionId: () => number | null;
     imageLocation: () => ImageLocation | null;
+    imageFormat: () => string | null;
     mutationsAvailable: () => boolean;
     selectedSource: () => DiskTreeItem;
     setSelectedSource: (item: DiskTreeItem) => void;
@@ -43,7 +58,11 @@ export class AudioImportWorkflow {
     constructor(private readonly dependencies: AudioImportDependencies) {}
 
     dropAvailable(): boolean {
-        return this.dependencies.mutationsAvailable() && this.dependencies.imageLocation() !== null;
+        return (
+            this.dependencies.mutationsAvailable() &&
+            this.dependencies.imageLocation() !== null &&
+            this.dependencies.imageFormat() === 'sfs'
+        );
     }
 
     activeTarget(): AudioImportTarget | null {
@@ -56,19 +75,20 @@ export class AudioImportWorkflow {
     }
 
     chooseFiles(): void {
-        const target = this.activeTarget();
-        if (!target || !this.dependencies.imageLocation()) {
-            this.dependencies.setStatus('Select a writable volume first');
+        if (!this.dropAvailable()) {
+            this.dependencies.setStatus('Open a writable SFS hard-disk image first');
             return;
         }
-        this.request = { files: [], target };
+        this.request = this.newRequest([], this.dependencies.selectedSource());
     }
 
     filesChosen(event: Event): void {
         const input = event.currentTarget as HTMLInputElement;
+        const request = this.request;
         void this.requestDroppedFiles(
             Array.from(input.files ?? []).map(browserUploadSource),
-            this.request?.target ?? this.activeTarget(),
+            null,
+            request ?? undefined,
         );
         input.value = '';
     }
@@ -82,7 +102,7 @@ export class AudioImportWorkflow {
             ondirectorychange: (directory) => (this.lastDirectory = directory),
         });
         if (!selections || !this.request) return;
-        await this.requestDroppedFiles(selections, request.target);
+        await this.requestDroppedFiles(selections, null, request);
     }
 
     chooseLocal(input: HTMLInputElement): void {
@@ -94,7 +114,8 @@ export class AudioImportWorkflow {
         const request = this.request;
         const sessionId = this.dependencies.sessionId();
         if (!request || sessionId === null) throw new Error('Audio import target is no longer available');
-        const target = request.target;
+        const target = this.destination();
+        if (!target) throw new Error('Choose a valid audio import destination');
         const firstName = items[0]?.sampleName;
         const started = performance.now();
         this.dependencies.setStatus('Importing audio');
@@ -108,7 +129,10 @@ export class AudioImportWorkflow {
             );
             if (completed.status !== 'completed') throw new Error(completed.error ?? 'Audio import did not complete');
             this.dependencies.selectWorkspace(grouping.kind === 'SAMPLE_BANK' ? 'sample-banks' : 'samples');
-            await this.dependencies.refreshSession(target);
+            await this.dependencies.refreshSession({
+                partitionIndex: target.partitionIndex,
+                volumeName: target.volumeName,
+            });
             if (grouping.kind === 'SAMPLE_BANK') {
                 const inserted = this.dependencies
                     .sampleBanks()
@@ -127,7 +151,8 @@ export class AudioImportWorkflow {
 
     async requestDroppedFiles(
         files: (ClientUploadSource | FileLocation)[],
-        target = this.activeTarget(),
+        selected: DiskTreeItem | null = this.dependencies.selectedSource(),
+        destinationRequest?: AudioImportRequest,
     ): Promise<void> {
         const admitted: (ClientUploadSource | FileLocation)[] = [];
         for (const source of files) {
@@ -138,27 +163,94 @@ export class AudioImportWorkflow {
             this.dependencies.setStatus('No supported WAV, FLAC, or AIFF files were selected');
             return;
         }
-        if (!target || admitted.length === 0 || !this.dependencies.imageLocation()) {
-            this.dependencies.setStatus(
-                target ? 'Drop WAV, FLAC, or AIFF audio files' : 'Select a writable volume first',
-            );
+        if (admitted.length === 0 || !this.dropAvailable()) {
+            this.dependencies.setStatus('Drop WAV, FLAC, or AIFF audio files onto a writable SFS hard-disk image');
             return;
         }
-        const active = this.activeTarget();
-        if (!sameVolumeTarget(active, target)) {
-            const item = findVolumeSourceItem(this.dependencies.sourceItems(), target);
-            if (!item) {
-                this.dependencies.setStatus('Audio import target is no longer available');
-                return;
-            }
-            this.dependencies.setSelectedSource(item);
-            await this.dependencies.loadVolume(item.id);
-            if (this.dependencies.activeVolumeId() !== item.id) {
-                this.dependencies.setStatus('Audio import target is no longer available');
-                return;
+        this.request = destinationRequest
+            ? { ...destinationRequest, files: admitted }
+            : this.newRequest(admitted, selected);
+        const target = this.destination();
+        if (target?.kind === 'EXISTING_VOLUME') await this.loadExistingVolume(target);
+    }
+
+    destination(): AudioImportDestination | null {
+        const request = this.request;
+        if (!request) return null;
+        return importDestination(
+            request.destinationMode,
+            request.destinationPartitionIndex,
+            request.destinationVolumeName,
+        );
+    }
+
+    partitionOptions() {
+        return collectImportDestinations(this.dependencies.sourceItems()).partitions;
+    }
+
+    volumeOptions() {
+        return collectImportDestinations(this.dependencies.sourceItems()).volumes;
+    }
+
+    setDestinationMode(mode: ImportDestinationMode): void {
+        const request = this.request;
+        if (!request) return;
+        const destinations = collectImportDestinations(this.dependencies.sourceItems());
+        request.destinationMode = mode;
+        request.destinationVolumeName = '';
+        request.destinationPartitionIndex =
+            mode === 'create'
+                ? (request.destinationPartitionIndex ?? destinations.partitions[0]?.partitionIndex ?? null)
+                : null;
+    }
+
+    async setExistingVolume(partitionIndex: number | null, volumeName: string): Promise<void> {
+        const request = this.request;
+        if (!request) return;
+        request.destinationPartitionIndex = partitionIndex;
+        request.destinationVolumeName = volumeName;
+        if (partitionIndex !== null && volumeName) {
+            try {
+                await this.loadExistingVolume({ partitionIndex, volumeName });
+            } catch (error) {
+                request.destinationPartitionIndex = null;
+                request.destinationVolumeName = '';
+                this.dependencies.setStatus(userFacingMessage(error));
             }
         }
-        this.request = { files: admitted, target };
+    }
+
+    setDestinationPartition(partitionIndex: number): void {
+        if (this.request) this.request.destinationPartitionIndex = partitionIndex;
+    }
+
+    setDestinationVolumeName(volumeName: string): void {
+        if (this.request) this.request.destinationVolumeName = volumeName.slice(0, 16);
+    }
+
+    private newRequest(
+        files: (ClientUploadSource | FileLocation)[],
+        selected: DiskTreeItem | null,
+    ): AudioImportRequest {
+        const initial = selected ? initialImportDestination(selected) : null;
+        return {
+            files,
+            destinationMode: initial?.mode ?? 'existing',
+            destinationPartitionIndex: initial?.partitionIndex ?? null,
+            destinationVolumeName: initial?.volumeName ?? '',
+        };
+    }
+
+    private async loadExistingVolume(target: AudioImportTarget): Promise<void> {
+        const active = this.activeTarget();
+        if (sameVolumeTarget(active, target)) return;
+        const item = findVolumeSourceItem(this.dependencies.sourceItems(), target);
+        if (!item) throw new Error('Audio import target is no longer available');
+        this.dependencies.setSelectedSource(item);
+        await this.dependencies.loadVolume(item.id);
+        if (this.dependencies.activeVolumeId() !== item.id) {
+            throw new Error('Audio import target is no longer available');
+        }
     }
 }
 
diff --git a/apps/axkdeck/src/features/import/mediaDropWorkflow.svelte.ts b/apps/axkdeck/src/features/import/mediaDropWorkflow.svelte.ts
index fe9d329b..0191c798 100644
--- a/apps/axkdeck/src/features/import/mediaDropWorkflow.svelte.ts
+++ b/apps/axkdeck/src/features/import/mediaDropWorkflow.svelte.ts
@@ -2,7 +2,7 @@ import { audioMediaType } from '../../lib/audioImport';
 import { browserUploadSource, type ClientUploadSource } from '../../lib/clientUploadSource';
 import { reportDiagnostic, reportError } from '../../lib/diagnostics';
 import { midiMediaType } from '../../lib/midiImport';
-import { listenForNativeMediaDrops, type NativeDropPosition } from '../../lib/nativeMediaDrop';
+import { listenForNativeMediaDrops } from '../../lib/nativeMediaDrop';
 import { packageImportUploadKind } from '../../lib/packageImportMedia';
 import type { AudioImportTarget } from '../../lib/transport';
 import { tx16wDiskMediaType } from '../../lib/tx16wImport';
@@ -14,7 +14,6 @@ import type { Tx16wImportWorkflow } from './tx16wWorkflow.svelte';
 
 export type MediaDropKind = 'audio' | 'midi' | 'tx16w' | 'package' | 'mixed';
 type ClassifiedMedia = MediaDropKind | 'none';
-type DropTarget = AudioImportTarget | DiskTreeItem;
 
 export interface MediaDropNotice {
     title: string;
@@ -28,6 +27,10 @@ interface MediaDropDependencies {
     sequenceImport: SequenceImportWorkflow;
     tx16wImport: Tx16wImportWorkflow;
     packageImport: PackageImportWorkflow;
+    sessionId: () => number | null;
+    imageFormat: () => string | null;
+    mutationsAvailable: () => boolean;
+    selectedSource: () => DiskTreeItem;
     setStatus: (status: string) => void;
 }
 
@@ -48,8 +51,8 @@ export class MediaDropWorkflow {
         let disposed = false;
         let unlisten: (() => void) | null = null;
         void listenForNativeMediaDrops({
-            onHover: (paths, position) => this.updateHover(paths, position),
-            onDrop: (files, position, droppedPathCount) => {
+            onHover: (paths) => this.updateHover(paths),
+            onDrop: (files, _position, droppedPathCount) => {
                 const kind = classifyDroppedNames(files.map((file) => file.name));
                 reportDiagnostic('native_media_drop_received', {
                     droppedPathCount,
@@ -62,7 +65,7 @@ export class MediaDropWorkflow {
                     );
                     return;
                 }
-                void this.route(files, position ? this.nativeDroppedTarget(position, kind) : null);
+                void this.route(files);
             },
             onError: (reason) => {
                 this.clearHover();
@@ -99,11 +102,9 @@ export class MediaDropWorkflow {
             return;
         }
         this.dragKind = kind;
-        const target = kind === 'mixed' ? null : this.targetForElement(event.target, kind);
-        this.dragTarget = target && !('kind' in target) ? target : null;
+        this.dragTarget = kind === 'mixed' ? null : this.selectedVolumeTarget();
         this.dragActive = true;
-        const dropAvailable = kind === 'package' ? this.dependencies.packageImport.dropAvailable() : target !== null;
-        dataTransfer.dropEffect = kind === 'mixed' || !dropAvailable ? 'none' : 'copy';
+        dataTransfer.dropEffect = kind === 'mixed' || this.admission() ? 'none' : 'copy';
     }
 
     leave(event: DragEvent): void {
@@ -116,13 +117,18 @@ export class MediaDropWorkflow {
         event.preventDefault();
         const files = Array.from(dataTransfer.files).map(browserUploadSource);
         const kind = classifyDroppedNames(files.map((file) => file.name));
-        const target = this.targetForElement(event.target, kind === 'none' ? this.defaultKind() : kind);
         this.clearHover();
-        if (files.length > 0) void this.route(files, target);
+        if (files.length > 0) void this.route(files);
     }
 
-    private async route(files: ClientUploadSource[], target: DropTarget | null): Promise<void> {
+    private async route(files: ClientUploadSource[]): Promise<void> {
         if (this.importDialogOpen() || files.length === 0) return;
+        const admission = this.admission();
+        if (admission) {
+            this.dependencies.setStatus(admission.message);
+            this.notice = admission;
+            return;
+        }
         const kind = classifyDroppedNames(files.map((file) => file.name));
         if (kind === 'mixed') {
             this.dependencies.setStatus('Drop one media type at a time');
@@ -134,10 +140,10 @@ export class MediaDropWorkflow {
         }
         const selectedKind = kind === 'none' ? this.defaultKind() : kind;
         if (kind === 'none') {
-            const volumeTarget = target && !('kind' in target) ? target : null;
+            const volumeTarget = this.selectedVolumeTarget();
             if (selectedKind === 'midi')
                 await this.dependencies.sequenceImport.requestDroppedFiles(files, volumeTarget);
-            else await this.dependencies.audioImport.requestDroppedFiles(files, volumeTarget);
+            else await this.dependencies.audioImport.requestDroppedFiles(files, this.dependencies.selectedSource());
             return;
         }
         if (selectedKind === 'package') {
@@ -157,13 +163,10 @@ export class MediaDropWorkflow {
                 };
                 return;
             }
-            await this.dependencies.packageImport.requestDroppedFile(
-                files[0],
-                target && 'kind' in target ? target : null,
-            );
+            await this.dependencies.packageImport.requestDroppedFile(files[0], this.dependencies.selectedSource());
             return;
         }
-        const volumeTarget = target && !('kind' in target) ? target : null;
+        const volumeTarget = this.selectedVolumeTarget();
         if (selectedKind === 'tx16w') {
             if (!this.dependencies.tx16wImport.dropAvailable()) {
                 this.dependencies.setStatus('TX16W import requires a writable SFS hard-disk image');
@@ -196,18 +199,10 @@ export class MediaDropWorkflow {
             await this.dependencies.sequenceImport.requestDroppedFiles(files, volumeTarget);
             return;
         }
-        if (!volumeTarget) {
-            this.dependencies.setStatus('Select a writable volume first');
-            this.notice = {
-                title: 'Audio import unavailable',
-                message: 'Select a writable volume in Contents, then drop the audio files again.',
-            };
-            return;
-        }
-        await this.dependencies.audioImport.requestDroppedFiles(files, volumeTarget);
+        await this.dependencies.audioImport.requestDroppedFiles(files, this.dependencies.selectedSource());
     }
 
-    private updateHover(paths: readonly string[], position?: NativeDropPosition): void {
+    private updateHover(paths: readonly string[]): void {
         if (paths.length === 0 || this.importDialogOpen()) {
             this.clearHover();
             return;
@@ -218,8 +213,7 @@ export class MediaDropWorkflow {
             return;
         }
         this.dragKind = kind;
-        const target = kind === 'mixed' || !position ? null : this.nativeDroppedTarget(position, kind);
-        this.dragTarget = target && !('kind' in target) ? target : null;
+        this.dragTarget = kind === 'mixed' ? null : this.selectedVolumeTarget();
         this.dragActive = true;
     }
 
@@ -227,43 +221,19 @@ export class MediaDropWorkflow {
         return this.dependencies.workspaceView() === 'sequences' ? 'midi' : 'audio';
     }
 
-    private targetForElement(target: EventTarget | null, kind: ClassifiedMedia): DropTarget | null {
-        if (kind === 'mixed' || kind === 'none') return null;
-        if (kind === 'package') {
-            if (!this.dependencies.packageImport.dropAvailable()) return null;
-            const element = target instanceof Element ? target.closest<HTMLElement>('[data-import-drop-kind]') : null;
-            const partition = element?.dataset.importDropPartition;
-            const itemKind = element?.dataset.importDropKind;
-            const name = element?.dataset.importDropName;
-            if ((itemKind === 'partition' || itemKind === 'volume') && partition !== undefined && name) {
-                return {
-                    id: `drop-${itemKind}-${partition}-${name}`,
-                    name,
-                    kind: itemKind,
-                    partitionIndex: Number(partition),
-                    childCount: 0,
-                };
-            }
-            return null;
-        }
-        const workflow =
-            kind === 'midi'
-                ? this.dependencies.sequenceImport
-                : kind === 'tx16w'
-                  ? this.dependencies.tx16wImport
-                  : this.dependencies.audioImport;
-        if (!workflow.dropAvailable()) return null;
-        const element = target instanceof Element ? target.closest<HTMLElement>('[data-import-drop-volume]') : null;
-        const partition = element?.dataset.importDropPartition;
-        if (element?.dataset.importDropVolume && partition !== undefined) {
-            return { partitionIndex: Number(partition), volumeName: element.dataset.importDropVolume };
-        }
-        return workflow.activeTarget();
+    private selectedVolumeTarget(): AudioImportTarget | null {
+        const selected = this.dependencies.selectedSource();
+        return selected.kind === 'volume' && selected.partitionIndex !== undefined
+            ? { partitionIndex: selected.partitionIndex, volumeName: selected.name }
+            : null;
     }
 
-    private nativeDroppedTarget(position: NativeDropPosition, kind: ClassifiedMedia): DropTarget | null {
-        const scale = window.devicePixelRatio > 0 ? window.devicePixelRatio : 1;
-        return this.targetForElement(document.elementFromPoint?.(position.x / scale, position.y / scale) ?? null, kind);
+    private admission(): MediaDropNotice | null {
+        return mediaDropAdmission(
+            this.dependencies.sessionId(),
+            this.dependencies.imageFormat(),
+            this.dependencies.mutationsAvailable(),
+        );
     }
 
     private importDialogOpen(): boolean {
@@ -283,6 +253,32 @@ export class MediaDropWorkflow {
     }
 }
 
+export function mediaDropAdmission(
+    sessionId: number | null,
+    imageFormat: string | null,
+    mutationsAvailable: boolean,
+): MediaDropNotice | null {
+    if (sessionId === null) {
+        return {
+            title: 'Open a hard-disk image',
+            message: 'Open a writable SFS hard-disk image before importing dropped files.',
+        };
+    }
+    if (imageFormat !== 'sfs') {
+        return {
+            title: 'Drag and drop unavailable',
+            message: 'Drag and drop import can only be performed on SFS hard-disk images.',
+        };
+    }
+    if (!mutationsAvailable) {
+        return {
+            title: 'Image is read-only',
+            message: 'Drag and drop import requires a writable SFS hard-disk image.',
+        };
+    }
+    return null;
+}
+
 export function classifyDroppedNames(names: readonly string[]): ClassifiedMedia {
     let audio = false;
     let midi = false;
diff --git a/apps/axkdeck/src/features/import/mediaDropWorkflow.test.ts b/apps/axkdeck/src/features/import/mediaDropWorkflow.test.ts
index 8d3c9ad4..4aca32f0 100644
--- a/apps/axkdeck/src/features/import/mediaDropWorkflow.test.ts
+++ b/apps/axkdeck/src/features/import/mediaDropWorkflow.test.ts
@@ -1,5 +1,29 @@
 import { describe, expect, it } from 'vitest';
-import { classifyDroppedNames } from './mediaDropWorkflow.svelte';
+import { classifyDroppedNames, mediaDropAdmission } from './mediaDropWorkflow.svelte';
+
+describe('media drop admission', () => {
+    it('requires an open hard-disk image when no media is open', () => {
+        expect(mediaDropAdmission(null, null, false)).toEqual({
+            title: 'Open a hard-disk image',
+            message: 'Open a writable SFS hard-disk image before importing dropped files.',
+        });
+    });
+
+    it('rejects writable non-SFS media with a format-specific explanation', () => {
+        expect(mediaDropAdmission(12, 'iso9660', true)).toEqual({
+            title: 'Drag and drop unavailable',
+            message: 'Drag and drop import can only be performed on SFS hard-disk images.',
+        });
+    });
+
+    it('requires an alterable SFS image', () => {
+        expect(mediaDropAdmission(12, 'sfs', false)).toEqual({
+            title: 'Image is read-only',
+            message: 'Drag and drop import requires a writable SFS hard-disk image.',
+        });
+        expect(mediaDropAdmission(12, 'sfs', true)).toBeNull();
+    });
+});
 
 describe('media drop classification', () => {
     it.each([
diff --git a/apps/axkdeck/src/features/import/packageDestinations.test.ts b/apps/axkdeck/src/features/import/packageDestinations.test.ts
index cc866fe3..acd97e49 100644
--- a/apps/axkdeck/src/features/import/packageDestinations.test.ts
+++ b/apps/axkdeck/src/features/import/packageDestinations.test.ts
@@ -1,9 +1,13 @@
 import { describe, expect, it } from 'vitest';
-import { packageImportDestination } from './packageDestinations';
+import { importDestination, initialImportDestination } from './packageDestinations';
+
+describe('importDestination', () => {
+    it('leaves the chooser unresolved without a partition or volume selection', () => {
+        expect(initialImportDestination(null)).toBeNull();
+    });
 
-describe('packageImportDestination', () => {
     it('preserves the exact name of an existing sampler volume', () => {
-        expect(packageImportDestination('existing', 2, '  Existing Volume  ')).toEqual({
+        expect(importDestination('existing', 2, '  Existing Volume  ')).toEqual({
             kind: 'EXISTING_VOLUME',
             partitionIndex: 2,
             volumeName: '  Existing Volume  ',
@@ -11,7 +15,7 @@ describe('packageImportDestination', () => {
     });
 
     it('accepts a valid new sampler volume name without rewriting it', () => {
-        expect(packageImportDestination('create', 0, 'New Volume')).toEqual({
+        expect(importDestination('create', 0, 'New Volume')).toEqual({
             kind: 'CREATE_VOLUME',
             partitionIndex: 0,
             volumeName: 'New Volume',
@@ -21,7 +25,7 @@ describe('packageImportDestination', () => {
     it.each([' New Volume', 'New Volume ', '12345678901234567', 'New\nVolume'])(
         'rejects the invalid new sampler volume name %j',
         (volumeName) => {
-            expect(packageImportDestination('create', 0, volumeName)).toBeNull();
+            expect(importDestination('create', 0, volumeName)).toBeNull();
         },
     );
 });
diff --git a/apps/axkdeck/src/features/import/packageDestinations.ts b/apps/axkdeck/src/features/import/packageDestinations.ts
index a7e5748f..21ee731e 100644
--- a/apps/axkdeck/src/features/import/packageDestinations.ts
+++ b/apps/axkdeck/src/features/import/packageDestinations.ts
@@ -1,30 +1,30 @@
 import type { DiskTreeItem } from '../../lib/types';
 import type { PackageInspection } from '../../lib/transport';
 
-export type PackageImportDestinationMode = 'existing' | 'create';
+export type ImportDestinationMode = 'existing' | 'create';
 
-export interface PackageImportPartitionOption {
+export interface ImportPartitionOption {
     partitionIndex: number;
     name: string;
 }
 
-export interface PackageImportVolumeOption extends PackageImportPartitionOption {
+export interface ImportVolumeOption extends ImportPartitionOption {
     volumeName: string;
     label: string;
 }
 
-export interface PackageImportDestinations {
-    partitions: PackageImportPartitionOption[];
-    volumes: PackageImportVolumeOption[];
+export interface ImportDestinations {
+    partitions: ImportPartitionOption[];
+    volumes: ImportVolumeOption[];
     partitionItems: DiskTreeItem[];
     volumeItems: DiskTreeItem[];
 }
 
-export type PackageImportDestination =
+export type ImportDestination =
     | { kind: 'EXISTING_VOLUME'; partitionIndex: number; volumeName: string }
     | { kind: 'CREATE_VOLUME'; partitionIndex: number; volumeName: string };
 
-export function collectPackageImportDestinations(sourceItems: readonly DiskTreeItem[]): PackageImportDestinations {
+export function collectImportDestinations(sourceItems: readonly DiskTreeItem[]): ImportDestinations {
     const partitionItems: DiskTreeItem[] = [];
     const volumeItems: DiskTreeItem[] = [];
     const visit = (item: DiskTreeItem): void => {
@@ -51,25 +51,25 @@ export function collectPackageImportDestinations(sourceItems: readonly DiskTreeI
     };
 }
 
-export function initialPackageImportDestination(item: DiskTreeItem): {
-    mode: PackageImportDestinationMode;
+export function initialImportDestination(item: DiskTreeItem | null | undefined): {
+    mode: ImportDestinationMode;
     partitionIndex: number | null;
     volumeName: string;
 } | null {
-    if (item.kind === 'volume' && item.partitionIndex !== undefined) {
+    if (item?.kind === 'volume' && item.partitionIndex !== undefined) {
         return { mode: 'existing', partitionIndex: item.partitionIndex, volumeName: item.name };
     }
-    if (item.kind === 'partition' && item.partitionIndex !== undefined) {
+    if (item?.kind === 'partition' && item.partitionIndex !== undefined) {
         return { mode: 'create', partitionIndex: item.partitionIndex, volumeName: '' };
     }
     return null;
 }
 
-export function packageImportDestination(
-    mode: PackageImportDestinationMode,
+export function importDestination(
+    mode: ImportDestinationMode,
     partitionIndex: number | null,
     rawVolumeName: string,
-): PackageImportDestination | null {
+): ImportDestination | null {
     if (partitionIndex === null || rawVolumeName.length === 0) return null;
     if (
         mode === 'create' &&
diff --git a/apps/axkdeck/src/features/import/packageWorkflow.svelte.ts b/apps/axkdeck/src/features/import/packageWorkflow.svelte.ts
index 48e984db..da3bbac6 100644
--- a/apps/axkdeck/src/features/import/packageWorkflow.svelte.ts
+++ b/apps/axkdeck/src/features/import/packageWorkflow.svelte.ts
@@ -19,26 +19,26 @@ import { reportError } from '../../lib/diagnostics';
 import type { PickerController } from '../dialogs/picker';
 import type { JobController } from '../jobs/actions';
 import {
-    collectPackageImportDestinations,
-    initialPackageImportDestination,
-    packageImportDestination,
+    collectImportDestinations,
+    importDestination,
+    initialImportDestination,
     suggestedPackageVolumeName,
-    type PackageImportDestinationMode,
-    type PackageImportPartitionOption,
-    type PackageImportVolumeOption,
+    type ImportDestinationMode,
+    type ImportPartitionOption,
+    type ImportVolumeOption,
 } from './packageDestinations';
 import { PackagePickerHistory } from './packagePickerHistory';
 
 const packageExtensionSet = packageImportExtensionSetCopy();
 
 export interface PackageImportRequest {
-    item: DiskTreeItem;
+    item: DiskTreeItem | null;
     canChangeSource: boolean;
     source: InputFileLocation | null;
     upload: ClientUploadLocation | null;
     localSourcePath: string | null;
     sourceName: string;
-    destinationMode: PackageImportDestinationMode;
+    destinationMode: ImportDestinationMode;
     destinationPartitionIndex: number | null;
     destinationVolumeName: string;
     inspection: PackageInspection | null;
@@ -77,12 +77,12 @@ export class PackageImportWorkflow {
         this.pickerHistory = dependencies.pickerHistory ?? new PackagePickerHistory();
     }
 
-    open(item: DiskTreeItem): void {
+    open(item: DiskTreeItem | null): void {
         ++this.generation;
         this.abortController?.abort();
         this.abortController = null;
-        const destination = initialPackageImportDestination(item) ?? {
-            mode: 'create' as const,
+        const destination = initialImportDestination(item) ?? {
+            mode: 'existing' as const,
             partitionIndex: null,
             volumeName: '',
         };
@@ -112,11 +112,11 @@ export class PackageImportWorkflow {
         return this.dependencies.mutationsAvailable?.() ?? false;
     }
 
-    partitionOptions(): PackageImportPartitionOption[] {
+    partitionOptions(): ImportPartitionOption[] {
         return this.destinations().partitions;
     }
 
-    volumeOptions(): PackageImportVolumeOption[] {
+    volumeOptions(): ImportVolumeOption[] {
         return this.destinations().volumes;
     }
 
@@ -128,7 +128,7 @@ export class PackageImportWorkflow {
             : request.destinationVolumeName;
     }
 
-    setDestinationMode(mode: PackageImportDestinationMode): void {
+    setDestinationMode(mode: ImportDestinationMode): void {
         const request = this.request;
         if (!request || request.status === 'applying' || request.destinationMode === mode) return;
         const destinations = this.destinations();
@@ -286,14 +286,8 @@ export class PackageImportWorkflow {
     async requestDroppedFile(file: ClientUploadSource, target?: DiskTreeItem | null): Promise<void> {
         if (this.request || !this.dropAvailable()) return;
         const selected = this.dependencies.selectedSource?.();
-        const item =
-            target ??
-            (selected && (selected.kind === 'partition' || selected.kind === 'volume') ? selected : null) ??
-            this.fallbackDestinationItem();
-        if (!item || (item.kind !== 'partition' && item.kind !== 'volume')) {
-            this.dependencies.setStatus('Choose an import destination first');
-            return;
-        }
+        const candidate = target ?? selected;
+        const item = candidate && (candidate.kind === 'partition' || candidate.kind === 'volume') ? candidate : null;
         const uploadKind = packageImportUploadKind(file.name);
         if (!uploadKind) return;
         this.open(item);
@@ -423,7 +417,7 @@ export class PackageImportWorkflow {
         const request = this.request;
         const sessionId = this.dependencies.sessionId();
         const destination = request
-            ? packageImportDestination(
+            ? importDestination(
                   request.destinationMode,
                   request.destinationPartitionIndex,
                   request.destinationVolumeName,
@@ -504,7 +498,7 @@ export class PackageImportWorkflow {
             status: request.source ? ('ready' as const) : request.status,
             error: '',
         };
-        const destination = packageImportDestination(
+        const destination = importDestination(
             next.destinationMode,
             next.destinationPartitionIndex,
             next.destinationVolumeName,
@@ -599,7 +593,7 @@ export class PackageImportWorkflow {
         const request = this.request;
         const sessionId = this.dependencies.sessionId();
         const destination = request
-            ? packageImportDestination(
+            ? importDestination(
                   request.destinationMode,
                   request.destinationPartitionIndex,
                   request.destinationVolumeName,
@@ -686,14 +680,7 @@ export class PackageImportWorkflow {
         return checkSuggestedProgramSlots ? plan.planToken : null;
     }
 
-    private fallbackDestinationItem(): DiskTreeItem | null {
-        const selected = this.dependencies.selectedSource?.();
-        if (selected && (selected.kind === 'partition' || selected.kind === 'volume')) return selected;
-        const destinations = this.destinations();
-        return destinations.partitionItems[0] ?? destinations.volumeItems[0] ?? null;
-    }
-
     private destinations() {
-        return collectPackageImportDestinations(this.dependencies.sourceItems?.() ?? []);
+        return collectImportDestinations(this.dependencies.sourceItems?.() ?? []);
     }
 }
diff --git a/apps/axkdeck/src/features/import/packageWorkflow.test.ts b/apps/axkdeck/src/features/import/packageWorkflow.test.ts
index 976f3f71..18fccc24 100644
--- a/apps/axkdeck/src/features/import/packageWorkflow.test.ts
+++ b/apps/axkdeck/src/features/import/packageWorkflow.test.ts
@@ -822,18 +822,11 @@ describe('PackageImportWorkflow', () => {
 
         await workflow.requestDroppedFile(dropped);
 
-        expect(workflow.request?.destinationMode).toBe('create');
-        expect(workflow.request?.destinationPartitionIndex).toBe(0);
-        expect(workflow.request?.destinationVolumeName).toBe('');
-        expect(workflow.request?.plan).toBeNull();
-        expect(workflow.request?.hasUnvalidatedChanges).toBe(true);
-        expect(planImagePackageImport).not.toHaveBeenCalled();
-
-        workflow.setDestinationMode('existing');
-
         expect(workflow.request?.destinationMode).toBe('existing');
         expect(workflow.request?.destinationPartitionIndex).toBeNull();
         expect(workflow.request?.destinationVolumeName).toBe('');
+        expect(workflow.request?.plan).toBeNull();
+        expect(workflow.request?.hasUnvalidatedChanges).toBe(true);
         expect(planImagePackageImport).not.toHaveBeenCalled();
 
         workflow.setDestinationMode('create');
diff --git a/apps/axkdeck/src/lib/audio/auditionController.test.ts b/apps/axkdeck/src/lib/audio/auditionController.test.ts
index b6a46635..797933a2 100644
--- a/apps/axkdeck/src/lib/audio/auditionController.test.ts
+++ b/apps/axkdeck/src/lib/audio/auditionController.test.ts
@@ -258,11 +258,17 @@ describe('AuditionController', () => {
         vi.stubGlobal('cancelAnimationFrame', vi.fn());
     }
 
-    it('creates and closes one output context per audition while reusing decoded audio', async () => {
+    it('reuses one output context across auditions and closes it only on disposal', async () => {
         installAudio();
         const transport = transportFor(descriptor());
         const updates: AuditionState[] = [];
-        const controller = new AuditionController(transport, (state) => updates.push(state));
+        const diagnostics: Record<string, unknown>[] = [];
+        const controller = new AuditionController(
+            transport,
+            (state) => updates.push(state),
+            (event) => diagnostics.push(event),
+            () => true,
+        );
 
         await controller.play(1, 'SMPL-1');
 
@@ -278,20 +284,22 @@ describe('AuditionController', () => {
         await controller.stop();
         await controller.play(1, 'SMPL-1');
 
-        expect(MockAudioContext.instances).toHaveLength(2);
-        expect(MockAudioContext.instances[0]?.state).toBe('closed');
-        expect(MockAudioContext.instances[1]?.state).toBe('running');
+        expect(MockAudioContext.instances).toHaveLength(1);
+        expect(MockAudioContext.instances[0]?.state).toBe('running');
         expect(transport.prepareAuditionBundle).toHaveBeenCalledTimes(1);
         expect(transport.readAuditionContent).toHaveBeenCalledTimes(1);
         expect(MockAudioContext.instances[0]?.decodeAudioData).toHaveBeenCalledTimes(1);
         expect(MockAudioBufferSourceNode.instances).toHaveLength(2);
+        expect(diagnostics.filter((event) => event.event === 'audio_context_ready')).toMatchObject([
+            { reused: false, creationDurationMs: expect.any(Number) },
+            { reused: true, creationDurationMs: 0 },
+        ]);
 
         MockAudioBufferSourceNode.instances[1]?.onended?.();
-        await vi.waitFor(() => expect(MockAudioContext.instances[1]?.state).toBe('closed'));
+        await vi.waitFor(() => expect(MockAudioContext.instances[0]?.state).toBe('running'));
 
         await controller.dispose();
         expect(MockAudioContext.instances[0]?.close).toHaveBeenCalledTimes(1);
-        expect(MockAudioContext.instances[1]?.close).toHaveBeenCalledTimes(1);
     });
 
     it('resumes each explicit audition from its initiating user action', async () => {
@@ -322,27 +330,22 @@ describe('AuditionController', () => {
         await controller.dispose();
     });
 
-    it('does not let a pending stop close the next audition context', async () => {
+    it('keeps the output context available during an immediate replay', async () => {
         installAudio();
-        vi.useFakeTimers();
         const transport = transportFor(descriptor());
         const controller = new AuditionController(transport, () => undefined);
 
         await controller.play(1, 'SMPL-1');
         const stopping = controller.stop();
         const replaying = controller.play(1, 'SMPL-1');
-        await vi.advanceTimersByTimeAsync(5);
         await Promise.all([stopping, replaying]);
 
-        expect(MockAudioContext.instances).toHaveLength(2);
-        expect(MockAudioContext.instances[0]?.state).toBe('closed');
-        expect(MockAudioContext.instances[1]?.state).toBe('running');
-        const disposing = controller.dispose();
-        await vi.advanceTimersByTimeAsync(5);
-        await disposing;
+        expect(MockAudioContext.instances).toHaveLength(1);
+        expect(MockAudioContext.instances[0]?.state).toBe('running');
+        await controller.dispose();
     });
 
-    it('replaces an active audition only after closing its context', async () => {
+    it('replaces an active audition without reopening its output context', async () => {
         installAudio();
         const transport = transportFor(descriptor());
         const controller = new AuditionController(transport, () => undefined);
@@ -350,10 +353,9 @@ describe('AuditionController', () => {
         await controller.play(1, 'SMPL-1');
         await controller.play(1, 'SMPL-2');
 
-        expect(MockAudioContext.instances).toHaveLength(2);
-        expect(MockAudioContext.instances[0]?.state).toBe('closed');
-        expect(MockAudioContext.instances[1]?.state).toBe('running');
-        expect(events.indexOf('close')).toBeLessThan(events.lastIndexOf('context'));
+        expect(MockAudioContext.instances).toHaveLength(1);
+        expect(MockAudioContext.instances[0]?.state).toBe('running');
+        expect(events).not.toContain('close');
         await controller.dispose();
     });
 
@@ -452,7 +454,7 @@ describe('AuditionController', () => {
         await controller.dispose();
     });
 
-    it('schedules Sample Bank members gaplessly on one temporary output context', async () => {
+    it('schedules Sample Bank members gaplessly on one retained output context', async () => {
         installAudio();
         const transport = transportFor(
             descriptor({
@@ -485,7 +487,7 @@ describe('AuditionController', () => {
         );
         expect(transport.prepareAuditionBundle).toHaveBeenCalledTimes(1);
         expect(transport.prepareAuditionBundle).toHaveBeenCalledWith(1, ['SBNK-1', 'SBNK-2'], expect.any(AbortSignal));
-        expect(MockAudioContext.instances[0]?.state).toBe('closed');
+        expect(MockAudioContext.instances[0]?.state).toBe('running');
         await controller.dispose();
     });
 
@@ -819,7 +821,7 @@ describe('AuditionController', () => {
         await controller.dispose();
     });
 
-    it('stops every scheduled Sample Bank member before closing the sequence context', async () => {
+    it('stops every scheduled Sample Bank member while retaining the output context', async () => {
         installAudio();
         const transport = transportFor(descriptor());
         const completed = vi.fn();
@@ -833,7 +835,7 @@ describe('AuditionController', () => {
         expect(MockAudioBufferSourceNode.instances[1]?.stop).toHaveBeenCalledWith(1.005);
         expect(transport.prepareAuditionBundle).toHaveBeenCalledTimes(1);
         expect(completed).toHaveBeenCalledWith({ status: 'cancelled', playedCount: 0, skippedCount: 2 });
-        expect(MockAudioContext.instances[0]?.state).toBe('closed');
+        expect(MockAudioContext.instances[0]?.state).toBe('running');
         await controller.dispose();
     });
 
@@ -863,7 +865,7 @@ describe('AuditionController', () => {
 
         expect(completed).toHaveBeenCalledWith({ status: 'cancelled', playedCount: 0, skippedCount: 2 });
         expect(MockAudioBufferSourceNode.instances).toHaveLength(0);
-        expect(MockAudioContext.instances[0]?.state).toBe('closed');
+        expect(MockAudioContext.instances[0]?.state).toBe('running');
         await controller.dispose();
     });
 
@@ -940,9 +942,8 @@ describe('AuditionController', () => {
 
         expect(transport.prepareAuditionBundle).toHaveBeenCalledTimes(2);
         expect(transport.readAuditionContent).toHaveBeenCalledTimes(2);
-        expect(MockAudioContext.instances).toHaveLength(2);
-        expect(MockAudioContext.instances[0]?.state).toBe('closed');
-        expect(MockAudioContext.instances[1]?.state).toBe('running');
+        expect(MockAudioContext.instances).toHaveLength(1);
+        expect(MockAudioContext.instances[0]?.state).toBe('running');
         await controller.dispose();
     });
 
diff --git a/apps/axkdeck/src/lib/audio/auditionController.ts b/apps/axkdeck/src/lib/audio/auditionController.ts
index b47a33ff..ec97a9da 100644
--- a/apps/axkdeck/src/lib/audio/auditionController.ts
+++ b/apps/axkdeck/src/lib/audio/auditionController.ts
@@ -56,6 +56,12 @@ interface SequenceCompletion {
     oncomplete: (result: AuditionSequenceResult) => void;
 }
 
+interface OutputContextAccess {
+    context: AudioContext;
+    reused: boolean;
+    creationDurationMs: number;
+}
+
 const startLeadSeconds = 0.01;
 const fadeSeconds = 0.005;
 const minimumForwardLoopSequenceSeconds = 0.5;
@@ -93,7 +99,6 @@ function bufferLevelSummary(buffer: AudioBuffer): { peak: number; rms: number; s
 
 export class AuditionController {
     private readonly assets: AuditionAssetStore;
-    private readonly closingContexts = new Set<Promise<void>>();
     private context?: AudioContext;
     private active?: ActivePlayback;
     private sequence?: ActiveSequence;
@@ -142,12 +147,10 @@ export class AuditionController {
         if (objectIds.length === 0) {
             this.generation += 1;
             this.assets.cancelActiveRequest();
-            const run = this.run;
             this.releaseActive('replaced');
             this.releaseSequence('replaced');
             this.run = undefined;
             this.update({ objectId: null, status: 'idle', playheadFrame: 0 });
-            void this.retireOutputContext('replaced', run);
             this.settleSequence(sequenceGeneration, { status: 'completed', playedCount: 0, skippedCount: 0 });
             return;
         }
@@ -162,10 +165,8 @@ export class AuditionController {
     ): Promise<void> {
         const generation = ++this.generation;
         this.assets.cancelActiveRequest();
-        const previousRun = this.run;
         this.releaseActive('replaced');
         this.releaseSequence('replaced');
-        const previousContextClosed = this.retireOutputContext('replaced', previousRun);
         const firstObjectId = objectIds[0]!;
         const run: PlaybackRun = {
             id: newPlaybackId(),
@@ -180,10 +181,11 @@ export class AuditionController {
 
         let failedObjectId = firstObjectId;
         try {
-            const context = this.ensureContext();
-            const resumed = this.resumeContext(context, run);
-            await Promise.all([previousContextClosed, resumed]);
-            const entries = await this.assets.loadSequence(sessionId, objectIds, context, run);
+            const output = this.ensureContext();
+            const context = output.context;
+            const resumed = this.resumeContext(output, run);
+            const loading = this.assets.loadSequence(sessionId, objectIds, context, run);
+            const [, entries] = await Promise.all([resumed, loading]);
             this.assets.finishRequest();
             if (generation !== this.generation || sequenceGeneration !== this.sequenceGeneration) return;
             const retainedDecodedBytes = entries.reduce((total, entry) => total + entry.weightBytes, 0);
@@ -211,7 +213,7 @@ export class AuditionController {
             this.emit(run, 'sequence_failed', { message, failedObjectId }, 'error');
             this.releaseSequence('failed');
             this.run = undefined;
-            await this.retireOutputContext('failed', run);
+            await this.discardOutputContext('failed', run);
             this.update({
                 objectId: failedObjectId,
                 status: 'failed',
@@ -234,10 +236,8 @@ export class AuditionController {
         const generation = ++this.generation;
         const requestKey = this.assets.key(sessionId, objectId);
         this.assets.cancelActiveRequest(requestKey);
-        const previousRun = this.run;
         this.releaseActive('replaced');
         this.releaseSequence('replaced');
-        const previousContextClosed = this.retireOutputContext('replaced', previousRun);
         const run: PlaybackRun = {
             id: newPlaybackId(),
             objectId,
@@ -251,11 +251,12 @@ export class AuditionController {
         this.update({ objectId, status: 'preparing', playheadFrame: 0 });
 
         try {
-            const context = this.ensureContext();
+            const output = this.ensureContext();
+            const context = output.context;
             // Resume synchronously from the click handler before any network await.
-            const resumed = this.resumeContext(context, run);
+            const resumed = this.resumeContext(output, run);
             const loaded = this.assets.load(sessionId, objectId, context, false, run);
-            let [, , entry] = await Promise.all([previousContextClosed, resumed, loaded]);
+            let [, entry] = await Promise.all([resumed, loaded]);
             if (generation !== this.generation) return;
             // An oversized speculative request may finish just as an explicit play promotes it.
             if (!entry) entry = await this.assets.load(sessionId, objectId, context, false, run);
@@ -285,12 +286,10 @@ export class AuditionController {
         this.cancelSequenceCompletion();
         const run = this.run;
         if (run) this.emit(run, 'playback_stop_requested');
-        const hadActivePlayback = Boolean(this.active || this.sequence);
         this.releaseActive('stopped');
         this.releaseSequence('stopped');
         this.run = undefined;
         this.update({ objectId: null, status: 'idle', playheadFrame: 0 });
-        await this.retireOutputContext('stopped', run, hadActivePlayback ? fadeSeconds : 0);
     }
 
     async invalidateSession(sessionId: number): Promise<void> {
@@ -307,19 +306,29 @@ export class AuditionController {
     async dispose(): Promise<void> {
         await this.stop();
         await this.assets.dispose();
-        await Promise.allSettled([...this.closingContexts]);
+        await this.discardOutputContext('disposed');
     }
 
-    private ensureContext(): AudioContext {
-        if (this.context && this.context.state !== 'closed') return this.context;
+    private ensureContext(): OutputContextAccess {
+        if (this.context && this.context.state !== 'closed') {
+            return { context: this.context, reused: true, creationDurationMs: 0 };
+        }
+        const started = monotonicNow();
         const context = new AudioContext();
         this.context = context;
-        return context;
+        return {
+            context,
+            reused: false,
+            creationDurationMs: Math.round(monotonicNow() - started),
+        };
     }
 
-    private async resumeContext(context: AudioContext, run: PlaybackRun): Promise<void> {
+    private async resumeContext(output: OutputContextAccess, run: PlaybackRun): Promise<void> {
+        const { context, reused, creationDurationMs } = output;
         this.emit(run, 'audio_context_ready', {
             state: context.state,
+            reused,
+            creationDurationMs,
             outputSampleRate: context.sampleRate,
             baseLatencySeconds: context.baseLatency,
             outputLatencySeconds: 'outputLatency' in context ? context.outputLatency : null,
@@ -575,7 +584,7 @@ export class AuditionController {
         if (this.run) this.emit(this.run, 'sequence_released', { reason, memberCount: sequence.segments.length });
     }
 
-    private async handleEnded(active: ActivePlayback, run: PlaybackRun): Promise<void> {
+    private handleEnded(active: ActivePlayback, run: PlaybackRun): void {
         active.source.disconnect();
         active.gain.disconnect();
         if (this.active !== active) return;
@@ -586,7 +595,6 @@ export class AuditionController {
         this.emit(run, 'playback_ended');
         this.run = undefined;
         this.update({ objectId: null, status: 'idle', playheadFrame: 0 });
-        await this.retireOutputContext('ended', run);
     }
 
     private async handleSequenceEnded(sequence: ActiveSequence, run: PlaybackRun): Promise<void> {
@@ -600,7 +608,7 @@ export class AuditionController {
         this.emit(run, 'sequence_ended', { memberCount: sequence.segments.length });
         this.run = undefined;
         this.update({ objectId: null, status: 'idle', playheadFrame: 0 });
-        await this.retireOutputContext('ended', run);
+        await Promise.resolve();
         this.settleSequence(sequence.completionGeneration, {
             status: 'completed',
             playedCount: sequence.segments.length,
@@ -608,33 +616,17 @@ export class AuditionController {
         });
     }
 
-    private retireOutputContext(reason: string, run?: PlaybackRun, delaySeconds = 0): Promise<void> {
+    private async discardOutputContext(reason: string, run?: PlaybackRun): Promise<void> {
         const context = this.context;
-        if (!context) return Promise.resolve();
+        if (!context) return;
         this.context = undefined;
         context.onstatechange = null;
-        const closing = this.closeOutputContext(context, reason, run, delaySeconds)
-            .catch((error) => {
-                reportDiagnostic('audio_context_close_failed', { reason, message: userFacingMessage(error) }, 'warn');
-            })
-            .finally(() => {
-                this.closingContexts.delete(closing);
-            });
-        this.closingContexts.add(closing);
-        return closing;
-    }
-
-    private async closeOutputContext(
-        context: AudioContext,
-        reason: string,
-        run?: PlaybackRun,
-        delaySeconds = 0,
-    ): Promise<void> {
-        if (delaySeconds > 0) {
-            await new Promise<void>((resolve) => window.setTimeout(resolve, delaySeconds * 1000));
+        try {
+            if (context.state !== 'closed') await context.close();
+            if (run) this.emit(run, 'audio_context_closed', { reason });
+        } catch (error) {
+            reportDiagnostic('audio_context_close_failed', { reason, message: userFacingMessage(error) }, 'warn');
         }
-        if (context.state !== 'closed') await context.close();
-        if (run) this.emit(run, 'audio_context_closed', { reason });
     }
 
     private settleSequence(generation: number, result: AuditionSequenceResult): void {
@@ -661,7 +653,7 @@ export class AuditionController {
         const typed = this.typedError(error);
         this.emit(run, 'playback_failed', { message }, 'error');
         this.run = undefined;
-        await this.retireOutputContext('failed', run);
+        await this.discardOutputContext('failed', run);
         this.update({ objectId, status: 'failed', playheadFrame: 0, error: message, ...typed });
     }
 
diff --git a/apps/axkdeck/src/lib/components/AudioImportDialog.svelte b/apps/axkdeck/src/lib/components/AudioImportDialog.svelte
index 3eebf2cf..a7361759 100644
--- a/apps/axkdeck/src/lib/components/AudioImportDialog.svelte
+++ b/apps/axkdeck/src/lib/components/AudioImportDialog.svelte
@@ -3,30 +3,45 @@
     import { defaultAudioImportNames, defaultAudioSamplerSettings, validSamplerName } from '../audioImport';
     import { AudioImportAuditionController, type AudioImportAuditionState } from '../audio/audioImportAudition';
     import { browserUploadSource, type ClientUploadSource } from '../clientUploadSource';
+    import type {
+        ImportDestinationMode,
+        ImportPartitionOption,
+        ImportVolumeOption,
+    } from '../../features/import/packageDestinations';
     import { modal } from '../modal';
     import type { FileLocation, InputFileLocation } from '../storageLocations';
     import type {
         AudioImportCapabilities,
+        AudioImportDestination,
         AudioImportGrouping,
         AudioImportItem,
-        AudioImportTarget,
         AudioSourceInfo,
         ImageTransport,
     } from '../transport';
     import AudioImportRows from './AudioImportRows.svelte';
     import type { AudioImportRow } from './audioImportDialogTypes';
     import Icon from './Icon.svelte';
+    import ImportDestinationChooser from './ImportDestinationChooser.svelte';
     import ImportSourceChoice from './ImportSourceChoice.svelte';
 
     interface Props {
         transport: ImageTransport;
         files: (File | ClientUploadSource | FileLocation)[];
-        target: AudioImportTarget;
+        target: AudioImportDestination | null;
+        destinationMode: ImportDestinationMode;
+        destinationPartitionIndex: number | null;
+        destinationVolumeName: string;
+        partitionOptions: ImportPartitionOption[];
+        volumeOptions: ImportVolumeOption[];
         existingSampleNames: string[];
         existingSampleBankNames?: string[];
         existingWaveformNames: string[];
         onchooseworkspace?: () => void;
         onchooselocal?: () => void;
+        ondestinationmode: (mode: ImportDestinationMode) => void;
+        ondestinationvolume: (partitionIndex: number | null, volumeName: string) => void;
+        ondestinationpartition: (partitionIndex: number) => void;
+        ondestinationname: (volumeName: string) => void;
         oncommit: (items: AudioImportItem[], grouping: AudioImportGrouping) => Promise<void>;
         oncancel: () => void;
     }
@@ -35,11 +50,20 @@
         transport,
         files,
         target,
+        destinationMode,
+        destinationPartitionIndex,
+        destinationVolumeName,
+        partitionOptions,
+        volumeOptions,
         existingSampleNames,
         existingSampleBankNames = [],
         existingWaveformNames,
         onchooseworkspace,
         onchooselocal,
+        ondestinationmode,
+        ondestinationvolume,
+        ondestinationpartition,
+        ondestinationname,
         oncommit,
         oncancel,
     }: Props = $props();
@@ -63,6 +87,7 @@
     const inspectedCount = $derived(rows.filter((row) => row.status === 'inspected' || row.status === 'failed').length);
     const ready = $derived(
         rows.length > 0 &&
+            target !== null &&
             rows.every((row) => row.status === 'ready') &&
             validationErrors.every((error) => error === '') &&
             sampleBankError === '',
@@ -425,20 +450,29 @@
         use:modal={{ onescape: () => void cancel() }}
     >
         <header class="dialog-header">
-            <div>
-                <h2>Import audio</h2>
-                <p>Volume {target.volumeName}</p>
-            </div>
+            <h2>Import audio</h2>
             <button class="icon-button" type="button" aria-label="Close" disabled={busy} onclick={() => void cancel()}>
                 <Icon name="close" size={15} />
             </button>
         </header>
         <div class="audio-import-body">
+            <ImportDestinationChooser
+                mode={destinationMode}
+                partitionIndex={destinationPartitionIndex}
+                volumeName={destinationVolumeName}
+                partitions={partitionOptions}
+                volumes={volumeOptions}
+                disabled={busy}
+                onmode={ondestinationmode}
+                onvolume={ondestinationvolume}
+                onpartition={ondestinationpartition}
+                onname={ondestinationname}
+            />
             {#if files.length === 0}
                 <ImportSourceChoice
                     label="Audio source"
                     heading="Choose audio files"
-                    description={`Import into ${target.volumeName} from a configured storage location or this computer.`}
+                    description="Choose audio files from a configured storage location or this computer."
                     workspaceDetail="Choose one or more files from a configured workspace"
                     computerDetail="Choose local audio files and upload them"
                     computerAvailable={onchooselocal !== undefined}
@@ -512,11 +546,6 @@
         max-width: none;
         max-height: min(720px, calc(100vh - 48px));
     }
-    .dialog-header p {
-        margin: 2px 0 0;
-        color: var(--color-text-muted);
-        font-size: 11px;
-    }
     .audio-import-body {
         min-height: 0;
         overflow: hidden;
diff --git a/apps/axkdeck/src/lib/components/AudioImportDialog.test.ts b/apps/axkdeck/src/lib/components/AudioImportDialog.test.ts
index 0f42586b..e3b8be12 100644
--- a/apps/axkdeck/src/lib/components/AudioImportDialog.test.ts
+++ b/apps/axkdeck/src/lib/components/AudioImportDialog.test.ts
@@ -75,6 +75,29 @@ function transport(): ImageTransport {
     } as unknown as ImageTransport;
 }
 
+function destinationProps(volumeName: string, partitionIndex = 0) {
+    const partitionName = `Partition ${partitionIndex + 1}`;
+    return {
+        target: { kind: 'EXISTING_VOLUME' as const, partitionIndex, volumeName },
+        destinationMode: 'existing' as const,
+        destinationPartitionIndex: partitionIndex,
+        destinationVolumeName: volumeName,
+        partitionOptions: [{ partitionIndex, name: partitionName }],
+        volumeOptions: [
+            {
+                partitionIndex,
+                name: partitionName,
+                volumeName,
+                label: `${partitionName} / ${volumeName}`,
+            },
+        ],
+        ondestinationmode: vi.fn(),
+        ondestinationvolume: vi.fn(),
+        ondestinationpartition: vi.fn(),
+        ondestinationname: vi.fn(),
+    };
+}
+
 describe('AudioImportDialog', () => {
     it('keeps sampler fields aligned while reserving clearance for the scrollbar', () => {
         expect(audioSamplerSettingsSource).toContain('grid-template-columns: repeat(7, minmax(0, 1fr));');
@@ -89,7 +112,7 @@ describe('AudioImportDialog', () => {
             props: {
                 transport: transport(),
                 files: [new File([new Uint8Array(64)], 'Bass.wav', { type: 'audio/wav' })],
-                target: { partitionIndex: 0, volumeName: 'Sounds' },
+                ...destinationProps('Sounds'),
                 existingSampleNames: [],
                 existingSampleBankNames: ['Existing'],
                 existingWaveformNames: [],
@@ -131,7 +154,7 @@ describe('AudioImportDialog', () => {
                     new File([new Uint8Array(64)], 'Second.wav', { type: 'audio/wav' }),
                     new File([new Uint8Array(64)], 'Third.wav', { type: 'audio/wav' }),
                 ],
-                target: { partitionIndex: 0, volumeName: 'Bulk' },
+                ...destinationProps('Bulk'),
                 existingSampleNames: [],
                 existingWaveformNames: [],
                 oncommit: vi.fn(),
@@ -152,7 +175,7 @@ describe('AudioImportDialog', () => {
             props: {
                 transport: transport(),
                 files: [],
-                target: { partitionIndex: 0, volumeName: 'My Volume' },
+                ...destinationProps('My Volume'),
                 existingSampleNames: [],
                 existingWaveformNames: [],
                 onchooseworkspace,
@@ -193,7 +216,7 @@ describe('AudioImportDialog', () => {
             props: {
                 transport: imageTransport,
                 files: [workspaceFile],
-                target: { partitionIndex: 0, volumeName: 'My Volume' },
+                ...destinationProps('My Volume'),
                 existingSampleNames: ['16bit_11k'],
                 existingWaveformNames: ['16bit_11k'],
                 oncommit,
@@ -238,7 +261,7 @@ describe('AudioImportDialog', () => {
             props: {
                 transport: imageTransport,
                 files: [first, second],
-                target: { partitionIndex: 0, volumeName: 'Batch' },
+                ...destinationProps('Batch'),
                 existingSampleNames: [],
                 existingWaveformNames: [],
                 oncommit: vi.fn(),
@@ -313,7 +336,7 @@ describe('AudioImportDialog', () => {
                     new File([new Uint8Array(64)], monoFilename, { type: 'audio/wav' }),
                     new File([new Uint8Array(128)], 'Stereo pad.wav', { type: 'audio/wav' }),
                 ],
-                target: { partitionIndex: 0, volumeName: 'Mixed' },
+                ...destinationProps('Mixed'),
                 existingSampleNames: [],
                 existingWaveformNames: [],
                 oncommit: vi.fn(),
@@ -356,7 +379,7 @@ describe('AudioImportDialog', () => {
             props: {
                 transport: imageTransport,
                 files: [file],
-                target: { partitionIndex: 2, volumeName: 'Keys' },
+                ...destinationProps('Keys', 2),
                 existingSampleNames: [],
                 existingWaveformNames: [],
                 oncommit,
@@ -416,7 +439,7 @@ describe('AudioImportDialog', () => {
         const baseProps = {
             transport: imageTransport,
             files: [file],
-            target: { partitionIndex: 0, volumeName: 'Import' },
+            ...destinationProps('Import'),
             existingSampleNames: [] as string[],
             existingWaveformNames: [] as string[],
             oncommit,
@@ -457,7 +480,7 @@ describe('AudioImportDialog', () => {
         const baseProps = {
             transport: imageTransport,
             files: [file],
-            target: { partitionIndex: 0, volumeName: 'Import' },
+            ...destinationProps('Import'),
             existingSampleNames: [] as string[],
             existingWaveformNames: [] as string[],
             oncommit,
@@ -520,7 +543,7 @@ describe('AudioImportDialog', () => {
             props: {
                 transport: imageTransport,
                 files: [new File([new Uint8Array(128)], 'Mapped.wav', { type: 'audio/wav' })],
-                target: { partitionIndex: 0, volumeName: 'Mapped' },
+                ...destinationProps('Mapped'),
                 existingSampleNames: [],
                 existingWaveformNames: [],
                 oncommit,
@@ -605,7 +628,7 @@ describe('AudioImportDialog', () => {
             props: {
                 transport: imageTransport,
                 files: [file],
-                target: { partitionIndex: 0, volumeName: 'Rates' },
+                ...destinationProps('Rates'),
                 existingSampleNames: [],
                 existingWaveformNames: [],
                 oncommit,
@@ -649,7 +672,7 @@ describe('AudioImportDialog', () => {
             props: {
                 transport: imageTransport,
                 files: [new File([new Uint8Array(64)], 'voice.wav', { type: 'audio/wav' })],
-                target: { partitionIndex: 0, volumeName: 'Voice' },
+                ...destinationProps('Voice'),
                 existingSampleNames: [],
                 existingWaveformNames: [],
                 oncommit: vi.fn(),
@@ -728,7 +751,7 @@ describe('AudioImportDialog', () => {
                     new File([new Uint8Array(64)], 'Too large.wav', { type: 'audio/wav' }),
                     new File([new Uint8Array(64)], 'Valid.wav', { type: 'audio/wav' }),
                 ],
-                target: { partitionIndex: 0, volumeName: 'Mixed' },
+                ...destinationProps('Mixed'),
                 existingSampleNames: [],
                 existingWaveformNames: [],
                 oncommit: vi.fn(),
diff --git a/apps/axkdeck/src/lib/components/PackageImportDestination.svelte b/apps/axkdeck/src/lib/components/ImportDestinationChooser.svelte
similarity index 74%
rename from apps/axkdeck/src/lib/components/PackageImportDestination.svelte
rename to apps/axkdeck/src/lib/components/ImportDestinationChooser.svelte
index 5104f183..ec244c56 100644
--- a/apps/axkdeck/src/lib/components/PackageImportDestination.svelte
+++ b/apps/axkdeck/src/lib/components/ImportDestinationChooser.svelte
@@ -1,18 +1,19 @@
 <script lang="ts">
     import type {
-        PackageImportDestinationMode,
-        PackageImportPartitionOption,
-        PackageImportVolumeOption,
+        ImportDestinationMode,
+        ImportPartitionOption,
+        ImportVolumeOption,
     } from '../../features/import/packageDestinations';
+    import Icon from './Icon.svelte';
 
     interface Props {
-        mode: PackageImportDestinationMode;
+        mode: ImportDestinationMode;
         partitionIndex: number | null;
         volumeName: string;
-        partitions: PackageImportPartitionOption[];
-        volumes: PackageImportVolumeOption[];
+        partitions: ImportPartitionOption[];
+        volumes: ImportVolumeOption[];
         disabled: boolean;
-        onmode: (mode: PackageImportDestinationMode) => void;
+        onmode: (mode: ImportDestinationMode) => void;
         onvolume: (partitionIndex: number | null, volumeName: string) => void;
         onpartition: (partitionIndex: number) => void;
         onname: (name: string) => void;
@@ -36,6 +37,7 @@
     let listOpen = $state(false);
     let filtering = $state(false);
     let synchronizedSelection = $state('');
+    let volumeInput = $state<HTMLInputElement>();
     const normalizedQuery = $derived(query.trim().toLocaleLowerCase());
     const filteredVolumes = $derived(
         filtering ? volumes.filter((option) => option.label.toLocaleLowerCase().includes(normalizedQuery)) : volumes,
@@ -54,15 +56,15 @@
         synchronizedSelection = nextSelection;
     });
 
-    function volumeKey(option: PackageImportVolumeOption): string {
+    function volumeKey(option: ImportVolumeOption): string {
         return `${option.partitionIndex}:${option.volumeName}`;
     }
 
-    function optionId(option: PackageImportVolumeOption): string {
-        return `package-volume-option-${option.partitionIndex}-${volumes.indexOf(option)}`;
+    function optionId(option: ImportVolumeOption): string {
+        return `import-volume-option-${option.partitionIndex}-${volumes.indexOf(option)}`;
     }
 
-    function selectVolume(option: PackageImportVolumeOption): void {
+    function selectVolume(option: ImportVolumeOption): void {
         if (disabled) return;
         query = option.label;
         filtering = false;
@@ -86,6 +88,17 @@
         activeIndex = selectedVolume ? filteredVolumes.indexOf(selectedVolume) : -1;
     }
 
+    function clearVolume(): void {
+        if (disabled) return;
+        query = '';
+        filtering = false;
+        activeIndex = -1;
+        listOpen = volumes.length > 0;
+        synchronizedSelection = selectedVolume ? volumeKey(selectedVolume) : '';
+        onvolume(null, '');
+        queueMicrotask(() => volumeInput?.focus());
+    }
+
     function handleKey(event: KeyboardEvent): void {
         if (event.key === 'ArrowDown' || event.key === 'ArrowUp') {
             event.preventDefault();
@@ -108,10 +121,10 @@
     }
 </script>
 
-<section class="package-import-destination" aria-label="Import destination">
-    <div class="package-destination-heading">
+<section class="import-destination" aria-label="Import destination">
+    <div class="destination-heading">
         <strong>Destination</strong>
-        <div class="package-destination-mode" role="group" aria-label="Destination type">
+        <div class="destination-mode" role="group" aria-label="Destination type">
             <button
                 type="button"
                 class:active={mode === 'existing'}
@@ -130,16 +143,17 @@
     </div>
 
     {#if mode === 'existing'}
-        <label class="target-field" for="package-volume-search">Volume</label>
-        <div class="package-volume-combobox">
+        <label class="target-field" for="import-volume-search">Volume</label>
+        <div class="volume-combobox">
             <input
-                id="package-volume-search"
+                bind:this={volumeInput}
+                id="import-volume-search"
                 class="dialog-field-control"
                 type="text"
                 role="combobox"
                 aria-autocomplete="list"
                 aria-expanded={listOpen}
-                aria-controls="package-volume-options"
+                aria-controls="import-volume-options"
                 aria-activedescendant={listOpen && filteredVolumes[activeIndex]
                     ? optionId(filteredVolumes[activeIndex])
                     : undefined}
@@ -152,10 +166,20 @@
                 onclick={openList}
                 onkeydown={handleKey}
             />
+            {#if query.length > 0 || selectedVolume}
+                <button
+                    class="volume-clear"
+                    type="button"
+                    aria-label="Clear volume"
+                    title="Clear volume"
+                    {disabled}
+                    onclick={clearVolume}><Icon name="close" size={14} /></button
+                >
+            {/if}
             {#if listOpen}
                 <div
-                    id="package-volume-options"
-                    class="package-volume-options dialog-autocomplete-list"
+                    id="import-volume-options"
+                    class="volume-options dialog-autocomplete-list"
                     role="listbox"
                     aria-label="Volumes"
                 >
@@ -179,7 +203,7 @@
             {/if}
         </div>
     {:else}
-        <div class="package-new-volume-fields">
+        <div class="new-volume-fields">
             <label class="target-field">
                 <span>Partition</span>
                 <select
@@ -212,7 +236,7 @@
 </section>
 
 <style>
-    .package-import-destination {
+    .import-destination {
         display: grid;
         gap: 9px;
         margin-bottom: 12px;
@@ -222,19 +246,19 @@
         background: rgb(255 255 255 / 2%);
     }
 
-    .package-destination-heading {
+    .destination-heading {
         display: flex;
         align-items: center;
         justify-content: space-between;
         gap: 12px;
     }
 
-    .package-destination-heading > strong {
+    .destination-heading > strong {
         color: var(--color-text-strong);
         font-size: 11px;
     }
 
-    .package-destination-mode {
+    .destination-mode {
         display: grid;
         grid-template-columns: repeat(2, minmax(0, 1fr));
         overflow: hidden;
@@ -243,7 +267,7 @@
         background: var(--color-bg-deep);
     }
 
-    .package-destination-mode button {
+    .destination-mode button {
         min-height: 27px;
         padding: 0 10px;
         color: var(--color-text-muted);
@@ -254,29 +278,51 @@
         font-size: 10px;
     }
 
-    .package-destination-mode button:last-child {
+    .destination-mode button:last-child {
         border-right: 0;
     }
 
-    .package-destination-mode button.active {
+    .destination-mode button.active {
         color: #fff;
         background: var(--color-accent-strong);
     }
 
-    .package-destination-mode button:disabled {
+    .destination-mode button:disabled {
         cursor: default;
         opacity: 0.45;
     }
 
-    .package-volume-combobox {
+    .volume-combobox {
         position: relative;
     }
 
-    .package-volume-combobox > input {
+    .volume-combobox > input {
         width: 100%;
+        padding-right: 30px;
+    }
+
+    .volume-clear {
+        position: absolute;
+        z-index: 5;
+        top: 1px;
+        right: 1px;
+        display: grid;
+        width: 25px;
+        height: 24px;
+        padding: 0;
+        place-items: center;
+        color: var(--color-text-muted);
+        border: 0;
+        background: var(--color-bg-deep);
+        cursor: pointer;
+        font-size: 15px;
+    }
+
+    .volume-clear:hover:not(:disabled) {
+        color: var(--color-text-strong);
     }
 
-    .package-volume-options {
+    .volume-options {
         position: absolute;
         z-index: 4;
         top: calc(100% + 4px);
@@ -284,12 +330,12 @@
         left: 0;
     }
 
-    .package-volume-options p {
+    .volume-options p {
         margin: 0;
         padding: 9px;
     }
 
-    .package-new-volume-fields {
+    .new-volume-fields {
         display: grid;
         grid-template-columns: minmax(140px, 0.7fr) minmax(180px, 1fr);
         gap: 10px;
@@ -303,18 +349,18 @@
         font-size: var(--dialog-label-font-size);
     }
 
-    .package-new-volume-fields :global(.dialog-field-control) {
+    .new-volume-fields :global(.dialog-field-control) {
         min-width: 0;
         width: 100%;
     }
 
     @media (max-width: 640px) {
-        .package-destination-heading,
-        .package-new-volume-fields {
+        .destination-heading,
+        .new-volume-fields {
             grid-template-columns: 1fr;
         }
 
-        .package-destination-heading {
+        .destination-heading {
             display: grid;
         }
     }
diff --git a/apps/axkdeck/src/lib/components/PackageImportDestination.test.ts b/apps/axkdeck/src/lib/components/ImportDestinationChooser.test.ts
similarity index 83%
rename from apps/axkdeck/src/lib/components/PackageImportDestination.test.ts
rename to apps/axkdeck/src/lib/components/ImportDestinationChooser.test.ts
index b014b1ac..669e0b09 100644
--- a/apps/axkdeck/src/lib/components/PackageImportDestination.test.ts
+++ b/apps/axkdeck/src/lib/components/ImportDestinationChooser.test.ts
@@ -6,7 +6,7 @@ import { resolve } from 'node:path';
 import { fireEvent, render, screen } from '@testing-library/svelte';
 import { describe, expect, it, vi } from 'vitest';
 
-import PackageImportDestination from './PackageImportDestination.svelte';
+import ImportDestinationChooser from './ImportDestinationChooser.svelte';
 
 const appStyles = readFileSync(resolve(process.cwd(), 'src/app.css'), 'utf8');
 
@@ -37,9 +37,9 @@ function props(overrides: Record<string, unknown> = {}) {
     };
 }
 
-describe('PackageImportDestination', () => {
+describe('ImportDestinationChooser', () => {
     it('preselects the exact volume and exposes every partition volume through an autocomplete', async () => {
-        render(PackageImportDestination, { props: props() });
+        render(ImportDestinationChooser, { props: props() });
 
         const combobox = screen.getByRole('combobox', { name: 'Volume' }) as HTMLInputElement;
         expect(combobox.value).toBe('SOUNDS 01 / Strings');
@@ -52,7 +52,7 @@ describe('PackageImportDestination', () => {
 
     it('filters volumes and selects an exact destination with the keyboard', async () => {
         const onvolume = vi.fn();
-        render(PackageImportDestination, { props: props({ partitionIndex: null, volumeName: '', onvolume }) });
+        render(ImportDestinationChooser, { props: props({ partitionIndex: null, volumeName: '', onvolume }) });
 
         const combobox = screen.getByRole('combobox', { name: 'Volume' });
         await fireEvent.input(combobox, { target: { value: 'sounds 02' } });
@@ -64,8 +64,21 @@ describe('PackageImportDestination', () => {
         expect(onvolume).toHaveBeenLastCalledWith(1, 'Pianos');
     });
 
+    it('clears the selected volume, reopens all options, and retains keyboard focus', async () => {
+        const onvolume = vi.fn();
+        render(ImportDestinationChooser, { props: props({ onvolume }) });
+
+        await fireEvent.click(screen.getByRole('button', { name: 'Clear volume' }));
+
+        const combobox = screen.getByRole('combobox', { name: 'Volume' }) as HTMLInputElement;
+        expect(onvolume).toHaveBeenLastCalledWith(null, '');
+        expect(combobox.value).toBe('');
+        expect(document.activeElement).toBe(combobox);
+        expect(screen.getAllByRole('option')).toHaveLength(3);
+    });
+
     it('uses the same dark dialog control treatment for a new volume name', async () => {
-        render(PackageImportDestination, {
+        render(ImportDestinationChooser, {
             props: props({ mode: 'create', partitionIndex: 0, volumeName: '' }),
         });
 
@@ -74,7 +87,7 @@ describe('PackageImportDestination', () => {
     });
 
     it('uses the shared compact dialog typography and dark autocomplete palette', async () => {
-        render(PackageImportDestination, { props: props() });
+        render(ImportDestinationChooser, { props: props() });
 
         const combobox = screen.getByRole('combobox', { name: 'Volume' });
         await fireEvent.focus(combobox);
diff --git a/apps/axkdeck/src/lib/components/PackageImportDialog.svelte b/apps/axkdeck/src/lib/components/PackageImportDialog.svelte
index 01d7cb62..7836da1b 100644
--- a/apps/axkdeck/src/lib/components/PackageImportDialog.svelte
+++ b/apps/axkdeck/src/lib/components/PackageImportDialog.svelte
@@ -2,23 +2,23 @@
     import { formatStoredSize } from '../formatBytes';
     import { modal } from '../modal';
     import {
-        packageImportDestination,
-        type PackageImportDestinationMode,
-        type PackageImportPartitionOption,
-        type PackageImportVolumeOption,
+        importDestination,
+        type ImportDestinationMode,
+        type ImportPartitionOption,
+        type ImportVolumeOption,
     } from '../../features/import/packageDestinations';
     import type { ImageSessionPackageImportPlan, PackageInspection, PackageOpaqueSequenceDecision } from '../transport';
     import Icon from './Icon.svelte';
     import ImportSourceChoice from './ImportSourceChoice.svelte';
-    import PackageImportDestination from './PackageImportDestination.svelte';
+    import ImportDestinationChooser from './ImportDestinationChooser.svelte';
 
     interface Props {
         targetName: string;
-        destinationMode: PackageImportDestinationMode;
+        destinationMode: ImportDestinationMode;
         destinationPartitionIndex: number | null;
         destinationVolumeName: string;
-        partitionOptions: PackageImportPartitionOption[];
-        volumeOptions: PackageImportVolumeOption[];
+        partitionOptions: ImportPartitionOption[];
+        volumeOptions: ImportVolumeOption[];
         desktop: boolean;
         canChangeSource: boolean;
         sourceName: string;
@@ -34,7 +34,7 @@
         onchooseworkspace: () => void;
         onchooselocal: () => void;
         onchange: () => void;
-        ondestinationmode: (mode: PackageImportDestinationMode) => void;
+        ondestinationmode: (mode: ImportDestinationMode) => void;
         ondestinationvolume: (partitionIndex: number | null, volumeName: string) => void;
         ondestinationpartition: (partitionIndex: number) => void;
         ondestinationname: (name: string) => void;
@@ -177,7 +177,7 @@
         hasUnvalidatedChanges || renameActions.length > 0 || editableProgramPlacements.length > 0,
     );
     const destinationReady = $derived(
-        packageImportDestination(destinationMode, destinationPartitionIndex, destinationVolumeName) !== null,
+        importDestination(destinationMode, destinationPartitionIndex, destinationVolumeName) !== null,
     );
     const canCheckConflicts = $derived(
         status === 'ready' &&
@@ -307,7 +307,7 @@
                     {/if}
                 </section>
 
-                <PackageImportDestination
+                <ImportDestinationChooser
                     mode={destinationMode}
                     partitionIndex={destinationPartitionIndex}
                     volumeName={destinationVolumeName}
diff --git a/apps/axkdeck/src/lib/httpImageSessions.ts b/apps/axkdeck/src/lib/httpImageSessions.ts
index 319e87fa..34bcd6d0 100644
--- a/apps/axkdeck/src/lib/httpImageSessions.ts
+++ b/apps/axkdeck/src/lib/httpImageSessions.ts
@@ -443,6 +443,7 @@ export class HttpImageSessions {
             mediaConversionAvailable: (summary.availableOperations ?? []).includes('images.media_conversion'),
             extentLayoutRepairAvailable: (summary.availableOperations ?? []).includes('images.extent_layout.repair'),
             allocationInspectionAvailable: summary.format === 'sfs',
+            format: summary.format,
             tree: [disk],
         };
     }
diff --git a/apps/axkdeck/src/lib/httpImportOperations.test.ts b/apps/axkdeck/src/lib/httpImportOperations.test.ts
index 3187c523..efb0f1cb 100644
--- a/apps/axkdeck/src/lib/httpImportOperations.test.ts
+++ b/apps/axkdeck/src/lib/httpImportOperations.test.ts
@@ -2,11 +2,60 @@ import { describe, expect, it } from 'vitest';
 
 import { clientUploadLocation, serverFileLocation } from './storageLocations';
 import {
+    audioImportRequest,
     sampleBankAssignmentRequest,
     sampleBankCreationRequest,
     tx16wDiskSetImportRequest,
 } from './httpImportOperations';
 
+describe('audioImportRequest', () => {
+    it('creates a new volume and imports its audio in one alteration manifest', () => {
+        const source = serverFileLocation({ rootId: 'workspace', relativePath: 'audio/Tone.wav' });
+
+        const result = audioImportRequest(
+            'image-1',
+            8,
+            { kind: 'CREATE_VOLUME', partitionIndex: 1, volumeName: 'Imported' },
+            [
+                {
+                    source,
+                    sampleName: 'Tone',
+                    waveformNames: ['Tone Wave'],
+                    rootKey: 60,
+                    fineTuneCents: 0,
+                    keyLow: 0,
+                    keyHigh: 127,
+                    velocityLow: 0,
+                    velocityHigh: 127,
+                    loopMode: 4,
+                    loopStartFrame: 0,
+                    loopLengthFrames: 0,
+                    targetSampleRate: 44_100,
+                },
+            ],
+            { kind: 'SAMPLES' },
+        );
+
+        expect(result.manifest.inline.operations.map((operation) => operation.type)).toEqual([
+            'insert_volume',
+            'insert_waveform',
+            'insert_sbnk',
+        ]);
+        expect(result.manifest.inline.operations[0]).toEqual({
+            id: 'volume-audio-import',
+            type: 'insert_volume',
+            partition_index: 1,
+            volume: { name: 'Imported', waveforms: [], samples: [] },
+        });
+        expect(result.inputBindings).toEqual([
+            {
+                manifestPath: 'audio/import-0',
+                input: { fileRef: { rootId: 'workspace', relativePath: 'audio/Tone.wav' } },
+            },
+        ]);
+    });
+});
+
 describe('sampleBankCreationRequest', () => {
     it('creates one ordered Sample Bank insertion without input bindings', () => {
         expect(
diff --git a/apps/axkdeck/src/lib/httpImportOperations.ts b/apps/axkdeck/src/lib/httpImportOperations.ts
index 4d095cc8..f23dffc4 100644
--- a/apps/axkdeck/src/lib/httpImportOperations.ts
+++ b/apps/axkdeck/src/lib/httpImportOperations.ts
@@ -1,6 +1,7 @@
 import type {
     AudioImportItem,
     AudioImportGrouping,
+    AudioImportDestination,
     AudioImportTarget,
     SampleBankCreation,
     SampleBankAssignment,
@@ -83,7 +84,7 @@ export class HttpImportOperations {
 
     startAudioImport(
         sessionId: number,
-        target: AudioImportTarget,
+        target: AudioImportDestination,
         items: AudioImportItem[],
         grouping: AudioImportGrouping,
     ): Promise<JobState> {
@@ -179,12 +180,20 @@ function request(
 export function audioImportRequest(
     imageId: string,
     expectedRevision: number,
-    target: AudioImportTarget,
+    target: AudioImportDestination,
     items: AudioImportItem[],
     grouping: AudioImportGrouping,
 ): ImportAlterationRequest {
     const operations: Record<string, unknown>[] = [];
     const inputBindings: ImportAlterationRequest['inputBindings'] = [];
+    if (target.kind === 'CREATE_VOLUME') {
+        operations.push({
+            id: 'volume-audio-import',
+            type: 'insert_volume',
+            partition_index: target.partitionIndex,
+            volume: { name: target.volumeName, waveforms: [], samples: [] },
+        });
+    }
     items.forEach((item, index) => {
         const logicalPath = `audio/import-${index}`;
         operations.push({
diff --git a/apps/axkdeck/src/lib/httpTransport.test.ts b/apps/axkdeck/src/lib/httpTransport.test.ts
index ddfbd1fe..7273e240 100644
--- a/apps/axkdeck/src/lib/httpTransport.test.ts
+++ b/apps/axkdeck/src/lib/httpTransport.test.ts
@@ -1772,7 +1772,7 @@ describe('HttpImageTransport', () => {
         const opened = await transport.openImage(serverFile('images/base.hds'));
         const job = await transport.startAudioImport(
             opened.sessionId,
-            { partitionIndex: 3, volumeName: 'Imported' },
+            { kind: 'EXISTING_VOLUME', partitionIndex: 3, volumeName: 'Imported' },
             [
                 {
                     source: mono,
diff --git a/apps/axkdeck/src/lib/httpTransport.ts b/apps/axkdeck/src/lib/httpTransport.ts
index 178257b2..ad698e56 100644
--- a/apps/axkdeck/src/lib/httpTransport.ts
+++ b/apps/axkdeck/src/lib/httpTransport.ts
@@ -9,6 +9,7 @@ import type {
     AudioImportGrouping,
     AudioImportItem,
     AudioImportCapabilities,
+    AudioImportDestination,
     AudioImportTarget,
     SampleBankCreation,
     SampleBankAssignment,
@@ -170,7 +171,7 @@ export class HttpImageTransport extends HttpImageSessionReads implements ImageTr
     }
     startAudioImport(
         sessionId: number,
-        target: AudioImportTarget,
+        target: AudioImportDestination,
         items: AudioImportItem[],
         grouping: AudioImportGrouping,
     ): Promise<JobState> {
diff --git a/apps/axkdeck/src/lib/testing/inMemoryTransport.ts b/apps/axkdeck/src/lib/testing/inMemoryTransport.ts
index 68174daf..83676cef 100644
--- a/apps/axkdeck/src/lib/testing/inMemoryTransport.ts
+++ b/apps/axkdeck/src/lib/testing/inMemoryTransport.ts
@@ -2,6 +2,7 @@ import type {
     AudioImportGrouping,
     AllocationMapReference,
     AudioImportItem,
+    AudioImportDestination,
     AudioImportTarget,
     AudioSourceInfo,
     AudioImportCapabilities,
@@ -381,7 +382,7 @@ export class InMemoryImageTransport implements ImageTransport {
 
     startAudioImport(
         sessionId: number,
-        target: AudioImportTarget,
+        target: AudioImportDestination,
         items: AudioImportItem[],
         grouping: AudioImportGrouping,
     ): Promise<JobState> {
diff --git a/apps/axkdeck/src/lib/transport.ts b/apps/axkdeck/src/lib/transport.ts
index d575247d..b7c73898 100644
--- a/apps/axkdeck/src/lib/transport.ts
+++ b/apps/axkdeck/src/lib/transport.ts
@@ -48,8 +48,13 @@ export interface OpenedImage {
     mediaConversionAvailable: boolean;
     extentLayoutRepairAvailable: boolean;
     allocationInspectionAvailable: boolean;
+    format?: string;
 }
 
+export type AudioImportDestination =
+    | { kind: 'EXISTING_VOLUME'; partitionIndex: number; volumeName: string }
+    | { kind: 'CREATE_VOLUME'; partitionIndex: number; volumeName: string };
+
 export interface AllocationMapReference {
     imageId: string;
     revision: number;
@@ -538,7 +543,7 @@ export interface ImageTransport {
     ): Promise<Tx16wImportInspection>;
     startAudioImport(
         sessionId: number,
-        target: AudioImportTarget,
+        target: AudioImportDestination,
         items: AudioImportItem[],
         grouping: AudioImportGrouping,
     ): Promise<JobState>;

From 1863efbea874d653d06d78207c2e8b87a6f4c90c Mon Sep 17 00:00:00 2001
From: bzeiss <ben@zeiss.net>
Date: Thu, 20 Aug 2026 16:45:58 +0200
Subject: [PATCH 07/12] session keepalive

---
 .../features/image-session/actions.test.ts    | 29 +++++-
 .../src/features/image-session/actions.ts     |  9 +-
 .../features/image-session/workflow.svelte.ts | 39 ++++++++
 .../features/image-session/workflow.test.ts   | 94 +++++++++++++++++++
 apps/axkdeck/src/lib/createTransport.ts       |  3 +
 apps/axkdeck/src/lib/httpImageSessionReads.ts |  4 +
 apps/axkdeck/src/lib/httpImageSessions.ts     |  9 ++
 apps/axkdeck/src/lib/httpTransport.test.ts    | 21 ++++-
 .../src/lib/testing/inMemoryTransport.ts      |  5 +
 apps/axkdeck/src/lib/transport.ts             |  1 +
 10 files changed, 210 insertions(+), 4 deletions(-)
 create mode 100644 apps/axkdeck/src/features/image-session/workflow.test.ts

diff --git a/apps/axkdeck/src/features/image-session/actions.test.ts b/apps/axkdeck/src/features/image-session/actions.test.ts
index 96f9a8f6..4243ffba 100644
--- a/apps/axkdeck/src/features/image-session/actions.test.ts
+++ b/apps/axkdeck/src/features/image-session/actions.test.ts
@@ -51,6 +51,26 @@ function opened(sessionId: number): OpenedImage {
 }
 
 describe('ImageSessionController', () => {
+    it('keeps only the active session alive', async () => {
+        const keepImageAlive = vi.fn(async () => undefined);
+        const controller = new ImageSessionController(
+            {
+                openImage: vi.fn(async () => opened(7)),
+                keepImageAlive,
+                refreshImage: vi.fn(),
+                closeImage: vi.fn(),
+            },
+            async () => undefined,
+            () => undefined,
+        );
+
+        await expect(controller.keepAlive()).resolves.toBe(false);
+        await controller.open(firstLocation);
+        await expect(controller.keepAlive()).resolves.toBe(true);
+        expect(keepImageAlive).toHaveBeenCalledOnce();
+        expect(keepImageAlive).toHaveBeenCalledWith(7);
+    });
+
     it('closes a stale late open without replacing the current session', async () => {
         let resolveFirst: ((value: OpenedImage) => void) | undefined;
         const openImage = vi
@@ -64,7 +84,7 @@ describe('ImageSessionController', () => {
             .mockResolvedValueOnce(opened(2));
         const closeImage = vi.fn(async () => undefined);
         const controller = new ImageSessionController(
-            { openImage, refreshImage: vi.fn(), closeImage },
+            { openImage, keepImageAlive: vi.fn(), refreshImage: vi.fn(), closeImage },
             async () => undefined,
             () => undefined,
         );
@@ -81,7 +101,12 @@ describe('ImageSessionController', () => {
         const closeImage = vi.fn(async () => undefined);
         const invalidate = vi.fn(async () => undefined);
         const controller = new ImageSessionController(
-            { openImage: vi.fn(async () => opened(9)), refreshImage: vi.fn(), closeImage },
+            {
+                openImage: vi.fn(async () => opened(9)),
+                keepImageAlive: vi.fn(),
+                refreshImage: vi.fn(),
+                closeImage,
+            },
             invalidate,
             () => undefined,
         );
diff --git a/apps/axkdeck/src/features/image-session/actions.ts b/apps/axkdeck/src/features/image-session/actions.ts
index 82a83ecf..f35f62cc 100644
--- a/apps/axkdeck/src/features/image-session/actions.ts
+++ b/apps/axkdeck/src/features/image-session/actions.ts
@@ -1,7 +1,7 @@
 import type { ImageLocation } from '../../lib/storageLocations';
 import type { ImageTransport, OpenedImage } from '../../lib/transport';
 
-type SessionTransport = Pick<ImageTransport, 'openImage' | 'refreshImage' | 'closeImage'>;
+type SessionTransport = Pick<ImageTransport, 'openImage' | 'keepImageAlive' | 'refreshImage' | 'closeImage'>;
 
 export interface ImageSessionSnapshot {
     sessionId: number | null;
@@ -64,6 +64,13 @@ export class ImageSessionController {
         return this.snapshotValue.sessionId === sessionId && !this.disposed ? opened : null;
     }
 
+    async keepAlive(): Promise<boolean> {
+        const sessionId = this.snapshotValue.sessionId;
+        if (sessionId === null || this.disposed) return false;
+        await this.transport.keepImageAlive(sessionId);
+        return this.snapshotValue.sessionId === sessionId && !this.disposed;
+    }
+
     async close(): Promise<void> {
         ++this.generation;
         const sessionId = this.snapshotValue.sessionId;
diff --git a/apps/axkdeck/src/features/image-session/workflow.svelte.ts b/apps/axkdeck/src/features/image-session/workflow.svelte.ts
index 26f571fe..84316938 100644
--- a/apps/axkdeck/src/features/image-session/workflow.svelte.ts
+++ b/apps/axkdeck/src/features/image-session/workflow.svelte.ts
@@ -8,6 +8,7 @@ import type {
     OpenedImage,
 } from '../../lib/transport';
 import type { DiskTreeItem } from '../../lib/types';
+import { AxklibApiError } from '../../lib/httpErrors';
 import { userFacingMessage } from '../../lib/userFacingMessage';
 import type { AuditionWorkflow } from '../audition/workflow.svelte';
 import type { CatalogWorkflow } from '../catalog/workflow.svelte';
@@ -35,6 +36,7 @@ const allocationBlockerCodes = new Set([
     'SFS_ALLOCATION_MISMATCH',
     'SFS_EXTENT_BYTE_TOTAL_MISMATCH',
 ]);
+const imageSessionKeepAliveIntervalMs = 5 * 60 * 1000;
 
 interface SessionCollaborators {
     catalog: CatalogWorkflow;
@@ -101,6 +103,11 @@ export class ImageSessionWorkflow {
     private lastOpenedImageFile = $state<FileRef | null>(null);
     private lastCompanionDirectory = $state<DirectoryRef | null>(null);
     private lastAutomaticIntegrityKey = '';
+    private leaseMaintenanceActive = false;
+    private leaseTimer: number | null = null;
+    private readonly renewVisibleLease = (): void => {
+        if (typeof document === 'undefined' || document.visibilityState === 'visible') void this.maintainLease();
+    };
 
     constructor(
         private readonly transport: ImageTransport,
@@ -120,6 +127,7 @@ export class ImageSessionWorkflow {
     connect(collaborators: SessionCollaborators): void {
         if (this.collaborators) throw new Error('Image session workflow is already connected');
         this.collaborators = collaborators;
+        this.startLeaseMaintenance();
     }
 
     setStatus(status: string): void {
@@ -178,6 +186,21 @@ export class ImageSessionWorkflow {
         if (opened) await this.applyOpenedImage(opened, preferred);
     }
 
+    async maintainLease(): Promise<void> {
+        if (this.leaseMaintenanceActive || this.sessionId === null || this.opening) return;
+        const sessionId = this.sessionId;
+        this.leaseMaintenanceActive = true;
+        try {
+            await this.controller.keepAlive();
+        } catch (error) {
+            if (error instanceof AxklibApiError && error.code === 'image_not_found' && this.sessionId === sessionId) {
+                await this.reopen(this.currentSourcePreference());
+            }
+        } finally {
+            this.leaseMaintenanceActive = false;
+        }
+    }
+
     async chooseAndOpen(): Promise<void> {
         const selected = await this.chooseImageLocation();
         if (selected) await this.open(selected);
@@ -294,9 +317,25 @@ export class ImageSessionWorkflow {
     }
 
     async dispose(): Promise<void> {
+        this.stopLeaseMaintenance();
         await this.controller.dispose();
     }
 
+    private startLeaseMaintenance(): void {
+        if (typeof window === 'undefined' || this.leaseTimer !== null) return;
+        this.leaseTimer = window.setInterval(() => void this.maintainLease(), imageSessionKeepAliveIntervalMs);
+        window.addEventListener('focus', this.renewVisibleLease);
+        document.addEventListener('visibilitychange', this.renewVisibleLease);
+    }
+
+    private stopLeaseMaintenance(): void {
+        if (typeof window === 'undefined' || this.leaseTimer === null) return;
+        window.clearInterval(this.leaseTimer);
+        this.leaseTimer = null;
+        window.removeEventListener('focus', this.renewVisibleLease);
+        document.removeEventListener('visibilitychange', this.renewVisibleLease);
+    }
+
     private requireCollaborators(): SessionCollaborators {
         if (!this.collaborators) throw new Error('Image session workflow is not connected');
         return this.collaborators;
diff --git a/apps/axkdeck/src/features/image-session/workflow.test.ts b/apps/axkdeck/src/features/image-session/workflow.test.ts
new file mode 100644
index 00000000..5b52f98c
--- /dev/null
+++ b/apps/axkdeck/src/features/image-session/workflow.test.ts
@@ -0,0 +1,94 @@
+import { describe, expect, it, vi } from 'vitest';
+import { AxklibApiError } from '../../lib/httpErrors';
+import type { ImageLocation } from '../../lib/storageLocations';
+import type { ImageTransport, OpenedImage } from '../../lib/transport';
+import type { PickerController } from '../dialogs/picker';
+import { ImageSessionWorkflow } from './workflow.svelte';
+
+const location: ImageLocation = {
+    kind: 'server-file',
+    reference: { rootId: 'root', relativePath: 'test-disk.hds' },
+    displayName: 'test-disk.hds',
+};
+
+function opened(sessionId: number): OpenedImage {
+    const volume = {
+        id: `volume-${sessionId}`,
+        name: 'newvolume',
+        kind: 'volume' as const,
+        childCount: 0,
+        partitionIndex: 0,
+    };
+    return {
+        sessionId,
+        allocationInspectionAvailable: true,
+        revision: 1,
+        companionSources: [],
+        floppySet: null,
+        tree: [
+            {
+                id: `disk-${sessionId}`,
+                name: 'test-disk.hds',
+                kind: 'disk',
+                childCount: 1,
+                children: [volume],
+            },
+        ],
+        validation: {
+            valid: true,
+            issueCount: 0,
+            errorCount: 0,
+            warningCount: 0,
+            objectCount: 49,
+            relationshipCount: 48,
+        },
+        objects: [],
+        objectTotalCount: 0,
+        initialVolume: volume,
+        volumeMutationsAvailable: true,
+        partitionMutationsAvailable: true,
+        objectRenameAvailable: true,
+        objectDeletionAvailable: true,
+        waveDataCleanupAvailable: true,
+        programGenerationAvailable: true,
+        packageImportAvailable: true,
+        packageExportAvailable: true,
+        volumePackageExportAvailable: true,
+        volumeFloppyExportAvailable: true,
+        audioExportAvailable: true,
+        sequenceExportAvailable: true,
+        mediaConversionAvailable: true,
+        extentLayoutRepairAvailable: true,
+        format: 'sfs',
+    };
+}
+
+describe('ImageSessionWorkflow lease maintenance', () => {
+    it('reopens an expired image session at the selected volume', async () => {
+        const openImage = vi.fn().mockResolvedValueOnce(opened(1)).mockResolvedValueOnce(opened(2));
+        const loadVolume = vi.fn(async () => undefined);
+        const transport = {
+            openImage,
+            keepImageAlive: vi.fn(async () => {
+                throw new AxklibApiError('image_not_found', 'Image session does not exist', 404);
+            }),
+            closeImage: vi.fn(async () => undefined),
+        } as unknown as ImageTransport;
+        const workflow = new ImageSessionWorkflow(transport, {} as PickerController);
+        workflow.connect({
+            catalog: { loadVolume, clear: vi.fn() },
+            audition: { invalidateSession: vi.fn(async () => undefined) },
+            mutation: { setCapabilities: vi.fn() },
+            clearExportSelection: vi.fn(),
+        } as never);
+
+        await workflow.open(location, { partitionIndex: 0, volumeName: 'newvolume' });
+        await workflow.maintainLease();
+
+        expect(openImage).toHaveBeenCalledTimes(2);
+        expect(workflow.sessionId).toBe(2);
+        expect(workflow.selectedSource).toMatchObject({ name: 'newvolume', partitionIndex: 0 });
+        expect(loadVolume).toHaveBeenLastCalledWith('volume-2', 0);
+        await workflow.dispose();
+    });
+});
diff --git a/apps/axkdeck/src/lib/createTransport.ts b/apps/axkdeck/src/lib/createTransport.ts
index 8c6e99ad..dec17159 100644
--- a/apps/axkdeck/src/lib/createTransport.ts
+++ b/apps/axkdeck/src/lib/createTransport.ts
@@ -176,6 +176,9 @@ class UnavailableTransport implements ImageTransport {
     openImage(): Promise<OpenedImage> {
         return this.unavailable();
     }
+    keepImageAlive(): Promise<void> {
+        return this.unavailable();
+    }
     refreshImage(): Promise<OpenedImage> {
         return this.unavailable();
     }
diff --git a/apps/axkdeck/src/lib/httpImageSessionReads.ts b/apps/axkdeck/src/lib/httpImageSessionReads.ts
index 772f9bba..6f051f4b 100644
--- a/apps/axkdeck/src/lib/httpImageSessionReads.ts
+++ b/apps/axkdeck/src/lib/httpImageSessionReads.ts
@@ -20,6 +20,10 @@ export class HttpImageSessionReads {
         return this.imageSessions.open(location);
     }
 
+    keepImageAlive(sessionId: number): Promise<void> {
+        return this.imageSessions.keepAlive(sessionId);
+    }
+
     refreshImage(sessionId: number): Promise<OpenedImage> {
         return this.imageSessions.refresh(sessionId);
     }
diff --git a/apps/axkdeck/src/lib/httpImageSessions.ts b/apps/axkdeck/src/lib/httpImageSessions.ts
index 34bcd6d0..004b95f2 100644
--- a/apps/axkdeck/src/lib/httpImageSessions.ts
+++ b/apps/axkdeck/src/lib/httpImageSessions.ts
@@ -88,6 +88,15 @@ export class HttpImageSessions {
         return this.openedImage(sessionId, summary);
     }
 
+    async keepAlive(sessionId: number): Promise<void> {
+        const session = this.get(sessionId);
+        const summary = await this.client.request<ApiImageSummary>(
+            'GET',
+            `/images/${encodeURIComponent(session.remoteId)}`,
+        );
+        if (summary.revision > session.revision) this.replaceRevision(session, summary.revision);
+    }
+
     async attachCompanions(sessionId: number, selection: CompanionSelection): Promise<OpenedImage> {
         const session = this.get(sessionId);
         const wireSelection: components['schemas']['CompanionSelection'] =
diff --git a/apps/axkdeck/src/lib/httpTransport.test.ts b/apps/axkdeck/src/lib/httpTransport.test.ts
index 7273e240..40c39a14 100644
--- a/apps/axkdeck/src/lib/httpTransport.test.ts
+++ b/apps/axkdeck/src/lib/httpTransport.test.ts
@@ -225,6 +225,23 @@ describe('HttpImageTransport', () => {
                     expect(url.searchParams.get('cursor')).toBe('objects-next');
                     return json({ items: [], totalCount: 2, nextCursor: null });
                 }
+                if (url.pathname.endsWith('/images/image-remote') && init?.method !== 'DELETE') {
+                    return json({
+                        imageId: 'image-remote',
+                        revision: 1,
+                        source: {
+                            kind: 'FILE',
+                            file: { rootId: 'workspace', relativePath: 'images/test.hds' },
+                        },
+                        companionSources: [],
+                        floppySet: null,
+                        format: 'sfs',
+                        rootCount: 1,
+                        objectCount: 2,
+                        relationshipCount: 1,
+                        validation: { valid: true, infoCount: 0, warningCount: 0, errorCount: 0 },
+                    });
+                }
                 if (url.pathname.endsWith('/images/image-remote') && init?.method === 'DELETE') {
                     return json({ closed: true });
                 }
@@ -269,8 +286,10 @@ describe('HttpImageTransport', () => {
             items: [{ id: 'volume-1', partitionIndex: 0 }],
             totalCount: 1,
         });
+        await transport.keepImageAlive(1);
         await transport.closeImage(1);
-        expect(requests).toHaveLength(6);
+        expect(requests).toHaveLength(7);
+        expect(requests.filter((request) => request.includes('/content'))).toHaveLength(3);
     });
 
     it('opens an AXK object directory through the explicit directory source contract', async () => {
diff --git a/apps/axkdeck/src/lib/testing/inMemoryTransport.ts b/apps/axkdeck/src/lib/testing/inMemoryTransport.ts
index 83676cef..3af127bb 100644
--- a/apps/axkdeck/src/lib/testing/inMemoryTransport.ts
+++ b/apps/axkdeck/src/lib/testing/inMemoryTransport.ts
@@ -218,6 +218,11 @@ export class InMemoryImageTransport implements ImageTransport {
         };
     }
 
+    async keepImageAlive(sessionId: number): Promise<void> {
+        this.calls.push('keepImageAlive');
+        await this.options.operations?.keepImageAlive?.(sessionId);
+    }
+
     attachCompanions(sessionId: number, selection: CompanionSelection): Promise<OpenedImage> {
         return this.invoke('attachCompanions', [sessionId, selection]);
     }
diff --git a/apps/axkdeck/src/lib/transport.ts b/apps/axkdeck/src/lib/transport.ts
index b7c73898..9f743cd9 100644
--- a/apps/axkdeck/src/lib/transport.ts
+++ b/apps/axkdeck/src/lib/transport.ts
@@ -472,6 +472,7 @@ export interface ImageTransport {
     renameSandboxEntry(entry: FileRef, name: string): Promise<void>;
     deleteSandboxEntry(entry: FileRef): Promise<void>;
     openImage(source: ImageLocation): Promise<OpenedImage>;
+    keepImageAlive(sessionId: number): Promise<void>;
     refreshImage(sessionId: number): Promise<OpenedImage>;
     attachCompanions(sessionId: number, selection: CompanionSelection): Promise<OpenedImage>;
     contentChildren(sessionId: number, parentId: string, offset: number, limit: number): Promise<ContentPage>;

From 0ce42a1588f1e071ddf2992ba49304c2b2e1929f Mon Sep 17 00:00:00 2001
From: bzeiss <ben@zeiss.net>
Date: Thu, 20 Aug 2026 16:59:47 +0200
Subject: [PATCH 08/12] updates

---
 apps/axkdeck/src-tauri/windows/webview2-consent.nsh | 4 +++-
 tools/python/tests/test_release_tools.py            | 6 +++++-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/apps/axkdeck/src-tauri/windows/webview2-consent.nsh b/apps/axkdeck/src-tauri/windows/webview2-consent.nsh
index 1809cf21..e93789e2 100644
--- a/apps/axkdeck/src-tauri/windows/webview2-consent.nsh
+++ b/apps/axkdeck/src-tauri/windows/webview2-consent.nsh
@@ -1,9 +1,11 @@
 !define AXKDECK_WEBVIEW2_APP_GUID "{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}"
 !define AXKDECK_MINIMUM_WEBVIEW2_VERSION "111.0.0.0"
+!define MUI_CUSTOMFUNCTION_GUIINIT axkdeck_webview2_consent
 
 ; Tauri's WebView2 section runs before NSIS_HOOK_PREINSTALL. Use the GUI
 ; callback so an interactive user can decline before any runtime is changed.
-Function .onGUIInit
+; Modern UI owns .onGUIInit and calls this registered callback from it.
+Function axkdeck_webview2_consent
   IfSilent axkdeck_webview2_consent_done 0
 
   StrCpy $0 ""
diff --git a/tools/python/tests/test_release_tools.py b/tools/python/tests/test_release_tools.py
index 1bb78b9a..525982af 100644
--- a/tools/python/tests/test_release_tools.py
+++ b/tools/python/tests/test_release_tools.py
@@ -880,7 +880,11 @@ def test_windows_desktop_bundle_uses_branded_gui_startup() -> None:
     installer_hook = (desktop / "src-tauri" / nsis["installerHooks"]).read_text(
         encoding="utf-8"
     )
-    assert "Function .onGUIInit" in installer_hook
+    assert (
+        "!define MUI_CUSTOMFUNCTION_GUIINIT axkdeck_webview2_consent" in installer_hook
+    )
+    assert "Function axkdeck_webview2_consent" in installer_hook
+    assert "Function .onGUIInit" not in installer_hook
     assert "IfSilent" in installer_hook
     assert minimum_webview2_version in installer_hook
     assert "{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}" in installer_hook

From 172a0725cfe4d5673a2df853d726676cefb37cd7 Mon Sep 17 00:00:00 2001
From: bzeiss <ben@zeiss.net>
Date: Thu, 20 Aug 2026 18:51:31 +0200
Subject: [PATCH 09/12] about box on non-menu operating systems.

---
 apps/axkdeck/src/App.test.ts                  |  36 +++++-
 apps/axkdeck/src/app.css                      |  12 ++
 .../workspace/WorkspaceShell.layout.test.ts   |   3 +
 .../features/workspace/WorkspaceShell.svelte  |  32 ++++-
 .../src/lib/components/AboutDialog.svelte     | 119 ++++++++++++++++++
 .../src/lib/components/AboutDialog.test.ts    |  57 +++++++++
 apps/axkdeck/src/lib/desktopBuildInfo.ts      |  17 +++
 7 files changed, 273 insertions(+), 3 deletions(-)
 create mode 100644 apps/axkdeck/src/lib/components/AboutDialog.svelte
 create mode 100644 apps/axkdeck/src/lib/components/AboutDialog.test.ts
 create mode 100644 apps/axkdeck/src/lib/desktopBuildInfo.ts

diff --git a/apps/axkdeck/src/App.test.ts b/apps/axkdeck/src/App.test.ts
index f4cd9e25..cd9b8e3d 100644
--- a/apps/axkdeck/src/App.test.ts
+++ b/apps/axkdeck/src/App.test.ts
@@ -1,4 +1,4 @@
-import { fireEvent, render, screen, within } from '@testing-library/svelte';
+import { fireEvent, render, screen, waitFor, within } from '@testing-library/svelte';
 import { flushSync } from 'svelte';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
@@ -30,6 +30,7 @@ const mocks = vi.hoisted(() => ({
     audioImportCapabilities: vi.fn(),
     inspectAudio: vi.fn(),
     uploadClientFile: vi.fn(),
+    desktopBuildInfo: vi.fn(),
 }));
 
 vi.mock('./lib/createTransport', () => ({
@@ -69,6 +70,10 @@ vi.mock('./lib/nativeMediaDrop', () => ({
     listenForNativeMediaDrops: mocks.listenForNativeMediaDrops,
 }));
 
+vi.mock('./lib/desktopBuildInfo', () => ({
+    desktopBuildInfo: mocks.desktopBuildInfo,
+}));
+
 import App from './App.svelte';
 import { AuditionController } from './lib/audio/auditionController';
 
@@ -197,6 +202,14 @@ describe('App panel layout', () => {
             issues: [],
         });
         mocks.uploadClientFile.mockReset();
+        mocks.desktopBuildInfo.mockReset().mockResolvedValue({
+            schemaVersion: 1,
+            semanticVersion: '0.4.0',
+            projectVersion: '0.4.0',
+            sourceIdentity: 'v0.4.0-1234567',
+            releaseTag: 'v0.4.0',
+            isRelease: true,
+        });
     });
 
     it('requires acknowledgement on every application start', async () => {
@@ -214,6 +227,27 @@ describe('App panel layout', () => {
         expect(screen.getByRole('dialog', { name: 'Experimental software' })).toBeTruthy();
     });
 
+    it('opens About from the brand and reuses the authoritative build information', async () => {
+        renderAcknowledgedApp();
+        const brand = screen.getByRole('button', { name: 'About axkdeck' });
+
+        brand.focus();
+        expect(document.activeElement).toBe(brand);
+        await fireEvent.click(brand);
+        const firstDialog = await screen.findByRole('dialog', { name: 'About axkdeck' });
+        expect(within(firstDialog).getByText('0.4.0')).toBeTruthy();
+        expect(within(firstDialog).getByText('v0.4.0-1234567')).toBeTruthy();
+        expect(mocks.desktopBuildInfo).toHaveBeenCalledOnce();
+
+        await fireEvent.click(within(firstDialog).getByRole('button', { name: 'Close' }));
+        expect(screen.queryByRole('dialog', { name: 'About axkdeck' })).toBeNull();
+        await waitFor(() => expect(document.activeElement).toBe(brand));
+
+        await fireEvent.click(brand);
+        expect(await screen.findByRole('dialog', { name: 'About axkdeck' })).toBeTruthy();
+        expect(mocks.desktopBuildInfo).toHaveBeenCalledOnce();
+    });
+
     it('keeps one stable toolbar across all side-panel combinations', async () => {
         const { container } = renderAcknowledgedApp();
         const shell = container.querySelector('.app-shell');
diff --git a/apps/axkdeck/src/app.css b/apps/axkdeck/src/app.css
index 75046b12..c71db098 100644
--- a/apps/axkdeck/src/app.css
+++ b/apps/axkdeck/src/app.css
@@ -133,6 +133,18 @@ input:focus-visible {
   align-items: center;
   gap: 10px;
   padding: 0 10px;
+  border: 0;
+  background: transparent;
+  cursor: pointer;
+  text-align: left;
+}
+
+.brand:hover {
+  background: rgb(255 255 255 / 4%);
+}
+
+.brand:focus-visible {
+  outline-offset: -3px;
 }
 
 .brand-mark {
diff --git a/apps/axkdeck/src/features/workspace/WorkspaceShell.layout.test.ts b/apps/axkdeck/src/features/workspace/WorkspaceShell.layout.test.ts
index bd6046de..8940f5c4 100644
--- a/apps/axkdeck/src/features/workspace/WorkspaceShell.layout.test.ts
+++ b/apps/axkdeck/src/features/workspace/WorkspaceShell.layout.test.ts
@@ -28,6 +28,9 @@ describe('WorkspaceShell layout contract', () => {
         expect(shellRule).toContain('--library-column-width: 248px');
         expect(shellRule).toContain('grid-template-columns: var(--library-column-width) minmax(520px, 1fr) 268px');
         expect(headerRule).toContain('grid-template-columns: var(--library-column-width) minmax(0, 1fr) auto auto');
+        expect(brandRule).toContain('height: 100%');
+        expect(brandRule).toContain('border: 0');
+        expect(brandRule).toContain('background: transparent');
         expect(brandRule).not.toMatch(/(?:^|\n)\s*width:/);
         expect(mediumLayout).toContain('--library-column-width: 220px');
         expect(compactLayout).toContain('--library-column-width: 205px');
diff --git a/apps/axkdeck/src/features/workspace/WorkspaceShell.svelte b/apps/axkdeck/src/features/workspace/WorkspaceShell.svelte
index 2fe5a2d0..dfb31e89 100644
--- a/apps/axkdeck/src/features/workspace/WorkspaceShell.svelte
+++ b/apps/axkdeck/src/features/workspace/WorkspaceShell.svelte
@@ -5,6 +5,7 @@
     import type { AudioImportWorkflow } from '../import/audioWorkflow.svelte';
     import type { SequenceImportWorkflow } from '../import/sequenceWorkflow.svelte';
     import type { MutationWorkflow } from '../mutation/workflow.svelte';
+    import AboutDialog from '../../lib/components/AboutDialog.svelte';
     import AuditionBar from '../../lib/components/AuditionBar.svelte';
     import ContainedObjectWorkspace from '../../lib/components/ContainedObjectWorkspace.svelte';
     import Icon from '../../lib/components/Icon.svelte';
@@ -32,6 +33,7 @@
         WorkspaceView,
     } from '../../lib/types';
     import type { PackageExportSelectionState } from '../../lib/objectSelection';
+    import { desktopBuildInfo, type DesktopBuildInfo, type DesktopBuildInfoState } from '../../lib/desktopBuildInfo';
 
     interface WorkspaceTab {
         id: WorkspaceView;
@@ -173,6 +175,10 @@
     let observedSessionId = $state<number | null>(null);
     let observedVolumeId = $state('');
     let observedSystemProgramContexts = $state<SystemProgramContexts | null>(null);
+    let aboutDialogOpen = $state(false);
+    let aboutBuildInfoState = $state<DesktopBuildInfoState>({ status: 'loading' });
+    let cachedDesktopBuildInfo: DesktopBuildInfo | null = null;
+    let desktopBuildInfoRequest: Promise<DesktopBuildInfo> | null = null;
     const lowerPanelAvailable = $derived(workspaceView !== 'wave-data' && workspaceView !== 'sequences');
     const auditionAvailable = $derived(workspaceView !== 'programs' && workspaceView !== 'sequences');
     const multiPartEditorContext = $derived(
@@ -271,13 +277,31 @@
         catalog.inspectorObjectId = '';
         catalog.editorObjectIds.programs = '';
     }
+
+    async function openAbout(): Promise<void> {
+        aboutDialogOpen = true;
+        if (cachedDesktopBuildInfo) {
+            aboutBuildInfoState = { status: 'ready', buildInfo: cachedDesktopBuildInfo };
+            return;
+        }
+
+        aboutBuildInfoState = { status: 'loading' };
+        desktopBuildInfoRequest ??= desktopBuildInfo();
+        try {
+            cachedDesktopBuildInfo = await desktopBuildInfoRequest;
+            aboutBuildInfoState = { status: 'ready', buildInfo: cachedDesktopBuildInfo };
+        } catch {
+            desktopBuildInfoRequest = null;
+            aboutBuildInfoState = { status: 'error' };
+        }
+    }
 </script>
 
 <div class:sidebar-closed={!sidebarOpen} class:inspector-closed={!inspectorOpen} class="app-shell">
     <header class="app-header">
-        <div class="brand">
+        <button class="brand" type="button" aria-label="About axkdeck" title="About axkdeck" onclick={openAbout}>
             <span class="brand-mark"><Icon name="waveform" size={20} strokeWidth={2.1} /></span><strong>axkdeck</strong>
-        </div>
+        </button>
         <nav class="workspace-tabs" aria-label="Workspace views">
             {#each workspaceTabs as tab (tab.id)}
                 <button class:active={workspaceView === tab.id} type="button" onclick={() => selectWorkspace(tab.id)}>
@@ -542,3 +566,7 @@
         >
     </footer>
 </div>
+
+{#if aboutDialogOpen}
+    <AboutDialog state={aboutBuildInfoState} onclose={() => (aboutDialogOpen = false)} />
+{/if}
diff --git a/apps/axkdeck/src/lib/components/AboutDialog.svelte b/apps/axkdeck/src/lib/components/AboutDialog.svelte
new file mode 100644
index 00000000..82478b70
--- /dev/null
+++ b/apps/axkdeck/src/lib/components/AboutDialog.svelte
@@ -0,0 +1,119 @@
+<script lang="ts">
+    import type { DesktopBuildInfoState } from '../desktopBuildInfo';
+    import { modal } from '../modal';
+    import Icon from './Icon.svelte';
+
+    interface Props {
+        state: DesktopBuildInfoState;
+        onclose: () => void;
+    }
+
+    let { state, onclose }: Props = $props();
+</script>
+
+<div class="dialog-backdrop" role="presentation">
+    <div
+        class="dialog-shell about-dialog"
+        role="dialog"
+        aria-modal="true"
+        aria-labelledby="about-title"
+        aria-describedby="about-description"
+        use:modal={{ onescape: onclose }}
+    >
+        <header class="dialog-header">
+            <div>
+                <span class="about-mark" aria-hidden="true">
+                    <Icon name="waveform" size={18} strokeWidth={2.1} />
+                </span>
+                <h2 id="about-title">About axkdeck</h2>
+            </div>
+            <button class="icon-button" type="button" aria-label="Close About" onclick={onclose}>×</button>
+        </header>
+
+        <div class="about-content">
+            <p id="about-description">A-series sampler disk workspace</p>
+            {#if state.status === 'loading'}
+                <p class="about-status" aria-live="polite">Loading version information…</p>
+            {:else if state.status === 'error'}
+                <p class="about-status about-error" role="status">Version information is unavailable.</p>
+            {:else}
+                <dl>
+                    <div>
+                        <dt>Version</dt>
+                        <dd>{state.buildInfo.semanticVersion}</dd>
+                    </div>
+                    <div>
+                        <dt>Build</dt>
+                        <dd>{state.buildInfo.sourceIdentity}</dd>
+                    </div>
+                </dl>
+            {/if}
+        </div>
+
+        <footer class="dialog-footer">
+            <button class="secondary-button" type="button" data-dialog-initial-focus onclick={onclose}>Close</button>
+        </footer>
+    </div>
+</div>
+
+<style>
+    .about-dialog {
+        width: min(440px, calc(100vw - 32px));
+    }
+
+    .about-mark {
+        display: inline-grid;
+        width: 28px;
+        height: 28px;
+        place-items: center;
+        color: #f3d6bd;
+        border: 1px solid rgb(204 120 50 / 55%);
+        border-radius: 7px;
+        background: linear-gradient(145deg, #b86c2c, #70421f);
+    }
+
+    .about-content {
+        min-height: 118px;
+        padding: 16px;
+    }
+
+    .about-content p {
+        margin: 0;
+    }
+
+    #about-description {
+        color: var(--color-text-muted);
+    }
+
+    .about-status {
+        margin-top: 24px !important;
+        color: var(--color-text-muted);
+    }
+
+    .about-error {
+        color: var(--color-danger);
+    }
+
+    dl {
+        margin: 20px 0 0;
+    }
+
+    dl div {
+        display: grid;
+        grid-template-columns: 72px minmax(0, 1fr);
+        gap: 12px;
+        padding: 7px 0;
+        border-top: 1px solid var(--color-border);
+    }
+
+    dt {
+        color: var(--color-text-muted);
+    }
+
+    dd {
+        min-width: 0;
+        margin: 0;
+        overflow-wrap: anywhere;
+        color: var(--color-text-strong);
+    }
+</style>
diff --git a/apps/axkdeck/src/lib/components/AboutDialog.test.ts b/apps/axkdeck/src/lib/components/AboutDialog.test.ts
new file mode 100644
index 00000000..ce71c125
--- /dev/null
+++ b/apps/axkdeck/src/lib/components/AboutDialog.test.ts
@@ -0,0 +1,57 @@
+import { fireEvent, render, screen, waitFor, within } from '@testing-library/svelte';
+import { describe, expect, it, vi } from 'vitest';
+
+import AboutDialog from './AboutDialog.svelte';
+
+describe('AboutDialog', () => {
+    it('appears immediately while authoritative build information is loading', async () => {
+        render(AboutDialog, {
+            props: {
+                state: { status: 'loading' },
+                onclose: vi.fn(),
+            },
+        });
+
+        const dialog = screen.getByRole('dialog', { name: 'About axkdeck' });
+        expect(within(dialog).getByText('Loading version information…')).toBeTruthy();
+        await waitFor(() => expect(document.activeElement).toBe(within(dialog).getByRole('button', { name: 'Close' })));
+    });
+
+    it('renders version and source identity and closes with Escape', async () => {
+        const onclose = vi.fn();
+        render(AboutDialog, {
+            props: {
+                state: {
+                    status: 'ready',
+                    buildInfo: {
+                        schemaVersion: 1,
+                        semanticVersion: '0.4.0',
+                        projectVersion: '0.4.0',
+                        sourceIdentity: 'v0.4.0-1234567-mod',
+                        releaseTag: '',
+                        isRelease: false,
+                    },
+                },
+                onclose,
+            },
+        });
+
+        const dialog = screen.getByRole('dialog', { name: 'About axkdeck' });
+        expect(within(dialog).getByText('0.4.0')).toBeTruthy();
+        expect(within(dialog).getByText('v0.4.0-1234567-mod')).toBeTruthy();
+
+        await fireEvent.keyDown(dialog, { key: 'Escape' });
+        expect(onclose).toHaveBeenCalledOnce();
+    });
+
+    it('shows a stable fallback when build information cannot be loaded', () => {
+        render(AboutDialog, {
+            props: {
+                state: { status: 'error' },
+                onclose: vi.fn(),
+            },
+        });
+
+        expect(screen.getByText('Version information is unavailable.')).toBeTruthy();
+    });
+});
diff --git a/apps/axkdeck/src/lib/desktopBuildInfo.ts b/apps/axkdeck/src/lib/desktopBuildInfo.ts
new file mode 100644
index 00000000..4ac91332
--- /dev/null
+++ b/apps/axkdeck/src/lib/desktopBuildInfo.ts
@@ -0,0 +1,17 @@
+import { invoke } from '@tauri-apps/api/core';
+
+export interface DesktopBuildInfo {
+    schemaVersion: number;
+    semanticVersion: string;
+    projectVersion: string;
+    sourceIdentity: string;
+    releaseTag: string;
+    isRelease: boolean;
+}
+
+export type DesktopBuildInfoState =
+    { status: 'loading' } | { status: 'ready'; buildInfo: DesktopBuildInfo } | { status: 'error' };
+
+export function desktopBuildInfo(): Promise<DesktopBuildInfo> {
+    return invoke<DesktopBuildInfo>('desktop_build_info');
+}

From 2a4810b6d714b9e4277d30d10ed9eeac3f2bb995 Mon Sep 17 00:00:00 2001
From: bzeiss <ben@zeiss.net>
Date: Thu, 20 Aug 2026 23:02:43 +0200
Subject: [PATCH 10/12] various export glitch fixes.

---
 apps/axkdeck/src/App.svelte                   |  52 +++--
 apps/axkdeck/src/App.test.ts                  |   1 +
 .../src/features/dialogs/AppDialogs.svelte    | 101 +++++++--
 .../features/export/mediaWorkflow.svelte.ts   |   8 +-
 .../export/progressVisibility.svelte.ts       |  39 ++++
 .../export/progressVisibility.test.ts         |  55 +++++
 .../export/volumeFloppyWorkflow.svelte.ts     |   8 +-
 .../export/volumePackageWorkflow.svelte.ts    |   8 +-
 .../src/features/export/workflow.svelte.ts    |  24 ++-
 .../file-operations/ClientFileInputs.svelte   |  41 ++++
 .../directComputerWorkflow.test.ts            |  51 +++++
 .../file-operations/directComputerWorkflow.ts | 194 ++++++++++++++++++
 .../import/packageBatchWorkflow.svelte.ts     |   8 +-
 .../features/import/packageWorkflow.svelte.ts |   8 +-
 .../features/import/packageWorkflow.test.ts   |   3 +-
 .../features/workspace/WorkspaceShell.svelte  |   8 +-
 .../ExportDestinationChooser.svelte           |   8 +-
 .../components/ExportProgressDialog.svelte    |  55 +++++
 .../components/ExportProgressDialog.test.ts   |  39 ++++
 .../components/ImageTreeContextMenu.svelte    |  37 ++--
 .../components/ImageTreeContextMenu.test.ts   |  59 ++++++
 .../lib/components/MediaExportDialog.svelte   |  17 +-
 .../lib/components/MidiExportDialog.svelte    |  16 +-
 .../lib/components/MidiExportDialog.test.ts   |   9 +-
 .../lib/components/PackageExportDialog.svelte |  14 +-
 .../components/PackageExportDialog.test.ts    |  19 +-
 .../components/ServerStoragePicker.test.ts    |   2 +
 .../src/lib/components/SfzExportDialog.svelte |  34 +--
 .../lib/components/SfzExportDialog.test.ts    |   6 -
 .../VolumeFloppyExportDialog.svelte           |  20 +-
 .../VolumeFloppyExportDialog.test.ts          |   4 -
 .../VolumePackageExportDialog.svelte          |  20 +-
 .../VolumePackageExportDialog.test.ts         |   4 -
 apps/axkdeck/src/lib/createTransport.test.ts  |  13 ++
 apps/axkdeck/src/lib/createTransport.ts       |   1 +
 .../src/lib/fileOperationRouting.test.ts      |  21 ++
 apps/axkdeck/src/lib/fileOperationRouting.ts  |   5 +
 apps/axkdeck/src/lib/httpTransport.test.ts    |  85 ++++++--
 apps/axkdeck/src/lib/httpTransport.ts         |   5 +-
 .../src/lib/testing/inMemoryTransport.ts      |   3 +
 apps/axkdeck/src/lib/transport.ts             |   3 +
 .../src/lib/transportConformance.test.ts      |   2 +-
 42 files changed, 893 insertions(+), 217 deletions(-)
 create mode 100644 apps/axkdeck/src/features/export/progressVisibility.svelte.ts
 create mode 100644 apps/axkdeck/src/features/export/progressVisibility.test.ts
 create mode 100644 apps/axkdeck/src/features/file-operations/ClientFileInputs.svelte
 create mode 100644 apps/axkdeck/src/features/file-operations/directComputerWorkflow.test.ts
 create mode 100644 apps/axkdeck/src/features/file-operations/directComputerWorkflow.ts
 create mode 100644 apps/axkdeck/src/lib/components/ExportProgressDialog.svelte
 create mode 100644 apps/axkdeck/src/lib/components/ExportProgressDialog.test.ts
 create mode 100644 apps/axkdeck/src/lib/components/ImageTreeContextMenu.test.ts
 create mode 100644 apps/axkdeck/src/lib/fileOperationRouting.test.ts
 create mode 100644 apps/axkdeck/src/lib/fileOperationRouting.ts

diff --git a/apps/axkdeck/src/App.svelte b/apps/axkdeck/src/App.svelte
index 22cbe192..cd7c00bb 100644
--- a/apps/axkdeck/src/App.svelte
+++ b/apps/axkdeck/src/App.svelte
@@ -8,11 +8,13 @@
     import { DeletionWorkflow } from './features/deletion/workflow.svelte';
     import { PickerController, type PickerRequest } from './features/dialogs/picker';
     import { hasOpenAppDialog } from './features/dialogs/visibility';
+    import ClientFileInputs from './features/file-operations/ClientFileInputs.svelte';
+    import { DirectComputerWorkflow } from './features/file-operations/directComputerWorkflow';
     import { ExportWorkflow } from './features/export/workflow.svelte';
     import { MediaExportWorkflow } from './features/export/mediaWorkflow.svelte';
     import { VolumePackageExportWorkflow } from './features/export/volumePackageWorkflow.svelte';
     import { VolumeFloppyExportWorkflow } from './features/export/volumeFloppyWorkflow.svelte';
-    import { AudioImportWorkflow, audioExtensions } from './features/import/audioWorkflow.svelte';
+    import { AudioImportWorkflow } from './features/import/audioWorkflow.svelte';
     import { MediaDropWorkflow } from './features/import/mediaDropWorkflow.svelte';
     import { PackageImportWorkflow } from './features/import/packageWorkflow.svelte';
     import { PackageBatchImportWorkflow } from './features/import/packageBatchWorkflow.svelte';
@@ -38,7 +40,6 @@
         type PackageExportSelectionState,
     } from './lib/objectSelection';
     import { userFacingMessage } from './lib/userFacingMessage';
-    import { midiExtensions } from './lib/midiImport';
     import type {
         DiskTreeItem,
         InspectorSelection,
@@ -268,6 +269,8 @@
         setStatus: (status) => imageSessionWorkflow.setStatus(status),
         reportTiming: reportMutationTiming,
     });
+    const directComputerWorkflow = new DirectComputerWorkflow(isDesktop, transport.connectionMode);
+    const pendingDirectComputerOperation = directComputerWorkflow.pendingOperation;
     const mediaDropWorkflow = new MediaDropWorkflow({
         isDesktop,
         workspaceView: () => workspaceView,
@@ -429,19 +432,19 @@
         if (action === 'import-package') {
             if (!imageSessionWorkflow.packageImportAvailable || item.kind !== 'volume') return;
             imageSessionWorkflow.selectedSource = item;
-            packageImportWorkflow.open(item);
+            directComputerWorkflow.importPackage(packageImportWorkflow, item);
             return;
         }
         if (action === 'import-packages') {
             if (!imageSessionWorkflow.packageImportAvailable || item.kind !== 'partition') return;
             imageSessionWorkflow.selectedSource = item;
-            packageBatchImportWorkflow.open(item);
+            directComputerWorkflow.importVolumePackages(packageBatchImportWorkflow, item);
             return;
         }
         if (action === 'export-package') {
             if (!imageSessionWorkflow.packageExportAvailable || item.kind !== 'volume') return;
             imageSessionWorkflow.selectedSource = item;
-            exportWorkflow.requestPackage([
+            directComputerWorkflow.exportPackage(exportWorkflow, [
                 {
                     kind: 'VOLUME',
                     contentId: item.id,
@@ -456,19 +459,19 @@
         if (action === 'export-volume-packages') {
             if (!imageSessionWorkflow.volumePackageExportAvailable || item.kind !== 'partition') return;
             imageSessionWorkflow.selectedSource = item;
-            void volumePackageExportWorkflow.open(item);
+            void directComputerWorkflow.exportVolumePackages(volumePackageExportWorkflow, item);
             return;
         }
         if (action === 'export-volume-floppies') {
             if (!imageSessionWorkflow.volumeFloppyExportAvailable || item.kind !== 'partition') return;
             imageSessionWorkflow.selectedSource = item;
-            void volumeFloppyExportWorkflow.open(item);
+            void directComputerWorkflow.exportVolumeFloppies(volumeFloppyExportWorkflow, item);
             return;
         }
         if (action === 'export-sfz') {
             if (!imageSessionWorkflow.audioExportAvailable || item.kind !== 'volume') return;
             imageSessionWorkflow.selectedSource = item;
-            void exportWorkflow.requestAudio([
+            void requestAudioExport([
                 {
                     kind: 'VOLUME',
                     contentId: item.id,
@@ -483,7 +486,7 @@
         if (action === 'export-cdrom' || action === 'export-floppy') {
             if (!imageSessionWorkflow.mediaConversionAvailable) return;
             imageSessionWorkflow.selectedSource = item;
-            void mediaExportWorkflow.open(item);
+            void directComputerWorkflow.exportMedia(mediaExportWorkflow, item);
             return;
         }
         if (mutationWorkflow.requestVolumeAction(item, action)) imageSessionWorkflow.selectedSource = item;
@@ -497,7 +500,7 @@
         ) {
             return;
         }
-        exportWorkflow.requestPackage(items);
+        directComputerWorkflow.exportPackage(exportWorkflow, items);
     }
 
     function clearPackageExportSelection(): void {
@@ -511,11 +514,11 @@
 
     async function requestAudioExport(items: PackageExportSelection[]): Promise<void> {
         if (!imageSessionWorkflow.audioExportAvailable) return;
-        await exportWorkflow.requestAudio(items);
+        await directComputerWorkflow.exportAudio(exportWorkflow, items);
     }
     function requestSequenceExport(items: PackageExportObject[]): void {
         if (!imageSessionWorkflow.sequenceExportAvailable) return;
-        exportWorkflow.requestSequence(items);
+        directComputerWorkflow.exportMidi(exportWorkflow, items);
     }
 
     function requestObjectDeletion(targets: PackageExportObject[]): void {
@@ -556,21 +559,13 @@
     ondrop={(event) => mediaDropWorkflow.drop(event)}
 />
 
-<input
-    bind:this={audioFileInput}
-    class="sr-only"
-    type="file"
-    multiple
-    accept={audioExtensions.map((extension) => `.${extension}`).join(',')}
-    onchange={(event) => audioImportWorkflow.filesChosen(event)}
-/>
-<input
-    bind:this={sequenceFileInput}
-    class="sr-only"
-    type="file"
-    multiple
-    accept={midiExtensions.map((extension) => `.${extension}`).join(',')}
-    onchange={(event) => sequenceImportWorkflow.filesChosen(event)}
+<ClientFileInputs
+    bind:audioInput={audioFileInput}
+    bind:sequenceInput={sequenceFileInput}
+    audioChanged={(event) => directComputerWorkflow.audioFilesChosen(audioImportWorkflow, event)}
+    audioCancelled={() => directComputerWorkflow.cancelAudioSelection(audioImportWorkflow)}
+    sequenceChanged={(event) => directComputerWorkflow.midiFilesChosen(sequenceImportWorkflow, event)}
+    sequenceCancelled={() => directComputerWorkflow.cancelMidiSelection(sequenceImportWorkflow)}
 />
 
 <WorkspaceShell
@@ -590,6 +585,8 @@
     mutation={mutationWorkflow}
     audioImport={audioImportWorkflow}
     sequenceImport={sequenceImportWorkflow}
+    importAudio={() => directComputerWorkflow.importAudio(audioImportWorkflow, audioFileInput)}
+    importMidi={() => directComputerWorkflow.importMidi(sequenceImportWorkflow, sequenceFileInput)}
     {programs}
     {sampleBanks}
     {samples}
@@ -658,6 +655,7 @@
         <AppDialogs
             {transport}
             {isDesktop}
+            directComputerOperation={$pendingDirectComputerOperation}
             {pickerRequest}
             finishPicker={(selection) => pickerController.finish(selection)}
             manageLocations={() => (workspaceManagerOpen = true)}
diff --git a/apps/axkdeck/src/App.test.ts b/apps/axkdeck/src/App.test.ts
index cd9b8e3d..e58a380a 100644
--- a/apps/axkdeck/src/App.test.ts
+++ b/apps/axkdeck/src/App.test.ts
@@ -36,6 +36,7 @@ const mocks = vi.hoisted(() => ({
 vi.mock('./lib/createTransport', () => ({
     createTransport: () => ({
         storageMode: 'server',
+        connectionMode: 'remote',
         supportsClientUploads: true,
         sandboxRoots: mocks.sandboxRoots,
         sandboxDirectory: mocks.sandboxDirectory,
diff --git a/apps/axkdeck/src/features/dialogs/AppDialogs.svelte b/apps/axkdeck/src/features/dialogs/AppDialogs.svelte
index f67389bf..44fb9b56 100644
--- a/apps/axkdeck/src/features/dialogs/AppDialogs.svelte
+++ b/apps/axkdeck/src/features/dialogs/AppDialogs.svelte
@@ -1,4 +1,5 @@
 <script lang="ts">
+    import { onDestroy } from 'svelte';
     import type { DeletionWorkflow } from '../deletion/workflow.svelte';
     import type { PickerRequest, PickerSelection } from './picker';
     import type { ExportWorkflow } from '../export/workflow.svelte';
@@ -23,6 +24,7 @@
     import ObjectDeletionDialog from '../../lib/components/ObjectDeletionDialog.svelte';
     import ObjectRenameDialog from '../../lib/components/ObjectRenameDialog.svelte';
     import PackageExportDialog from '../../lib/components/PackageExportDialog.svelte';
+    import ExportProgressDialog from '../../lib/components/ExportProgressDialog.svelte';
     import PackageImportDialog from '../../lib/components/PackageImportDialog.svelte';
     import PackageBatchImportDialog from '../../lib/components/PackageBatchImportDialog.svelte';
     import PlacementRepairDialog from '../../lib/components/PlacementRepairDialog.svelte';
@@ -42,6 +44,11 @@
     import type { RemoteServerSettingsInput, RemoteServerSettingsView } from '../../lib/serverSettings';
     import type { DirectoryLocation, FileLocation, ImageLocation } from '../../lib/storageLocations';
     import type { CompanionSelection, ImageTransport } from '../../lib/transport';
+    import {
+        directComputerDialogVisible,
+        type DirectComputerOperation,
+    } from '../file-operations/directComputerWorkflow';
+    import { DelayedExportProgressVisibility, type ExportProgressOperation } from '../export/progressVisibility.svelte';
 
     interface CompanionDialogState {
         sources: ImageLocation[];
@@ -55,6 +62,7 @@
     interface Props {
         transport: ImageTransport;
         isDesktop: boolean;
+        directComputerOperation: DirectComputerOperation | null;
         pickerRequest: PickerRequest | null;
         finishPicker: (selection: PickerSelection | null) => void;
         manageLocations: () => void;
@@ -97,6 +105,7 @@
     let {
         transport,
         isDesktop,
+        directComputerOperation,
         pickerRequest,
         finishPicker,
         manageLocations,
@@ -135,6 +144,25 @@
         waveDataNames,
         sequenceNames,
     }: Props = $props();
+
+    function directChoiceVisible(operation: DirectComputerOperation, contentAvailable: boolean): boolean {
+        return directComputerDialogVisible(directComputerOperation, operation, contentAvailable);
+    }
+
+    const exportProgressVisibility = new DelayedExportProgressVisibility();
+
+    function busyExportOperation(): ExportProgressOperation | null {
+        if (exports.packageRequest?.busy) return 'package-export';
+        if (volumePackages.request?.busy) return 'volume-package-export';
+        if (volumeFloppies.request?.busy) return 'volume-floppy-export';
+        if (exports.audioRequest?.busy) return 'audio-export';
+        if (exports.sequenceRequest?.busy) return 'sequence-export';
+        if (mediaExports.request?.busy) return 'media-export';
+        return null;
+    }
+
+    $effect(() => exportProgressVisibility.update(busyExportOperation()));
+    onDestroy(() => exportProgressVisibility.dispose());
 </script>
 
 {#if pickerRequest}
@@ -253,7 +281,7 @@
         onsubmit={(bankObjectId) => void mutation.submitSampleBankAssignment(bankObjectId)}
     />
 {/if}
-{#if packageImport.request && pickerRequest?.parentDialog !== 'package-import'}
+{#if packageImport.request && pickerRequest?.parentDialog !== 'package-import' && directChoiceVisible('package-import', packageImport.request.status !== 'choosing' || Boolean(packageImport.request.sourceName || packageImport.request.error))}
     <PackageImportDialog
         targetName={packageImport.targetName()}
         destinationMode={packageImport.request.destinationMode}
@@ -290,7 +318,7 @@
         onconfirm={() => void packageImport.apply()}
     />
 {/if}
-{#if packageBatchImport.request && pickerRequest?.parentDialog !== 'package-import'}
+{#if packageBatchImport.request && pickerRequest?.parentDialog !== 'package-import' && directChoiceVisible('package-batch-import', packageBatchImport.request.status !== 'choosing' || packageBatchImport.request.items.length > 0 || Boolean(packageBatchImport.request.error))}
     <PackageBatchImportDialog
         partitionName={packageBatchImport.request.partition.name}
         desktop={isDesktop}
@@ -316,54 +344,46 @@
         onconfirm={() => void packageBatchImport.apply()}
     />
 {/if}
-{#if exports.packageRequest && pickerRequest?.parentDialog !== 'package-export' && !companionRequest}
+{#if exports.packageRequest && !exports.packageRequest.busy && pickerRequest?.parentDialog !== 'package-export' && !companionRequest && directChoiceVisible('package-export', Boolean(exports.packageRequest.error))}
     <PackageExportDialog
         items={exports.packageRequest.items}
         desktop={isDesktop}
-        busy={exports.packageRequest.busy}
-        progressLabel={exports.packageRequest.progressLabel}
         error={exports.packageRequest.error}
         onworkspace={() => void exports.packageToWorkspace()}
         onlocal={() => void exports.packageToComputer()}
         oncancel={() => exports.closePackage()}
     />
 {/if}
-{#if volumePackages.request && pickerRequest?.parentDialog !== 'volume-package-export'}
+{#if volumePackages.request && !volumePackages.request.busy && pickerRequest?.parentDialog !== 'volume-package-export' && directChoiceVisible('volume-package-export', Boolean(volumePackages.request.error))}
     <VolumePackageExportDialog
         scopeName={volumePackages.request.scope.name}
         inspection={volumePackages.request.inspection}
         desktop={isDesktop}
         loading={volumePackages.request.loading}
-        busy={volumePackages.request.busy}
-        progressLabel={volumePackages.request.progressLabel}
         error={volumePackages.request.error}
         onworkspace={() => void volumePackages.toWorkspace()}
         onlocal={() => void volumePackages.toComputer()}
         oncancel={() => volumePackages.cancel()}
     />
 {/if}
-{#if volumeFloppies.request && pickerRequest?.parentDialog !== 'volume-floppy-export'}
+{#if volumeFloppies.request && !volumeFloppies.request.busy && pickerRequest?.parentDialog !== 'volume-floppy-export' && directChoiceVisible('volume-floppy-export', Boolean(volumeFloppies.request.error))}
     <VolumeFloppyExportDialog
         scopeName={volumeFloppies.request.scope.name}
         inspection={volumeFloppies.request.inspection}
         desktop={isDesktop}
         loading={volumeFloppies.request.loading}
-        busy={volumeFloppies.request.busy}
-        progressLabel={volumeFloppies.request.progressLabel}
         error={volumeFloppies.request.error}
         onworkspace={() => void volumeFloppies.toWorkspace()}
         onlocal={() => void volumeFloppies.toComputer()}
         oncancel={() => volumeFloppies.cancel()}
     />
 {/if}
-{#if exports.audioRequest && pickerRequest?.parentDialog !== 'audio-export' && !companionRequest}
+{#if exports.audioRequest && !exports.audioRequest.busy && pickerRequest?.parentDialog !== 'audio-export' && !companionRequest && directChoiceVisible('audio-export', Boolean(exports.audioRequest.error))}
     <SfzExportDialog
         items={exports.audioRequest.items}
         inspection={exports.audioRequest.inspection}
         desktop={isDesktop}
         loading={exports.audioRequest.loading}
-        busy={exports.audioRequest.busy}
-        progressLabel={exports.audioRequest.progressLabel}
         error={exports.audioRequest.error}
         format={exports.audioRequest.format}
         onformatchange={(format) => exports.setAudioFormat(format)}
@@ -372,19 +392,17 @@
         oncancel={() => exports.cancelAudio()}
     />
 {/if}
-{#if exports.sequenceRequest && pickerRequest?.parentDialog !== 'sequence-export'}
+{#if exports.sequenceRequest && !exports.sequenceRequest.busy && pickerRequest?.parentDialog !== 'sequence-export' && directChoiceVisible('sequence-export', Boolean(exports.sequenceRequest.error))}
     <MidiExportDialog
         items={exports.sequenceRequest.items}
         desktop={isDesktop}
-        busy={exports.sequenceRequest.busy}
-        progressLabel={exports.sequenceRequest.progressLabel}
         error={exports.sequenceRequest.error}
         onworkspace={() => void exports.sequenceToWorkspace()}
         onlocal={() => void exports.sequenceToComputer()}
         oncancel={() => exports.cancelSequence()}
     />
 {/if}
-{#if mediaExports.request && pickerRequest?.parentDialog !== 'media-export'}
+{#if mediaExports.request && !mediaExports.request.busy && pickerRequest?.parentDialog !== 'media-export' && directChoiceVisible('media-export', Boolean(mediaExports.request.error))}
     <MediaExportDialog
         request={mediaExports.request}
         desktop={isDesktop}
@@ -393,6 +411,49 @@
         oncancel={() => mediaExports.cancel()}
     />
 {/if}
+{#if exportProgressVisibility.operation === 'package-export' && exports.packageRequest?.busy}
+    <ExportProgressDialog
+        title="Export package"
+        progressLabel={exports.packageRequest.progressLabel || 'Exporting package…'}
+        cancellable={false}
+        oncancel={() => undefined}
+    />
+{:else if exportProgressVisibility.operation === 'volume-package-export' && volumePackages.request?.busy}
+    <ExportProgressDialog
+        title="Export volume packages"
+        progressLabel={volumePackages.request.progressLabel || 'Exporting packages…'}
+        cancellable={true}
+        oncancel={() => volumePackages.cancel()}
+    />
+{:else if exportProgressVisibility.operation === 'volume-floppy-export' && volumeFloppies.request?.busy}
+    <ExportProgressDialog
+        title="Export volumes to floppies"
+        progressLabel={volumeFloppies.request.progressLabel || 'Exporting floppy sets…'}
+        cancellable={true}
+        oncancel={() => volumeFloppies.cancel()}
+    />
+{:else if exportProgressVisibility.operation === 'audio-export' && exports.audioRequest?.busy}
+    <ExportProgressDialog
+        title="Export audio"
+        progressLabel={exports.audioRequest.progressLabel || 'Exporting audio…'}
+        cancellable={true}
+        oncancel={() => exports.cancelAudio()}
+    />
+{:else if exportProgressVisibility.operation === 'sequence-export' && exports.sequenceRequest?.busy}
+    <ExportProgressDialog
+        title="Export MIDI"
+        progressLabel={exports.sequenceRequest.progressLabel || 'Exporting MIDI…'}
+        cancellable={true}
+        oncancel={() => exports.cancelSequence()}
+    />
+{:else if exportProgressVisibility.operation === 'media-export' && mediaExports.request?.busy}
+    <ExportProgressDialog
+        title="Export sampler media"
+        progressLabel={mediaExports.request.progressLabel || 'Exporting sampler media…'}
+        cancellable={true}
+        oncancel={() => mediaExports.cancel()}
+    />
+{/if}
 {#if deletion.objectRequest}
     <ObjectDeletionDialog
         inspection={deletion.objectRequest.inspection}
@@ -434,7 +495,7 @@
         onconfirm={() => void programGeneration.submit()}
     />
 {/if}
-{#if audioImport.request && pickerRequest?.parentDialog !== 'audio-import'}
+{#if audioImport.request && pickerRequest?.parentDialog !== 'audio-import' && directChoiceVisible('audio-import', audioImport.request.files.length > 0)}
     <AudioImportDialog
         {transport}
         files={audioImport.request.files}
@@ -460,7 +521,7 @@
         oncancel={() => (audioImport.request = null)}
     />
 {/if}
-{#if sequenceImport.request && pickerRequest?.parentDialog !== 'sequence-import'}
+{#if sequenceImport.request && pickerRequest?.parentDialog !== 'sequence-import' && directChoiceVisible('sequence-import', sequenceImport.request.files.length > 0)}
     <MidiImportDialog
         {transport}
         files={sequenceImport.request.files}
diff --git a/apps/axkdeck/src/features/export/mediaWorkflow.svelte.ts b/apps/axkdeck/src/features/export/mediaWorkflow.svelte.ts
index 5f72017a..4ce01e95 100644
--- a/apps/axkdeck/src/features/export/mediaWorkflow.svelte.ts
+++ b/apps/axkdeck/src/features/export/mediaWorkflow.svelte.ts
@@ -91,13 +91,17 @@ export class MediaExportWorkflow {
         await this.run({ kind: 'WORKSPACE', output: selection.reference, overwrite: false });
     }
 
-    async toComputer(): Promise<void> {
+    async toComputer(closeOnCancel = false): Promise<void> {
         const request = this.request;
         if (!request?.inspection?.canExport || request.busy || !this.dependencies.isDesktop) return;
         const generation = this.generation;
         try {
             const destination = await selectLocalMediaDestination(request.inspection.defaultFilename);
-            if (!destination || generation !== this.generation || !this.request) return;
+            if (!destination) {
+                if (closeOnCancel) this.cancel();
+                return;
+            }
+            if (generation !== this.generation || !this.request) return;
             await this.run(
                 { kind: 'DOWNLOAD', filename: destination.filename },
                 { candidateId: destination.candidateId },
diff --git a/apps/axkdeck/src/features/export/progressVisibility.svelte.ts b/apps/axkdeck/src/features/export/progressVisibility.svelte.ts
new file mode 100644
index 00000000..a59cb2fb
--- /dev/null
+++ b/apps/axkdeck/src/features/export/progressVisibility.svelte.ts
@@ -0,0 +1,39 @@
+export const EXPORT_PROGRESS_DELAY_MS = 750;
+
+export type ExportProgressOperation =
+    | 'package-export'
+    | 'audio-export'
+    | 'sequence-export'
+    | 'volume-package-export'
+    | 'volume-floppy-export'
+    | 'media-export';
+
+export class DelayedExportProgressVisibility {
+    operation = $state<ExportProgressOperation | null>(null);
+    private pendingOperation: ExportProgressOperation | null = null;
+    private timer: ReturnType<typeof setTimeout> | null = null;
+
+    update(operation: ExportProgressOperation | null): void {
+        if (operation === this.pendingOperation) return;
+        this.clearTimer();
+        this.pendingOperation = operation;
+        this.operation = null;
+        if (operation === null) return;
+        this.timer = setTimeout(() => {
+            if (this.pendingOperation === operation) this.operation = operation;
+            this.timer = null;
+        }, EXPORT_PROGRESS_DELAY_MS);
+    }
+
+    dispose(): void {
+        this.clearTimer();
+        this.pendingOperation = null;
+        this.operation = null;
+    }
+
+    private clearTimer(): void {
+        if (this.timer === null) return;
+        clearTimeout(this.timer);
+        this.timer = null;
+    }
+}
diff --git a/apps/axkdeck/src/features/export/progressVisibility.test.ts b/apps/axkdeck/src/features/export/progressVisibility.test.ts
new file mode 100644
index 00000000..66048c78
--- /dev/null
+++ b/apps/axkdeck/src/features/export/progressVisibility.test.ts
@@ -0,0 +1,55 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { DelayedExportProgressVisibility, EXPORT_PROGRESS_DELAY_MS } from './progressVisibility.svelte';
+
+describe('DelayedExportProgressVisibility', () => {
+    beforeEach(() => vi.useFakeTimers());
+
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+
+    it('keeps fast exports hidden', async () => {
+        const visibility = new DelayedExportProgressVisibility();
+
+        visibility.update('package-export');
+        await vi.advanceTimersByTimeAsync(EXPORT_PROGRESS_DELAY_MS - 1);
+        visibility.update(null);
+        await vi.advanceTimersByTimeAsync(1);
+
+        expect(visibility.operation).toBeNull();
+    });
+
+    it('reveals an export that remains busy for the complete delay', async () => {
+        const visibility = new DelayedExportProgressVisibility();
+
+        visibility.update('audio-export');
+        await vi.advanceTimersByTimeAsync(EXPORT_PROGRESS_DELAY_MS);
+
+        expect(visibility.operation).toBe('audio-export');
+    });
+
+    it('restarts the delay when a different export supersedes the pending operation', async () => {
+        const visibility = new DelayedExportProgressVisibility();
+
+        visibility.update('package-export');
+        await vi.advanceTimersByTimeAsync(EXPORT_PROGRESS_DELAY_MS - 1);
+        visibility.update('media-export');
+        await vi.advanceTimersByTimeAsync(1);
+
+        expect(visibility.operation).toBeNull();
+
+        await vi.advanceTimersByTimeAsync(EXPORT_PROGRESS_DELAY_MS - 1);
+        expect(visibility.operation).toBe('media-export');
+    });
+
+    it('clears visible progress when the export finishes', async () => {
+        const visibility = new DelayedExportProgressVisibility();
+        visibility.update('sequence-export');
+        await vi.advanceTimersByTimeAsync(EXPORT_PROGRESS_DELAY_MS);
+
+        visibility.update(null);
+
+        expect(visibility.operation).toBeNull();
+    });
+});
diff --git a/apps/axkdeck/src/features/export/volumeFloppyWorkflow.svelte.ts b/apps/axkdeck/src/features/export/volumeFloppyWorkflow.svelte.ts
index b698de96..c628fcd6 100644
--- a/apps/axkdeck/src/features/export/volumeFloppyWorkflow.svelte.ts
+++ b/apps/axkdeck/src/features/export/volumeFloppyWorkflow.svelte.ts
@@ -160,7 +160,7 @@ export class VolumeFloppyExportWorkflow {
         await this.run({ kind: 'WORKSPACE', output: selection.reference });
     }
 
-    async toComputer(): Promise<void> {
+    async toComputer(closeOnCancel = false): Promise<void> {
         const request = this.request;
         if (
             !request?.inspection ||
@@ -176,7 +176,11 @@ export class VolumeFloppyExportWorkflow {
                 request.inspection.defaultDirectoryName,
                 'Floppies',
             );
-            if (!destination || generation !== this.generation || !this.request) return;
+            if (!destination) {
+                if (closeOnCancel) this.cancel();
+                return;
+            }
+            if (generation !== this.generation || !this.request) return;
             await this.run(
                 { kind: 'DOWNLOAD', directoryName: destination.directoryName },
                 { candidateId: destination.candidateId },
diff --git a/apps/axkdeck/src/features/export/volumePackageWorkflow.svelte.ts b/apps/axkdeck/src/features/export/volumePackageWorkflow.svelte.ts
index 341604e2..62d89b14 100644
--- a/apps/axkdeck/src/features/export/volumePackageWorkflow.svelte.ts
+++ b/apps/axkdeck/src/features/export/volumePackageWorkflow.svelte.ts
@@ -159,7 +159,7 @@ export class VolumePackageExportWorkflow {
         await this.run({ kind: 'WORKSPACE', output: selection.reference });
     }
 
-    async toComputer(): Promise<void> {
+    async toComputer(closeOnCancel = false): Promise<void> {
         const request = this.request;
         if (
             !request?.inspection ||
@@ -175,7 +175,11 @@ export class VolumePackageExportWorkflow {
                 request.inspection.defaultDirectoryName,
                 'Packages',
             );
-            if (!destination || generation !== this.generation || !this.request) return;
+            if (!destination) {
+                if (closeOnCancel) this.cancel();
+                return;
+            }
+            if (generation !== this.generation || !this.request) return;
             await this.run(
                 { kind: 'DOWNLOAD', directoryName: destination.directoryName },
                 { candidateId: destination.candidateId },
diff --git a/apps/axkdeck/src/features/export/workflow.svelte.ts b/apps/axkdeck/src/features/export/workflow.svelte.ts
index fb6a0e0f..b41f95d8 100644
--- a/apps/axkdeck/src/features/export/workflow.svelte.ts
+++ b/apps/axkdeck/src/features/export/workflow.svelte.ts
@@ -186,7 +186,7 @@ export class ExportWorkflow {
         await this.runPackage({ kind: 'WORKSPACE', output: selection.reference, overwrite: false });
     }
 
-    async packageToComputer(): Promise<void> {
+    async packageToComputer(closeOnCancel = false): Promise<void> {
         const request = this.packageRequest;
         if (!request || request.busy || !this.dependencies.isDesktop) return;
         const generation = this.generation;
@@ -194,7 +194,11 @@ export class ExportWorkflow {
             const destination = await selectLocalPackageDestination(
                 packageExportFilename(request.items, this.dependencies.imageLocation()),
             );
-            if (!destination || generation !== this.generation || !this.packageRequest) return;
+            if (!destination) {
+                if (closeOnCancel) this.closePackage();
+                return;
+            }
+            if (generation !== this.generation || !this.packageRequest) return;
             await this.runPackage(
                 { kind: 'DOWNLOAD', filename: destination.filename },
                 { candidateId: destination.candidateId },
@@ -361,7 +365,7 @@ export class ExportWorkflow {
         await this.runAudio({ kind: 'WORKSPACE', output: selection.reference }, this.audioRequest.format);
     }
 
-    async audioToComputer(): Promise<void> {
+    async audioToComputer(closeOnCancel = false): Promise<void> {
         const request = this.audioRequest;
         if (!request?.inspection || request.busy || !this.dependencies.isDesktop) return;
         const generation = this.audioGeneration;
@@ -370,7 +374,11 @@ export class ExportWorkflow {
                 request.inspection.defaultDirectoryName,
                 'SFZ',
             );
-            if (!destination || generation !== this.audioGeneration || !this.audioRequest) return;
+            if (!destination) {
+                if (closeOnCancel) this.cancelAudio();
+                return;
+            }
+            if (generation !== this.audioGeneration || !this.audioRequest) return;
             await this.runAudio(
                 { kind: 'DOWNLOAD', directoryName: destination.directoryName },
                 this.audioRequest.format,
@@ -520,7 +528,7 @@ export class ExportWorkflow {
         await this.runSequence({ kind: 'WORKSPACE', output: selection.reference });
     }
 
-    async sequenceToComputer(): Promise<void> {
+    async sequenceToComputer(closeOnCancel = false): Promise<void> {
         const request = this.sequenceRequest;
         if (!request || request.busy || !this.dependencies.isDesktop) return;
         const generation = this.sequenceGeneration;
@@ -529,7 +537,11 @@ export class ExportWorkflow {
                 sequenceDirectoryName(request.items),
                 'MIDI',
             );
-            if (!destination || generation !== this.sequenceGeneration || !this.sequenceRequest) return;
+            if (!destination) {
+                if (closeOnCancel) this.cancelSequence();
+                return;
+            }
+            if (generation !== this.sequenceGeneration || !this.sequenceRequest) return;
             await this.runSequence(
                 { kind: 'DOWNLOAD', directoryName: destination.directoryName },
                 { candidateId: destination.candidateId },
diff --git a/apps/axkdeck/src/features/file-operations/ClientFileInputs.svelte b/apps/axkdeck/src/features/file-operations/ClientFileInputs.svelte
new file mode 100644
index 00000000..8004184b
--- /dev/null
+++ b/apps/axkdeck/src/features/file-operations/ClientFileInputs.svelte
@@ -0,0 +1,41 @@
+<script lang="ts">
+    import { audioExtensions } from '../import/audioWorkflow.svelte';
+    import { midiExtensions } from '../../lib/midiImport';
+
+    interface Props {
+        audioInput?: HTMLInputElement;
+        sequenceInput?: HTMLInputElement;
+        audioChanged: (event: Event) => void;
+        audioCancelled: () => void;
+        sequenceChanged: (event: Event) => void;
+        sequenceCancelled: () => void;
+    }
+
+    let {
+        audioInput = $bindable(),
+        sequenceInput = $bindable(),
+        audioChanged,
+        audioCancelled,
+        sequenceChanged,
+        sequenceCancelled,
+    }: Props = $props();
+</script>
+
+<input
+    bind:this={audioInput}
+    class="sr-only"
+    type="file"
+    multiple
+    accept={audioExtensions.map((extension) => `.${extension}`).join(',')}
+    onchange={audioChanged}
+    oncancel={audioCancelled}
+/>
+<input
+    bind:this={sequenceInput}
+    class="sr-only"
+    type="file"
+    multiple
+    accept={midiExtensions.map((extension) => `.${extension}`).join(',')}
+    onchange={sequenceChanged}
+    oncancel={sequenceCancelled}
+/>
diff --git a/apps/axkdeck/src/features/file-operations/directComputerWorkflow.test.ts b/apps/axkdeck/src/features/file-operations/directComputerWorkflow.test.ts
new file mode 100644
index 00000000..daa918b7
--- /dev/null
+++ b/apps/axkdeck/src/features/file-operations/directComputerWorkflow.test.ts
@@ -0,0 +1,51 @@
+import { describe, expect, it, vi } from 'vitest';
+import { get } from 'svelte/store';
+
+import type { PackageImportWorkflow } from '../import/packageWorkflow.svelte';
+import type { DiskTreeItem } from '../../lib/types';
+import { directComputerDialogVisible, DirectComputerWorkflow } from './directComputerWorkflow';
+
+const target = { kind: 'volume', id: 'volume-1', name: 'Volume 1' } as DiskTreeItem;
+
+function packageImportWorkflow(): PackageImportWorkflow {
+    return {
+        open: vi.fn(),
+        chooseLocal: vi.fn(),
+    } as unknown as PackageImportWorkflow;
+}
+
+describe('DirectComputerWorkflow', () => {
+    it('opens the native package picker immediately for the managed local sidecar', () => {
+        const workflow = packageImportWorkflow();
+        const coordinator = new DirectComputerWorkflow(true, 'local');
+
+        coordinator.importPackage(workflow, target);
+
+        expect(workflow.open).toHaveBeenCalledWith(target);
+        expect(workflow.chooseLocal).toHaveBeenCalledWith(true);
+        expect(get(coordinator.pendingOperation)).toBe('package-import');
+        expect(directComputerDialogVisible(get(coordinator.pendingOperation), 'package-import', false)).toBe(false);
+    });
+
+    it('retains the destination chooser for a configured remote connection', () => {
+        const workflow = packageImportWorkflow();
+
+        new DirectComputerWorkflow(true, 'remote').importPackage(workflow, target);
+
+        expect(workflow.open).toHaveBeenCalledWith(target);
+        expect(workflow.chooseLocal).not.toHaveBeenCalled();
+    });
+
+    it('reveals package loading and validation after a native source is selected', () => {
+        const workflow = packageImportWorkflow();
+        const coordinator = new DirectComputerWorkflow(true, 'local');
+
+        coordinator.importPackage(workflow, target);
+
+        expect(directComputerDialogVisible(get(coordinator.pendingOperation), 'package-import', true)).toBe(true);
+    });
+
+    it('never suppresses dialogs for configured remote connections', () => {
+        expect(directComputerDialogVisible(null, 'package-import', false)).toBe(true);
+    });
+});
diff --git a/apps/axkdeck/src/features/file-operations/directComputerWorkflow.ts b/apps/axkdeck/src/features/file-operations/directComputerWorkflow.ts
new file mode 100644
index 00000000..efe02fdd
--- /dev/null
+++ b/apps/axkdeck/src/features/file-operations/directComputerWorkflow.ts
@@ -0,0 +1,194 @@
+import type { MediaExportWorkflow } from '../export/mediaWorkflow.svelte';
+import type { VolumeFloppyExportWorkflow } from '../export/volumeFloppyWorkflow.svelte';
+import type { VolumePackageExportWorkflow } from '../export/volumePackageWorkflow.svelte';
+import type { ExportWorkflow } from '../export/workflow.svelte';
+import type { AudioImportWorkflow } from '../import/audioWorkflow.svelte';
+import type { PackageBatchImportWorkflow } from '../import/packageBatchWorkflow.svelte';
+import type { PackageImportWorkflow } from '../import/packageWorkflow.svelte';
+import type { SequenceImportWorkflow } from '../import/sequenceWorkflow.svelte';
+import { shouldUseDirectComputerFileOperations } from '../../lib/fileOperationRouting';
+import type { ConnectionMode } from '../../lib/transport';
+import type { DiskTreeItem, PackageExportObject, PackageExportSelection } from '../../lib/types';
+import { writable } from 'svelte/store';
+
+export type DirectComputerOperation =
+    | 'package-import'
+    | 'package-batch-import'
+    | 'package-export'
+    | 'audio-export'
+    | 'sequence-export'
+    | 'volume-package-export'
+    | 'volume-floppy-export'
+    | 'media-export'
+    | 'audio-import'
+    | 'sequence-import';
+
+export function directComputerDialogVisible(
+    pendingOperation: DirectComputerOperation | null,
+    operation: DirectComputerOperation,
+    contentAvailable: boolean,
+): boolean {
+    return pendingOperation !== operation || contentAvailable;
+}
+
+export class DirectComputerWorkflow {
+    readonly enabled: boolean;
+    readonly pendingOperation = writable<DirectComputerOperation | null>(null);
+    private operationGeneration = 0;
+
+    constructor(isDesktop: boolean, connectionMode: ConnectionMode) {
+        this.enabled = shouldUseDirectComputerFileOperations(isDesktop, connectionMode);
+    }
+
+    private begin(operation: DirectComputerOperation): number {
+        const generation = ++this.operationGeneration;
+        this.pendingOperation.set(operation);
+        return generation;
+    }
+
+    private finish(generation?: number): void {
+        if (generation !== undefined && generation !== this.operationGeneration) return;
+        this.pendingOperation.set(null);
+    }
+
+    private async run(operation: DirectComputerOperation, action: () => void | Promise<void>): Promise<void> {
+        const generation = this.begin(operation);
+        try {
+            await action();
+        } finally {
+            this.finish(generation);
+        }
+    }
+
+    importPackage(workflow: PackageImportWorkflow, target: DiskTreeItem): void {
+        if (!this.enabled) {
+            workflow.open(target);
+            return;
+        }
+        void this.run('package-import', async () => {
+            workflow.open(target);
+            await workflow.chooseLocal(true);
+        });
+    }
+
+    importVolumePackages(workflow: PackageBatchImportWorkflow, target: DiskTreeItem): void {
+        if (!this.enabled) {
+            workflow.open(target);
+            return;
+        }
+        void this.run('package-batch-import', async () => {
+            workflow.open(target);
+            await workflow.chooseLocal(true);
+        });
+    }
+
+    exportPackage(workflow: ExportWorkflow, items: PackageExportSelection[]): void {
+        if (!this.enabled) {
+            workflow.requestPackage(items);
+            return;
+        }
+        void this.run('package-export', async () => {
+            workflow.requestPackage(items);
+            await workflow.packageToComputer(true);
+        });
+    }
+
+    async exportAudio(workflow: ExportWorkflow, items: PackageExportSelection[]): Promise<void> {
+        if (!this.enabled) {
+            await workflow.requestAudio(items);
+            return;
+        }
+        await this.run('audio-export', async () => {
+            await workflow.requestAudio(items);
+            if (workflow.audioRequest?.inspection) await workflow.audioToComputer(true);
+        });
+    }
+
+    exportMidi(workflow: ExportWorkflow, items: PackageExportObject[]): void {
+        if (!this.enabled) {
+            workflow.requestSequence(items);
+            return;
+        }
+        void this.run('sequence-export', async () => {
+            workflow.requestSequence(items);
+            await workflow.sequenceToComputer(true);
+        });
+    }
+
+    async exportVolumePackages(workflow: VolumePackageExportWorkflow, target: DiskTreeItem): Promise<void> {
+        if (!this.enabled) {
+            await workflow.open(target);
+            return;
+        }
+        await this.run('volume-package-export', async () => {
+            await workflow.open(target);
+            if (workflow.request?.inspection) await workflow.toComputer(true);
+        });
+    }
+
+    async exportVolumeFloppies(workflow: VolumeFloppyExportWorkflow, target: DiskTreeItem): Promise<void> {
+        if (!this.enabled) {
+            await workflow.open(target);
+            return;
+        }
+        await this.run('volume-floppy-export', async () => {
+            await workflow.open(target);
+            if (workflow.request?.inspection) await workflow.toComputer(true);
+        });
+    }
+
+    async exportMedia(workflow: MediaExportWorkflow, target: DiskTreeItem): Promise<void> {
+        if (!this.enabled) {
+            await workflow.open(target);
+            return;
+        }
+        await this.run('media-export', async () => {
+            await workflow.open(target);
+            if (workflow.request?.inspection?.canExport) await workflow.toComputer(true);
+        });
+    }
+
+    importAudio(workflow: AudioImportWorkflow, input?: HTMLInputElement): void {
+        const generation = this.enabled ? this.begin('audio-import') : undefined;
+        workflow.chooseFiles();
+        if (this.enabled && input && workflow.request) {
+            workflow.chooseLocal(input);
+        } else if (generation !== undefined) {
+            this.finish(generation);
+        }
+    }
+
+    importMidi(workflow: SequenceImportWorkflow, input?: HTMLInputElement): void {
+        const generation = this.enabled ? this.begin('sequence-import') : undefined;
+        workflow.chooseFiles();
+        if (this.enabled && input && workflow.request) {
+            workflow.chooseLocal(input);
+        } else if (generation !== undefined) {
+            this.finish(generation);
+        }
+    }
+
+    audioFilesChosen(workflow: AudioImportWorkflow, event: Event): void {
+        workflow.filesChosen(event);
+        this.finish();
+    }
+
+    midiFilesChosen(workflow: SequenceImportWorkflow, event: Event): void {
+        workflow.filesChosen(event);
+        this.finish();
+    }
+
+    cancelAudioSelection(workflow: AudioImportWorkflow): void {
+        if (this.enabled && workflow.request?.files.length === 0) {
+            workflow.request = null;
+        }
+        this.finish();
+    }
+
+    cancelMidiSelection(workflow: SequenceImportWorkflow): void {
+        if (this.enabled && workflow.request?.files.length === 0) {
+            workflow.request = null;
+        }
+        this.finish();
+    }
+}
diff --git a/apps/axkdeck/src/features/import/packageBatchWorkflow.svelte.ts b/apps/axkdeck/src/features/import/packageBatchWorkflow.svelte.ts
index e818c66a..84b5bd53 100644
--- a/apps/axkdeck/src/features/import/packageBatchWorkflow.svelte.ts
+++ b/apps/axkdeck/src/features/import/packageBatchWorkflow.svelte.ts
@@ -168,7 +168,7 @@ export class PackageBatchImportWorkflow {
         );
     }
 
-    async chooseLocal(): Promise<void> {
+    async chooseLocal(closeOnCancel = false): Promise<void> {
         if (!this.request || !this.dependencies.isDesktop) return;
         const staged: Array<{
             source: InputFileLocation;
@@ -178,7 +178,11 @@ export class PackageBatchImportWorkflow {
         }> = [];
         try {
             const paths = await selectLocalVolumePackages(this.dependencies.pickerHistory.lastImportedLocalPath);
-            if (!paths.length || !this.request) return;
+            if (!paths.length) {
+                if (closeOnCancel) await this.close();
+                return;
+            }
+            if (!this.request) return;
             if (paths.length > maximumBatchPackages) {
                 this.request = {
                     ...this.request,
diff --git a/apps/axkdeck/src/features/import/packageWorkflow.svelte.ts b/apps/axkdeck/src/features/import/packageWorkflow.svelte.ts
index da3bbac6..cbd72a84 100644
--- a/apps/axkdeck/src/features/import/packageWorkflow.svelte.ts
+++ b/apps/axkdeck/src/features/import/packageWorkflow.svelte.ts
@@ -345,13 +345,17 @@ export class PackageImportWorkflow {
         await this.inspect(selection, selection.displayName);
     }
 
-    async chooseLocal(): Promise<void> {
+    async chooseLocal(closeOnCancel = false): Promise<void> {
         if (!this.request || !this.dependencies.isDesktop) return;
         let controller: AbortController | null = null;
         let generation = -1;
         try {
             const path = await selectLocalPackage(this.pickerHistory.lastImportedLocalPath);
-            if (!path || !this.request) return;
+            if (!path) {
+                if (closeOnCancel) await this.close();
+                return;
+            }
+            if (!this.request) return;
             const file = await nativeFileSource(path, packageExtensionSet, 'application/octet-stream');
             controller = new AbortController();
             this.abortController?.abort();
diff --git a/apps/axkdeck/src/features/import/packageWorkflow.test.ts b/apps/axkdeck/src/features/import/packageWorkflow.test.ts
index 18fccc24..35fa6c5f 100644
--- a/apps/axkdeck/src/features/import/packageWorkflow.test.ts
+++ b/apps/axkdeck/src/features/import/packageWorkflow.test.ts
@@ -659,10 +659,11 @@ describe('PackageImportWorkflow', () => {
         await workflow.chooseLocal();
         await workflow.apply();
         workflow.open(target);
-        await workflow.chooseLocal();
+        await workflow.chooseLocal(true);
 
         expect(nativeMocks.selectLocalPackage).toHaveBeenNthCalledWith(1, null);
         expect(nativeMocks.selectLocalPackage).toHaveBeenNthCalledWith(2, localPath);
+        expect(workflow.request).toBeNull();
     });
 
     it('plans a dropped A3K archive into a new volume named from its archive root', async () => {
diff --git a/apps/axkdeck/src/features/workspace/WorkspaceShell.svelte b/apps/axkdeck/src/features/workspace/WorkspaceShell.svelte
index dfb31e89..05e0c4fe 100644
--- a/apps/axkdeck/src/features/workspace/WorkspaceShell.svelte
+++ b/apps/axkdeck/src/features/workspace/WorkspaceShell.svelte
@@ -58,6 +58,8 @@
         mutation: MutationWorkflow;
         audioImport: AudioImportWorkflow;
         sequenceImport: SequenceImportWorkflow;
+        importAudio: () => void;
+        importMidi: () => void;
         programs: Program[];
         sampleBanks: SampleStructureItem[];
         samples: SampleStructureItem[];
@@ -119,6 +121,8 @@
         mutation,
         audioImport,
         sequenceImport,
+        importAudio,
+        importMidi,
         programs,
         sampleBanks,
         samples,
@@ -409,7 +413,7 @@
                 onplaysample={(item) => void audition.playSample(item)}
                 onplaywavedata={(item) => void audition.playContainedWaveData(item)}
                 onstop={() => void audition.stop()}
-                onimportaudio={() => audioImport.chooseFiles()}
+                onimportaudio={importAudio}
                 playingSampleBankId={audition.playingSampleBankId}
                 playingObjectId={audition.state.status === 'playing' ? audition.state.objectId : null}
                 preparingObjectId={audition.state.status === 'preparing' ? audition.state.objectId : null}
@@ -451,7 +455,7 @@
                 {sequenceExportAvailable}
                 onexportmidi={exportMidi}
                 sequenceImportAvailable={mutation.objectRenameAvailable && sequenceImport.activeTarget() !== null}
-                onimportmidi={() => sequenceImport.chooseFiles()}
+                onimportmidi={importMidi}
                 selection={packageSelection}
                 onselectionchange={selectionChanged}
                 onselectionlimit={selectionLimit}
diff --git a/apps/axkdeck/src/lib/components/ExportDestinationChooser.svelte b/apps/axkdeck/src/lib/components/ExportDestinationChooser.svelte
index 6af50faa..603850c0 100644
--- a/apps/axkdeck/src/lib/components/ExportDestinationChooser.svelte
+++ b/apps/axkdeck/src/lib/components/ExportDestinationChooser.svelte
@@ -3,21 +3,21 @@
 
     interface Props {
         desktop: boolean;
-        busy: boolean;
+        disabled?: boolean;
         onworkspace: () => void;
         onlocal: () => void;
     }
 
-    let { desktop, busy, onworkspace, onlocal }: Props = $props();
+    let { desktop, disabled = false, onworkspace, onlocal }: Props = $props();
 </script>
 
 <div class="export-destination-choices">
-    <button class="source-choice-button" type="button" disabled={busy} onclick={onworkspace}>
+    <button class="source-choice-button" type="button" {disabled} onclick={onworkspace}>
         <Icon name="folder-open" size={18} />
         <span><strong>Storage location</strong><small>Save to a configured workspace</small></span>
     </button>
     {#if desktop}
-        <button class="source-choice-button" type="button" disabled={busy} onclick={onlocal}>
+        <button class="source-choice-button" type="button" {disabled} onclick={onlocal}>
             <Icon name="hard-drive" size={18} />
             <span><strong>This computer</strong><small>Save with the desktop file chooser</small></span>
         </button>
diff --git a/apps/axkdeck/src/lib/components/ExportProgressDialog.svelte b/apps/axkdeck/src/lib/components/ExportProgressDialog.svelte
new file mode 100644
index 00000000..5a210e8f
--- /dev/null
+++ b/apps/axkdeck/src/lib/components/ExportProgressDialog.svelte
@@ -0,0 +1,55 @@
+<script lang="ts">
+    import Icon from './Icon.svelte';
+    import { modal } from '../modal';
+
+    interface Props {
+        title: string;
+        progressLabel: string;
+        cancellable: boolean;
+        oncancel: () => void;
+    }
+
+    let { title, progressLabel, cancellable, oncancel }: Props = $props();
+</script>
+
+<div class="dialog-backdrop" role="presentation">
+    <div
+        class="dialog-shell export-progress-dialog"
+        role="dialog"
+        aria-modal="true"
+        aria-label={`${title} progress`}
+        aria-busy="true"
+        use:modal={{ onescape: cancellable ? oncancel : undefined }}
+    >
+        <header class="dialog-header">
+            <div>
+                <Icon name="save" size={16} />
+                <h2>{title}</h2>
+            </div>
+        </header>
+
+        <div class="export-progress-content">
+            <p class="dialog-progress" role="status">{progressLabel}</p>
+        </div>
+
+        {#if cancellable}
+            <footer class="dialog-footer">
+                <button class="secondary-button" type="button" onclick={oncancel}>Cancel export</button>
+            </footer>
+        {/if}
+    </div>
+</div>
+
+<style>
+    .export-progress-dialog {
+        width: min(460px, calc(100vw - 32px));
+    }
+
+    .export-progress-content {
+        padding: 20px;
+    }
+
+    .export-progress-content .dialog-progress {
+        margin: 0;
+    }
+</style>
diff --git a/apps/axkdeck/src/lib/components/ExportProgressDialog.test.ts b/apps/axkdeck/src/lib/components/ExportProgressDialog.test.ts
new file mode 100644
index 00000000..5999a547
--- /dev/null
+++ b/apps/axkdeck/src/lib/components/ExportProgressDialog.test.ts
@@ -0,0 +1,39 @@
+import { fireEvent, render, screen } from '@testing-library/svelte';
+import { describe, expect, it, vi } from 'vitest';
+
+import ExportProgressDialog from './ExportProgressDialog.svelte';
+
+describe('ExportProgressDialog', () => {
+    it('shows export progress without destination choices', () => {
+        render(ExportProgressDialog, {
+            props: {
+                title: 'Export package',
+                progressLabel: 'Building package',
+                cancellable: false,
+                oncancel: vi.fn(),
+            },
+        });
+
+        expect(screen.getByRole('dialog', { name: 'Export package progress' })).toBeTruthy();
+        expect(screen.getByRole('status').textContent).toContain('Building package');
+        expect(screen.queryByText('This computer')).toBeNull();
+        expect(screen.queryByText('Server location')).toBeNull();
+        expect(screen.queryByRole('button', { name: 'Cancel export' })).toBeNull();
+    });
+
+    it('offers cancellation only for cancellable exports', async () => {
+        const oncancel = vi.fn();
+        render(ExportProgressDialog, {
+            props: {
+                title: 'Export audio',
+                progressLabel: 'Writing WAV files',
+                cancellable: true,
+                oncancel,
+            },
+        });
+
+        await fireEvent.click(screen.getByRole('button', { name: 'Cancel export' }));
+
+        expect(oncancel).toHaveBeenCalledOnce();
+    });
+});
diff --git a/apps/axkdeck/src/lib/components/ImageTreeContextMenu.svelte b/apps/axkdeck/src/lib/components/ImageTreeContextMenu.svelte
index 16eb6ddd..86435cde 100644
--- a/apps/axkdeck/src/lib/components/ImageTreeContextMenu.svelte
+++ b/apps/axkdeck/src/lib/components/ImageTreeContextMenu.svelte
@@ -1,5 +1,5 @@
 <script lang="ts">
-    import { onDestroy, onMount } from 'svelte';
+    import { flushSync, onDestroy, onMount } from 'svelte';
     import type { DiskTreeItem, ImageTreeAction } from '../types';
     import Icon from './Icon.svelte';
 
@@ -46,6 +46,8 @@
     let rootTop = $state(0);
     let submenuLeft = $state(0);
     let submenuTop = $state(0);
+    let rootPositioned = $state(false);
+    let submenuPositioned = $state(false);
     let activeSubmenu = $state<Submenu | null>(null);
     const invoker =
         typeof document !== 'undefined' && document.activeElement instanceof HTMLElement
@@ -106,15 +108,18 @@
 
     function openSubmenu(kind: Submenu, focusFirst: boolean): void {
         activeSubmenu = kind;
-        queueMicrotask(() => {
-            positionSubmenu(submenuParent(kind));
-            if (focusFirst) focusItem(submenuMenu, 0);
-        });
+        submenuPositioned = false;
+        flushSync();
+        positionSubmenu(submenuParent(kind));
+        submenuPositioned = true;
+        flushSync();
+        if (focusFirst) focusItem(submenuMenu, 0);
     }
 
     function closeSubmenu(restoreParent: boolean): void {
         const parent = activeSubmenu ? submenuParent(activeSubmenu) : undefined;
         activeSubmenu = null;
+        submenuPositioned = false;
         if (restoreParent) queueMicrotask(() => parent?.focus());
     }
 
@@ -176,17 +181,25 @@
     }
 
     onMount(() => {
-        queueMicrotask(() => {
-            positionRoot();
-            focusItem(rootMenu, 0);
-        });
+        positionRoot();
+        rootPositioned = true;
+        flushSync();
+        focusItem(rootMenu, 0);
         const dismissFromOutsidePointer = (event: PointerEvent): void => {
             const path = event.composedPath();
             if ((rootMenu && path.includes(rootMenu)) || (submenuMenu && path.includes(submenuMenu))) return;
             onclose();
         };
+        const reposition = (): void => {
+            positionRoot();
+            if (activeSubmenu) positionSubmenu(submenuParent(activeSubmenu));
+        };
         window.addEventListener('pointerdown', dismissFromOutsidePointer, true);
-        return () => window.removeEventListener('pointerdown', dismissFromOutsidePointer, true);
+        window.addEventListener('resize', reposition);
+        return () => {
+            window.removeEventListener('pointerdown', dismissFromOutsidePointer, true);
+            window.removeEventListener('resize', reposition);
+        };
     });
 
     onDestroy(() => {
@@ -200,7 +213,7 @@
     role="menu"
     aria-label={`${item.name} actions`}
     tabindex="-1"
-    style={`left: ${rootLeft}px; top: ${rootTop}px;`}
+    style={`left: ${rootLeft}px; top: ${rootTop}px; visibility: ${rootPositioned ? 'visible' : 'hidden'}; pointer-events: ${rootPositioned ? 'auto' : 'none'};`}
     onclick={(event) => event.stopPropagation()}
     onkeydown={handleRootKey}
 >
@@ -308,7 +321,7 @@
         role="menu"
         aria-label={`${activeSubmenu === 'import' ? 'Import' : 'Export'} actions`}
         tabindex="-1"
-        style={`left: ${submenuLeft}px; top: ${submenuTop}px;`}
+        style={`left: ${submenuLeft}px; top: ${submenuTop}px; visibility: ${submenuPositioned ? 'visible' : 'hidden'}; pointer-events: ${submenuPositioned ? 'auto' : 'none'};`}
         onclick={(event) => event.stopPropagation()}
         onkeydown={handleSubmenuKey}
     >
diff --git a/apps/axkdeck/src/lib/components/ImageTreeContextMenu.test.ts b/apps/axkdeck/src/lib/components/ImageTreeContextMenu.test.ts
new file mode 100644
index 00000000..4bb25e77
--- /dev/null
+++ b/apps/axkdeck/src/lib/components/ImageTreeContextMenu.test.ts
@@ -0,0 +1,59 @@
+import { fireEvent, render, screen, waitFor } from '@testing-library/svelte';
+import { describe, expect, it, vi } from 'vitest';
+
+import type { DiskTreeItem } from '../types';
+import ImageTreeContextMenu from './ImageTreeContextMenu.svelte';
+
+const partition = {
+    id: 'partition-1',
+    kind: 'partition',
+    name: 'Partition 1',
+} as DiskTreeItem;
+
+const common = {
+    item: partition,
+    left: 240,
+    top: 180,
+    volumeActionsEnabled: true,
+    partitionActionsEnabled: true,
+    packageImportEnabled: true,
+    packageExportEnabled: true,
+    volumePackageExportEnabled: true,
+    volumeFloppyExportEnabled: true,
+    audioExportEnabled: true,
+    mediaConversionEnabled: true,
+    allocationInspectionEnabled: true,
+    onaction: vi.fn(),
+    onclose: vi.fn(),
+};
+
+describe('ImageTreeContextMenu', () => {
+    it('renders the root menu only at its viewport-clamped position', () => {
+        const { container } = render(ImageTreeContextMenu, { props: common });
+
+        const menu = container.querySelector<HTMLDivElement>('[aria-label="Partition 1 actions"]');
+        expect(menu).not.toBeNull();
+        if (!menu) throw new Error('root menu was not rendered');
+        expect(menu.style.visibility).toBe('visible');
+        expect(menu.style.pointerEvents).toBe('auto');
+        expect(menu.style.left).toBe('240px');
+        expect(menu.style.top).toBe('180px');
+    });
+
+    it('keeps a submenu hidden until it has been positioned beside its parent', async () => {
+        const { container } = render(ImageTreeContextMenu, { props: common });
+        const root = container.querySelector<HTMLDivElement>('[aria-label="Partition 1 actions"]');
+        expect(root).not.toBeNull();
+        if (!root) throw new Error('root menu was not rendered');
+        await waitFor(() => expect(root.style.visibility).toBe('visible'));
+
+        await fireEvent.mouseEnter(screen.getByRole('menuitem', { name: 'Import' }));
+
+        const submenu = container.querySelector<HTMLDivElement>('[aria-label="Import actions"]');
+        expect(submenu).not.toBeNull();
+        if (!submenu) throw new Error('submenu was not rendered');
+        await waitFor(() => expect(submenu.style.visibility).toBe('visible'));
+        expect(submenu.style.pointerEvents).toBe('auto');
+        expect(submenu.style.left).not.toBe('0px');
+    });
+});
diff --git a/apps/axkdeck/src/lib/components/MediaExportDialog.svelte b/apps/axkdeck/src/lib/components/MediaExportDialog.svelte
index e68e8844..838e250b 100644
--- a/apps/axkdeck/src/lib/components/MediaExportDialog.svelte
+++ b/apps/axkdeck/src/lib/components/MediaExportDialog.svelte
@@ -43,17 +43,15 @@
         role="dialog"
         aria-modal="true"
         aria-label={title}
-        aria-busy={request.loading || request.busy}
-        use:modal={{ onescape: request.busy ? undefined : oncancel }}
+        aria-busy={request.loading}
+        use:modal={{ onescape: oncancel }}
     >
         <header class="dialog-header">
             <div>
                 <Icon name="hard-drive" size={16} />
                 <h2>{title}</h2>
             </div>
-            <button class="icon-button" type="button" aria-label="Close" disabled={request.busy} onclick={oncancel}
-                >×</button
-            >
+            <button class="icon-button" type="button" aria-label="Close" onclick={oncancel}>×</button>
         </header>
 
         <div class="package-dialog-content">
@@ -90,22 +88,17 @@
                     {/each}
                     <ExportDestinationChooser
                         {desktop}
-                        busy={request.busy || !request.inspection.canExport}
+                        disabled={!request.inspection.canExport}
                         {onworkspace}
                         {onlocal}
                     />
                 {/if}
-                {#if request.busy}
-                    <p class="dialog-progress" role="status">{request.progressLabel || 'Exporting sampler media…'}</p>
-                {/if}
                 {#if request.error}<p class="dialog-error" role="alert">{request.error}</p>{/if}
             </section>
         </div>
 
         <footer class="dialog-footer">
-            <button class="secondary-button" type="button" onclick={oncancel}
-                >{request.busy ? 'Cancel export' : 'Cancel'}</button
-            >
+            <button class="secondary-button" type="button" onclick={oncancel}>Cancel</button>
         </footer>
     </div>
 </div>
diff --git a/apps/axkdeck/src/lib/components/MidiExportDialog.svelte b/apps/axkdeck/src/lib/components/MidiExportDialog.svelte
index a44a9b7b..2d101eaa 100644
--- a/apps/axkdeck/src/lib/components/MidiExportDialog.svelte
+++ b/apps/axkdeck/src/lib/components/MidiExportDialog.svelte
@@ -7,15 +7,13 @@
     interface Props {
         items: PackageExportSelection[];
         desktop: boolean;
-        busy: boolean;
-        progressLabel: string;
         error: string;
         onworkspace: () => void;
         onlocal: () => void;
         oncancel: () => void;
     }
 
-    let { items, desktop, busy, progressLabel, error, onworkspace, onlocal, oncancel }: Props = $props();
+    let { items, desktop, error, onworkspace, onlocal, oncancel }: Props = $props();
     const singleItem = $derived(items.length === 1 ? items[0] : undefined);
 </script>
 
@@ -25,15 +23,14 @@
         role="dialog"
         aria-modal="true"
         aria-label="Export MIDI"
-        aria-busy={busy}
-        use:modal={{ onescape: busy ? undefined : oncancel }}
+        use:modal={{ onescape: oncancel }}
     >
         <header class="dialog-header">
             <div>
                 <Icon name="music" size={16} />
                 <h2>Export MIDI</h2>
             </div>
-            <button class="icon-button" type="button" aria-label="Close" disabled={busy} onclick={oncancel}>×</button>
+            <button class="icon-button" type="button" aria-label="Close" onclick={oncancel}>×</button>
         </header>
 
         <div class="package-dialog-content">
@@ -44,16 +41,13 @@
                         ? 'The selected Sequence will be saved as a standard MIDI file.'
                         : 'Each selected Sequence will be saved as a standard MIDI file in one folder.'}
                 </p>
-                <ExportDestinationChooser {desktop} {busy} {onworkspace} {onlocal} />
-                {#if busy}<p class="dialog-progress" role="status">{progressLabel || 'Exporting MIDI…'}</p>{/if}
+                <ExportDestinationChooser {desktop} {onworkspace} {onlocal} />
                 {#if error}<p class="dialog-error" role="alert">{error}</p>{/if}
             </section>
         </div>
 
         <footer class="dialog-footer">
-            <button class="secondary-button" type="button" onclick={oncancel}
-                >{busy ? 'Cancel export' : 'Cancel'}</button
-            >
+            <button class="secondary-button" type="button" onclick={oncancel}>Cancel</button>
         </footer>
     </div>
 </div>
diff --git a/apps/axkdeck/src/lib/components/MidiExportDialog.test.ts b/apps/axkdeck/src/lib/components/MidiExportDialog.test.ts
index f8fa0a41..904bb5cc 100644
--- a/apps/axkdeck/src/lib/components/MidiExportDialog.test.ts
+++ b/apps/axkdeck/src/lib/components/MidiExportDialog.test.ts
@@ -20,8 +20,6 @@ describe('MidiExportDialog', () => {
                     },
                 ],
                 desktop: true,
-                busy: false,
-                progressLabel: '',
                 error: '',
                 onworkspace,
                 onlocal,
@@ -37,7 +35,7 @@ describe('MidiExportDialog', () => {
         expect(onlocal).toHaveBeenCalledOnce();
     });
 
-    it('summarizes a multi-Sequence export and permits cancellation while busy', async () => {
+    it('summarizes a multi-Sequence export and permits closing the destination chooser', async () => {
         const oncancel = vi.fn();
         render(MidiExportDialog, {
             props: {
@@ -62,8 +60,6 @@ describe('MidiExportDialog', () => {
                     },
                 ],
                 desktop: false,
-                busy: true,
-                progressLabel: 'Writing MIDI files',
                 error: '',
                 onworkspace: vi.fn(),
                 onlocal: vi.fn(),
@@ -72,9 +68,8 @@ describe('MidiExportDialog', () => {
         });
 
         expect(screen.getByText('Export 2 Sequences')).toBeTruthy();
-        expect(screen.getByRole('status').textContent).toContain('Writing MIDI files');
         expect(screen.queryByRole('button', { name: /This computer/ })).toBeNull();
-        await fireEvent.click(screen.getByRole('button', { name: 'Cancel export' }));
+        await fireEvent.click(screen.getByRole('button', { name: 'Cancel' }));
         expect(oncancel).toHaveBeenCalledOnce();
     });
 });
diff --git a/apps/axkdeck/src/lib/components/PackageExportDialog.svelte b/apps/axkdeck/src/lib/components/PackageExportDialog.svelte
index a1962105..aa2740c7 100644
--- a/apps/axkdeck/src/lib/components/PackageExportDialog.svelte
+++ b/apps/axkdeck/src/lib/components/PackageExportDialog.svelte
@@ -7,15 +7,13 @@
     interface Props {
         items: PackageExportSelection[];
         desktop: boolean;
-        busy: boolean;
-        progressLabel: string;
         error: string;
         onworkspace: () => void;
         onlocal: () => void;
         oncancel: () => void;
     }
 
-    let { items, desktop, busy, progressLabel, error, onworkspace, onlocal, oncancel }: Props = $props();
+    let { items, desktop, error, onworkspace, onlocal, oncancel }: Props = $props();
     const singleItem = $derived(items.length === 1 ? items[0] : undefined);
     const typeSummary = $derived.by(() => {
         const labels = ['Program', 'Sequence', 'Sample Bank', 'Sample', 'Wave Data'] as const;
@@ -52,15 +50,14 @@
         role="dialog"
         aria-modal="true"
         aria-label="Export axklib package"
-        aria-busy={busy}
-        use:modal={{ onescape: busy ? undefined : oncancel }}
+        use:modal={{ onescape: oncancel }}
     >
         <header class="dialog-header">
             <div>
                 <Icon name="archive" size={16} />
                 <h2>Export package</h2>
             </div>
-            <button class="icon-button" type="button" aria-label="Close" disabled={busy} onclick={oncancel}>×</button>
+            <button class="icon-button" type="button" aria-label="Close" onclick={oncancel}>×</button>
         </header>
 
         <div class="package-dialog-content">
@@ -84,14 +81,13 @@
                         {/each}
                     </div>
                 {/if}
-                <ExportDestinationChooser {desktop} {busy} {onworkspace} {onlocal} />
-                {#if busy}<p class="dialog-progress" role="status">{progressLabel || 'Exporting package…'}</p>{/if}
+                <ExportDestinationChooser {desktop} {onworkspace} {onlocal} />
                 {#if error}<p class="dialog-error" role="alert">{error}</p>{/if}
             </section>
         </div>
 
         <footer class="dialog-footer">
-            <button class="secondary-button" type="button" disabled={busy} onclick={oncancel}>Cancel</button>
+            <button class="secondary-button" type="button" onclick={oncancel}>Cancel</button>
         </footer>
     </div>
 </div>
diff --git a/apps/axkdeck/src/lib/components/PackageExportDialog.test.ts b/apps/axkdeck/src/lib/components/PackageExportDialog.test.ts
index c40202de..0d2ec9c1 100644
--- a/apps/axkdeck/src/lib/components/PackageExportDialog.test.ts
+++ b/apps/axkdeck/src/lib/components/PackageExportDialog.test.ts
@@ -19,8 +19,6 @@ describe('PackageExportDialog', () => {
                     },
                 ],
                 desktop: true,
-                busy: false,
-                progressLabel: '',
                 error: '',
                 onworkspace,
                 onlocal,
@@ -35,7 +33,7 @@ describe('PackageExportDialog', () => {
         expect(onlocal).toHaveBeenCalledOnce();
     });
 
-    it('hides local save in browser mode and disables actions while exporting', () => {
+    it('hides local save in browser mode', () => {
         render(PackageExportDialog, {
             props: {
                 items: [
@@ -50,8 +48,6 @@ describe('PackageExportDialog', () => {
                     },
                 ],
                 desktop: false,
-                busy: true,
-                progressLabel: 'Writing package',
                 error: '',
                 onworkspace: vi.fn(),
                 onlocal: vi.fn(),
@@ -60,9 +56,8 @@ describe('PackageExportDialog', () => {
         });
 
         expect(screen.queryByRole('button', { name: /This computer/ })).toBeNull();
-        expect((screen.getByRole('button', { name: /Storage location/ }) as HTMLButtonElement).disabled).toBe(true);
-        expect((screen.getByRole('button', { name: 'Cancel' }) as HTMLButtonElement).disabled).toBe(true);
-        expect(screen.getByRole('status').textContent).toContain('Writing package');
+        expect((screen.getByRole('button', { name: /Storage location/ }) as HTMLButtonElement).disabled).toBe(false);
+        expect((screen.getByRole('button', { name: 'Cancel' }) as HTMLButtonElement).disabled).toBe(false);
     });
 
     it('summarizes every root in a multi-object package', () => {
@@ -89,8 +84,6 @@ describe('PackageExportDialog', () => {
                     },
                 ],
                 desktop: false,
-                busy: false,
-                progressLabel: '',
                 error: '',
                 onworkspace: vi.fn(),
                 onlocal: vi.fn(),
@@ -130,8 +123,6 @@ describe('PackageExportDialog', () => {
                     },
                 ],
                 desktop: false,
-                busy: false,
-                progressLabel: '',
                 error: '',
                 onworkspace: vi.fn(),
                 onlocal: vi.fn(),
@@ -168,8 +159,6 @@ describe('PackageExportDialog', () => {
                     },
                 ],
                 desktop: false,
-                busy: false,
-                progressLabel: '',
                 error: '',
                 onworkspace: vi.fn(),
                 onlocal: vi.fn(),
@@ -198,8 +187,6 @@ describe('PackageExportDialog', () => {
                     },
                 ],
                 desktop: false,
-                busy: false,
-                progressLabel: '',
                 error,
                 onworkspace: vi.fn(),
                 onlocal: vi.fn(),
diff --git a/apps/axkdeck/src/lib/components/ServerStoragePicker.test.ts b/apps/axkdeck/src/lib/components/ServerStoragePicker.test.ts
index b658374d..94212948 100644
--- a/apps/axkdeck/src/lib/components/ServerStoragePicker.test.ts
+++ b/apps/axkdeck/src/lib/components/ServerStoragePicker.test.ts
@@ -14,6 +14,8 @@ const appStyles = readFileSync(resolve(process.cwd(), 'src/app.css'), 'utf8');
 function transport(withRoots = true): ImageTransport {
     return {
         storageMode: 'server',
+        connectionMode: 'remote',
+        supportsClientUploads: false,
         sandboxRoots: vi.fn().mockResolvedValue(
             withRoots
                 ? [
diff --git a/apps/axkdeck/src/lib/components/SfzExportDialog.svelte b/apps/axkdeck/src/lib/components/SfzExportDialog.svelte
index f76cb84b..000a33c9 100644
--- a/apps/axkdeck/src/lib/components/SfzExportDialog.svelte
+++ b/apps/axkdeck/src/lib/components/SfzExportDialog.svelte
@@ -10,8 +10,6 @@
         inspection: ImageSessionAudioExportInspection | null;
         desktop: boolean;
         loading: boolean;
-        busy: boolean;
-        progressLabel: string;
         error: string;
         format: 'SFZ' | 'WAV';
         onformatchange: (format: 'SFZ' | 'WAV') => void;
@@ -26,20 +24,8 @@
         fatal: boolean;
     }
 
-    let {
-        items,
-        inspection,
-        desktop,
-        loading,
-        busy,
-        progressLabel,
-        error,
-        format,
-        onformatchange,
-        onworkspace,
-        onlocal,
-        oncancel,
-    }: Props = $props();
+    let { items, inspection, desktop, loading, error, format, onformatchange, onworkspace, onlocal, oncancel }: Props =
+        $props();
 
     const singleItem = $derived(items.length === 1 ? items[0] : undefined);
     const counts = $derived.by(() => {
@@ -93,15 +79,15 @@
         role="dialog"
         aria-modal="true"
         aria-label="Export SFZ"
-        aria-busy={loading || busy}
-        use:modal={{ onescape: busy ? undefined : oncancel }}
+        aria-busy={loading}
+        use:modal={{ onescape: oncancel }}
     >
         <header class="dialog-header">
             <div>
                 <Icon name="music" size={16} />
                 <h2>Export SFZ</h2>
             </div>
-            <button class="icon-button" type="button" aria-label="Close" disabled={busy} onclick={oncancel}>×</button>
+            <button class="icon-button" type="button" aria-label="Close" onclick={oncancel}>×</button>
         </header>
 
         <div class="package-dialog-content">
@@ -117,14 +103,13 @@
                         <button
                             class:active={format === 'SFZ'}
                             type="button"
-                            disabled={busy || !inspection.sfzEligible}
+                            disabled={!inspection.sfzEligible}
                             aria-pressed={format === 'SFZ'}
                             onclick={() => onformatchange('SFZ')}>SFZ + WAV</button
                         >
                         <button
                             class:active={format === 'WAV'}
                             type="button"
-                            disabled={busy}
                             aria-pressed={format === 'WAV'}
                             onclick={() => onformatchange('WAV')}>WAV files</button
                         >
@@ -144,17 +129,14 @@
                     {#each displayIssues as issue (issue.key)}
                         <p class:dialog-error={issue.fatal} class="audio-export-issue">{issue.message}</p>
                     {/each}
-                    <ExportDestinationChooser {desktop} {busy} {onworkspace} {onlocal} />
+                    <ExportDestinationChooser {desktop} {onworkspace} {onlocal} />
                 {/if}
-                {#if busy}<p class="dialog-progress" role="status">{progressLabel || 'Exporting audio…'}</p>{/if}
                 {#if error}<p class="dialog-error" role="alert">{error}</p>{/if}
             </section>
         </div>
 
         <footer class="dialog-footer">
-            <button class="secondary-button" type="button" onclick={oncancel}
-                >{busy ? 'Cancel export' : 'Cancel'}</button
-            >
+            <button class="secondary-button" type="button" onclick={oncancel}>Cancel</button>
         </footer>
     </div>
 </div>
diff --git a/apps/axkdeck/src/lib/components/SfzExportDialog.test.ts b/apps/axkdeck/src/lib/components/SfzExportDialog.test.ts
index 3e3246d9..2c8a6eef 100644
--- a/apps/axkdeck/src/lib/components/SfzExportDialog.test.ts
+++ b/apps/axkdeck/src/lib/components/SfzExportDialog.test.ts
@@ -34,8 +34,6 @@ describe('SfzExportDialog', () => {
                 },
                 desktop: true,
                 loading: false,
-                busy: false,
-                progressLabel: '',
                 error: '',
                 format: 'SFZ',
                 onformatchange: vi.fn(),
@@ -79,8 +77,6 @@ describe('SfzExportDialog', () => {
                 },
                 desktop: false,
                 loading: false,
-                busy: false,
-                progressLabel: '',
                 error: '',
                 format: 'WAV',
                 onformatchange,
@@ -136,8 +132,6 @@ describe('SfzExportDialog', () => {
                 },
                 desktop: true,
                 loading: false,
-                busy: false,
-                progressLabel: '',
                 error: '',
                 format: 'SFZ',
                 onformatchange: vi.fn(),
diff --git a/apps/axkdeck/src/lib/components/VolumeFloppyExportDialog.svelte b/apps/axkdeck/src/lib/components/VolumeFloppyExportDialog.svelte
index 4db660c4..b84e9444 100644
--- a/apps/axkdeck/src/lib/components/VolumeFloppyExportDialog.svelte
+++ b/apps/axkdeck/src/lib/components/VolumeFloppyExportDialog.svelte
@@ -9,17 +9,14 @@
         inspection: ImageSessionVolumeFloppyExportInspection | null;
         desktop: boolean;
         loading: boolean;
-        busy: boolean;
-        progressLabel: string;
         error: string;
         onworkspace: () => void;
         onlocal: () => void;
         oncancel: () => void;
     }
 
-    let { scopeName, inspection, desktop, loading, busy, progressLabel, error, onworkspace, onlocal, oncancel }: Props =
-        $props();
-    const unavailable = $derived(loading || busy || !inspection || inspection.exportableCount === 0);
+    let { scopeName, inspection, desktop, loading, error, onworkspace, onlocal, oncancel }: Props = $props();
+    const unavailable = $derived(loading || !inspection || inspection.exportableCount === 0);
 
     function outcome(volume: NonNullable<typeof inspection>['volumes'][number]): string {
         if (volume.state === 'EMPTY') return 'Empty';
@@ -34,15 +31,15 @@
         role="dialog"
         aria-modal="true"
         aria-label="Export volumes to floppies"
-        aria-busy={loading || busy}
-        use:modal={{ onescape: busy ? undefined : oncancel }}
+        aria-busy={loading}
+        use:modal={{ onescape: oncancel }}
     >
         <header class="dialog-header">
             <div>
                 <Icon name="disc" size={16} />
                 <h2>Export volumes to floppies</h2>
             </div>
-            <button class="icon-button" type="button" aria-label="Close" disabled={busy} onclick={oncancel}>×</button>
+            <button class="icon-button" type="button" aria-label="Close" onclick={oncancel}>×</button>
         </header>
 
         <div class="package-dialog-content">
@@ -74,10 +71,9 @@
                     </div>
                 {/if}
                 {#if !unavailable}
-                    <ExportDestinationChooser {desktop} {busy} {onworkspace} {onlocal} />
+                    <ExportDestinationChooser {desktop} {onworkspace} {onlocal} />
                 {/if}
                 {#if loading}<p class="dialog-progress" role="status">Inspecting volumes…</p>{/if}
-                {#if busy}<p class="dialog-progress" role="status">{progressLabel || 'Exporting floppy sets…'}</p>{/if}
                 {#if inspection?.exportableCount === 0}
                     <p class="dialog-error" role="alert">The selected partition has no exportable volumes.</p>
                 {/if}
@@ -86,9 +82,7 @@
         </div>
 
         <footer class="dialog-footer">
-            <button class="secondary-button" type="button" onclick={oncancel}
-                >{busy ? 'Cancel export' : 'Cancel'}</button
-            >
+            <button class="secondary-button" type="button" onclick={oncancel}>Cancel</button>
         </footer>
     </div>
 </div>
diff --git a/apps/axkdeck/src/lib/components/VolumeFloppyExportDialog.test.ts b/apps/axkdeck/src/lib/components/VolumeFloppyExportDialog.test.ts
index 54e1c787..fc97ab53 100644
--- a/apps/axkdeck/src/lib/components/VolumeFloppyExportDialog.test.ts
+++ b/apps/axkdeck/src/lib/components/VolumeFloppyExportDialog.test.ts
@@ -78,8 +78,6 @@ describe('VolumeFloppyExportDialog', () => {
                 inspection,
                 desktop: true,
                 loading: false,
-                busy: false,
-                progressLabel: '',
                 error: '',
                 onworkspace,
                 onlocal,
@@ -106,8 +104,6 @@ describe('VolumeFloppyExportDialog', () => {
                 inspection: { ...inspection, exportableCount: 0, totalFloppyImageCount: 0 },
                 desktop: true,
                 loading: false,
-                busy: false,
-                progressLabel: '',
                 error: '',
                 onworkspace: vi.fn(),
                 onlocal: vi.fn(),
diff --git a/apps/axkdeck/src/lib/components/VolumePackageExportDialog.svelte b/apps/axkdeck/src/lib/components/VolumePackageExportDialog.svelte
index ecf1abba..0df47b08 100644
--- a/apps/axkdeck/src/lib/components/VolumePackageExportDialog.svelte
+++ b/apps/axkdeck/src/lib/components/VolumePackageExportDialog.svelte
@@ -9,17 +9,14 @@
         inspection: ImageSessionVolumePackageExportInspection | null;
         desktop: boolean;
         loading: boolean;
-        busy: boolean;
-        progressLabel: string;
         error: string;
         onworkspace: () => void;
         onlocal: () => void;
         oncancel: () => void;
     }
 
-    let { scopeName, inspection, desktop, loading, busy, progressLabel, error, onworkspace, onlocal, oncancel }: Props =
-        $props();
-    const unavailable = $derived(loading || busy || !inspection || inspection.exportableCount === 0);
+    let { scopeName, inspection, desktop, loading, error, onworkspace, onlocal, oncancel }: Props = $props();
+    const unavailable = $derived(loading || !inspection || inspection.exportableCount === 0);
 </script>
 
 <div class="dialog-backdrop" role="presentation">
@@ -28,15 +25,15 @@
         role="dialog"
         aria-modal="true"
         aria-label="Export volume packages"
-        aria-busy={loading || busy}
-        use:modal={{ onescape: busy ? undefined : oncancel }}
+        aria-busy={loading}
+        use:modal={{ onescape: oncancel }}
     >
         <header class="dialog-header">
             <div>
                 <Icon name="archive" size={16} />
                 <h2>Export volume packages</h2>
             </div>
-            <button class="icon-button" type="button" aria-label="Close" disabled={busy} onclick={oncancel}>×</button>
+            <button class="icon-button" type="button" aria-label="Close" onclick={oncancel}>×</button>
         </header>
 
         <div class="package-dialog-content">
@@ -60,10 +57,9 @@
                     </div>
                 {/if}
                 {#if !unavailable}
-                    <ExportDestinationChooser {desktop} {busy} {onworkspace} {onlocal} />
+                    <ExportDestinationChooser {desktop} {onworkspace} {onlocal} />
                 {/if}
                 {#if loading}<p class="dialog-progress" role="status">Inspecting volumes…</p>{/if}
-                {#if busy}<p class="dialog-progress" role="status">{progressLabel || 'Exporting packages…'}</p>{/if}
                 {#if inspection?.exportableCount === 0}
                     <p class="dialog-error" role="alert">The selected scope has no non-empty volumes.</p>
                 {/if}
@@ -72,9 +68,7 @@
         </div>
 
         <footer class="dialog-footer">
-            <button class="secondary-button" type="button" onclick={oncancel}
-                >{busy ? 'Cancel export' : 'Cancel'}</button
-            >
+            <button class="secondary-button" type="button" onclick={oncancel}>Cancel</button>
         </footer>
     </div>
 </div>
diff --git a/apps/axkdeck/src/lib/components/VolumePackageExportDialog.test.ts b/apps/axkdeck/src/lib/components/VolumePackageExportDialog.test.ts
index f6059abf..37b71b6b 100644
--- a/apps/axkdeck/src/lib/components/VolumePackageExportDialog.test.ts
+++ b/apps/axkdeck/src/lib/components/VolumePackageExportDialog.test.ts
@@ -46,8 +46,6 @@ describe('VolumePackageExportDialog', () => {
                 inspection,
                 desktop: true,
                 loading: false,
-                busy: false,
-                progressLabel: '',
                 error: '',
                 onworkspace,
                 onlocal,
@@ -71,8 +69,6 @@ describe('VolumePackageExportDialog', () => {
                 inspection: { ...inspection, exportableCount: 0, emptyCount: 2 },
                 desktop: true,
                 loading: false,
-                busy: false,
-                progressLabel: '',
                 error: '',
                 onworkspace: vi.fn(),
                 onlocal: vi.fn(),
diff --git a/apps/axkdeck/src/lib/createTransport.test.ts b/apps/axkdeck/src/lib/createTransport.test.ts
index a5da43ec..afaef73a 100644
--- a/apps/axkdeck/src/lib/createTransport.test.ts
+++ b/apps/axkdeck/src/lib/createTransport.test.ts
@@ -16,6 +16,19 @@ describe('createTransport', () => {
         const transport = createTransport();
 
         expect(transport.storageMode).toBe('unavailable');
+        expect(transport.connectionMode).toBe('unavailable');
         await expect(transport.sandboxRoots()).rejects.toThrow('axklib-server');
     });
+
+    it.each(['local', 'remote'] as const)('preserves the explicit %s connection mode', (mode) => {
+        window.__AXKLIB_SERVER__ = {
+            baseUrl: 'http://127.0.0.1:42101',
+            bearerToken: 'token',
+            mode,
+        };
+
+        const transport = createTransport();
+
+        expect(transport.connectionMode).toBe(mode);
+    });
 });
diff --git a/apps/axkdeck/src/lib/createTransport.ts b/apps/axkdeck/src/lib/createTransport.ts
index dec17159..5db0105d 100644
--- a/apps/axkdeck/src/lib/createTransport.ts
+++ b/apps/axkdeck/src/lib/createTransport.ts
@@ -35,6 +35,7 @@ import type { DirectoryListing, DirectoryRef, FileRef, SandboxRoot } from './sto
 
 class UnavailableTransport implements ImageTransport {
     readonly storageMode = 'unavailable' as const;
+    readonly connectionMode = 'unavailable' as const;
     readonly supportsClientUploads = false;
     private unavailable<T>(): Promise<T> {
         return Promise.reject(new Error('axklib-server is unavailable; configure or restart the server connection'));
diff --git a/apps/axkdeck/src/lib/fileOperationRouting.test.ts b/apps/axkdeck/src/lib/fileOperationRouting.test.ts
new file mode 100644
index 00000000..0a21bfc4
--- /dev/null
+++ b/apps/axkdeck/src/lib/fileOperationRouting.test.ts
@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest';
+
+import { shouldUseDirectComputerFileOperations } from './fileOperationRouting';
+
+describe('shouldUseDirectComputerFileOperations', () => {
+    it('uses native file dialogs for the managed local desktop sidecar', () => {
+        expect(shouldUseDirectComputerFileOperations(true, 'local')).toBe(true);
+    });
+
+    it('retains the storage chooser for configured remote connections', () => {
+        expect(shouldUseDirectComputerFileOperations(true, 'remote')).toBe(false);
+    });
+
+    it('does not infer locality from a configured loopback URL', () => {
+        expect(shouldUseDirectComputerFileOperations(true, 'remote')).toBe(false);
+    });
+
+    it('does not use native file dialogs outside the desktop shell', () => {
+        expect(shouldUseDirectComputerFileOperations(false, 'local')).toBe(false);
+    });
+});
diff --git a/apps/axkdeck/src/lib/fileOperationRouting.ts b/apps/axkdeck/src/lib/fileOperationRouting.ts
new file mode 100644
index 00000000..1a084cc7
--- /dev/null
+++ b/apps/axkdeck/src/lib/fileOperationRouting.ts
@@ -0,0 +1,5 @@
+import type { ConnectionMode } from './transport';
+
+export function shouldUseDirectComputerFileOperations(isDesktop: boolean, connectionMode: ConnectionMode): boolean {
+    return isDesktop && connectionMode === 'local';
+}
diff --git a/apps/axkdeck/src/lib/httpTransport.test.ts b/apps/axkdeck/src/lib/httpTransport.test.ts
index 40c39a14..20717600 100644
--- a/apps/axkdeck/src/lib/httpTransport.test.ts
+++ b/apps/axkdeck/src/lib/httpTransport.test.ts
@@ -114,7 +114,11 @@ describe('HttpImageTransport', () => {
             }),
         );
 
-        const transport = new HttpImageTransport({ baseUrl: 'http://localhost/api/v1', bearerToken: 'secret' });
+        const transport = new HttpImageTransport({
+            baseUrl: 'http://localhost/api/v1',
+            bearerToken: 'secret',
+            mode: 'remote',
+        });
 
         await expect(transport.audioImportCapabilities()).resolves.toEqual({
             supportedSampleRates: [44_100],
@@ -252,6 +256,7 @@ describe('HttpImageTransport', () => {
         const transport = new HttpImageTransport({
             baseUrl: 'http://127.0.0.1:4000/api/v1',
             bearerToken: 'secret',
+            mode: 'remote',
         });
         const opened = await transport.openImage(serverFile('images/test.hds'));
         expect(opened).toMatchObject({ sessionId: 1, objectTotalCount: 0, initialVolume: { id: 'volume-1' } });
@@ -331,7 +336,11 @@ describe('HttpImageTransport', () => {
             }),
         );
 
-        const transport = new HttpImageTransport({ baseUrl: 'http://localhost/api/v1', bearerToken: 'secret' });
+        const transport = new HttpImageTransport({
+            baseUrl: 'http://localhost/api/v1',
+            bearerToken: 'secret',
+            mode: 'remote',
+        });
         const opened = await transport.openImage(
             axkObjectDirectoryLocation({ rootId: 'workspace', relativePath: 'unpacked/volume' }),
         );
@@ -402,7 +411,11 @@ describe('HttpImageTransport', () => {
             }),
         );
 
-        const transport = new HttpImageTransport({ baseUrl: 'http://localhost/api/v1', bearerToken: 'secret' });
+        const transport = new HttpImageTransport({
+            baseUrl: 'http://localhost/api/v1',
+            bearerToken: 'secret',
+            mode: 'remote',
+        });
         const opened = await transport.openImage(
             axkObjectDirectoryLocation({ rootId: 'workspace', relativePath: 'set/DISK2' }),
         );
@@ -476,6 +489,7 @@ describe('HttpImageTransport', () => {
         const transport = new HttpImageTransport({
             baseUrl: 'http://127.0.0.1:4000/api/v1',
             bearerToken: 'secret',
+            mode: 'remote',
         });
 
         const audio = await transport.readAuditionContent('audition-1', 10);
@@ -526,6 +540,7 @@ describe('HttpImageTransport', () => {
         const transport = new HttpImageTransport({
             baseUrl: 'http://127.0.0.1:4000/api/v1',
             bearerToken: 'secret',
+            mode: 'remote',
         });
         const result = await transport.downloadFile(serverFile('exports/tone.wav'));
 
@@ -562,6 +577,7 @@ describe('HttpImageTransport', () => {
         const transport = new HttpImageTransport({
             baseUrl: 'http://127.0.0.1:4000/api/v1',
             bearerToken: 'secret',
+            mode: 'remote',
         });
 
         await expect(transport.readAuditionContent('audition-1', 4)).rejects.toThrow('returned 3 bytes; expected 4');
@@ -600,6 +616,7 @@ describe('HttpImageTransport', () => {
         const transport = new HttpImageTransport({
             baseUrl: 'http://127.0.0.1:4000/api/v1',
             bearerToken: 'secret',
+            mode: 'remote',
         });
         const request = transport.readAuditionContent('audition-1', 4, controller.signal);
         await requestStarted;
@@ -722,6 +739,7 @@ describe('HttpImageTransport', () => {
         const transport = new HttpImageTransport({
             baseUrl: 'http://localhost/api/v1',
             bearerToken: 'secret',
+            mode: 'remote',
         });
         const manifest = serverFile('authoring/build.json');
         const output = serverFile('images/new.hds');
@@ -870,7 +888,11 @@ describe('HttpImageTransport', () => {
             }),
         );
 
-        const transport = new HttpImageTransport({ baseUrl: 'http://localhost/api/v1', bearerToken: 'secret' });
+        const transport = new HttpImageTransport({
+            baseUrl: 'http://localhost/api/v1',
+            bearerToken: 'secret',
+            mode: 'remote',
+        });
         const profiles = await transport.hardDiskCreationProfiles();
         expect(profiles[0]).toMatchObject({ profileId: 'CD_R_700', defaultPartitionCount: 1 });
         const plan = await transport.planHardDiskCreation('CD_R_700', 1, serverFile('images/new.hds'));
@@ -978,6 +1000,7 @@ describe('HttpImageTransport', () => {
         const transport = new HttpImageTransport({
             baseUrl: 'http://localhost/api/v1',
             bearerToken: 'secret',
+            mode: 'remote',
         });
         const source = serverFile('images/base.hds');
         const opened = await transport.openImage(source);
@@ -1324,7 +1347,11 @@ describe('HttpImageTransport', () => {
             }),
         );
 
-        const transport = new HttpImageTransport({ baseUrl: 'http://localhost/api/v1', bearerToken: 'secret' });
+        const transport = new HttpImageTransport({
+            baseUrl: 'http://localhost/api/v1',
+            bearerToken: 'secret',
+            mode: 'remote',
+        });
         const opened = await transport.openImage(serverFile('images/base.hds'));
         const deletion = await transport.inspectVolumeDeletion(opened.sessionId, 0, 'Samples');
         expect(deletion).toMatchObject({ canDelete: false, crossingRelationshipCount: 1 });
@@ -1475,6 +1502,7 @@ describe('HttpImageTransport', () => {
         const transport = new HttpImageTransport({
             baseUrl: 'http://localhost/api/v1',
             bearerToken: 'secret',
+            mode: 'remote',
         });
         const opened = await transport.openImage(serverFile('images/base.hds'));
         expect(opened.objectDeletionAvailable).toBe(true);
@@ -1574,6 +1602,7 @@ describe('HttpImageTransport', () => {
         const transport = new HttpImageTransport({
             baseUrl: 'http://localhost/api/v1',
             bearerToken: 'secret',
+            mode: 'remote',
         });
         const opened = await transport.openImage(serverFile('images/base.hds'));
         expect(opened.waveDataCleanupAvailable).toBe(true);
@@ -1692,6 +1721,7 @@ describe('HttpImageTransport', () => {
         const transport = new HttpImageTransport({
             baseUrl: 'http://localhost/api/v1',
             bearerToken: 'secret',
+            mode: 'remote',
         });
         const opened = await transport.openImage(serverFile('images/base.hds'));
         expect(opened.programGenerationAvailable).toBe(true);
@@ -1785,6 +1815,7 @@ describe('HttpImageTransport', () => {
         const transport = new HttpImageTransport({
             baseUrl: 'http://localhost/api/v1',
             bearerToken: 'secret',
+            mode: 'remote',
         });
         const mono = clientUploadLocation({ uploadId: 'upload-mono' }, 'AUDIO', 'mono.wav');
         const stereo = serverFile('audio/stereo.flac');
@@ -2000,6 +2031,7 @@ describe('HttpImageTransport', () => {
         const transport = new HttpImageTransport({
             baseUrl: 'http://localhost/api/v1',
             bearerToken: 'secret',
+            mode: 'remote',
         });
         const uploaded = clientUploadLocation({ uploadId: 'upload-midi' }, 'MIDI', 'Intro.mid');
         const workspace = serverFile('midi/Ending.midi');
@@ -2057,7 +2089,11 @@ describe('HttpImageTransport', () => {
     });
 
     it('rejects desktop paths instead of relabeling them as sandbox paths', async () => {
-        const transport = new HttpImageTransport({ baseUrl: 'http://localhost/api/v1', bearerToken: 'secret' });
+        const transport = new HttpImageTransport({
+            baseUrl: 'http://localhost/api/v1',
+            bearerToken: 'secret',
+            mode: 'remote',
+        });
         const desktopPath = { kind: 'native-file', path: 'C:\\Users\\example\\disk.hds' } as unknown as FileLocation;
         await expect(transport.openImage(desktopPath)).rejects.toThrow('server sandbox file selection');
     });
@@ -2107,7 +2143,11 @@ describe('HttpImageTransport', () => {
             }),
         );
 
-        const transport = new HttpImageTransport({ baseUrl: 'http://localhost/api/v1', bearerToken: 'secret' });
+        const transport = new HttpImageTransport({
+            baseUrl: 'http://localhost/api/v1',
+            bearerToken: 'secret',
+            mode: 'remote',
+        });
         const manifest = clientUploadLocation({ uploadId: 'upload-manifest' }, 'MANIFEST', 'build.json');
         const audio = clientUploadLocation({ uploadId: 'upload-audio' }, 'AUDIO', 'tone.wav');
         await expect(
@@ -2212,7 +2252,11 @@ describe('HttpImageTransport', () => {
             }),
         );
 
-        const transport = new HttpImageTransport({ baseUrl: 'http://localhost/api/v1', bearerToken: 'secret' });
+        const transport = new HttpImageTransport({
+            baseUrl: 'http://localhost/api/v1',
+            bearerToken: 'secret',
+            mode: 'remote',
+        });
         const file = await transport.downloadFile(serverFile('exports/tone.wav'));
         expect(file.filename).toBe('tone.wav');
         expect(await file.blob.text()).toBe('wave-bytes');
@@ -2344,7 +2388,11 @@ describe('HttpImageTransport', () => {
             }),
         );
 
-        const transport = new HttpImageTransport({ baseUrl: 'http://localhost/api/v1', bearerToken: 'secret' });
+        const transport = new HttpImageTransport({
+            baseUrl: 'http://localhost/api/v1',
+            bearerToken: 'secret',
+            mode: 'remote',
+        });
         const uploaded = clientUploadLocation({ uploadId: 'upload-package' }, 'PACKAGE', 'volume.axkvol');
         await expect(transport.inspectPackage(uploaded, true)).resolves.toMatchObject({
             packageId: 'package-one',
@@ -2657,7 +2705,11 @@ describe('HttpImageTransport', () => {
             }),
         );
 
-        const transport = new HttpImageTransport({ baseUrl: 'http://localhost/api/v1', bearerToken: 'secret' });
+        const transport = new HttpImageTransport({
+            baseUrl: 'http://localhost/api/v1',
+            bearerToken: 'secret',
+            mode: 'remote',
+        });
         const opened = await transport.openImage(serverFile('images/base.hds'));
         expect(opened).toMatchObject({
             packageImportAvailable: true,
@@ -2965,6 +3017,7 @@ describe('HttpImageTransport', () => {
         const transport = new HttpImageTransport({
             baseUrl: 'https://sampler.example.test/api/v1',
             bearerToken: 'remote-secret',
+            mode: 'remote',
         });
         const opened = await transport.openImage(serverFile('images/base.hds'));
         const audio = clientUploadLocation({ uploadId: 'audio-upload' }, 'AUDIO', 'tone.wav');
@@ -3090,7 +3143,11 @@ describe('HttpImageTransport', () => {
             }),
         );
 
-        const transport = new HttpImageTransport({ baseUrl: 'http://localhost/api/v1', bearerToken: 'secret' });
+        const transport = new HttpImageTransport({
+            baseUrl: 'http://localhost/api/v1',
+            bearerToken: 'secret',
+            mode: 'remote',
+        });
         const manifest = serverFile('authoring/build.json');
         const output = serverFile('images/new.hds');
         await transport.planCreate(manifest, output, false);
@@ -3190,7 +3247,11 @@ describe('HttpImageTransport', () => {
             }),
         );
 
-        const transport = new HttpImageTransport({ baseUrl: 'http://localhost/api/v1', bearerToken: 'secret' });
+        const transport = new HttpImageTransport({
+            baseUrl: 'http://localhost/api/v1',
+            bearerToken: 'secret',
+            mode: 'remote',
+        });
         const manifest = serverFile('authoring/build.json');
         const output = serverFile('images/new.hds');
         await transport.planCreate(manifest, output, false);
diff --git a/apps/axkdeck/src/lib/httpTransport.ts b/apps/axkdeck/src/lib/httpTransport.ts
index ad698e56..cf3c44d9 100644
--- a/apps/axkdeck/src/lib/httpTransport.ts
+++ b/apps/axkdeck/src/lib/httpTransport.ts
@@ -60,6 +60,7 @@ import type {
     Tx16wImportMode,
     VolumeMutation,
     VolumeDeletionInspection,
+    ConnectionMode,
 } from './transport';
 import {
     clientUploadLocation,
@@ -92,9 +93,10 @@ import {
     serverInputBindings,
     volumeMutationOperation,
 } from './httpTransportWire';
-type HttpImageTransportConnection = AxklibApiConnection;
+type HttpImageTransportConnection = AxklibApiConnection & { mode: Exclude<ConnectionMode, 'unavailable'> };
 export class HttpImageTransport extends HttpImageSessionReads implements ImageTransport {
     readonly storageMode = 'server' as const;
+    readonly connectionMode: Exclude<ConnectionMode, 'unavailable'>;
     readonly supportsClientUploads = true;
     private readonly client: AxklibHttpApiClient;
     private readonly jobs: HttpJobController;
@@ -111,6 +113,7 @@ export class HttpImageTransport extends HttpImageSessionReads implements ImageTr
         this.jobs = jobs;
         this.imports = new HttpImportOperations(this.client, this.jobs, this.imageSessions);
         this.packages = new HttpPackageOperations(this.client, this.jobs, this.imageSessions);
+        this.connectionMode = connection.mode;
     }
     sandboxRoots(): Promise<SandboxRoot[]> {
         return this.client.roots();
diff --git a/apps/axkdeck/src/lib/testing/inMemoryTransport.ts b/apps/axkdeck/src/lib/testing/inMemoryTransport.ts
index 3af127bb..092f1ef7 100644
--- a/apps/axkdeck/src/lib/testing/inMemoryTransport.ts
+++ b/apps/axkdeck/src/lib/testing/inMemoryTransport.ts
@@ -80,6 +80,7 @@ import type { ClientUploadSource } from '../clientUploadSource';
 
 export interface InMemoryImageTransportOptions {
     storageMode?: ImageTransport['storageMode'];
+    connectionMode?: ImageTransport['connectionMode'];
     supportsClientUploads?: boolean;
     opened: Omit<
         OpenedImage,
@@ -129,12 +130,14 @@ export interface InMemoryImageTransportOptions {
 
 export class InMemoryImageTransport implements ImageTransport {
     readonly storageMode: ImageTransport['storageMode'];
+    readonly connectionMode: ImageTransport['connectionMode'];
     readonly supportsClientUploads: boolean;
     readonly calls: string[] = [];
     private nextSessionId = 1;
 
     constructor(private readonly options: InMemoryImageTransportOptions) {
         this.storageMode = options.storageMode ?? 'server';
+        this.connectionMode = options.connectionMode ?? 'remote';
         this.supportsClientUploads = options.supportsClientUploads ?? false;
     }
 
diff --git a/apps/axkdeck/src/lib/transport.ts b/apps/axkdeck/src/lib/transport.ts
index 9f743cd9..bd2db196 100644
--- a/apps/axkdeck/src/lib/transport.ts
+++ b/apps/axkdeck/src/lib/transport.ts
@@ -462,8 +462,11 @@ export interface SequenceImportTarget {
     volumeName: string;
 }
 
+export type ConnectionMode = 'local' | 'remote' | 'unavailable';
+
 export interface ImageTransport {
     readonly storageMode: 'server' | 'unavailable';
+    readonly connectionMode: ConnectionMode;
     readonly supportsClientUploads: boolean;
     sandboxRoots(): Promise<SandboxRoot[]>;
     sandboxDirectory(directory: DirectoryRef, cursor?: string): Promise<DirectoryListing>;
diff --git a/apps/axkdeck/src/lib/transportConformance.test.ts b/apps/axkdeck/src/lib/transportConformance.test.ts
index ab50a39b..a427a4c5 100644
--- a/apps/axkdeck/src/lib/transportConformance.test.ts
+++ b/apps/axkdeck/src/lib/transportConformance.test.ts
@@ -303,7 +303,7 @@ describe('ImageTransport shared read contract', () => {
             }),
         );
         await exerciseReadContract(
-            new HttpImageTransport({ baseUrl: 'http://127.0.0.1:7300/api/v1', bearerToken: 'secret' }),
+            new HttpImageTransport({ baseUrl: 'http://127.0.0.1:7300/api/v1', bearerToken: 'secret', mode: 'remote' }),
             serverFileLocation({ rootId: 'workspace', relativePath: 'images/fixture.hds' }),
         );
     });

From f4f71273f7be04e101a958cef1357a67fbe4f2b5 Mon Sep 17 00:00:00 2001
From: bzeiss <ben@zeiss.net>
Date: Thu, 20 Aug 2026 23:50:23 +0200
Subject: [PATCH 11/12] add self-report about webview version

---
 apps/axkdeck/src-tauri/Cargo.lock             |  1 +
 apps/axkdeck/src-tauri/Cargo.toml             |  1 +
 apps/axkdeck/src-tauri/src/lib.rs             | 13 ++++-
 apps/axkdeck/src-tauri/src/webview_runtime.rs | 57 +++++++++++++++++++
 apps/axkdeck/src/App.test.ts                  |  2 +
 .../src/lib/components/AboutDialog.svelte     |  7 +++
 .../src/lib/components/AboutDialog.test.ts    | 28 +++++++++
 apps/axkdeck/src/lib/desktopBuildInfo.ts      |  2 +
 8 files changed, 109 insertions(+), 2 deletions(-)
 create mode 100644 apps/axkdeck/src-tauri/src/webview_runtime.rs

diff --git a/apps/axkdeck/src-tauri/Cargo.lock b/apps/axkdeck/src-tauri/Cargo.lock
index 53965a38..8d640afe 100644
--- a/apps/axkdeck/src-tauri/Cargo.lock
+++ b/apps/axkdeck/src-tauri/Cargo.lock
@@ -245,6 +245,7 @@ dependencies = [
  "tauri-plugin-fs",
  "tauri-plugin-log",
  "url",
+ "webview2-com",
  "windows-sys 0.61.2",
 ]
 
diff --git a/apps/axkdeck/src-tauri/Cargo.toml b/apps/axkdeck/src-tauri/Cargo.toml
index 98773648..a31ac138 100644
--- a/apps/axkdeck/src-tauri/Cargo.toml
+++ b/apps/axkdeck/src-tauri/Cargo.toml
@@ -34,6 +34,7 @@ url = "2.5.7"
 rustix = { version = "1", features = ["fs", "process"] }
 
 [target.'cfg(windows)'.dependencies]
+webview2-com = "0.38.2"
 windows-sys = { version = "0.61", features = [
     "Win32_Foundation",
     "Win32_Security",
diff --git a/apps/axkdeck/src-tauri/src/lib.rs b/apps/axkdeck/src-tauri/src/lib.rs
index 5f80007e..a509ba5a 100644
--- a/apps/axkdeck/src-tauri/src/lib.rs
+++ b/apps/axkdeck/src-tauri/src/lib.rs
@@ -8,6 +8,7 @@ mod remote_settings;
 mod retained_download;
 mod server_sidecar;
 mod startup_diagnostics;
+mod webview_runtime;
 
 use std::sync::Mutex;
 
@@ -42,6 +43,8 @@ struct DesktopBuildInfo {
     source_identity: &'static str,
     release_tag: &'static str,
     is_release: bool,
+    webview_engine: &'static str,
+    webview_version: Option<String>,
 }
 
 fn current_build_info() -> DesktopBuildInfo {
@@ -52,6 +55,8 @@ fn current_build_info() -> DesktopBuildInfo {
         source_identity: env!("AXKDECK_SOURCE_IDENTITY"),
         release_tag: env!("AXKDECK_RELEASE_TAG"),
         is_release: env!("AXKDECK_IS_RELEASE") == "true",
+        webview_engine: webview_runtime::ENGINE,
+        webview_version: None,
     }
 }
 
@@ -124,6 +129,8 @@ mod tests {
         assert!(!build.project_version.is_empty());
         assert!(!build.source_identity.is_empty());
         assert_eq!(build.is_release, !build.release_tag.is_empty());
+        assert!(!build.webview_engine.is_empty());
+        assert!(build.webview_version.is_none());
     }
 
     #[test]
@@ -318,8 +325,10 @@ fn diagnostic_log_level() -> &'static str {
 }
 
 #[tauri::command]
-fn desktop_build_info() -> DesktopBuildInfo {
-    current_build_info()
+async fn desktop_build_info(window: WebviewWindow) -> DesktopBuildInfo {
+    let mut build = current_build_info();
+    build.webview_version = webview_runtime::version(&window).await;
+    build
 }
 
 #[tauri::command]
diff --git a/apps/axkdeck/src-tauri/src/webview_runtime.rs b/apps/axkdeck/src-tauri/src/webview_runtime.rs
new file mode 100644
index 00000000..55093e96
--- /dev/null
+++ b/apps/axkdeck/src-tauri/src/webview_runtime.rs
@@ -0,0 +1,57 @@
+use tauri::WebviewWindow;
+
+#[cfg(windows)]
+pub const ENGINE: &str = "Microsoft Edge WebView2";
+
+#[cfg(target_os = "macos")]
+pub const ENGINE: &str = "Apple WebKit";
+
+#[cfg(not(any(windows, target_os = "macos")))]
+pub const ENGINE: &str = "WebKitGTK";
+
+#[cfg(windows)]
+pub async fn version(window: &WebviewWindow) -> Option<String> {
+    let (sender, mut receiver) = tauri::async_runtime::channel(1);
+    if let Err(error) = window.with_webview(move |webview| {
+        let environment = webview.environment();
+        let mut raw_version = Default::default();
+        let result = unsafe { environment.BrowserVersionString(&mut raw_version) }
+            .map(|()| webview2_com::take_pwstr(raw_version))
+            .map_err(|error| error.to_string());
+        let _ = sender.try_send(result);
+    }) {
+        log::warn!("query active WebView2 environment: {error}");
+        return None;
+    }
+
+    match receiver.recv().await {
+        Some(Ok(version)) if !version.trim().is_empty() => Some(version),
+        Some(Ok(_)) => {
+            log::warn!("active WebView2 environment returned an empty version");
+            None
+        }
+        Some(Err(error)) => {
+            log::warn!("query active WebView2 version: {error}");
+            None
+        }
+        None => {
+            log::warn!("active WebView2 version query did not return a result");
+            None
+        }
+    }
+}
+
+#[cfg(not(windows))]
+pub async fn version(_window: &WebviewWindow) -> Option<String> {
+    match tauri::webview_version() {
+        Ok(version) if !version.trim().is_empty() => Some(version),
+        Ok(_) => {
+            log::warn!("active web view engine returned an empty version");
+            None
+        }
+        Err(error) => {
+            log::warn!("query active web view version: {error}");
+            None
+        }
+    }
+}
diff --git a/apps/axkdeck/src/App.test.ts b/apps/axkdeck/src/App.test.ts
index e58a380a..0db30d70 100644
--- a/apps/axkdeck/src/App.test.ts
+++ b/apps/axkdeck/src/App.test.ts
@@ -210,6 +210,8 @@ describe('App panel layout', () => {
             sourceIdentity: 'v0.4.0-1234567',
             releaseTag: 'v0.4.0',
             isRelease: true,
+            webviewEngine: 'WebKitGTK',
+            webviewVersion: '2.50.4',
         });
     });
 
diff --git a/apps/axkdeck/src/lib/components/AboutDialog.svelte b/apps/axkdeck/src/lib/components/AboutDialog.svelte
index 82478b70..0361d159 100644
--- a/apps/axkdeck/src/lib/components/AboutDialog.svelte
+++ b/apps/axkdeck/src/lib/components/AboutDialog.svelte
@@ -46,6 +46,13 @@
                         <dt>Build</dt>
                         <dd>{state.buildInfo.sourceIdentity}</dd>
                     </div>
+                    <div>
+                        <dt>Web view</dt>
+                        <dd>
+                            {state.buildInfo.webviewEngine}
+                            {state.buildInfo.webviewVersion ?? 'unavailable'}
+                        </dd>
+                    </div>
                 </dl>
             {/if}
         </div>
diff --git a/apps/axkdeck/src/lib/components/AboutDialog.test.ts b/apps/axkdeck/src/lib/components/AboutDialog.test.ts
index ce71c125..d2ce29a0 100644
--- a/apps/axkdeck/src/lib/components/AboutDialog.test.ts
+++ b/apps/axkdeck/src/lib/components/AboutDialog.test.ts
@@ -30,6 +30,8 @@ describe('AboutDialog', () => {
                         sourceIdentity: 'v0.4.0-1234567-mod',
                         releaseTag: '',
                         isRelease: false,
+                        webviewEngine: 'Microsoft Edge WebView2',
+                        webviewVersion: '120.0.2210.144',
                     },
                 },
                 onclose,
@@ -39,11 +41,37 @@ describe('AboutDialog', () => {
         const dialog = screen.getByRole('dialog', { name: 'About axkdeck' });
         expect(within(dialog).getByText('0.4.0')).toBeTruthy();
         expect(within(dialog).getByText('v0.4.0-1234567-mod')).toBeTruthy();
+        expect(within(dialog).getByText('Microsoft Edge WebView2 120.0.2210.144')).toBeTruthy();
 
         await fireEvent.keyDown(dialog, { key: 'Escape' });
         expect(onclose).toHaveBeenCalledOnce();
     });
 
+    it('keeps build information available when webview introspection fails', () => {
+        render(AboutDialog, {
+            props: {
+                state: {
+                    status: 'ready',
+                    buildInfo: {
+                        schemaVersion: 1,
+                        semanticVersion: '0.4.0',
+                        projectVersion: '0.4.0',
+                        sourceIdentity: 'v0.4.0-1234567-mod',
+                        releaseTag: '',
+                        isRelease: false,
+                        webviewEngine: 'WebKitGTK',
+                        webviewVersion: null,
+                    },
+                },
+                onclose: vi.fn(),
+            },
+        });
+
+        const dialog = screen.getByRole('dialog', { name: 'About axkdeck' });
+        expect(within(dialog).getByText('WebKitGTK unavailable')).toBeTruthy();
+        expect(within(dialog).getByText('v0.4.0-1234567-mod')).toBeTruthy();
+    });
+
     it('shows a stable fallback when build information cannot be loaded', () => {
         render(AboutDialog, {
             props: {
diff --git a/apps/axkdeck/src/lib/desktopBuildInfo.ts b/apps/axkdeck/src/lib/desktopBuildInfo.ts
index 4ac91332..690aca16 100644
--- a/apps/axkdeck/src/lib/desktopBuildInfo.ts
+++ b/apps/axkdeck/src/lib/desktopBuildInfo.ts
@@ -7,6 +7,8 @@ export interface DesktopBuildInfo {
     sourceIdentity: string;
     releaseTag: string;
     isRelease: boolean;
+    webviewEngine: string;
+    webviewVersion: string | null;
 }
 
 export type DesktopBuildInfoState =

From 78acdf89787fac7a11fbec98060a2ca3ae755fb0 Mon Sep 17 00:00:00 2001
From: bzeiss <ben@zeiss.net>
Date: Fri, 21 Aug 2026 18:18:25 +0200
Subject: [PATCH 12/12] batch import of packages + a3k

---
 .../src/session_package_import_plan.cpp       |  12 +-
 .../tests/package_operations_test.cpp         |  39 ++
 apps/axkdeck/src-tauri/src/lib.rs             |   4 +-
 apps/axkdeck/src-tauri/src/local_packages.rs  |  23 +-
 apps/axkdeck/src/App.svelte                   |   4 +-
 apps/axkdeck/src/App.test.ts                  |   6 +-
 .../src/features/dialogs/AppDialogs.svelte    |  22 +-
 .../import/mediaDropWorkflow.svelte.ts        |  22 +-
 .../features/import/packageBatchPlanning.ts   | 192 +++++++
 .../features/import/packageBatchSources.ts    |  78 +++
 .../src/features/import/packageBatchTypes.ts  |  59 ++
 .../import/packageBatchWorkflow.svelte.ts     | 543 ++++++++++++------
 .../import/packageBatchWorkflow.test.ts       | 133 ++++-
 .../PackageBatchConflictControls.svelte       | 247 ++++++++
 .../PackageBatchDestinationChooser.svelte     | 163 ++++++
 .../PackageBatchImportDialog.svelte           | 445 +++++---------
 .../PackageBatchImportDialog.test.ts          |  74 ++-
 .../components/PackageBatchItemsTable.svelte  | 306 ++++++++++
 apps/axkdeck/src/lib/generated/axklibApiV1.ts |   2 +-
 apps/axkdeck/src/lib/nativePackages.test.ts   |  12 +-
 apps/axkdeck/src/lib/nativePackages.ts        |   4 +-
 apps/server/contracts/openapi-v1.base.json    |   2 +-
 apps/server/contracts/openapi-v1.json         |   2 +-
 23 files changed, 1849 insertions(+), 545 deletions(-)
 create mode 100644 apps/axkdeck/src/features/import/packageBatchPlanning.ts
 create mode 100644 apps/axkdeck/src/features/import/packageBatchSources.ts
 create mode 100644 apps/axkdeck/src/features/import/packageBatchTypes.ts
 create mode 100644 apps/axkdeck/src/lib/components/PackageBatchConflictControls.svelte
 create mode 100644 apps/axkdeck/src/lib/components/PackageBatchDestinationChooser.svelte
 create mode 100644 apps/axkdeck/src/lib/components/PackageBatchItemsTable.svelte

diff --git a/apps/application/src/session_package_import_plan.cpp b/apps/application/src/session_package_import_plan.cpp
index 4395591a..74e513e4 100644
--- a/apps/application/src/session_package_import_plan.cpp
+++ b/apps/application/src/session_package_import_plan.cpp
@@ -108,9 +108,6 @@ prepare_session_import(const Json &input, std::span<const axk::PortablePackage>
                 }
             }
         } else if (kind == "CREATE_VOLUME") {
-            if (packages.size() != 1U)
-                return std::unexpected(
-                    operation_error("invalid_request", "CREATE_VOLUME requires exactly one import source"));
             const auto volume_name = destination.at("volumeName").get<std::string>();
             if (!valid_volume_name(volume_name))
                 return std::unexpected(operation_error("invalid_request", "destination volume name is invalid"));
@@ -120,9 +117,12 @@ prepare_session_import(const Json &input, std::span<const axk::PortablePackage>
                 return std::unexpected(
                     operation_error("package_destination_conflict", "destination volume name already exists"));
             }
-            result.destination_volume_names.assign(1U, volume_name);
-            for (std::size_t root_index = 0U; root_index < packages.front().roots.size(); ++root_index) {
-                result.request.root_destinations.push_back({0U, root_index, *partition, {}, volume_name, {}, {}, true});
+            result.destination_volume_names.assign(packages.size(), volume_name);
+            for (std::size_t package_index = 0U; package_index < packages.size(); ++package_index) {
+                for (std::size_t root_index = 0U; root_index < packages[package_index].roots.size(); ++root_index) {
+                    result.request.root_destinations.push_back(
+                        {package_index, root_index, *partition, {}, volume_name, {}, {}, true});
+                }
             }
         } else if (kind == "CREATE_VOLUMES_FROM_HINTS") {
             std::map<std::size_t, std::string> overrides;
diff --git a/apps/application/tests/package_operations_test.cpp b/apps/application/tests/package_operations_test.cpp
index 7c9a81ef..1c992017 100644
--- a/apps/application/tests/package_operations_test.cpp
+++ b/apps/application/tests/package_operations_test.cpp
@@ -597,6 +597,45 @@ TEST_F(PackageOperationsTest, SessionBatchImportCreatesUniquelyNamedVolumesAtomi
     EXPECT_FALSE(volume_content_id(*refreshed, "Percussion").empty());
 }
 
+TEST_F(PackageOperationsTest, SessionBatchImportCreatesOneSharedVolumeFromMultiplePackages) {
+    for (const auto filename : {"shared-one.axkvol", "shared-two.axkvol"}) {
+        const auto exported =
+            registry_.invoke("package.export",
+                             {{"source", {{"rootId", "workspace"}, {"relativePath", "mixed-roots.hds"}}},
+                              {"output", {{"rootId", "workspace"}, {"relativePath", filename}}},
+                              {"roots", {{{"kind", "volume"}, {"partitionIndex", 0U}, {"volumeName", "Mixed"}}}}},
+                             context());
+        ASSERT_TRUE(exported) << exported.error().message;
+    }
+
+    const auto target = images_->open({"workspace", "target.hds"}, "owner");
+    ASSERT_TRUE(target) << target.error().message;
+    const auto request = nlohmann::json{
+        {"imageId", target->image_id},
+        {"expectedRevision", target->revision},
+        {"packages",
+         {{{"fileRef", {{"rootId", "workspace"}, {"relativePath", "shared-one.axkvol"}}}},
+          {{"fileRef", {{"rootId", "workspace"}, {"relativePath", "shared-two.axkvol"}}}}}},
+        {"destination", {{"kind", "CREATE_VOLUME"}, {"partitionIndex", 0U}, {"volumeName", "Shared"}}},
+        {"renames", nlohmann::json::array()},
+        {"programSlotAssignments", nlohmann::json::array()},
+        {"opaqueSequenceDecisions", nlohmann::json::array()},
+    };
+    const auto planned = registry_.invoke("images.package_import.plan", request, context());
+    ASSERT_TRUE(planned) << planned.error().message;
+    ASSERT_TRUE(planned->at("valid").get<bool>());
+    ASSERT_EQ(planned->at("packages").size(), 2U);
+    EXPECT_EQ(planned->at("packages").at(0).at("destinationVolumeName"), "Shared");
+    EXPECT_EQ(planned->at("packages").at(1).at("destinationVolumeName"), "Shared");
+
+    const auto applied = registry_.invoke("images.package_import",
+                                          {{"planToken", planned->at("planToken").get<std::string>()}}, context());
+    ASSERT_TRUE(applied) << applied.error().message;
+    const auto refreshed = images_->inspect(target->image_id, "owner");
+    ASSERT_TRUE(refreshed) << refreshed.error().message;
+    EXPECT_FALSE(volume_content_id(*refreshed, "Shared").empty());
+}
+
 TEST_F(PackageOperationsTest, SessionExportsExactSingleAndMultiRootPackagesToWorkspaceOrRetainedDownload) {
     const auto opened = images_->open({"workspace", "fixture.hds"}, "owner");
     ASSERT_TRUE(opened) << opened.error().message;
diff --git a/apps/axkdeck/src-tauri/src/lib.rs b/apps/axkdeck/src-tauri/src/lib.rs
index a509ba5a..f4c330ef 100644
--- a/apps/axkdeck/src-tauri/src/lib.rs
+++ b/apps/axkdeck/src-tauri/src/lib.rs
@@ -26,7 +26,7 @@ use local_directory_exports::{
 use local_packages::{
     PackageSaveCandidateStore, save_retained_media, save_retained_package,
     select_local_media_destination, select_local_package, select_local_package_destination,
-    select_local_volume_packages,
+    select_local_packages,
 };
 use local_workspaces::{WorkspaceCandidateStore, commit_local_workspace, select_local_workspace};
 use startup_diagnostics::{StartupDiagnostics, StartupMilestone, complete_startup};
@@ -490,7 +490,7 @@ pub fn run() {
             select_local_workspace,
             commit_local_workspace,
             select_local_package,
-            select_local_volume_packages,
+            select_local_packages,
             select_local_package_destination,
             save_retained_package,
             select_local_media_destination,
diff --git a/apps/axkdeck/src-tauri/src/local_packages.rs b/apps/axkdeck/src-tauri/src/local_packages.rs
index 39e005d1..c0517943 100644
--- a/apps/axkdeck/src-tauri/src/local_packages.rs
+++ b/apps/axkdeck/src-tauri/src/local_packages.rs
@@ -157,7 +157,7 @@ pub(crate) async fn select_local_package(
 }
 
 #[tauri::command]
-pub(crate) async fn select_local_volume_packages(
+pub(crate) async fn select_local_packages(
     app: AppHandle,
     window: WebviewWindow,
     preferred_path: Option<String>,
@@ -168,8 +168,11 @@ pub(crate) async fn select_local_volume_packages(
         let mut dialog = app
             .dialog()
             .file()
-            .set_title("Choose volume packages")
-            .add_filter("axklib volume packages", &["axkvol"])
+            .set_title("Choose axklib packages")
+            .add_filter(
+                "axklib packages and A3K archives",
+                &SUPPORTED_PACKAGE_EXTENSIONS,
+            )
             .set_parent(&window);
         if let Some(directory) = starting_directory {
             dialog = dialog.set_directory(directory);
@@ -177,7 +180,7 @@ pub(crate) async fn select_local_volume_packages(
         dialog.blocking_pick_files()
     })
     .await
-    .map_err(|error| format!("open volume package file picker: {error}"))?;
+    .map_err(|error| format!("open package file picker: {error}"))?;
     selected
         .unwrap_or_default()
         .into_iter()
@@ -188,12 +191,16 @@ pub(crate) async fn select_local_volume_packages(
                 .canonicalize()
                 .map_err(|error| format!("resolve selected package: {error}"))?;
             if !path.is_file()
-                || !path
-                    .extension()
+                || path
+                    .file_name()
                     .and_then(|value| value.to_str())
-                    .is_some_and(|extension| extension.eq_ignore_ascii_case("axkvol"))
+                    .and_then(supported_package_extension)
+                    .is_none()
             {
-                return Err("every selected package must be a regular .axkvol file".to_owned());
+                return Err(
+                    "every selected file must be a supported axklib package or A3K archive"
+                        .to_owned(),
+                );
             }
             scope_window
                 .fs_scope()
diff --git a/apps/axkdeck/src/App.svelte b/apps/axkdeck/src/App.svelte
index cd7c00bb..8bd9db0e 100644
--- a/apps/axkdeck/src/App.svelte
+++ b/apps/axkdeck/src/App.svelte
@@ -176,6 +176,8 @@
         invalidateSession: (sessionId) => auditionWorkflow.invalidateSession(sessionId),
         refreshSession: (preferred) => imageSessionWorkflow.refresh(preferred),
         setStatus: (status) => imageSessionWorkflow.setStatus(status),
+        mutationsAvailable: () => imageSessionWorkflow.packageImportAvailable,
+        sourceItems: () => imageSessionWorkflow.sourceItems,
     });
     const deletionWorkflow = new DeletionWorkflow({
         transport,
@@ -278,6 +280,7 @@
         sequenceImport: sequenceImportWorkflow,
         tx16wImport: tx16wImportWorkflow,
         packageImport: packageImportWorkflow,
+        packageBatchImport: packageBatchImportWorkflow,
         sessionId: () => imageSessionWorkflow.sessionId,
         imageFormat: () => imageSessionWorkflow.imageFormat,
         mutationsAvailable: () => mutationWorkflow.volumeAvailable,
@@ -491,7 +494,6 @@
         }
         if (mutationWorkflow.requestVolumeAction(item, action)) imageSessionWorkflow.selectedSource = item;
     }
-
     function requestObjectPackageExport(items: PackageExportObject[]): void {
         if (
             !imageSessionWorkflow.packageExportAvailable ||
diff --git a/apps/axkdeck/src/App.test.ts b/apps/axkdeck/src/App.test.ts
index 0db30d70..59308057 100644
--- a/apps/axkdeck/src/App.test.ts
+++ b/apps/axkdeck/src/App.test.ts
@@ -1366,8 +1366,10 @@ describe('App panel layout', () => {
         await fireEvent.click(screen.getByRole('menuitem', { name: 'Import' }));
         await fireEvent.click(screen.getByRole('menuitem', { name: 'Import packages…' }));
 
-        const dialog = await screen.findByRole('dialog', { name: 'Import volume packages' });
-        expect(within(dialog).getByText('Create volumes in My Partition from selected .axkvol packages.')).toBeTruthy();
+        const dialog = await screen.findByRole('dialog', { name: 'Import packages' });
+        expect(
+            within(dialog).getByText('Import portable axklib packages or A3K archives into the open SFS image.'),
+        ).toBeTruthy();
         expect(within(dialog).getByRole('button', { name: /Storage location/ })).toBeTruthy();
     });
 
diff --git a/apps/axkdeck/src/features/dialogs/AppDialogs.svelte b/apps/axkdeck/src/features/dialogs/AppDialogs.svelte
index 44fb9b56..78488f8d 100644
--- a/apps/axkdeck/src/features/dialogs/AppDialogs.svelte
+++ b/apps/axkdeck/src/features/dialogs/AppDialogs.svelte
@@ -320,11 +320,20 @@
 {/if}
 {#if packageBatchImport.request && pickerRequest?.parentDialog !== 'package-import' && directChoiceVisible('package-batch-import', packageBatchImport.request.status !== 'choosing' || packageBatchImport.request.items.length > 0 || Boolean(packageBatchImport.request.error))}
     <PackageBatchImportDialog
-        partitionName={packageBatchImport.request.partition.name}
         desktop={isDesktop}
+        canChangeSources={packageBatchImport.request.canChangeSources}
         items={packageBatchImport.request.items}
         plan={packageBatchImport.request.plan}
+        destinationStrategy={packageBatchImport.request.destinationStrategy}
+        destinationMode={packageBatchImport.request.destinationMode}
+        destinationPartitionIndex={packageBatchImport.request.destinationPartitionIndex}
+        destinationVolumeName={packageBatchImport.request.destinationVolumeName}
+        partitionOptions={packageBatchImport.partitionOptions()}
+        volumeOptions={packageBatchImport.volumeOptions()}
+        separateVolumesAvailable={packageBatchImport.canUseSeparateVolumes()}
         volumeNames={packageBatchImport.request.volumeNames}
+        renames={packageBatchImport.request.renames}
+        programSlots={packageBatchImport.request.programSlots}
         opaqueSequenceActions={packageBatchImport.request.opaqueSequenceActions}
         hasUnvalidatedChanges={packageBatchImport.request.hasUnvalidatedChanges}
         status={packageBatchImport.request.status}
@@ -334,7 +343,16 @@
         error={packageBatchImport.request.error}
         onchooseworkspace={() => void packageBatchImport.chooseWorkspace()}
         onchooselocal={() => void packageBatchImport.chooseLocal()}
-        onrename={(itemId, name) => packageBatchImport.renameVolume(itemId, name)}
+        ondestinationstrategy={(strategy) => packageBatchImport.setDestinationStrategy(strategy)}
+        ondestinationmode={(mode) => packageBatchImport.setDestinationMode(mode)}
+        ondestinationvolume={(partitionIndex, volumeName) =>
+            packageBatchImport.setExistingVolume(partitionIndex, volumeName)}
+        ondestinationpartition={(partitionIndex) => packageBatchImport.setDestinationPartition(partitionIndex)}
+        ondestinationname={(name) => packageBatchImport.setDestinationVolumeName(name)}
+        onrenamevolume={(itemId, name) => packageBatchImport.renameVolume(itemId, name)}
+        onrename={(itemId, nodeId, name) => packageBatchImport.rename(itemId, nodeId, name)}
+        onprogramslot={(itemId, nodeId, slot) => packageBatchImport.programSlot(itemId, nodeId, slot)}
+        onprogramstart={(placementId, start) => packageBatchImport.programStart(placementId, start)}
         ontoggleselected={(itemId, selected) => packageBatchImport.setSelected(itemId, selected)}
         ontoggleall={(selected) => packageBatchImport.setAllSelected(selected)}
         onopaquesequenceaction={(itemId, nodeId, action) =>
diff --git a/apps/axkdeck/src/features/import/mediaDropWorkflow.svelte.ts b/apps/axkdeck/src/features/import/mediaDropWorkflow.svelte.ts
index 0191c798..c7588ae1 100644
--- a/apps/axkdeck/src/features/import/mediaDropWorkflow.svelte.ts
+++ b/apps/axkdeck/src/features/import/mediaDropWorkflow.svelte.ts
@@ -8,6 +8,7 @@ import type { AudioImportTarget } from '../../lib/transport';
 import { tx16wDiskMediaType } from '../../lib/tx16wImport';
 import type { DiskTreeItem, WorkspaceView } from '../../lib/types';
 import type { AudioImportWorkflow } from './audioWorkflow.svelte';
+import type { PackageBatchImportWorkflow } from './packageBatchWorkflow.svelte';
 import type { PackageImportWorkflow } from './packageWorkflow.svelte';
 import type { SequenceImportWorkflow } from './sequenceWorkflow.svelte';
 import type { Tx16wImportWorkflow } from './tx16wWorkflow.svelte';
@@ -27,6 +28,7 @@ interface MediaDropDependencies {
     sequenceImport: SequenceImportWorkflow;
     tx16wImport: Tx16wImportWorkflow;
     packageImport: PackageImportWorkflow;
+    packageBatchImport: PackageBatchImportWorkflow;
     sessionId: () => number | null;
     imageFormat: () => string | null;
     mutationsAvailable: () => boolean;
@@ -147,14 +149,6 @@ export class MediaDropWorkflow {
             return;
         }
         if (selectedKind === 'package') {
-            if (files.length !== 1) {
-                this.dependencies.setStatus('Drop one package or A3K archive at a time');
-                this.notice = {
-                    title: 'Import unavailable',
-                    message: 'Choose one portable package or A3K archive for each import.',
-                };
-                return;
-            }
             if (!this.dependencies.packageImport.dropAvailable()) {
                 this.dependencies.setStatus('Package import requires a writable SFS hard-disk image');
                 this.notice = {
@@ -163,7 +157,14 @@ export class MediaDropWorkflow {
                 };
                 return;
             }
-            await this.dependencies.packageImport.requestDroppedFile(files[0], this.dependencies.selectedSource());
+            if (files.length === 1) {
+                await this.dependencies.packageImport.requestDroppedFile(files[0], this.dependencies.selectedSource());
+            } else {
+                await this.dependencies.packageBatchImport.requestDroppedFiles(
+                    files,
+                    this.dependencies.selectedSource(),
+                );
+            }
             return;
         }
         const volumeTarget = this.selectedVolumeTarget();
@@ -242,7 +243,8 @@ export class MediaDropWorkflow {
             this.dependencies.audioImport.request !== null ||
             this.dependencies.sequenceImport.request !== null ||
             this.dependencies.tx16wImport.request !== null ||
-            this.dependencies.packageImport.request !== null
+            this.dependencies.packageImport.request !== null ||
+            this.dependencies.packageBatchImport.request !== null
         );
     }
 
diff --git a/apps/axkdeck/src/features/import/packageBatchPlanning.ts b/apps/axkdeck/src/features/import/packageBatchPlanning.ts
new file mode 100644
index 00000000..e99ae752
--- /dev/null
+++ b/apps/axkdeck/src/features/import/packageBatchPlanning.ts
@@ -0,0 +1,192 @@
+import type {
+    ImageSessionPackageImportDestination,
+    ImageSessionPackageImportPlan,
+    PackageOpaqueSequenceDecision,
+    PackageProgramSlotAssignment,
+    PackageRename,
+} from '../../lib/transport';
+import type { BatchPackageItem, PackageBatchImportRequest } from './packageBatchTypes';
+import { importDestination, suggestedPackageVolumeName, type ImportDestinations } from './packageDestinations';
+
+export interface BatchPlanArguments {
+    destination: ImageSessionPackageImportDestination;
+    renames: PackageRename[];
+    programSlotAssignments: PackageProgramSlotAssignment[];
+    opaqueSequenceDecisions: PackageOpaqueSequenceDecision[];
+}
+
+export function batchDecisionKey(itemId: string, nodeId: string): string {
+    return `${itemId}:${nodeId}`;
+}
+
+export function separateVolumesAvailable(items: readonly BatchPackageItem[]): boolean {
+    return (
+        items.length > 0 &&
+        items.every(
+            (item) =>
+                item.inspection.packageKind === 'VOLUME' &&
+                item.inspection.roots.length === 1 &&
+                item.inspection.roots[0]?.kind === 'VOLUME',
+        )
+    );
+}
+
+export function suggestedSharedVolumeName(items: readonly BatchPackageItem[]): string {
+    const selected = items.filter((item) => item.selected);
+    return selected.length === 1 ? suggestedPackageVolumeName(selected[0].sourceName, selected[0].inspection) : '';
+}
+
+export function batchDestinationName(request: PackageBatchImportRequest, itemId: string): string {
+    const item = request.items.find((candidate) => candidate.id === itemId);
+    if (!item) return '';
+    const packageIndex = request.items
+        .filter((candidate) => candidate.selected)
+        .findIndex((entry) => entry.id === itemId);
+    return (
+        request.volumeNames[itemId] ??
+        (!request.hasUnvalidatedChanges && packageIndex >= 0
+            ? request.plan?.packages.find((candidate) => candidate.packageIndex === packageIndex)?.destinationVolumeName
+            : undefined) ??
+        item.inspection.roots[0]?.displayName ??
+        ''
+    );
+}
+
+export function normalizedBatchDestination(
+    request: PackageBatchImportRequest,
+    items: BatchPackageItem[],
+    destinations: ImportDestinations,
+): Partial<PackageBatchImportRequest> {
+    if (request.destinationStrategy === 'separate' && separateVolumesAvailable(items)) return {};
+    const selectedVolume = destinations.volumes.find(
+        (volume) =>
+            volume.partitionIndex === request.destinationPartitionIndex &&
+            volume.volumeName === request.destinationVolumeName,
+    );
+    const mode = selectedVolume ? 'existing' : request.item?.kind === 'partition' ? 'create' : 'existing';
+    const firstVolume = selectedVolume ?? destinations.volumes[0];
+    return {
+        destinationStrategy: 'shared',
+        destinationMode: mode,
+        destinationPartitionIndex:
+            mode === 'existing'
+                ? (firstVolume?.partitionIndex ?? null)
+                : (request.destinationPartitionIndex ?? destinations.partitions[0]?.partitionIndex ?? null),
+        destinationVolumeName: mode === 'existing' ? (firstVolume?.volumeName ?? '') : suggestedSharedVolumeName(items),
+    };
+}
+
+export function batchPlanArguments(
+    request: PackageBatchImportRequest,
+    selectedItems: BatchPackageItem[],
+): BatchPlanArguments | null {
+    const sharedDestination = importDestination(
+        request.destinationMode,
+        request.destinationPartitionIndex,
+        request.destinationVolumeName,
+    );
+    if (
+        request.destinationPartitionIndex === null ||
+        (request.destinationStrategy === 'shared' && !sharedDestination) ||
+        (request.destinationStrategy === 'separate' && !separateVolumesAvailable(selectedItems))
+    ) {
+        return null;
+    }
+    const packageEntries = new Map(selectedItems.map((item, packageIndex) => [item.id, packageIndex]));
+    const decisions = <T, R>(
+        values: Record<string, T>,
+        convert: (packageIndex: number, nodeId: string, value: T) => R,
+    ): R[] =>
+        Object.entries(values).flatMap(([key, value]) => {
+            const separator = key.indexOf(':');
+            const packageIndex = packageEntries.get(key.slice(0, separator));
+            return separator < 0 || packageIndex === undefined
+                ? []
+                : [convert(packageIndex, key.slice(separator + 1), value)];
+        });
+    const volumeNameOverrides = selectedItems
+        .map((item, packageIndex) => ({
+            packageIndex,
+            volumeName: request.volumeNames[item.id]?.trim() ?? '',
+        }))
+        .filter((item) => item.volumeName.length > 0);
+    return {
+        destination:
+            request.destinationStrategy === 'separate'
+                ? {
+                      kind: 'CREATE_VOLUMES_FROM_HINTS',
+                      partitionIndex: request.destinationPartitionIndex,
+                      volumeNameOverrides,
+                  }
+                : sharedDestination!,
+        renames: decisions(request.renames, (packageIndex, nodeId, destinationName) => ({
+            packageIndex,
+            nodeId,
+            destinationName: destinationName.trim(),
+        })).filter((rename) => rename.destinationName.length > 0),
+        programSlotAssignments: decisions(request.programSlots, (packageIndex, nodeId, destinationSlot) => ({
+            packageIndex,
+            nodeId,
+            destinationSlot,
+        })).sort(
+            (left, right) =>
+                left.destinationSlot - right.destinationSlot ||
+                left.packageIndex - right.packageIndex ||
+                left.nodeId.localeCompare(right.nodeId),
+        ),
+        opaqueSequenceDecisions: decisions(request.opaqueSequenceActions, (packageIndex, nodeId, action) => ({
+            packageIndex,
+            nodeId,
+            action,
+        })),
+    };
+}
+
+export function mergeBatchPlanSuggestions(
+    request: PackageBatchImportRequest,
+    selectedItems: BatchPackageItem[],
+    plan: ImageSessionPackageImportPlan,
+): Pick<PackageBatchImportRequest, 'volumeNames' | 'renames' | 'programSlots'> & { suggestedSlotsAdded: boolean } {
+    const volumeNames = { ...request.volumeNames };
+    for (const summary of plan.packages) {
+        const item = selectedItems[summary.packageIndex];
+        if (item) volumeNames[item.id] ??= summary.destinationVolumeName;
+    }
+    const placementKeys = new Set(
+        plan.programSlotPlacements.flatMap((placement) =>
+            placement.mappings.flatMap((mapping) => {
+                const item = selectedItems[mapping.packageIndex];
+                return item ? [batchDecisionKey(item.id, mapping.nodeId)] : [];
+            }),
+        ),
+    );
+    const renames = Object.fromEntries(Object.entries(request.renames).filter(([key]) => !placementKeys.has(key)));
+    for (const action of plan.actions) {
+        const item = selectedItems[action.packageIndex];
+        if (!item) continue;
+        const key = batchDecisionKey(item.id, action.nodeId);
+        if (
+            !placementKeys.has(key) &&
+            plan.conflicts.some(
+                (conflict) => conflict.packageIndex === action.packageIndex && conflict.nodeId === action.nodeId,
+            ) &&
+            !renames[key]
+        ) {
+            renames[key] = action.destinationName;
+        }
+    }
+    const programSlots = { ...request.programSlots };
+    let suggestedSlotsAdded = false;
+    for (const placement of plan.programSlotPlacements) {
+        for (const mapping of placement.mappings) {
+            const item = selectedItems[mapping.packageIndex];
+            if (!item) continue;
+            const key = batchDecisionKey(item.id, mapping.nodeId);
+            if (programSlots[key] === undefined) {
+                programSlots[key] = mapping.destinationSlot;
+                suggestedSlotsAdded = true;
+            }
+        }
+    }
+    return { volumeNames, renames, programSlots, suggestedSlotsAdded };
+}
diff --git a/apps/axkdeck/src/features/import/packageBatchSources.ts b/apps/axkdeck/src/features/import/packageBatchSources.ts
new file mode 100644
index 00000000..8744ae2c
--- /dev/null
+++ b/apps/axkdeck/src/features/import/packageBatchSources.ts
@@ -0,0 +1,78 @@
+import type { ClientUploadSource } from '../../lib/clientUploadSource';
+import { nativeFileSource } from '../../lib/nativeFileSource';
+import { packageImportExtensionSetCopy, packageImportUploadKind } from '../../lib/packageImportMedia';
+import type { ClientUploadLocation, InputFileLocation } from '../../lib/storageLocations';
+import type { ImageTransport } from '../../lib/transport';
+
+export interface BatchPackageSource {
+    source: InputFileLocation;
+    sourceName: string;
+    upload: ClientUploadLocation | null;
+    localPath: string | null;
+}
+
+interface UploadCallbacks {
+    progress: (completedFiles: number, currentProgress: number) => void;
+}
+
+export async function uploadLocalPackageSources(
+    transport: ImageTransport,
+    paths: readonly string[],
+    signal: AbortSignal,
+    callbacks: UploadCallbacks,
+): Promise<BatchPackageSource[]> {
+    const extensions = packageImportExtensionSetCopy();
+    const files = await Promise.all(
+        paths.map(async (path) => ({
+            file: await nativeFileSource(path, extensions, 'application/octet-stream'),
+            localPath: path,
+        })),
+    );
+    return uploadPackageSources(transport, files, signal, callbacks);
+}
+
+export async function uploadDroppedPackageSources(
+    transport: ImageTransport,
+    files: readonly ClientUploadSource[],
+    signal: AbortSignal,
+    callbacks: UploadCallbacks,
+): Promise<BatchPackageSource[]> {
+    return uploadPackageSources(
+        transport,
+        files.map((file) => ({ file, localPath: null })),
+        signal,
+        callbacks,
+    );
+}
+
+async function uploadPackageSources(
+    transport: ImageTransport,
+    files: readonly { file: ClientUploadSource; localPath: string | null }[],
+    signal: AbortSignal,
+    callbacks: UploadCallbacks,
+): Promise<BatchPackageSource[]> {
+    const staged: BatchPackageSource[] = [];
+    try {
+        for (const [index, item] of files.entries()) {
+            const uploadKind = packageImportUploadKind(item.file.name);
+            if (!uploadKind) throw new Error(`${item.file.name} is not a supported package or A3K archive`);
+            const upload = await transport.uploadClientFile(
+                item.file,
+                uploadKind,
+                (sent, total) => callbacks.progress(index, total === 0 ? 0 : sent / total),
+                signal,
+            );
+            staged.push({
+                source: upload,
+                sourceName: item.file.name,
+                upload,
+                localPath: item.localPath,
+            });
+            callbacks.progress(index + 1, 0);
+        }
+        return staged;
+    } catch (error) {
+        await Promise.all(staged.map((item) => transport.releaseClientUpload(item.upload!).catch(() => undefined)));
+        throw error;
+    }
+}
diff --git a/apps/axkdeck/src/features/import/packageBatchTypes.ts b/apps/axkdeck/src/features/import/packageBatchTypes.ts
new file mode 100644
index 00000000..6c3277bf
--- /dev/null
+++ b/apps/axkdeck/src/features/import/packageBatchTypes.ts
@@ -0,0 +1,59 @@
+import type { ClientUploadLocation, InputFileLocation } from '../../lib/storageLocations';
+import type {
+    ImageSessionPackageImportPlan,
+    ImageTransport,
+    PackageInspection,
+    PackageOpaqueSequenceDecision,
+} from '../../lib/transport';
+import type { DiskTreeItem } from '../../lib/types';
+import type { PickerController } from '../dialogs/picker';
+import type { JobController } from '../jobs/actions';
+import type { ImportDestinationMode } from './packageDestinations';
+import type { PackagePickerHistory } from './packagePickerHistory';
+
+export type PackageBatchDestinationStrategy = 'shared' | 'separate';
+
+export interface BatchPackageItem {
+    id: string;
+    selected: boolean;
+    source: InputFileLocation;
+    sourceName: string;
+    inspection: PackageInspection;
+    upload: ClientUploadLocation | null;
+    localPath: string | null;
+}
+
+export interface PackageBatchImportRequest {
+    item: DiskTreeItem | null;
+    canChangeSources: boolean;
+    items: BatchPackageItem[];
+    plan: ImageSessionPackageImportPlan | null;
+    destinationStrategy: PackageBatchDestinationStrategy;
+    destinationMode: ImportDestinationMode;
+    destinationPartitionIndex: number | null;
+    destinationVolumeName: string;
+    volumeNames: Record<string, string>;
+    renames: Record<string, string>;
+    programSlots: Record<string, number>;
+    opaqueSequenceActions: Record<string, PackageOpaqueSequenceDecision['action']>;
+    hasUnvalidatedChanges: boolean;
+    status: 'choosing' | 'loading' | 'planning' | 'ready' | 'applying';
+    completedFiles: number;
+    totalFiles: number;
+    progress: number;
+    error: string;
+}
+
+export interface PackageBatchImportDependencies {
+    transport: ImageTransport;
+    jobs: JobController;
+    picker: PickerController;
+    pickerHistory: PackagePickerHistory;
+    isDesktop: boolean;
+    sessionId: () => number | null;
+    invalidateSession: (sessionId: number) => Promise<void>;
+    refreshSession: (preferred: { partitionIndex: number; volumeName?: string }) => Promise<void>;
+    setStatus: (status: string) => void;
+    mutationsAvailable?: () => boolean;
+    sourceItems?: () => DiskTreeItem[];
+}
diff --git a/apps/axkdeck/src/features/import/packageBatchWorkflow.svelte.ts b/apps/axkdeck/src/features/import/packageBatchWorkflow.svelte.ts
index 84b5bd53..6e34f07c 100644
--- a/apps/axkdeck/src/features/import/packageBatchWorkflow.svelte.ts
+++ b/apps/axkdeck/src/features/import/packageBatchWorkflow.svelte.ts
@@ -1,58 +1,38 @@
-import { nativeFileSource } from '../../lib/nativeFileSource';
-import { selectLocalVolumePackages } from '../../lib/nativePackages';
-import type { ClientUploadLocation, InputFileLocation } from '../../lib/storageLocations';
-import type {
-    ImageSessionPackageImportPlan,
-    ImageTransport,
-    PackageInspection,
-    PackageOpaqueSequenceDecision,
-} from '../../lib/transport';
+import { selectLocalPackages } from '../../lib/nativePackages';
+import type { ClientUploadSource } from '../../lib/clientUploadSource';
+import { packageImportExtensions } from '../../lib/packageImportMedia';
+import type { ClientUploadLocation } from '../../lib/storageLocations';
+import type { ImageSessionPackageImportPlan, PackageOpaqueSequenceDecision } from '../../lib/transport';
 import type { DiskTreeItem } from '../../lib/types';
 import { reportError } from '../../lib/diagnostics';
 import { userFacingMessage } from '../../lib/userFacingMessage';
-import type { PickerController } from '../dialogs/picker';
-import type { JobController } from '../jobs/actions';
-import { PackagePickerHistory } from './packagePickerHistory';
+import {
+    collectImportDestinations,
+    importDestination,
+    initialImportDestination,
+    type ImportDestinationMode,
+    type ImportPartitionOption,
+    type ImportVolumeOption,
+} from './packageDestinations';
+import {
+    batchDecisionKey,
+    batchDestinationName,
+    batchPlanArguments,
+    mergeBatchPlanSuggestions,
+    normalizedBatchDestination,
+    separateVolumesAvailable,
+    suggestedSharedVolumeName,
+} from './packageBatchPlanning';
+import { uploadDroppedPackageSources, uploadLocalPackageSources, type BatchPackageSource } from './packageBatchSources';
+import type {
+    BatchPackageItem,
+    PackageBatchImportDependencies,
+    PackageBatchDestinationStrategy,
+    PackageBatchImportRequest,
+} from './packageBatchTypes';
 
-const volumePackageExtensions = new Set(['axkvol']);
 const maximumBatchPackages = 256;
 
-export interface BatchPackageItem {
-    id: string;
-    selected: boolean;
-    source: InputFileLocation;
-    sourceName: string;
-    inspection: PackageInspection;
-    upload: ClientUploadLocation | null;
-    localPath: string | null;
-}
-
-export interface PackageBatchImportRequest {
-    partition: DiskTreeItem;
-    items: BatchPackageItem[];
-    plan: ImageSessionPackageImportPlan | null;
-    volumeNames: Record<string, string>;
-    opaqueSequenceActions: Record<string, PackageOpaqueSequenceDecision['action']>;
-    hasUnvalidatedChanges: boolean;
-    status: 'choosing' | 'loading' | 'planning' | 'ready' | 'applying';
-    completedFiles: number;
-    totalFiles: number;
-    progress: number;
-    error: string;
-}
-
-interface PackageBatchImportDependencies {
-    transport: ImageTransport;
-    jobs: JobController;
-    picker: PickerController;
-    pickerHistory: PackagePickerHistory;
-    isDesktop: boolean;
-    sessionId: () => number | null;
-    invalidateSession: (sessionId: number) => Promise<void>;
-    refreshSession: (preferred: { partitionIndex: number; volumeName?: string }) => Promise<void>;
-    setStatus: (status: string) => void;
-}
-
 export class PackageBatchImportWorkflow {
     request = $state<PackageBatchImportRequest | null>(null);
     private generation = 0;
@@ -61,16 +41,44 @@ export class PackageBatchImportWorkflow {
 
     constructor(private readonly dependencies: PackageBatchImportDependencies) {}
 
-    open(partition: DiskTreeItem): void {
+    dropAvailable(): boolean {
+        return this.dependencies.mutationsAvailable?.() ?? false;
+    }
+
+    partitionOptions(): ImportPartitionOption[] {
+        return this.destinations().partitions;
+    }
+
+    volumeOptions(): ImportVolumeOption[] {
+        return this.destinations().volumes;
+    }
+
+    canUseSeparateVolumes(): boolean {
+        return this.request ? separateVolumesAvailable(this.request.items.filter((item) => item.selected)) : false;
+    }
+
+    open(item: DiskTreeItem | null): void {
         ++this.generation;
         this.abortController?.abort();
         this.abortController = null;
         this.plannedItemIds = [];
+        const destination = initialImportDestination(item) ?? {
+            mode: 'existing' as const,
+            partitionIndex: null,
+            volumeName: '',
+        };
         this.request = {
-            partition,
+            item,
+            canChangeSources: true,
             items: [],
             plan: null,
+            destinationStrategy: item?.kind === 'partition' ? 'separate' : 'shared',
+            destinationMode: destination.mode,
+            destinationPartitionIndex: destination.partitionIndex,
+            destinationVolumeName: destination.volumeName,
             volumeNames: {},
+            renames: {},
+            programSlots: {},
             opaqueSequenceActions: {},
             hasUnvalidatedChanges: false,
             status: 'choosing',
@@ -81,6 +89,64 @@ export class PackageBatchImportWorkflow {
         };
     }
 
+    setDestinationStrategy(strategy: PackageBatchDestinationStrategy): void {
+        const request = this.request;
+        if (!request || request.status === 'applying' || request.destinationStrategy === strategy) return;
+        if (strategy === 'separate' && !separateVolumesAvailable(request.items.filter((item) => item.selected))) return;
+        this.updateDestination({ destinationStrategy: strategy }, true);
+    }
+
+    setDestinationMode(mode: ImportDestinationMode): void {
+        const request = this.request;
+        if (!request || request.status === 'applying' || request.destinationMode === mode) return;
+        const destinations = this.destinations();
+        const currentVolume = destinations.volumes.find(
+            (option) =>
+                option.partitionIndex === request.destinationPartitionIndex &&
+                option.volumeName === request.destinationVolumeName,
+        );
+        const existingVolume = currentVolume ?? destinations.volumes[0];
+        this.updateDestination(
+            {
+                destinationStrategy: 'shared',
+                destinationMode: mode,
+                destinationPartitionIndex:
+                    mode === 'existing'
+                        ? (existingVolume?.partitionIndex ?? null)
+                        : (request.destinationPartitionIndex ?? destinations.partitions[0]?.partitionIndex ?? null),
+                destinationVolumeName:
+                    mode === 'existing' ? (existingVolume?.volumeName ?? '') : suggestedSharedVolumeName(request.items),
+            },
+            true,
+        );
+    }
+
+    setExistingVolume(partitionIndex: number | null, volumeName: string): void {
+        const request = this.request;
+        if (!request || request.status === 'applying') return;
+        this.updateDestination(
+            {
+                destinationStrategy: 'shared',
+                destinationMode: 'existing',
+                destinationPartitionIndex: partitionIndex,
+                destinationVolumeName: volumeName,
+            },
+            partitionIndex !== null,
+        );
+    }
+
+    setDestinationPartition(partitionIndex: number): void {
+        const request = this.request;
+        if (!request || request.status === 'applying') return;
+        this.updateDestination({ destinationPartitionIndex: partitionIndex }, true);
+    }
+
+    setDestinationVolumeName(volumeName: string): void {
+        const request = this.request;
+        if (!request || request.status === 'applying') return;
+        this.updateDestination({ destinationVolumeName: volumeName.slice(0, 16) }, false);
+    }
+
     renameVolume(itemId: string, name: string): void {
         if (!this.request || this.request.status !== 'ready') return;
         const current = this.destinationName(itemId);
@@ -92,15 +158,68 @@ export class PackageBatchImportWorkflow {
         };
     }
 
+    rename(itemId: string, nodeId: string, name: string): void {
+        if (!this.request || this.request.status !== 'ready') return;
+        const key = batchDecisionKey(itemId, nodeId);
+        if (this.request.renames[key] === name) return;
+        this.request = {
+            ...this.request,
+            renames: { ...this.request.renames, [key]: name },
+            hasUnvalidatedChanges: true,
+        };
+    }
+
+    programSlot(itemId: string, nodeId: string, slot: number): void {
+        if (!this.request || this.request.status !== 'ready' || !Number.isInteger(slot) || slot < 1 || slot > 128) {
+            return;
+        }
+        const key = batchDecisionKey(itemId, nodeId);
+        if (this.request.programSlots[key] === slot) return;
+        this.request = {
+            ...this.request,
+            programSlots: { ...this.request.programSlots, [key]: slot },
+            hasUnvalidatedChanges: true,
+        };
+    }
+
+    programStart(placementId: string, start: number): void {
+        const request = this.request;
+        if (!request || request.status !== 'ready' || !Number.isInteger(start)) return;
+        const placement = request.plan?.programSlotPlacements.find(
+            (candidate) => candidate.placementId === placementId,
+        );
+        if (
+            !placement ||
+            placement.mode !== 'CONTIGUOUS' ||
+            start < 1 ||
+            start + placement.requiredSlotCount - 1 > 128
+        ) {
+            return;
+        }
+        const selectedItems = request.items.filter((item) => item.selected);
+        const programSlots = { ...request.programSlots };
+        for (const [offset, mapping] of placement.mappings.entries()) {
+            const item = selectedItems[mapping.packageIndex];
+            if (item) programSlots[batchDecisionKey(item.id, mapping.nodeId)] = start + offset;
+        }
+        this.request = { ...request, programSlots, hasUnvalidatedChanges: true };
+    }
+
     setSelected(itemId: string, selected: boolean): void {
         if (!this.request || this.request.status !== 'ready') return;
         const item = this.request.items.find((candidate) => candidate.id === itemId);
         if (!item || item.selected === selected) return;
+        const items = this.request.items.map((candidate) =>
+            candidate.id === itemId ? { ...candidate, selected } : candidate,
+        );
         this.request = {
             ...this.request,
-            items: this.request.items.map((candidate) =>
-                candidate.id === itemId ? { ...candidate, selected } : candidate,
-            ),
+            items,
+            destinationStrategy:
+                this.request.destinationStrategy === 'separate' &&
+                !separateVolumesAvailable(items.filter((entry) => entry.selected))
+                    ? 'shared'
+                    : this.request.destinationStrategy,
             hasUnvalidatedChanges: true,
             error: '',
         };
@@ -109,9 +228,15 @@ export class PackageBatchImportWorkflow {
     setAllSelected(selected: boolean): void {
         if (!this.request || this.request.status !== 'ready') return;
         if (this.request.items.every((item) => item.selected === selected)) return;
+        const items = this.request.items.map((item) => ({ ...item, selected }));
         this.request = {
             ...this.request,
-            items: this.request.items.map((item) => ({ ...item, selected })),
+            items,
+            destinationStrategy:
+                this.request.destinationStrategy === 'separate' &&
+                !separateVolumesAvailable(items.filter((entry) => entry.selected))
+                    ? 'shared'
+                    : this.request.destinationStrategy,
             hasUnvalidatedChanges: true,
             error: '',
         };
@@ -119,7 +244,7 @@ export class PackageBatchImportWorkflow {
 
     opaqueSequenceAction(itemId: string, nodeId: string, action: PackageOpaqueSequenceDecision['action']): void {
         if (!this.request || this.request.status !== 'ready') return;
-        const key = this.opaqueSequenceKey(itemId, nodeId);
+        const key = batchDecisionKey(itemId, nodeId);
         if (this.request.opaqueSequenceActions[key] === action) return;
         this.request = {
             ...this.request,
@@ -130,36 +255,26 @@ export class PackageBatchImportWorkflow {
     }
 
     destinationName(itemId: string): string {
-        const request = this.request;
-        if (!request) return '';
-        const item = request.items.find((candidate) => candidate.id === itemId);
-        if (!item) return '';
-        const selectedItems = request.items.filter((candidate) => candidate.selected);
-        const packageIndex = selectedItems.findIndex((candidate) => candidate.id === itemId);
-        return (
-            request.volumeNames[itemId] ??
-            (!request.hasUnvalidatedChanges && packageIndex >= 0
-                ? request.plan?.packages.find((candidate) => candidate.packageIndex === packageIndex)
-                      ?.destinationVolumeName
-                : undefined) ??
-            item.inspection.roots[0]?.displayName ??
-            ''
-        );
+        return this.request ? batchDestinationName(this.request, itemId) : '';
     }
 
     async chooseWorkspace(): Promise<void> {
         if (!this.request) return;
-        const selections = await this.dependencies.picker.chooseFiles('Choose volume packages', ['axkvol'], {
-            parentDialog: 'package-import',
-            initialDirectory: this.dependencies.pickerHistory.lastDirectory,
-            initialFile: this.dependencies.pickerHistory.lastImportedWorkspaceFile,
-            ondirectorychange: (directory) => (this.dependencies.pickerHistory.lastDirectory = directory),
-        });
+        const selections = await this.dependencies.picker.chooseFiles(
+            'Choose axklib packages',
+            [...packageImportExtensions],
+            {
+                parentDialog: 'package-import',
+                initialDirectory: this.dependencies.pickerHistory.lastDirectory,
+                initialFile: this.dependencies.pickerHistory.lastImportedWorkspaceFile,
+                ondirectorychange: (directory) => (this.dependencies.pickerHistory.lastDirectory = directory),
+            },
+        );
         if (!selections?.length || !this.request) return;
         if (selections.length > maximumBatchPackages) {
             this.request = {
                 ...this.request,
-                error: `Select at most ${maximumBatchPackages} volume packages at once`,
+                error: `Select at most ${maximumBatchPackages} packages at once`,
             };
             return;
         }
@@ -170,14 +285,8 @@ export class PackageBatchImportWorkflow {
 
     async chooseLocal(closeOnCancel = false): Promise<void> {
         if (!this.request || !this.dependencies.isDesktop) return;
-        const staged: Array<{
-            source: InputFileLocation;
-            sourceName: string;
-            upload: ClientUploadLocation;
-            localPath: string;
-        }> = [];
         try {
-            const paths = await selectLocalVolumePackages(this.dependencies.pickerHistory.lastImportedLocalPath);
+            const paths = await selectLocalPackages(this.dependencies.pickerHistory.lastImportedLocalPath);
             if (!paths.length) {
                 if (closeOnCancel) await this.close();
                 return;
@@ -186,54 +295,82 @@ export class PackageBatchImportWorkflow {
             if (paths.length > maximumBatchPackages) {
                 this.request = {
                     ...this.request,
-                    error: `Select at most ${maximumBatchPackages} volume packages at once`,
+                    error: `Select at most ${maximumBatchPackages} packages at once`,
                 };
                 return;
             }
-            const controller = new AbortController();
-            this.abortController?.abort();
-            this.abortController = controller;
-            const generation = ++this.generation;
+            await this.stageSources(paths.length, (signal, progress) =>
+                uploadLocalPackageSources(this.dependencies.transport, paths, signal, { progress }),
+            );
+        } catch (error) {
+            if (!this.request) return;
+            reportError('Import local packages failed', error);
+            this.request = { ...this.request, status: 'choosing', error: userFacingMessage(error) };
+        }
+    }
+
+    async requestDroppedFiles(files: ClientUploadSource[], item: DiskTreeItem | null): Promise<void> {
+        if (!this.dropAvailable() || files.length === 0) return;
+        this.open(item);
+        if (files.length > maximumBatchPackages) {
             this.request = {
-                ...this.request,
-                status: 'loading',
-                totalFiles: paths.length,
-                completedFiles: 0,
-                progress: 0,
-                error: '',
+                ...this.request!,
+                canChangeSources: false,
+                error: `Drop at most ${maximumBatchPackages} packages at once`,
             };
-            for (const [index, path] of paths.entries()) {
-                const file = await nativeFileSource(path, volumePackageExtensions, 'application/octet-stream');
-                const upload = await this.dependencies.transport.uploadClientFile(
-                    file,
-                    'PACKAGE',
-                    (sent, total) => {
-                        if (generation === this.generation && this.request) {
-                            this.request = {
-                                ...this.request,
-                                progress: index + (total === 0 ? 0 : sent / total),
-                            };
-                        }
-                    },
-                    controller.signal,
-                );
-                staged.push({ source: upload, sourceName: file.name, upload, localPath: path });
-                if (generation === this.generation && this.request) {
-                    this.request = { ...this.request, completedFiles: index + 1 };
-                }
+            return;
+        }
+        this.request = {
+            ...this.request!,
+            canChangeSources: false,
+        };
+        try {
+            await this.stageSources(files.length, (signal, progress) =>
+                uploadDroppedPackageSources(this.dependencies.transport, files, signal, { progress }),
+            );
+        } catch (error) {
+            if (this.request) {
+                this.request = { ...this.request, status: 'choosing', error: userFacingMessage(error) };
             }
+        }
+    }
+
+    private async stageSources(
+        totalFiles: number,
+        load: (
+            signal: AbortSignal,
+            progress: (completedFiles: number, currentProgress: number) => void,
+        ) => Promise<BatchPackageSource[]>,
+    ): Promise<void> {
+        if (!this.request) return;
+        const controller = new AbortController();
+        this.abortController?.abort();
+        this.abortController = controller;
+        const generation = ++this.generation;
+        let staged: BatchPackageSource[] = [];
+        this.request = {
+            ...this.request,
+            status: 'loading',
+            totalFiles,
+            completedFiles: 0,
+            progress: 0,
+            error: '',
+        };
+        try {
+            staged = await load(controller.signal, (completedFiles, currentProgress) => {
+                if (generation !== this.generation || !this.request) return;
+                this.request = { ...this.request, completedFiles, progress: completedFiles + currentProgress };
+            });
             if (this.abortController === controller) this.abortController = null;
             if (generation !== this.generation || !this.request) {
-                await Promise.all(staged.map((item) => this.releaseUpload(item.upload)));
+                await Promise.all(staged.map((source) => this.releaseUpload(source.upload)));
                 return;
             }
             await this.loadSources(staged, generation);
         } catch (error) {
-            await Promise.all(staged.map((item) => this.releaseUpload(item.upload)));
-            this.abortController = null;
-            if (!this.request) return;
-            reportError('Import local volume packages failed', error);
-            this.request = { ...this.request, status: 'choosing', error: userFacingMessage(error) };
+            await Promise.all(staged.map((source) => this.releaseUpload(source.upload)));
+            if (this.abortController === controller) this.abortController = null;
+            throw error;
         }
     }
 
@@ -265,14 +402,14 @@ export class PackageBatchImportWorkflow {
             request.hasUnvalidatedChanges ||
             selectedItems.length === 0 ||
             sessionId === null ||
-            request.partition.partitionIndex === undefined
+            request.destinationPartitionIndex === null
         ) {
             return;
         }
         const generation = ++this.generation;
         let jobStarted = false;
         this.request = { ...request, status: 'applying', error: '' };
-        this.dependencies.setStatus(`Importing ${selectedItems.length} volume packages`);
+        this.dependencies.setStatus(`Importing ${selectedItems.length} packages`);
         try {
             await this.dependencies.invalidateSession(sessionId);
             const completed = await this.dependencies.jobs.run(
@@ -303,10 +440,10 @@ export class PackageBatchImportWorkflow {
             await Promise.all(request.items.map((item) => this.releaseUpload(item.upload)));
             this.request = null;
             await this.dependencies.refreshSession({
-                partitionIndex: request.partition.partitionIndex,
+                partitionIndex: request.destinationPartitionIndex,
                 volumeName: request.plan.packages[0]?.destinationVolumeName,
             });
-            this.dependencies.setStatus(`Imported ${selectedItems.length} volume packages`);
+            this.dependencies.setStatus(`Imported ${selectedItems.length} packages`);
         } catch (error) {
             if (jobStarted) {
                 await this.recoverUncertainApply(request, generation);
@@ -336,7 +473,7 @@ export class PackageBatchImportWorkflow {
         this.plannedItemIds = [];
         await this.releasePlan(request.plan);
         try {
-            await this.dependencies.refreshSession({ partitionIndex: request.partition.partitionIndex! });
+            await this.dependencies.refreshSession({ partitionIndex: request.destinationPartitionIndex! });
             if (generation !== this.generation || !this.request) return;
             await this.plan(generation);
             if (generation === this.generation && this.request?.status === 'ready' && this.request.plan) {
@@ -358,7 +495,7 @@ export class PackageBatchImportWorkflow {
         const message = 'Import completion could not be confirmed; review the refreshed image before retrying';
         try {
             await this.dependencies.refreshSession({
-                partitionIndex: request.partition.partitionIndex!,
+                partitionIndex: request.destinationPartitionIndex!,
                 volumeName: request.plan?.packages[0]?.destinationVolumeName,
             });
             this.dependencies.setStatus(message);
@@ -381,15 +518,7 @@ export class PackageBatchImportWorkflow {
         await Promise.all(request.items.map((item) => this.releaseUpload(item.upload)));
     }
 
-    private async loadSources(
-        sources: Array<{
-            source: InputFileLocation;
-            sourceName: string;
-            upload: ClientUploadLocation | null;
-            localPath: string | null;
-        }>,
-        existingGeneration?: number,
-    ): Promise<void> {
+    private async loadSources(sources: BatchPackageSource[], existingGeneration?: number): Promise<void> {
         if (!this.request) return;
         const previous = this.request;
         await this.releasePlan(previous.plan);
@@ -401,6 +530,8 @@ export class PackageBatchImportWorkflow {
             items: [],
             plan: null,
             volumeNames: {},
+            renames: {},
+            programSlots: {},
             opaqueSequenceActions: {},
             hasUnvalidatedChanges: false,
             status: 'loading',
@@ -413,7 +544,9 @@ export class PackageBatchImportWorkflow {
         try {
             for (const [index, source] of sources.entries()) {
                 const inspection = await this.dependencies.transport.inspectPackage(source.source, false);
-                this.validateInspection(source.sourceName, inspection);
+                if (!inspection.valid) {
+                    throw new Error(`${source.sourceName} is not a valid portable package or A3K archive`);
+                }
                 items.push({ ...source, id: `batch-${generation}-${index}`, selected: true, inspection });
                 if (generation !== this.generation || !this.request) {
                     await Promise.all(sources.map((item) => this.releaseUpload(item.upload)));
@@ -421,7 +554,8 @@ export class PackageBatchImportWorkflow {
                 }
                 this.request = { ...this.request, items: [...items], completedFiles: index + 1 };
             }
-            this.request = { ...this.request, status: 'planning' };
+            const destination = normalizedBatchDestination(this.request, items, this.destinations());
+            this.request = { ...this.request, ...destination, status: 'planning' };
             await this.plan(generation);
         } catch (error) {
             await Promise.all(sources.map((item) => this.releaseUpload(item.upload)));
@@ -430,84 +564,119 @@ export class PackageBatchImportWorkflow {
         }
     }
 
-    private validateInspection(sourceName: string, inspection: PackageInspection): void {
-        if (
-            !inspection.valid ||
-            inspection.packageKind !== 'VOLUME' ||
-            inspection.requiredExtension.toLocaleLowerCase() !== '.axkvol' ||
-            inspection.roots.length !== 1 ||
-            inspection.roots[0]?.kind !== 'VOLUME'
-        ) {
-            throw new Error(`${sourceName} is not a valid single-volume .axkvol package`);
+    private async plan(generation: number, replacePlanToken?: string): Promise<void> {
+        const automaticPlanToken = await this.planOnce(generation, replacePlanToken, true);
+        if (!automaticPlanToken) return;
+        try {
+            await this.planOnce(generation, automaticPlanToken, false);
+        } catch (error) {
+            if (generation === this.generation && this.request) {
+                this.request = { ...this.request, status: 'ready', error: userFacingMessage(error) };
+            }
         }
     }
 
-    private async plan(generation: number, replacePlanToken?: string): Promise<void> {
+    private async planOnce(
+        generation: number,
+        replacePlanToken: string | undefined,
+        allowAutomaticProgramSlotCheck: boolean,
+    ): Promise<string | null> {
         const request = this.request;
         const sessionId = this.dependencies.sessionId();
-        const partitionIndex = request?.partition.partitionIndex;
         const selectedItems = request?.items.filter((item) => item.selected) ?? [];
-        if (!request || selectedItems.length === 0 || sessionId === null || partitionIndex === undefined) return;
+        const arguments_ = request ? batchPlanArguments(request, selectedItems) : null;
+        if (!request || selectedItems.length === 0 || sessionId === null || !arguments_) {
+            if (request && generation === this.generation) {
+                this.request = { ...request, status: 'ready', hasUnvalidatedChanges: true };
+            }
+            return null;
+        }
         this.request = { ...request, status: 'planning', error: '' };
         try {
-            const volumeNameOverrides = selectedItems
-                .map((item, packageIndex) => ({
-                    packageIndex,
-                    volumeName: request.volumeNames[item.id]?.trim() ?? '',
-                }))
-                .filter((item) => item.volumeName.length > 0);
-            const opaqueSequenceDecisions = selectedItems.flatMap((item, packageIndex) => {
-                const prefix = `${item.id}:`;
-                return Object.entries(request.opaqueSequenceActions)
-                    .filter(([key]) => key.startsWith(prefix))
-                    .map(([key, action]) => ({ packageIndex, nodeId: key.slice(prefix.length), action }));
-            });
             const plan = await this.dependencies.transport.planImagePackageImport(
                 sessionId,
                 selectedItems.map((item) => item.source),
-                { kind: 'CREATE_VOLUMES_FROM_HINTS', partitionIndex, volumeNameOverrides },
-                [],
-                [],
+                arguments_.destination,
+                arguments_.renames,
+                arguments_.programSlotAssignments,
                 replacePlanToken,
-                opaqueSequenceDecisions,
+                arguments_.opaqueSequenceDecisions,
             );
             if (generation !== this.generation || !this.request) {
                 await this.releasePlan(plan);
-                return;
+                return null;
             }
+            const merged = mergeBatchPlanSuggestions(request, selectedItems, plan);
+            const checkSuggestedProgramSlots =
+                allowAutomaticProgramSlotCheck &&
+                merged.suggestedSlotsAdded &&
+                plan.programSlotPlacements.some(
+                    (placement) =>
+                        !placement.applied && placement.mode !== 'UNAVAILABLE' && placement.mappings.length > 0,
+                );
             this.request = {
                 ...this.request,
                 plan,
-                volumeNames: {
-                    ...request.volumeNames,
-                    ...Object.fromEntries(
-                        plan.packages.flatMap((item) => {
-                            const selectedItem = selectedItems[item.packageIndex];
-                            return selectedItem
-                                ? [
-                                      [
-                                          selectedItem.id,
-                                          request.volumeNames[selectedItem.id] ?? item.destinationVolumeName,
-                                      ],
-                                  ]
-                                : [];
-                        }),
-                    ),
-                },
-                hasUnvalidatedChanges: false,
-                status: 'ready',
+                volumeNames: merged.volumeNames,
+                renames: merged.renames,
+                programSlots: merged.programSlots,
+                hasUnvalidatedChanges: merged.suggestedSlotsAdded,
+                status: checkSuggestedProgramSlots ? 'planning' : 'ready',
                 error: '',
             };
             this.plannedItemIds = selectedItems.map((item) => item.id);
+            return checkSuggestedProgramSlots ? plan.planToken : null;
         } catch (error) {
             if (generation === this.generation && this.request) {
                 this.request = { ...this.request, status: 'ready', error: userFacingMessage(error) };
             }
+            return null;
         }
     }
 
-    private opaqueSequenceKey(itemId: string, nodeId: string): string {
-        return `${itemId}:${nodeId}`;
+    private updateDestination(
+        update: Partial<
+            Pick<
+                PackageBatchImportRequest,
+                'destinationStrategy' | 'destinationMode' | 'destinationPartitionIndex' | 'destinationVolumeName'
+            >
+        >,
+        automaticallyPlan: boolean,
+    ): void {
+        const request = this.request;
+        if (!request || request.status === 'applying') return;
+        const previousPlan = request.plan;
+        const next = {
+            ...request,
+            ...update,
+            plan: null,
+            renames: {},
+            programSlots: {},
+            hasUnvalidatedChanges: true,
+            status: request.items.length > 0 ? ('ready' as const) : request.status,
+            error: '',
+        };
+        const destinationReady =
+            next.destinationStrategy === 'separate'
+                ? next.destinationPartitionIndex !== null &&
+                  separateVolumesAvailable(next.items.filter((item) => item.selected))
+                : importDestination(
+                      next.destinationMode,
+                      next.destinationPartitionIndex,
+                      next.destinationVolumeName,
+                  ) !== null;
+        const shouldPlan = automaticallyPlan && next.items.some((item) => item.selected) && destinationReady;
+        const generation = ++this.generation;
+        this.request = { ...next, status: shouldPlan ? 'planning' : next.status };
+        void (async () => {
+            await this.releasePlan(previousPlan);
+            if (!shouldPlan || generation !== this.generation || !this.request) return;
+            await this.plan(generation);
+        })();
+    }
+
+    private destinations() {
+        return collectImportDestinations(this.dependencies.sourceItems?.() ?? []);
     }
 
     private async releasePlan(plan: ImageSessionPackageImportPlan | null): Promise<void> {
diff --git a/apps/axkdeck/src/features/import/packageBatchWorkflow.test.ts b/apps/axkdeck/src/features/import/packageBatchWorkflow.test.ts
index 4eaff9f8..af977c0e 100644
--- a/apps/axkdeck/src/features/import/packageBatchWorkflow.test.ts
+++ b/apps/axkdeck/src/features/import/packageBatchWorkflow.test.ts
@@ -7,17 +7,23 @@ import type { JobController } from '../jobs/actions';
 import { PackageBatchImportWorkflow } from './packageBatchWorkflow.svelte';
 import { PackagePickerHistory } from './packagePickerHistory';
 
-function inspection(packageId: string, name: string, programs: number): PackageInspection {
+function inspection(
+    packageId: string,
+    name: string,
+    programs: number,
+    packageKind: Exclude<PackageInspection['packageKind'], 'BUNDLE'> = 'VOLUME',
+): PackageInspection {
+    const rootKind = packageKind === 'SEQUENCE' ? 'SEQU' : packageKind;
     return {
         schemaVersion: '1.0',
         packageId,
-        packageKind: 'VOLUME',
-        requiredExtension: '.axkvol',
+        packageKind,
+        requiredExtension: packageKind === 'VOLUME' ? '.axkvol' : '.axkprg',
         sourceMediaKind: 'SFS',
         valid: true,
         payloadsVerified: true,
         totalPayloadBytes: programs * 100,
-        roots: [{ kind: 'VOLUME', displayName: name, nodeIds: [] }],
+        roots: [{ kind: rootKind, displayName: name, nodeIds: [] }],
         objects: Array.from({ length: programs }, (_, index) => ({
             nodeId: `${packageId}-${index}`,
             objectType: 'PROG' as const,
@@ -278,7 +284,124 @@ describe('PackageBatchImportWorkflow', () => {
             rootId: 'workspace',
             relativePath: 'three.axkvol',
         });
-        expect(setStatus).toHaveBeenCalledWith('Imported 2 volume packages');
+        expect(setStatus).toHaveBeenCalledWith('Imported 2 packages');
+    });
+
+    it('plans mixed package kinds into one selected existing volume', async () => {
+        const sources = [
+            serverFileLocation({ rootId: 'workspace', relativePath: 'one.axkprg' }, 'one.axkprg'),
+            serverFileLocation({ rootId: 'workspace', relativePath: 'two.axksbac' }, 'two.axksbac'),
+        ];
+        const planImagePackageImport = vi.fn().mockResolvedValue(plan(['Target', 'Target'], 'mixed-plan'));
+        const picker = new PickerController(() => undefined);
+        const volume: DiskTreeItem = {
+            id: 'volume-0',
+            name: 'Target',
+            kind: 'volume',
+            childCount: 0,
+            partitionIndex: 0,
+        };
+        const partition: DiskTreeItem = {
+            id: 'partition-0',
+            name: 'Partition 1',
+            kind: 'partition',
+            childCount: 1,
+            partitionIndex: 0,
+            children: [volume],
+        };
+        const workflow = new PackageBatchImportWorkflow({
+            transport: {
+                inspectPackage: vi
+                    .fn()
+                    .mockResolvedValueOnce(inspection('package-0', 'Program', 1, 'PROGRAM'))
+                    .mockResolvedValueOnce(inspection('package-1', 'Bank', 0, 'SBAC')),
+                planImagePackageImport,
+                releaseImagePackageImportPlan: vi.fn().mockResolvedValue(undefined),
+            } as unknown as ImageTransport,
+            jobs: {} as JobController,
+            picker,
+            pickerHistory: new PackagePickerHistory(),
+            isDesktop: false,
+            sessionId: () => 17,
+            invalidateSession: vi.fn().mockResolvedValue(undefined),
+            refreshSession: vi.fn().mockResolvedValue(undefined),
+            setStatus: vi.fn(),
+            sourceItems: () => [partition],
+        });
+
+        workflow.open(volume);
+        const choosing = workflow.chooseWorkspace();
+        picker.finish(sources);
+        await choosing;
+
+        expect(workflow.request?.destinationStrategy).toBe('shared');
+        expect(workflow.canUseSeparateVolumes()).toBe(false);
+        expect(planImagePackageImport).toHaveBeenCalledWith(
+            17,
+            sources,
+            { kind: 'EXISTING_VOLUME', partitionIndex: 0, volumeName: 'Target' },
+            [],
+            [],
+            undefined,
+            [],
+        );
+    });
+
+    it('plans multiple portable packages into one explicitly named new volume', async () => {
+        const sources = [
+            serverFileLocation({ rootId: 'workspace', relativePath: 'one.axkprg' }, 'one.axkprg'),
+            serverFileLocation({ rootId: 'workspace', relativePath: 'two.axksbnk' }, 'two.axksbnk'),
+        ];
+        const planImagePackageImport = vi.fn().mockResolvedValue(plan(['Combined', 'Combined'], 'shared-plan'));
+        const picker = new PickerController(() => undefined);
+        const partition: DiskTreeItem = {
+            id: 'partition-0',
+            name: 'Partition 1',
+            kind: 'partition',
+            childCount: 0,
+            partitionIndex: 0,
+        };
+        const workflow = new PackageBatchImportWorkflow({
+            transport: {
+                inspectPackage: vi
+                    .fn()
+                    .mockResolvedValueOnce(inspection('package-0', 'Program', 1, 'PROGRAM'))
+                    .mockResolvedValueOnce(inspection('package-1', 'Sample', 0, 'SBNK')),
+                planImagePackageImport,
+                releaseImagePackageImportPlan: vi.fn().mockResolvedValue(undefined),
+            } as unknown as ImageTransport,
+            jobs: {} as JobController,
+            picker,
+            pickerHistory: new PackagePickerHistory(),
+            isDesktop: false,
+            sessionId: () => 17,
+            invalidateSession: vi.fn().mockResolvedValue(undefined),
+            refreshSession: vi.fn().mockResolvedValue(undefined),
+            setStatus: vi.fn(),
+            sourceItems: () => [partition],
+        });
+
+        workflow.open(partition);
+        const choosing = workflow.chooseWorkspace();
+        picker.finish(sources);
+        await choosing;
+
+        expect(workflow.request?.destinationStrategy).toBe('shared');
+        expect(workflow.request?.destinationMode).toBe('create');
+        expect(workflow.canUseSeparateVolumes()).toBe(false);
+        workflow.setDestinationVolumeName('Combined');
+        await workflow.replan();
+
+        expect(planImagePackageImport).toHaveBeenCalledTimes(1);
+        expect(planImagePackageImport).toHaveBeenCalledWith(
+            17,
+            sources,
+            { kind: 'CREATE_VOLUME', partitionIndex: 0, volumeName: 'Combined' },
+            [],
+            [],
+            undefined,
+            [],
+        );
     });
 
     it('refreshes and replans automatically when the image changed before apply', async () => {
diff --git a/apps/axkdeck/src/lib/components/PackageBatchConflictControls.svelte b/apps/axkdeck/src/lib/components/PackageBatchConflictControls.svelte
new file mode 100644
index 00000000..a52efc84
--- /dev/null
+++ b/apps/axkdeck/src/lib/components/PackageBatchConflictControls.svelte
@@ -0,0 +1,247 @@
+<script lang="ts">
+    import { batchDecisionKey } from '../../features/import/packageBatchPlanning';
+    import type { BatchPackageItem } from '../../features/import/packageBatchTypes';
+    import type { ImageSessionPackageImportPlan } from '../transport';
+
+    interface Props {
+        items: BatchPackageItem[];
+        plan: ImageSessionPackageImportPlan;
+        renames: Record<string, string>;
+        programSlots: Record<string, number>;
+        disabled: boolean;
+        onrename: (itemId: string, nodeId: string, name: string) => void;
+        onprogramslot: (itemId: string, nodeId: string, slot: number) => void;
+        onprogramstart: (placementId: string, start: number) => void;
+    }
+
+    const renameConflictCodes = new Set([
+        'SFS_NAME_CONFLICT',
+        'SFS_TARGET_NAME_AMBIGUOUS',
+        'FAT12_NAME_CONFLICT',
+        'FAT12_TARGET_NAME_AMBIGUOUS',
+        'ISO9660_NAME_CONFLICT',
+        'ISO9660_TARGET_NAME_AMBIGUOUS',
+    ]);
+
+    let { items, plan, renames, programSlots, disabled, onrename, onprogramslot, onprogramstart }: Props = $props();
+
+    const placementKeys = $derived(
+        new Set(
+            plan.programSlotPlacements.flatMap((placement) =>
+                placement.mappings.map((mapping) => `${mapping.packageIndex}:${mapping.nodeId}`),
+            ),
+        ),
+    );
+    const renameActions = $derived(
+        Array.from(
+            new Map(
+                plan.actions
+                    .filter(
+                        (action) =>
+                            !placementKeys.has(`${action.packageIndex}:${action.nodeId}`) &&
+                            action.actions.includes('CONFLICT') &&
+                            plan.conflicts.some(
+                                (conflict) =>
+                                    conflict.packageIndex === action.packageIndex &&
+                                    conflict.nodeId === action.nodeId &&
+                                    renameConflictCodes.has(conflict.code),
+                            ),
+                    )
+                    .map((action) => [`${action.packageIndex}:${action.nodeId}`, action]),
+            ).values(),
+        ),
+    );
+
+    function formatSlot(slot: number): string {
+        return String(slot).padStart(3, '0');
+    }
+
+    function formatRanges(ranges: { first: number; last: number }[]): string {
+        if (ranges.length === 0) return 'None';
+        return ranges
+            .map((range) =>
+                range.first === range.last
+                    ? formatSlot(range.first)
+                    : `${formatSlot(range.first)}–${formatSlot(range.last)}`,
+            )
+            .join(', ');
+    }
+
+    function assignmentKey(packageIndex: number, nodeId: string): string {
+        const item = items[packageIndex];
+        return item ? batchDecisionKey(item.id, nodeId) : '';
+    }
+
+    function placementHasChanges(placement: ImageSessionPackageImportPlan['programSlotPlacements'][number]): boolean {
+        return placement.mappings.some((mapping) => {
+            const key = assignmentKey(mapping.packageIndex, mapping.nodeId);
+            return key.length > 0 && (programSlots[key] ?? mapping.destinationSlot) !== mapping.destinationSlot;
+        });
+    }
+</script>
+
+{#if plan.programSlotPlacements.length > 0}
+    <section class="batch-program-slots" aria-label="Program slot placement">
+        {#each plan.programSlotPlacements as placement (placement.placementId)}
+            {@const firstMapping = placement.mappings[0]}
+            {@const firstKey = firstMapping ? assignmentKey(firstMapping.packageIndex, firstMapping.nodeId) : ''}
+            <div class:pending={!placement.applied || placementHasChanges(placement)} class="program-placement">
+                <div class="placement-heading">
+                    <strong>Program slots</strong>
+                    <small>
+                        {placement.mode === 'UNAVAILABLE'
+                            ? 'Not enough free slots'
+                            : placementHasChanges(placement)
+                              ? 'Needs check'
+                              : placement.applied
+                                ? 'Checked'
+                                : 'Suggested'}
+                    </small>
+                </div>
+                <dl>
+                    <div>
+                        <dt>Occupied</dt>
+                        <dd>{formatRanges(placement.occupiedRanges)}</dd>
+                    </div>
+                    <div>
+                        <dt>Package</dt>
+                        <dd>{formatRanges(placement.sourceRanges)}</dd>
+                    </div>
+                    <div>
+                        <dt>Destination</dt>
+                        <dd>{formatRanges(placement.destinationRanges)}</dd>
+                    </div>
+                </dl>
+                {#if placement.mode === 'UNAVAILABLE'}
+                    <p>
+                        {placement.requiredSlotCount} slots are required, but only {placement.availableSlotCount} are available.
+                    </p>
+                {:else if placement.mode === 'CONTIGUOUS'}
+                    <label class="slot-control">
+                        <span>Destination start</span>
+                        <input
+                            class="dialog-field-control"
+                            type="number"
+                            min="1"
+                            max={128 - placement.requiredSlotCount + 1}
+                            {disabled}
+                            value={programSlots[firstKey] ?? placement.suggestedStartSlot ?? 1}
+                            oninput={(event) =>
+                                onprogramstart(placement.placementId, event.currentTarget.valueAsNumber)}
+                        />
+                    </label>
+                {:else}
+                    <div class="slot-exceptions">
+                        {#each placement.mappings as mapping (`${mapping.packageIndex}:${mapping.nodeId}`)}
+                            {@const item = items[mapping.packageIndex]}
+                            {@const key = assignmentKey(mapping.packageIndex, mapping.nodeId)}
+                            {#if item}
+                                <label class="slot-control">
+                                    <span>{item.sourceName} · Program {formatSlot(mapping.sourceSlot)}</span>
+                                    <input
+                                        class="dialog-field-control"
+                                        type="number"
+                                        min="1"
+                                        max="128"
+                                        {disabled}
+                                        value={programSlots[key] ?? mapping.destinationSlot}
+                                        oninput={(event) =>
+                                            onprogramslot(item.id, mapping.nodeId, event.currentTarget.valueAsNumber)}
+                                    />
+                                </label>
+                            {/if}
+                        {/each}
+                    </div>
+                {/if}
+            </div>
+        {/each}
+    </section>
+{/if}
+
+{#if renameActions.length > 0}
+    <section class="batch-renames" aria-label="Destination names">
+        <strong>Choose unused destination names</strong>
+        {#each renameActions as action (`${action.packageIndex}:${action.actionId}`)}
+            {@const item = items[action.packageIndex]}
+            {@const key = item ? batchDecisionKey(item.id, action.nodeId) : ''}
+            {#if item}
+                <label>
+                    <span>{item.sourceName} · {action.sourceName}</span>
+                    <input
+                        class="dialog-field-control"
+                        value={renames[key] ?? action.destinationName}
+                        maxlength="16"
+                        {disabled}
+                        oninput={(event) => onrename(item.id, action.nodeId, event.currentTarget.value)}
+                    />
+                </label>
+            {/if}
+        {/each}
+    </section>
+{/if}
+
+<style>
+    .batch-program-slots,
+    .batch-renames {
+        display: grid;
+        gap: 10px;
+        margin-top: 10px;
+    }
+
+    .program-placement,
+    .batch-renames {
+        padding: 10px;
+        border: 1px solid var(--color-border);
+        border-radius: 5px;
+        background: rgb(255 255 255 / 2%);
+    }
+
+    .program-placement.pending {
+        border-color: #765d2d;
+    }
+
+    .placement-heading {
+        display: flex;
+        justify-content: space-between;
+        gap: 12px;
+    }
+
+    .placement-heading small,
+    dt {
+        color: var(--color-text-muted);
+    }
+
+    dl {
+        display: grid;
+        gap: 4px;
+        margin: 8px 0;
+    }
+
+    dl div,
+    .slot-control,
+    .batch-renames label {
+        display: grid;
+        grid-template-columns: minmax(150px, 1fr) minmax(90px, 0.4fr);
+        align-items: center;
+        gap: 10px;
+    }
+
+    dt,
+    dd,
+    p {
+        margin: 0;
+    }
+
+    .slot-exceptions {
+        display: grid;
+        gap: 6px;
+    }
+
+    @media (max-width: 620px) {
+        dl div,
+        .slot-control,
+        .batch-renames label {
+            grid-template-columns: 1fr;
+        }
+    }
+</style>
diff --git a/apps/axkdeck/src/lib/components/PackageBatchDestinationChooser.svelte b/apps/axkdeck/src/lib/components/PackageBatchDestinationChooser.svelte
new file mode 100644
index 00000000..fd1fb9dd
--- /dev/null
+++ b/apps/axkdeck/src/lib/components/PackageBatchDestinationChooser.svelte
@@ -0,0 +1,163 @@
+<script lang="ts">
+    import type {
+        ImportDestinationMode,
+        ImportPartitionOption,
+        ImportVolumeOption,
+    } from '../../features/import/packageDestinations';
+    import type { PackageBatchDestinationStrategy } from '../../features/import/packageBatchTypes';
+    import ImportDestinationChooser from './ImportDestinationChooser.svelte';
+
+    interface Props {
+        strategy: PackageBatchDestinationStrategy;
+        mode: ImportDestinationMode;
+        partitionIndex: number | null;
+        volumeName: string;
+        partitions: ImportPartitionOption[];
+        volumes: ImportVolumeOption[];
+        separateAvailable: boolean;
+        disabled: boolean;
+        onstrategy: (strategy: PackageBatchDestinationStrategy) => void;
+        onmode: (mode: ImportDestinationMode) => void;
+        onvolume: (partitionIndex: number | null, volumeName: string) => void;
+        onpartition: (partitionIndex: number) => void;
+        onname: (name: string) => void;
+    }
+
+    let {
+        strategy,
+        mode,
+        partitionIndex,
+        volumeName,
+        partitions,
+        volumes,
+        separateAvailable,
+        disabled,
+        onstrategy,
+        onmode,
+        onvolume,
+        onpartition,
+        onname,
+    }: Props = $props();
+</script>
+
+<section class="batch-destination" aria-label="Batch destination">
+    <div class="strategy-heading">
+        <strong>Placement</strong>
+        <div class="strategy-control" role="group" aria-label="Package placement">
+            <button
+                type="button"
+                class:active={strategy === 'shared'}
+                aria-pressed={strategy === 'shared'}
+                {disabled}
+                onclick={() => onstrategy('shared')}>One volume</button
+            >
+            <button
+                type="button"
+                class:active={strategy === 'separate'}
+                aria-pressed={strategy === 'separate'}
+                disabled={disabled || !separateAvailable}
+                title={separateAvailable
+                    ? 'Create one volume for each package'
+                    : 'Separate volumes require only Volume packages'}
+                onclick={() => onstrategy('separate')}>Separate volumes</button
+            >
+        </div>
+    </div>
+
+    {#if strategy === 'shared'}
+        <ImportDestinationChooser
+            {mode}
+            {partitionIndex}
+            {volumeName}
+            {partitions}
+            {volumes}
+            {disabled}
+            {onmode}
+            {onvolume}
+            {onpartition}
+            {onname}
+        />
+    {:else}
+        <label class="partition-field">
+            <span>Partition</span>
+            <select
+                class="dialog-field-control"
+                value={partitionIndex ?? ''}
+                disabled={disabled || partitions.length === 0}
+                onchange={(event) => onpartition(Number(event.currentTarget.value))}
+            >
+                {#each partitions as option (option.partitionIndex)}
+                    <option value={option.partitionIndex}>{option.name}</option>
+                {/each}
+            </select>
+        </label>
+        <small>Each selected package creates a volume using its placement hint and editable name below.</small>
+    {/if}
+</section>
+
+<style>
+    .batch-destination {
+        display: grid;
+        gap: 10px;
+        margin-bottom: 10px;
+        padding: 10px;
+        border: 1px solid var(--color-border);
+        border-radius: 6px;
+        background: rgb(255 255 255 / 2%);
+    }
+
+    .strategy-heading {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        gap: 12px;
+    }
+
+    .strategy-control {
+        display: flex;
+    }
+
+    .strategy-control button {
+        min-height: 32px;
+        padding: 0 12px;
+        border: 1px solid var(--color-border);
+        color: var(--color-text-muted);
+        background: var(--color-bg-deep);
+    }
+
+    .strategy-control button:first-child {
+        border-radius: 5px 0 0 5px;
+    }
+
+    .strategy-control button:last-child {
+        margin-left: -1px;
+        border-radius: 0 5px 5px 0;
+    }
+
+    .strategy-control button.active {
+        color: #fff;
+        background: var(--color-accent-strong);
+    }
+
+    .partition-field {
+        display: grid;
+        grid-template-columns: minmax(100px, 0.35fr) minmax(180px, 1fr);
+        align-items: center;
+        gap: 10px;
+    }
+
+    .batch-destination > small {
+        color: var(--color-text-muted);
+    }
+
+    @media (max-width: 620px) {
+        .strategy-heading {
+            align-items: flex-start;
+            flex-direction: column;
+        }
+
+        .partition-field {
+            grid-template-columns: 1fr;
+        }
+    }
+</style>
diff --git a/apps/axkdeck/src/lib/components/PackageBatchImportDialog.svelte b/apps/axkdeck/src/lib/components/PackageBatchImportDialog.svelte
index 648cd565..384e1fed 100644
--- a/apps/axkdeck/src/lib/components/PackageBatchImportDialog.svelte
+++ b/apps/axkdeck/src/lib/components/PackageBatchImportDialog.svelte
@@ -1,18 +1,44 @@
 <script lang="ts">
     import { tick } from 'svelte';
-    import type { BatchPackageItem } from '../../features/import/packageBatchWorkflow.svelte';
+    import type { BatchPackageItem, PackageBatchDestinationStrategy } from '../../features/import/packageBatchTypes';
+    import type {
+        ImportDestinationMode,
+        ImportPartitionOption,
+        ImportVolumeOption,
+    } from '../../features/import/packageDestinations';
     import { formatStoredSize } from '../formatBytes';
     import { modal } from '../modal';
     import type { ImageSessionPackageImportPlan, PackageOpaqueSequenceDecision } from '../transport';
     import Icon from './Icon.svelte';
     import ImportSourceChoice from './ImportSourceChoice.svelte';
+    import PackageBatchConflictControls from './PackageBatchConflictControls.svelte';
+    import PackageBatchDestinationChooser from './PackageBatchDestinationChooser.svelte';
+    import PackageBatchItemsTable from './PackageBatchItemsTable.svelte';
+
+    const renameConflictCodes = new Set([
+        'SFS_NAME_CONFLICT',
+        'SFS_TARGET_NAME_AMBIGUOUS',
+        'FAT12_NAME_CONFLICT',
+        'FAT12_TARGET_NAME_AMBIGUOUS',
+        'ISO9660_NAME_CONFLICT',
+        'ISO9660_TARGET_NAME_AMBIGUOUS',
+    ]);
 
     interface Props {
-        partitionName: string;
         desktop: boolean;
+        canChangeSources: boolean;
         items: BatchPackageItem[];
         plan: ImageSessionPackageImportPlan | null;
+        destinationStrategy: PackageBatchDestinationStrategy;
+        destinationMode: ImportDestinationMode;
+        destinationPartitionIndex: number | null;
+        destinationVolumeName: string;
+        partitionOptions: ImportPartitionOption[];
+        volumeOptions: ImportVolumeOption[];
+        separateVolumesAvailable: boolean;
         volumeNames: Record<string, string>;
+        renames: Record<string, string>;
+        programSlots: Record<string, number>;
         opaqueSequenceActions: Record<string, PackageOpaqueSequenceDecision['action']>;
         hasUnvalidatedChanges: boolean;
         status: 'choosing' | 'loading' | 'planning' | 'ready' | 'applying';
@@ -22,7 +48,15 @@
         error: string;
         onchooseworkspace: () => void;
         onchooselocal: () => void;
-        onrename: (itemId: string, name: string) => void;
+        ondestinationstrategy: (strategy: PackageBatchDestinationStrategy) => void;
+        ondestinationmode: (mode: ImportDestinationMode) => void;
+        ondestinationvolume: (partitionIndex: number | null, volumeName: string) => void;
+        ondestinationpartition: (partitionIndex: number) => void;
+        ondestinationname: (name: string) => void;
+        onrenamevolume: (itemId: string, name: string) => void;
+        onrename: (itemId: string, nodeId: string, name: string) => void;
+        onprogramslot: (itemId: string, nodeId: string, slot: number) => void;
+        onprogramstart: (placementId: string, start: number) => void;
         ontoggleselected: (itemId: string, selected: boolean) => void;
         ontoggleall: (selected: boolean) => void;
         onopaquesequenceaction: (
@@ -36,11 +70,20 @@
     }
 
     let {
-        partitionName,
         desktop,
+        canChangeSources,
         items,
         plan,
+        destinationStrategy,
+        destinationMode,
+        destinationPartitionIndex,
+        destinationVolumeName,
+        partitionOptions,
+        volumeOptions,
+        separateVolumesAvailable,
         volumeNames,
+        renames,
+        programSlots,
         opaqueSequenceActions,
         hasUnvalidatedChanges,
         status,
@@ -50,7 +93,15 @@
         error,
         onchooseworkspace,
         onchooselocal,
+        ondestinationstrategy,
+        ondestinationmode,
+        ondestinationvolume,
+        ondestinationpartition,
+        ondestinationname,
+        onrenamevolume,
         onrename,
+        onprogramslot,
+        onprogramstart,
         ontoggleselected,
         ontoggleall,
         onopaquesequenceaction,
@@ -58,20 +109,15 @@
         oncancel,
         onconfirm,
     }: Props = $props();
-    let selectAllCheckbox = $state<HTMLInputElement>();
     let batchPackageContent = $state<HTMLDivElement>();
 
     const busy = $derived(status === 'loading' || status === 'planning' || status === 'applying');
     const locked = $derived(status === 'applying');
+    const changeSources = $derived(items.some((item) => item.localPath !== null) ? onchooselocal : onchooseworkspace);
     const selectedItems = $derived(items.filter((item) => item.selected));
     const selectedCount = $derived(selectedItems.length);
-    const allSelected = $derived(items.length > 0 && selectedCount === items.length);
-    const someSelected = $derived(selectedCount > 0 && !allSelected);
-    const selectedPackageIndexById = $derived(
-        new Map(selectedItems.map((item, packageIndex) => [item.id, packageIndex])),
-    );
     const canImport = $derived(
-        status === 'ready' && Boolean(plan?.valid) && !hasUnvalidatedChanges && selectedCount > 0,
+        status === 'ready' && Boolean(plan?.valid) && !hasUnvalidatedChanges && selectedCount > 0 && !error,
     );
     const summaries = $derived(hasUnvalidatedChanges ? [] : (plan?.packages ?? []));
     const totalObjects = $derived(
@@ -84,37 +130,35 @@
             ? selectedItems.reduce((total, item) => total + item.inspection.totalPayloadBytes, 0)
             : summaries.reduce((total, item) => total + item.payloadBytes, 0),
     );
-    const capacityReports = $derived(
-        hasUnvalidatedChanges ? [] : (plan?.sfsIndexCapacity.filter((capacity) => capacity.packages.length > 0) ?? []),
+    const placementNodes = $derived(
+        new Set(
+            plan?.programSlotPlacements.flatMap((placement) =>
+                placement.mappings.map((mapping) => `${mapping.packageIndex}:${mapping.nodeId}`),
+            ) ?? [],
+        ),
+    );
+    const actionableRenameNodes = $derived(
+        new Set(
+            plan?.actions
+                .filter((action) => action.actions.includes('CONFLICT'))
+                .map((action) => `${action.packageIndex}:${action.nodeId}`) ?? [],
+        ),
     );
-    const capacityByPackage = $derived.by(() => {
-        const result = new Map<number, (typeof capacityReports)[number]['packages'][number]>();
-        for (const capacity of capacityReports) {
-            for (const usage of capacity.packages) result.set(usage.packageIndex, usage);
-        }
-        return result;
-    });
-    const allocatableRecordsByPackage = $derived.by(() => {
-        const result = new Map<number, number>();
-        for (const capacity of capacityReports) {
-            for (const usage of capacity.packages) result.set(usage.packageIndex, capacity.allocatableRecordSlots);
-        }
-        return result;
-    });
     const visibleConflicts = $derived(
         hasUnvalidatedChanges
             ? []
             : (plan?.conflicts.filter(
                   (conflict) =>
                       conflict.code !== 'OPAQUE_SEQUENCE_DECISION_REQUIRED' &&
-                      conflict.code !== 'SFS_RECORD_CAPACITY_EXHAUSTED',
+                      conflict.code !== 'SFS_RECORD_CAPACITY_EXHAUSTED' &&
+                      !(
+                          renameConflictCodes.has(conflict.code) &&
+                          (placementNodes.has(`${conflict.packageIndex}:${conflict.nodeId}`) ||
+                              actionableRenameNodes.has(`${conflict.packageIndex}:${conflict.nodeId}`))
+                      ),
               ) ?? []),
     );
 
-    $effect(() => {
-        if (selectAllCheckbox) selectAllCheckbox.indeterminate = someSelected;
-    });
-
     function opaqueKey(itemId: string, nodeId: string): string {
         return `${itemId}:${nodeId}`;
     }
@@ -141,7 +185,7 @@
         <header class="dialog-header">
             <div>
                 <Icon name="archive" size={16} />
-                <h2 id="batch-package-title">Import volume packages</h2>
+                <h2 id="batch-package-title">Import packages</h2>
             </div>
             <button class="icon-button" type="button" aria-label="Close" disabled={locked} onclick={oncancel}>×</button>
         </header>
@@ -149,18 +193,18 @@
         <div class="batch-package-content" bind:this={batchPackageContent}>
             {#if items.length === 0 && status === 'choosing'}
                 <ImportSourceChoice
-                    label="Volume package sources"
-                    heading="Choose volume packages"
-                    description={`Create volumes in ${partitionName} from selected .axkvol packages.`}
-                    workspaceDetail="Select one or more .axkvol files"
-                    computerDetail="Select local .axkvol files and upload them"
+                    label="Package sources"
+                    heading="Choose packages"
+                    description="Import portable axklib packages or A3K archives into the open SFS image."
+                    workspaceDetail="Select one or more package files"
+                    computerDetail="Select local package files and upload them"
                     computerAvailable={desktop}
                     {onchooseworkspace}
                     {onchooselocal}
                 />
             {:else if status === 'loading'}
                 <section class="batch-progress" aria-live="polite">
-                    <strong>Preparing volume packages</strong>
+                    <strong>Preparing packages</strong>
                     <progress value={Math.max(completedFiles, progress)} max={Math.max(1, totalFiles)}></progress>
                     <small>{completedFiles} of {totalFiles} files inspected</small>
                 </section>
@@ -171,15 +215,36 @@
                             >{selectedCount} of {items.length} package{items.length === 1 ? '' : 's'} selected</strong
                         >
                         <small>
-                            {selectedCount} volume{selectedCount === 1 ? '' : 's'} will be created · {totalObjects}
-                            objects · {formatStoredSize(totalPayload)}
+                            {destinationStrategy === 'separate'
+                                ? `${selectedCount} volume${selectedCount === 1 ? '' : 's'} will be created`
+                                : `${selectedCount} package${selectedCount === 1 ? '' : 's'} will be imported into one volume`}
+                            · {totalObjects} objects · {formatStoredSize(totalPayload)}
                         </small>
                     </div>
-                    <button class="secondary-button" type="button" disabled={busy} onclick={onchooseworkspace}>
-                        Change files
-                    </button>
+                    {#if canChangeSources}<button
+                            class="secondary-button"
+                            type="button"
+                            disabled={busy}
+                            onclick={changeSources}>Change files</button
+                        >{/if}
                 </section>
 
+                <PackageBatchDestinationChooser
+                    strategy={destinationStrategy}
+                    mode={destinationMode}
+                    partitionIndex={destinationPartitionIndex}
+                    volumeName={destinationVolumeName}
+                    partitions={partitionOptions}
+                    volumes={volumeOptions}
+                    separateAvailable={separateVolumesAvailable}
+                    disabled={busy}
+                    onstrategy={ondestinationstrategy}
+                    onmode={ondestinationmode}
+                    onvolume={ondestinationvolume}
+                    onpartition={ondestinationpartition}
+                    onname={ondestinationname}
+                />
+
                 {#if hasUnvalidatedChanges}
                     <p class="batch-plan-stale" role="status">
                         {selectedCount === 0
@@ -188,131 +253,18 @@
                     </p>
                 {/if}
 
-                {#each capacityReports as capacity (capacity.partitionIndex)}
-                    <section
-                        class:capacity-unavailable={capacity.shortfallRecordSlots > 0}
-                        class="capacity-summary"
-                        aria-label={`SFS record capacity for partition ${capacity.partitionIndex + 1}`}
-                    >
-                        <div class="capacity-heading">
-                            <strong>SFS record capacity</strong>
-                            <small
-                                >Partition {capacity.partitionIndex + 1} · {capacity.indexBlockCount} blocks ×
-                                {capacity.recordsPerIndexBlock} records · {capacity.reservedRecordSlots} reserved</small
-                            >
-                        </div>
-                        <div class="capacity-metrics">
-                            <span>{capacity.freeRecordSlots} free</span>
-                            <span>{capacity.requiredRecordSlots} required</span>
-                            {#if capacity.shortfallRecordSlots > 0}
-                                <strong>{capacity.shortfallRecordSlots} short</strong>
-                            {:else}
-                                <span>{capacity.remainingRecordSlots} remaining</span>
-                            {/if}
-                        </div>
-                    </section>
-                {/each}
-
-                <div class="batch-table" role="table" aria-label="Volumes to create">
-                    <div class="batch-table-header" role="row">
-                        <span class="selection-cell" role="columnheader">
-                            <input
-                                bind:this={selectAllCheckbox}
-                                type="checkbox"
-                                checked={allSelected}
-                                disabled={busy}
-                                aria-label="Select all packages"
-                                onchange={(event) => ontoggleall(event.currentTarget.checked)}
-                            />
-                        </span>
-                        <span role="columnheader">Package</span>
-                        <span role="columnheader">New volume</span>
-                        <span role="columnheader">Contents</span>
-                        <span role="columnheader">SFS records</span>
-                    </div>
-                    {#each items as item (item.id)}
-                        {@const packageIndex = selectedPackageIndexById.get(item.id)}
-                        {@const summary = summaries.find((entry) => entry.packageIndex === packageIndex)}
-                        {@const recordUsage =
-                            packageIndex === undefined ? undefined : capacityByPackage.get(packageIndex)}
-                        {@const allocatableRecords =
-                            packageIndex === undefined ? 0 : (allocatableRecordsByPackage.get(packageIndex) ?? 0)}
-                        {@const cannotFitEmptyPartition =
-                            recordUsage !== undefined && recordUsage.standaloneRequiredRecordSlots > allocatableRecords}
-                        <div class:row-excluded={!item.selected} class="batch-table-row" role="row">
-                            <div class="selection-cell" role="cell">
-                                <input
-                                    type="checkbox"
-                                    checked={item.selected}
-                                    disabled={busy}
-                                    aria-label={`Include ${item.sourceName}`}
-                                    onchange={(event) => ontoggleselected(item.id, event.currentTarget.checked)}
-                                />
-                            </div>
-                            <div role="cell">
-                                <strong>{item.sourceName}</strong>
-                                <small>{formatStoredSize(item.inspection.totalPayloadBytes)}</small>
-                            </div>
-                            <div role="cell">
-                                <label>
-                                    <span class="sr-only">New volume name for {item.sourceName}</span>
-                                    <input
-                                        type="text"
-                                        value={volumeNames[item.id] ??
-                                            summary?.destinationVolumeName ??
-                                            item.inspection.roots[0]?.displayName ??
-                                            ''}
-                                        maxlength="16"
-                                        disabled={busy || !item.selected}
-                                        oninput={(event) => onrename(item.id, event.currentTarget.value)}
-                                    />
-                                </label>
-                            </div>
-                            <div class="object-counts" role="cell">
-                                {#if summary}
-                                    <span>{summary.objectCounts.programs} Programs</span>
-                                    <span>{summary.objectCounts.sampleBanks} Sample Banks</span>
-                                    <span>{summary.objectCounts.samples} Samples</span>
-                                    <span>{summary.objectCounts.waveData} Wave Data</span>
-                                    <span>{summary.objectCounts.sequences} Sequences</span>
-                                {:else}
-                                    <span>{item.inspection.objects.length} objects</span>
-                                {/if}
-                            </div>
-                            <div
-                                class:record-unavailable={Boolean(recordUsage?.shortfallRecordSlots)}
-                                class:record-impossible={cannotFitEmptyPartition}
-                                class="record-usage"
-                                role="cell"
-                                title={cannotFitEmptyPartition
-                                    ? `Requires ${recordUsage?.standaloneRequiredRecordSlots} records on an empty partition; maximum ${allocatableRecords}`
-                                    : undefined}
-                            >
-                                {#if !item.selected}
-                                    <span>Not included</span>
-                                {:else if hasUnvalidatedChanges}
-                                    <span>Pending check</span>
-                                {:else if recordUsage}
-                                    <span>{recordUsage.plannedRecordSlots}</span>
-                                    <small>
-                                        {recordUsage.plannedObjectRecordSlots} objects
-                                        {#if recordUsage.volumeScaffoldingRecordSlots > 0}
-                                            + {recordUsage.volumeScaffoldingRecordSlots} volume
-                                        {/if}
-                                        {#if recordUsage.reusedObjectCount > 0}
-                                            · {recordUsage.reusedObjectCount} reused
-                                        {/if}
-                                        {#if recordUsage.shortfallRecordSlots > 0}
-                                            · {recordUsage.shortfallRecordSlots} short
-                                        {/if}
-                                    </small>
-                                {:else}
-                                    <span>—</span>
-                                {/if}
-                            </div>
-                        </div>
-                    {/each}
-                </div>
+                <PackageBatchItemsTable
+                    {items}
+                    {plan}
+                    {destinationStrategy}
+                    {destinationVolumeName}
+                    {volumeNames}
+                    {hasUnvalidatedChanges}
+                    {busy}
+                    {onrenamevolume}
+                    {ontoggleselected}
+                    {ontoggleall}
+                />
 
                 {#if !hasUnvalidatedChanges && plan?.opaqueSequences.length}
                     <section class="batch-sequence-decisions" aria-label="Sequence decisions">
@@ -351,6 +303,19 @@
                     </section>
                 {/if}
 
+                {#if !hasUnvalidatedChanges && plan}
+                    <PackageBatchConflictControls
+                        items={selectedItems}
+                        {plan}
+                        {renames}
+                        {programSlots}
+                        disabled={busy}
+                        {onrename}
+                        {onprogramslot}
+                        {onprogramstart}
+                    />
+                {/if}
+
                 {#if visibleConflicts.length > 0}
                     <section class="batch-conflicts" role="alert">
                         <strong
@@ -427,128 +392,16 @@
         margin-bottom: 10px;
     }
 
-    .capacity-summary {
-        display: flex;
-        align-items: center;
-        justify-content: space-between;
-        gap: 16px;
-        margin-bottom: 10px;
-        padding: 8px 10px;
-        border: 1px solid var(--border-strong);
-        border-radius: 6px;
-        background: var(--color-panel-raised);
-    }
-
-    .capacity-heading {
-        display: grid;
-        gap: 3px;
-    }
-
-    .capacity-heading small,
-    .record-usage small {
-        color: var(--text-muted);
-    }
-
-    .capacity-metrics {
-        display: flex;
-        flex-wrap: wrap;
-        justify-content: flex-end;
-        gap: 6px 16px;
-        white-space: nowrap;
-    }
-
-    .capacity-unavailable {
-        border-color: #765d2d;
-        background: rgb(150 108 26 / 10%);
-    }
-
-    .capacity-unavailable .capacity-metrics strong,
-    .record-unavailable,
-    .record-impossible {
-        color: var(--color-danger);
-    }
-
-    .batch-summary div,
-    .batch-table-row > div:first-child {
+    .batch-summary div {
         display: grid;
         gap: 4px;
     }
 
     .batch-summary small,
-    .batch-table-row small,
     .batch-sequence-decisions small {
         color: var(--text-muted);
     }
 
-    .batch-table {
-        border: 1px solid var(--border-strong);
-        border-radius: 6px;
-        overflow: hidden;
-    }
-
-    .batch-table-header,
-    .batch-table-row {
-        display: grid;
-        grid-template-columns:
-            30px minmax(170px, 1.1fr) minmax(160px, 0.8fr) minmax(240px, 1.4fr)
-            minmax(105px, 0.55fr);
-        gap: 12px;
-        padding-inline: 10px;
-    }
-
-    .batch-table-header {
-        align-items: center;
-        padding-block: 7px;
-        color: var(--text-muted);
-        background: var(--color-panel-raised);
-        font-size: 12px;
-    }
-
-    .batch-table-row {
-        align-items: start;
-        padding-block: 6px;
-    }
-
-    .batch-table-row + .batch-table-row {
-        border-top: 1px solid var(--border-subtle);
-    }
-
-    .batch-table-row input[type='text'] {
-        width: 100%;
-        min-width: 0;
-    }
-
-    .selection-cell {
-        display: flex;
-        align-items: center;
-        justify-content: center;
-    }
-
-    .selection-cell input {
-        margin: 0;
-    }
-
-    .batch-table-row .selection-cell {
-        padding-top: 2px;
-    }
-
-    .row-excluded > :not(.selection-cell) {
-        opacity: 0.55;
-    }
-
-    .object-counts {
-        display: flex;
-        flex-wrap: wrap;
-        gap: 2px 10px;
-        color: var(--text-muted);
-        font-size: 12px;
-    }
-
-    .record-usage {
-        display: grid;
-        gap: 3px;
-    }
-
     .batch-plan-stale {
         margin: 0 0 10px;
         color: var(--text-muted);
@@ -600,32 +453,4 @@
         gap: 8px;
         margin-left: auto;
     }
-
-    @media (max-width: 760px) {
-        .batch-table-header {
-            display: none;
-        }
-
-        .batch-table-row {
-            grid-template-columns: 30px 1fr;
-        }
-
-        .batch-table-row > :not(.selection-cell) {
-            grid-column: 2;
-        }
-
-        .capacity-summary {
-            align-items: flex-start;
-            flex-direction: column;
-        }
-
-        .capacity-metrics {
-            justify-content: flex-start;
-        }
-
-        .selection-cell {
-            grid-column: 1;
-            grid-row: 1;
-        }
-    }
 </style>
diff --git a/apps/axkdeck/src/lib/components/PackageBatchImportDialog.test.ts b/apps/axkdeck/src/lib/components/PackageBatchImportDialog.test.ts
index 04a25177..d21c38a5 100644
--- a/apps/axkdeck/src/lib/components/PackageBatchImportDialog.test.ts
+++ b/apps/axkdeck/src/lib/components/PackageBatchImportDialog.test.ts
@@ -4,10 +4,11 @@ import { resolve } from 'node:path';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { serverFileLocation } from '../storageLocations';
 import type { ImageSessionPackageImportPlan, PackageInspection } from '../transport';
-import type { BatchPackageItem } from '../../features/import/packageBatchWorkflow.svelte';
+import type { BatchPackageItem } from '../../features/import/packageBatchTypes';
 import PackageBatchImportDialog from './PackageBatchImportDialog.svelte';
 
 const dialogSource = readFileSync(resolve(process.cwd(), 'src/lib/components/PackageBatchImportDialog.svelte'), 'utf8');
+const tableSource = readFileSync(resolve(process.cwd(), 'src/lib/components/PackageBatchItemsTable.svelte'), 'utf8');
 
 function inspection(packageId: string, volumeName: string): PackageInspection {
     return {
@@ -114,7 +115,15 @@ const plan: ImageSessionPackageImportPlan = {
 const callbacks = {
     onchooseworkspace: vi.fn(),
     onchooselocal: vi.fn(),
+    ondestinationstrategy: vi.fn(),
+    ondestinationmode: vi.fn(),
+    ondestinationvolume: vi.fn(),
+    ondestinationpartition: vi.fn(),
+    ondestinationname: vi.fn(),
+    onrenamevolume: vi.fn(),
     onrename: vi.fn(),
+    onprogramslot: vi.fn(),
+    onprogramstart: vi.fn(),
     ontoggleselected: vi.fn(),
     ontoggleall: vi.fn(),
     onopaquesequenceaction: vi.fn(),
@@ -125,11 +134,27 @@ const callbacks = {
 
 function props() {
     return {
-        partitionName: 'Partition 1',
         desktop: false,
+        canChangeSources: true,
         items,
         plan,
+        destinationStrategy: 'separate' as const,
+        destinationMode: 'create' as const,
+        destinationPartitionIndex: 0,
+        destinationVolumeName: '',
+        partitionOptions: [{ partitionIndex: 0, name: 'Partition 1' }],
+        volumeOptions: [
+            {
+                partitionIndex: 0,
+                name: 'Partition 1',
+                volumeName: 'Existing',
+                label: 'Partition 1 / Existing',
+            },
+        ],
+        separateVolumesAvailable: true,
         volumeNames: { 'item-0': 'Drums', 'item-1': 'Drums 2' },
+        renames: {},
+        programSlots: {},
         opaqueSequenceActions: {},
         hasUnvalidatedChanges: false,
         status: 'ready' as const,
@@ -147,7 +172,7 @@ describe('PackageBatchImportDialog', () => {
     it('previews every destination and its object counts before one batch import', async () => {
         render(PackageBatchImportDialog, { props: props() });
 
-        expect(screen.getByRole('heading', { name: 'Import volume packages' })).toBeTruthy();
+        expect(screen.getByRole('heading', { name: 'Import packages' })).toBeTruthy();
         expect(screen.getByText('2 of 2 packages selected')).toBeTruthy();
         expect(screen.getByText(/2 volumes will be created/)).toBeTruthy();
         expect(screen.getAllByText('1 Programs')).toHaveLength(2);
@@ -167,7 +192,43 @@ describe('PackageBatchImportDialog', () => {
         await fireEvent.input(screen.getByLabelText('New volume name for two.axkvol'), {
             target: { value: 'Percussion' },
         });
-        expect(callbacks.onrename).toHaveBeenCalledWith('item-1', 'Percussion');
+        expect(callbacks.onrenamevolume).toHaveBeenCalledWith('item-1', 'Percussion');
+    });
+
+    it('uses the shared destination chooser for mixed package batches', async () => {
+        render(PackageBatchImportDialog, {
+            props: {
+                ...props(),
+                destinationStrategy: 'shared',
+                destinationMode: 'existing',
+                destinationVolumeName: 'Existing',
+                separateVolumesAvailable: false,
+            },
+        });
+
+        expect(screen.getByText(/2 packages will be imported into one volume/)).toBeTruthy();
+        expect(screen.getByRole('button', { name: 'One volume' }).getAttribute('aria-pressed')).toBe('true');
+        expect(screen.getByRole('button', { name: 'Separate volumes' }).hasAttribute('disabled')).toBe(true);
+        expect((screen.getByRole('combobox', { name: 'Volume' }) as HTMLInputElement).value).toBe(
+            'Partition 1 / Existing',
+        );
+
+        await fireEvent.click(screen.getByRole('button', { name: 'New volume' }));
+        expect(callbacks.ondestinationmode).toHaveBeenCalledWith('create');
+    });
+
+    it('changes native package selections with the native picker', async () => {
+        render(PackageBatchImportDialog, {
+            props: {
+                ...props(),
+                items: items.map((item) => ({ ...item, localPath: `/packages/${item.sourceName}` })),
+            },
+        });
+
+        await fireEvent.click(screen.getByRole('button', { name: 'Change files' }));
+
+        expect(callbacks.onchooselocal).toHaveBeenCalledOnce();
+        expect(callbacks.onchooseworkspace).not.toHaveBeenCalled();
     });
 
     it('keeps unchecked packages visible and exposes an indeterminate select-all control', async () => {
@@ -229,8 +290,8 @@ describe('PackageBatchImportDialog', () => {
         ).toEqual(['Check conflicts', 'Cancel', 'Import 2 packages']);
         expect(footer?.querySelector('.batch-package-footer-actions')).toBeTruthy();
         expect(screen.getByText('21').tagName).toBe('SPAN');
-        expect(dialogSource).toMatch(/\.batch-table-row\s*\{[^}]*align-items:\s*start;/s);
-        expect(dialogSource).toMatch(/\.batch-table-row\s*\{[^}]*padding-block:\s*6px;/s);
+        expect(tableSource).toMatch(/\.batch-table-row\s*\{[^}]*align-items:\s*start;/s);
+        expect(tableSource).toMatch(/\.batch-table-row\s*\{[^}]*padding-block:\s*6px;/s);
         expect(dialogSource).toMatch(/\.batch-package-footer\s*\{[^}]*flex-wrap:\s*wrap;/s);
     });
 
@@ -288,6 +349,7 @@ describe('PackageBatchImportDialog', () => {
 
         expect(screen.queryByText('Ready to import')).toBeNull();
         expect(screen.getByRole('alert').textContent).toContain('Alteration journal storage is full');
+        expect(screen.getByRole('button', { name: 'Import 2 packages' }).hasAttribute('disabled')).toBe(true);
     });
 
     it('summarizes record exhaustion without repeating every blocked object', () => {
diff --git a/apps/axkdeck/src/lib/components/PackageBatchItemsTable.svelte b/apps/axkdeck/src/lib/components/PackageBatchItemsTable.svelte
new file mode 100644
index 00000000..d32cfe11
--- /dev/null
+++ b/apps/axkdeck/src/lib/components/PackageBatchItemsTable.svelte
@@ -0,0 +1,306 @@
+<script lang="ts">
+    import type { BatchPackageItem, PackageBatchDestinationStrategy } from '../../features/import/packageBatchTypes';
+    import { formatStoredSize } from '../formatBytes';
+    import type { ImageSessionPackageImportPlan } from '../transport';
+
+    interface Props {
+        items: BatchPackageItem[];
+        plan: ImageSessionPackageImportPlan | null;
+        destinationStrategy: PackageBatchDestinationStrategy;
+        destinationVolumeName: string;
+        volumeNames: Record<string, string>;
+        hasUnvalidatedChanges: boolean;
+        busy: boolean;
+        onrenamevolume: (itemId: string, name: string) => void;
+        ontoggleselected: (itemId: string, selected: boolean) => void;
+        ontoggleall: (selected: boolean) => void;
+    }
+
+    let {
+        items,
+        plan,
+        destinationStrategy,
+        destinationVolumeName,
+        volumeNames,
+        hasUnvalidatedChanges,
+        busy,
+        onrenamevolume,
+        ontoggleselected,
+        ontoggleall,
+    }: Props = $props();
+    let selectAllCheckbox = $state<HTMLInputElement>();
+
+    const selectedItems = $derived(items.filter((item) => item.selected));
+    const allSelected = $derived(items.length > 0 && selectedItems.length === items.length);
+    const someSelected = $derived(selectedItems.length > 0 && !allSelected);
+    const packageIndexById = $derived(new Map(selectedItems.map((item, index) => [item.id, index])));
+    const summaries = $derived(hasUnvalidatedChanges ? [] : (plan?.packages ?? []));
+    const capacityReports = $derived(
+        hasUnvalidatedChanges ? [] : (plan?.sfsIndexCapacity.filter((capacity) => capacity.packages.length > 0) ?? []),
+    );
+    const capacityByPackage = $derived.by(() => {
+        const result = new Map<number, (typeof capacityReports)[number]['packages'][number]>();
+        for (const capacity of capacityReports) {
+            for (const usage of capacity.packages) result.set(usage.packageIndex, usage);
+        }
+        return result;
+    });
+    const allocatableRecordsByPackage = $derived.by(() => {
+        const result = new Map<number, number>();
+        for (const capacity of capacityReports) {
+            for (const usage of capacity.packages) result.set(usage.packageIndex, capacity.allocatableRecordSlots);
+        }
+        return result;
+    });
+
+    $effect(() => {
+        if (selectAllCheckbox) selectAllCheckbox.indeterminate = someSelected;
+    });
+</script>
+
+{#each capacityReports as capacity (capacity.partitionIndex)}
+    <section
+        class:capacity-unavailable={capacity.shortfallRecordSlots > 0}
+        class="capacity-summary"
+        aria-label={`SFS record capacity for partition ${capacity.partitionIndex + 1}`}
+    >
+        <div class="capacity-heading">
+            <strong>SFS record capacity</strong>
+            <small>
+                Partition {capacity.partitionIndex + 1} · {capacity.indexBlockCount} blocks ×
+                {capacity.recordsPerIndexBlock} records · {capacity.reservedRecordSlots} reserved
+            </small>
+        </div>
+        <div class="capacity-metrics">
+            <span>{capacity.freeRecordSlots} free</span>
+            <span>{capacity.requiredRecordSlots} required</span>
+            {#if capacity.shortfallRecordSlots > 0}
+                <strong>{capacity.shortfallRecordSlots} short</strong>
+            {:else}
+                <span>{capacity.remainingRecordSlots} remaining</span>
+            {/if}
+        </div>
+    </section>
+{/each}
+
+<div class="batch-table" role="table" aria-label="Packages to import">
+    <div class="batch-table-header" role="row">
+        <span class="selection-cell" role="columnheader">
+            <input
+                bind:this={selectAllCheckbox}
+                type="checkbox"
+                checked={allSelected}
+                disabled={busy}
+                aria-label="Select all packages"
+                onchange={(event) => ontoggleall(event.currentTarget.checked)}
+            />
+        </span>
+        <span role="columnheader">Package</span>
+        <span role="columnheader">Destination</span>
+        <span role="columnheader">Contents</span>
+        <span role="columnheader">SFS records</span>
+    </div>
+    {#each items as item (item.id)}
+        {@const packageIndex = packageIndexById.get(item.id)}
+        {@const summary = summaries.find((entry) => entry.packageIndex === packageIndex)}
+        {@const recordUsage = packageIndex === undefined ? undefined : capacityByPackage.get(packageIndex)}
+        {@const allocatableRecords =
+            packageIndex === undefined ? 0 : (allocatableRecordsByPackage.get(packageIndex) ?? 0)}
+        {@const cannotFitEmptyPartition =
+            recordUsage !== undefined && recordUsage.standaloneRequiredRecordSlots > allocatableRecords}
+        <div class:row-excluded={!item.selected} class="batch-table-row" role="row">
+            <div class="selection-cell" role="cell">
+                <input
+                    type="checkbox"
+                    checked={item.selected}
+                    disabled={busy}
+                    aria-label={`Include ${item.sourceName}`}
+                    onchange={(event) => ontoggleselected(item.id, event.currentTarget.checked)}
+                />
+            </div>
+            <div role="cell">
+                <strong>{item.sourceName}</strong>
+                <small>{formatStoredSize(item.inspection.totalPayloadBytes)}</small>
+            </div>
+            <div role="cell">
+                {#if destinationStrategy === 'separate'}
+                    <label>
+                        <span class="sr-only">New volume name for {item.sourceName}</span>
+                        <input
+                            class="dialog-field-control"
+                            type="text"
+                            value={volumeNames[item.id] ??
+                                summary?.destinationVolumeName ??
+                                item.inspection.roots[0]?.displayName ??
+                                ''}
+                            maxlength="16"
+                            disabled={busy || !item.selected}
+                            oninput={(event) => onrenamevolume(item.id, event.currentTarget.value)}
+                        />
+                    </label>
+                {:else if item.selected}
+                    <span>{destinationVolumeName || 'Choose a volume'}</span>
+                {:else}
+                    <span>Not included</span>
+                {/if}
+            </div>
+            <div class="object-counts" role="cell">
+                {#if summary}
+                    <span>{summary.objectCounts.programs} Programs</span>
+                    <span>{summary.objectCounts.sampleBanks} Sample Banks</span>
+                    <span>{summary.objectCounts.samples} Samples</span>
+                    <span>{summary.objectCounts.waveData} Wave Data</span>
+                    <span>{summary.objectCounts.sequences} Sequences</span>
+                {:else}
+                    <span>{item.inspection.objects.length} objects</span>
+                {/if}
+            </div>
+            <div
+                class:record-unavailable={Boolean(recordUsage?.shortfallRecordSlots)}
+                class:record-impossible={cannotFitEmptyPartition}
+                class="record-usage"
+                role="cell"
+                title={cannotFitEmptyPartition
+                    ? `Requires ${recordUsage?.standaloneRequiredRecordSlots} records on an empty partition; maximum ${allocatableRecords}`
+                    : undefined}
+            >
+                {#if !item.selected}
+                    <span>Not included</span>
+                {:else if hasUnvalidatedChanges}
+                    <span>Pending check</span>
+                {:else if recordUsage}
+                    <span>{recordUsage.plannedRecordSlots}</span>
+                    <small>
+                        {recordUsage.plannedObjectRecordSlots} objects
+                        {#if recordUsage.volumeScaffoldingRecordSlots > 0}
+                            + {recordUsage.volumeScaffoldingRecordSlots} volume
+                        {/if}
+                        {#if recordUsage.reusedObjectCount > 0}· {recordUsage.reusedObjectCount} reused{/if}
+                        {#if recordUsage.shortfallRecordSlots > 0}· {recordUsage.shortfallRecordSlots} short{/if}
+                    </small>
+                {:else}
+                    <span>—</span>
+                {/if}
+            </div>
+        </div>
+    {/each}
+</div>
+
+<style>
+    .capacity-summary {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        gap: 16px;
+        margin-bottom: 10px;
+        padding: 8px 10px;
+        border: 1px solid var(--border-strong);
+        border-radius: 6px;
+        background: var(--color-panel-raised);
+    }
+
+    .capacity-heading,
+    .record-usage,
+    .batch-table-row > div:nth-child(2) {
+        display: grid;
+        gap: 3px;
+    }
+
+    small {
+        color: var(--text-muted);
+    }
+
+    .capacity-metrics {
+        display: flex;
+        flex-wrap: wrap;
+        justify-content: flex-end;
+        gap: 6px 16px;
+        white-space: nowrap;
+    }
+
+    .capacity-unavailable {
+        border-color: #765d2d;
+        background: rgb(150 108 26 / 10%);
+    }
+
+    .capacity-unavailable strong,
+    .record-unavailable,
+    .record-impossible {
+        color: var(--color-danger);
+    }
+
+    .batch-table {
+        overflow: hidden;
+        border: 1px solid var(--border-strong);
+        border-radius: 6px;
+    }
+
+    .batch-table-header,
+    .batch-table-row {
+        display: grid;
+        grid-template-columns: 30px minmax(170px, 1.1fr) minmax(160px, 0.8fr) minmax(240px, 1.4fr) minmax(
+                105px,
+                0.55fr
+            );
+        gap: 12px;
+        padding-inline: 10px;
+    }
+
+    .batch-table-header {
+        align-items: center;
+        padding-block: 7px;
+        color: var(--text-muted);
+        background: var(--color-panel-raised);
+        font-size: 12px;
+    }
+
+    .batch-table-row {
+        align-items: start;
+        padding-block: 6px;
+    }
+
+    .batch-table-row + .batch-table-row {
+        border-top: 1px solid var(--border-subtle);
+    }
+
+    .selection-cell {
+        display: flex;
+        align-items: center;
+        justify-content: center;
+    }
+
+    .selection-cell input {
+        margin: 0;
+    }
+
+    .row-excluded > :not(.selection-cell) {
+        opacity: 0.55;
+    }
+
+    .object-counts {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 2px 10px;
+        color: var(--text-muted);
+        font-size: 12px;
+    }
+
+    @media (max-width: 760px) {
+        .batch-table-header {
+            display: none;
+        }
+
+        .batch-table-row {
+            grid-template-columns: 30px 1fr;
+        }
+
+        .batch-table-row > :not(.selection-cell) {
+            grid-column: 2;
+        }
+
+        .capacity-summary {
+            align-items: flex-start;
+            flex-direction: column;
+        }
+    }
+</style>
diff --git a/apps/axkdeck/src/lib/generated/axklibApiV1.ts b/apps/axkdeck/src/lib/generated/axklibApiV1.ts
index d240f031..9d02a17b 100644
--- a/apps/axkdeck/src/lib/generated/axklibApiV1.ts
+++ b/apps/axkdeck/src/lib/generated/axklibApiV1.ts
@@ -2754,7 +2754,7 @@ export interface components {
             totalPayloadBytes: number;
             valid: boolean;
         };
-        /** @description One existing SFS volume, one explicitly named new SFS volume, or one new SFS volume per volume package placement hint. */
+        /** @description One existing SFS volume, one explicitly named new SFS volume receiving all selected packages, or one new SFS volume per volume package placement hint. */
         ImageSessionPackageImportDestination:
             | {
                   /** @constant */
diff --git a/apps/axkdeck/src/lib/nativePackages.test.ts b/apps/axkdeck/src/lib/nativePackages.test.ts
index 3780ce36..6a1f2ff5 100644
--- a/apps/axkdeck/src/lib/nativePackages.test.ts
+++ b/apps/axkdeck/src/lib/nativePackages.test.ts
@@ -4,7 +4,7 @@ const mocks = vi.hoisted(() => ({ invoke: vi.fn() }));
 
 vi.mock('@tauri-apps/api/core', () => ({ invoke: mocks.invoke }));
 
-import { selectLocalPackage } from './nativePackages';
+import { selectLocalPackage, selectLocalPackages } from './nativePackages';
 
 describe('nativePackages', () => {
     beforeEach(() => mocks.invoke.mockReset());
@@ -26,4 +26,14 @@ describe('nativePackages', () => {
 
         expect(mocks.invoke).toHaveBeenCalledWith('select_local_package', { preferredPath: null });
     });
+
+    it('passes the preferred package path to the multi-file native chooser', async () => {
+        mocks.invoke.mockResolvedValue([]);
+
+        await selectLocalPackages('previous-package.axkprg');
+
+        expect(mocks.invoke).toHaveBeenCalledWith('select_local_packages', {
+            preferredPath: 'previous-package.axkprg',
+        });
+    });
 });
diff --git a/apps/axkdeck/src/lib/nativePackages.ts b/apps/axkdeck/src/lib/nativePackages.ts
index e1cc61ad..3b5515be 100644
--- a/apps/axkdeck/src/lib/nativePackages.ts
+++ b/apps/axkdeck/src/lib/nativePackages.ts
@@ -9,8 +9,8 @@ export function selectLocalPackage(preferredPath: string | null): Promise<string
     return invoke('select_local_package', { preferredPath });
 }
 
-export function selectLocalVolumePackages(preferredPath: string | null): Promise<string[]> {
-    return invoke('select_local_volume_packages', { preferredPath });
+export function selectLocalPackages(preferredPath: string | null): Promise<string[]> {
+    return invoke('select_local_packages', { preferredPath });
 }
 
 export function selectLocalPackageDestination(suggestedName: string): Promise<LocalPackageDestination | null> {
diff --git a/apps/server/contracts/openapi-v1.base.json b/apps/server/contracts/openapi-v1.base.json
index 804482fa..c97ec3ac 100644
--- a/apps/server/contracts/openapi-v1.base.json
+++ b/apps/server/contracts/openapi-v1.base.json
@@ -2586,7 +2586,7 @@
         }
       },
       "ImageSessionPackageImportDestination": {
-        "description": "One existing SFS volume, one explicitly named new SFS volume, or one new SFS volume per volume package placement hint.",
+        "description": "One existing SFS volume, one explicitly named new SFS volume receiving all selected packages, or one new SFS volume per volume package placement hint.",
         "oneOf": [
           {
             "type": "object",
diff --git a/apps/server/contracts/openapi-v1.json b/apps/server/contracts/openapi-v1.json
index b34f31a4..fbe608ac 100644
--- a/apps/server/contracts/openapi-v1.json
+++ b/apps/server/contracts/openapi-v1.json
@@ -5478,7 +5478,7 @@
         "type": "object"
       },
       "ImageSessionPackageImportDestination": {
-        "description": "One existing SFS volume, one explicitly named new SFS volume, or one new SFS volume per volume package placement hint.",
+        "description": "One existing SFS volume, one explicitly named new SFS volume receiving all selected packages, or one new SFS volume per volume package placement hint.",
         "oneOf": [
           {
             "additionalProperties": false,