fix: 修复实时日志与数据库切换可靠性

packages/app-lib/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "theseus"
 # The actual version is set by the theseus-build workflow on tagging
-version = "1.0.0-beta12"
+version = "1.0.0-beta15"
 edition.workspace = true
 
 [dependencies]

packages/app-lib/src/api/drop_classifier.rs

@@ -441,13 +441,14 @@ impl ZipEntrySet {
         let mut seen: std::collections::HashSet<&str> =
             std::collections::HashSet::new();
         for dir in &self.dirs {
-            if let Some(rest) = dir.strip_prefix(base)
-                && let Some((first, _)) = rest.split_once('/')
-                && !first.is_empty()
-                && !is_noise_entry(first)
-                && seen.insert(first)
-            {
-                children.push(first.to_string());
+            if let Some(rest) = dir.strip_prefix(base) {
+                let first = rest.split('/').next().unwrap_or_default();
+                if !first.is_empty()
+                    && !is_noise_entry(first)
+                    && seen.insert(first)
+                {
+                    children.push(first.to_string());
+                }
             }
         }
         for path in &self.files {

packages/app-lib/src/api/logs.rs

@@ -54,6 +54,18 @@ pub struct LatestLogCursor {
     pub new_file: bool,
 }
 
+#[derive(Serialize, Debug)]
+pub struct LiveLogLine {
+    pub sequence: u64,
+    pub message: CensoredString,
+}
+
+#[derive(Serialize, Debug)]
+pub struct LiveLogSnapshot {
+    pub lines: Vec<LiveLogLine>,
+    pub last_sequence: u64,
+}
+
 #[derive(Serialize, Debug)] // Not deserialize
 #[serde(transparent)]
 pub struct CensoredString(String);
@@ -651,31 +663,31 @@ pub async fn delete_logs_by_filename(
 }
 
 #[tracing::instrument]
-pub async fn get_live_log_buffer(
+pub async fn get_live_log_snapshot(
     instance_id: &str,
-) -> crate::Result<CensoredString> {
+) -> crate::Result<LiveLogSnapshot> {
     let state = State::get().await?;
-    let lines = crate::state::get_log_buffer(instance_id);
-    let joined = lines.join("\n");
-    let compacted =
-        cap_log_for_display(compact_duplicate_lines(&joined), false);
-
     let credentials = Credentials::get_all(&state.pool)
         .await?
         .into_iter()
         .map(|x| x.1)
         .collect::<Vec<_>>();
-    maybe_emit_log_compaction_warning("live log", compacted.stats).await;
-    maybe_emit_log_display_truncation_warning(
-        "live log",
-        compacted.display_truncated,
-    )
-    .await;
-    Ok(CensoredString::censor(compacted.output, &credentials))
+    let snapshot = crate::state::get_live_log_snapshot(instance_id);
+    Ok(LiveLogSnapshot {
+        lines: snapshot
+            .lines
+            .into_iter()
+            .map(|line| LiveLogLine {
+                sequence: line.sequence,
+                message: CensoredString::censor(line.message, &credentials),
+            })
+            .collect(),
+        last_sequence: snapshot.last_sequence,
+    })
 }
 
 pub fn clear_live_log_buffer(instance_id: &str) {
-    crate::state::remove_log_buffer(instance_id);
+    crate::state::clear_log_buffer(instance_id);
 }
 
 #[tracing::instrument]

packages/app-lib/src/event/mod.rs

@@ -409,6 +409,8 @@ mod log_types {
     #[derive(Serialize, Clone)]
     pub struct LogPayload {
         pub instance_id: String,
+        pub first_sequence: u64,
+        pub last_sequence: u64,
         #[serde(flatten)]
         pub event: LogEvent,
     }

packages/app-lib/src/install/missing_content.rs

@@ -1590,6 +1590,15 @@ mod tests {
     #[cfg(not(feature = "tauri"))]
     #[tokio::test]
     async fn import_api_trusts_persisted_job_context_and_keeps_other_missing_files_waiting()
+     {
+        Box::pin(
+            run_import_api_trusts_persisted_job_context_and_keeps_other_missing_files_waiting(),
+        )
+        .await;
+    }
+
+    #[cfg(not(feature = "tauri"))]
+    async fn run_import_api_trusts_persisted_job_context_and_keeps_other_missing_files_waiting()
      {
         crate::event::EventState::init().await.unwrap();
         let root = tempfile::tempdir().unwrap().keep();
@@ -1788,18 +1797,17 @@ mod tests {
         .await
         .unwrap();
         assert_eq!(observed.pending, 1);
-        let (scan_result, manual_result) = tokio::join!(
-            scan_missing_modpack_files_in_at(
-                job_id,
-                &race_downloads,
-                first_seen + DOWNLOAD_STABILITY_WINDOW,
-            ),
-            import_missing_modpack_file(
-                job_id,
-                first.item_id.clone(),
-                selected,
-            )
-        );
+        let scan = Box::pin(scan_missing_modpack_files_in_at(
+            job_id,
+            &race_downloads,
+            first_seen + DOWNLOAD_STABILITY_WINDOW,
+        ));
+        let manual = Box::pin(import_missing_modpack_file(
+            job_id,
+            first.item_id.clone(),
+            selected,
+        ));
+        let (scan_result, manual_result) = tokio::join!(scan, manual);
         let scan_result = scan_result.unwrap();
         assert!(manual_result.is_ok());
         assert!(

packages/app-lib/src/install/model.rs

@@ -13,7 +13,10 @@ use crate::state::{
 use chrono::{DateTime, Utc};
 use modrinth_content_management::{ContentType, ResolutionPreferences};
 use serde::{Deserialize, Serialize};
-use std::{collections::HashMap, path::PathBuf};
+use std::{
+    collections::{HashMap, HashSet},
+    path::PathBuf,
+};
 use uuid::Uuid;
 
 pub type InstallModpackPreview = CreatePackInstance;
@@ -483,7 +486,7 @@ mod tests {
         assert_eq!(summary.bytes_total, Some(300));
         let items = job.download_items();
         assert_eq!(items.len(), 3);
-        assert_eq!(items[0].status, DownloadItemStatus::Verifying);
+        assert_eq!(items[0].status, DownloadItemStatus::Completed);
         assert_eq!(items[0].attempt, Some(1));
         assert_eq!(items[0].max_attempts, Some(4));
         assert_eq!(
@@ -2395,6 +2398,7 @@ impl InstallJobState {
     fn download_items_from_events(&self) -> Vec<DownloadItemSnapshot> {
         let mut items = Vec::<DownloadItemSnapshot>::new();
         let mut indices = HashMap::<String, usize>::new();
+        let mut content_items = HashSet::<String>::new();
         for event in &self.events {
             match &event.kind {
                 InstallJobEventKind::ContentFileQueued {
@@ -2402,6 +2406,7 @@ impl InstallJobState {
                     bytes_total,
                     max_attempts,
                 } => {
+                    content_items.insert(path.clone());
                     if let Some(item) = indices
                         .get(path)
                         .and_then(|&index| items.get_mut(index))
@@ -2482,6 +2487,7 @@ impl InstallJobState {
                     attempt,
                     max_attempts,
                 } => {
+                    content_items.insert(path.clone());
                     if let Some(item) = indices
                         .get(path)
                         .and_then(|&index| items.get_mut(index))
@@ -2562,10 +2568,14 @@ impl InstallJobState {
                         .get(path)
                         .and_then(|&index| items.get_mut(index))
                     {
-                        // Network transfer completion is not content
-                        // finalization. `ContentFileCompleted` is the event
-                        // that confirms verification and DB registration.
-                        item.status = DownloadItemStatus::Verifying;
+                        // Content downloads still need verification and DB
+                        // registration. Standalone Java/Minecraft requests
+                        // are final once the request itself finishes.
+                        item.status = if content_items.contains(path) {
+                            DownloadItemStatus::Verifying
+                        } else {
+                            DownloadItemStatus::Completed
+                        };
                         item.bytes_downloaded = *bytes;
                         item.bytes_total = item.bytes_total.or(Some(*bytes));
                     }

packages/app-lib/src/install/recovery.rs

@@ -1361,12 +1361,11 @@ mod tests {
         assert_eq!(persisted.status, InstallJobStatus::Canceled);
         assert!(persisted.state.rollback.as_ref().unwrap().content.is_none());
         assert!(persisted.state.rollback_error.is_none());
-        assert_eq!(
-            crate::state::list_instances(&state.pool)
+        assert!(
+            crate::state::get_instance(&instance_id, &state.pool)
                 .await
                 .unwrap()
-                .len(),
-            1
+                .is_some()
         );
 
         let new_instance = crate::api::instance::create(

packages/app-lib/src/launcher/direct_ensure.rs

@@ -1107,12 +1107,17 @@ mod tests {
                 "org.lwjgl.lwjgl:lwjgl-platform:2.9.4-nightly-20150209:{classifier}"
             )
         );
-        assert!(
-            plan.destination
-                .to_string_lossy()
-                .ends_with(format!("{classifier}.jar").as_str())
-        );
-        assert_eq!(plan.sha1.as_deref(), Some("aaa"));
+        let (declared_path, declared_sha1) = match classifier.as_str() {
+            "natives-linux" => (
+                "org/lwjgl/lwjgl/lwjgl-platform/2.9.4-nightly-20150209/lwjgl-platform-2.9.4-nightly-20150209-natives-linux.jar",
+                "aaa",
+            ),
+            "natives-osx" => ("x-osx.jar", "bbb"),
+            "natives-windows" => ("x-win.jar", "ccc"),
+            other => panic!("unexpected native classifier {other}"),
+        };
+        assert!(plan.destination.to_string_lossy().ends_with(declared_path));
+        assert_eq!(plan.sha1.as_deref(), Some(declared_sha1));
     }
 
     #[test]

packages/app-lib/src/launcher/direct_link.rs

@@ -1940,13 +1940,16 @@ mod tests {
         assert_eq!(
             direct.version_json,
             Some(
-                version_dir
-                    .join("1.20.1-fabric.json")
-                    .canonicalize()
-                    .unwrap()
+                crate::util::io::canonicalize(
+                    version_dir.join("1.20.1-fabric.json"),
+                )
+                .unwrap(),
             )
         );
-        assert_eq!(direct.dot_minecraft, root.path().canonicalize().unwrap());
+        assert_eq!(
+            direct.dot_minecraft,
+            crate::util::io::canonicalize(root.path()).unwrap()
+        );
     }
 
     #[test]
@@ -2002,6 +2005,15 @@ mod tests {
         let root = tempfile::tempdir().unwrap();
         let version = root.path().join("versions/demo");
         std::fs::create_dir_all(&version).unwrap();
+        std::fs::write(
+            version.join("demo.json"),
+            serde_json::to_vec(&json!({
+                "id": "demo",
+                "mainClass": "net.minecraft.client.main.Main"
+            }))
+            .unwrap(),
+        )
+        .unwrap();
 
         assert_eq!(
             resolve_content_game_dir(root.path(), &version).unwrap(),
@@ -2469,7 +2481,13 @@ mod tests {
         );
         assert_eq!(
             candidates,
-            vec![launcher.path().join("runtime/jdk17/bin/java")]
+            vec![
+                launcher
+                    .path()
+                    .join("runtime/jdk17")
+                    .join("bin")
+                    .join(PCL_JAVA_BIN)
+            ]
         );
 
         // A relative path escaping the launcher directory degrades to the

packages/app-lib/src/state/db.rs

@@ -4,7 +4,7 @@ use sqlx::migrate::{Migration, Migrator};
 use sqlx::sqlite::{
     SqliteConnectOptions, SqliteJournalMode, SqlitePoolOptions,
 };
-use sqlx::{Pool, Sqlite};
+use sqlx::{ConnectOptions, Connection, Pool, Sqlite};
 use std::path::{Path, PathBuf};
 use std::time::Duration;
 
@@ -126,17 +126,7 @@ pub async fn copy_release_database_to_beta(
         .into());
     }
 
-    let release_pool = open_app_db_pool(&release_path).await?;
-    let escaped_path = beta_path.to_string_lossy().replace('\'', "''");
-    sqlx::query(&format!("VACUUM INTO '{escaped_path}'"))
-        .execute(&release_pool)
-        .await?;
-    release_pool.close().await;
-
-    if let Err(error) = open_app_db_pool(&beta_path).await {
-        let _ = tokio::fs::remove_file(&beta_path).await;
-        return Err(error);
-    }
+    copy_app_database(&release_path, &beta_path).await?;
 
     tracing::info!(
         source = %release_path.display(),
@@ -207,16 +197,7 @@ pub async fn copy_database_between_channels(
     }
 
     crate::util::io::create_dir_all(&target_dir).await?;
-    let temporary_path = target_dir.join(format!("{LEGACY_APP_DB_FILE}.tmp"));
-    let source_pool = open_app_db_pool(&source_path).await?;
-    let escaped_path = temporary_path.to_string_lossy().replace('\'', "''");
-    let result = sqlx::query(&format!("VACUUM INTO '{escaped_path}'"))
-        .execute(&source_pool)
-        .await;
-    source_pool.close().await;
-    result?;
-
-    tokio::fs::rename(&temporary_path, &target_path).await?;
+    copy_app_database(&source_path, &target_path).await?;
     tracing::info!(
         source = %source_path.display(),
         destination = %target_path.display(),
@@ -225,6 +206,87 @@ pub async fn copy_database_between_channels(
     Ok(())
 }
 
+async fn copy_app_database(source: &Path, target: &Path) -> crate::Result<()> {
+    let temporary = sidecar_path(target, ".copying");
+    remove_database_files(&temporary).await?;
+
+    let source_pool = open_app_db_pool(source).await?;
+    let escaped_path = temporary.to_string_lossy().replace('\'', "''");
+    let snapshot_result = sqlx::query(&format!("VACUUM INTO '{escaped_path}'"))
+        .execute(&source_pool)
+        .await;
+    source_pool.close().await;
+    if let Err(error) = snapshot_result {
+        let _ = remove_database_files(&temporary).await;
+        return Err(error.into());
+    }
+
+    if let Err(error) = verify_database_file(&temporary).await {
+        let _ = remove_database_files(&temporary).await;
+        return Err(error);
+    }
+
+    let previous = sidecar_path(target, ".replacing");
+    remove_database_files(&previous).await?;
+    let had_target = target.try_exists()?;
+    if had_target {
+        super::db_backup::archive_database_files(target, &previous).await?;
+    } else {
+        super::db_backup::remove_database_sidecars(target).await?;
+    }
+
+    if let Err(error) = tokio::fs::rename(&temporary, target).await {
+        if had_target {
+            super::db_backup::restore_archived_database_files(
+                &previous, target,
+            )
+            .await?;
+        }
+        let _ = remove_database_files(&temporary).await;
+        return Err(error.into());
+    }
+
+    if let Err(error) = remove_database_files(&previous).await {
+        tracing::warn!(
+            database = %previous.display(),
+            error = %error,
+            "Copied channel database but could not remove the previous snapshot"
+        );
+    }
+    Ok(())
+}
+
+async fn verify_database_file(path: &Path) -> crate::Result<()> {
+    let options = SqliteConnectOptions::new()
+        .filename(path)
+        .busy_timeout(Duration::from_secs(30))
+        .read_only(true)
+        .create_if_missing(false);
+    let mut connection = options.connect().await?;
+    let rows = sqlx::query_scalar::<_, String>("PRAGMA quick_check(1)")
+        .fetch_all(&mut connection)
+        .await?;
+    connection.close().await?;
+    if rows.as_slice() != ["ok"] {
+        return Err(crate::ErrorKind::FSError(format!(
+            "Database snapshot {} failed its integrity check: {}",
+            path.display(),
+            rows.join("; ")
+        ))
+        .into());
+    }
+    Ok(())
+}
+
+async fn remove_database_files(database: &Path) -> crate::Result<()> {
+    match tokio::fs::remove_file(database).await {
+        Ok(()) => {}
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
+        Err(error) => return Err(error.into()),
+    }
+    super::db_backup::remove_database_sidecars(database).await
+}
+
 pub async fn backup_current_app_db_for_update(
     app_identifier: &str,
     target_version: &str,
@@ -1461,6 +1523,53 @@ mod tests {
     const INSTANCE_POST_UPGRADE_NOTICES_MIGRATION_VERSION: i64 = 20260824000000;
     const MCARCHIVE_PROVIDER_FILE_ID_MIGRATION_VERSION: i64 = 20260823020000;
 
+    #[tokio::test]
+    async fn channel_copy_replaces_database_and_removes_stale_sidecars() {
+        let temp = tempfile::tempdir().unwrap();
+        let source = temp.path().join("beta").join(LEGACY_APP_DB_FILE);
+        let target = temp.path().join("release").join(LEGACY_APP_DB_FILE);
+        tokio::fs::create_dir_all(source.parent().unwrap())
+            .await
+            .unwrap();
+        tokio::fs::create_dir_all(target.parent().unwrap())
+            .await
+            .unwrap();
+
+        for (path, marker) in [(&source, "beta"), (&target, "release")] {
+            let pool = open_app_db_pool(path).await.unwrap();
+            sqlx::query("CREATE TABLE marker (value TEXT NOT NULL)")
+                .execute(&pool)
+                .await
+                .unwrap();
+            sqlx::query("INSERT INTO marker (value) VALUES (?)")
+                .bind(marker)
+                .execute(&pool)
+                .await
+                .unwrap();
+            pool.close().await;
+        }
+        tokio::fs::write(sidecar_path(&target, "-wal"), b"stale wal")
+            .await
+            .unwrap();
+        tokio::fs::write(sidecar_path(&target, "-shm"), b"stale shm")
+            .await
+            .unwrap();
+
+        copy_app_database(&source, &target).await.unwrap();
+
+        assert!(!sidecar_path(&target, "-wal").exists());
+        assert!(!sidecar_path(&target, "-shm").exists());
+        let pool = open_app_db_pool(&target).await.unwrap();
+        let marker: String = sqlx::query_scalar("SELECT value FROM marker")
+            .fetch_one(&pool)
+            .await
+            .unwrap();
+        pool.close().await;
+        assert_eq!(marker, "beta");
+        assert!(!sidecar_path(&target, ".copying").exists());
+        assert!(!sidecar_path(&target, ".replacing").exists());
+    }
+
     #[tokio::test]
     async fn post_upgrade_notices_migrate_fresh_and_existing_databases() {
         for previous_schema in [false, true] {
@@ -3956,7 +4065,7 @@ mod tests {
         assert_eq!(
             translation,
             (
-                "microsoft".to_string(),
+                "google".to_string(),
                 String::new(),
                 String::new(),
                 String::new(),
@@ -4065,7 +4174,7 @@ mod tests {
         assert_eq!(
             translation,
             (
-                "microsoft".to_string(),
+                "google".to_string(),
                 String::new(),
                 String::new(),
                 "https://api.openai.com/v1".to_string(),

packages/app-lib/src/state/db_backup.rs

@@ -39,6 +39,10 @@ async fn restore_corrupt_app_db_from(
         "App database integrity check failed"
     );
 
+    if restore_app_db_without_corrupt_sidecars(db_path, backup_dir).await? {
+        return Ok(());
+    }
+
     let Some(backup_path) = latest_healthy_app_db_backup(backup_dir).await?
     else {
         return Err(crate::ErrorKind::FSError(format!(
@@ -98,6 +102,49 @@ async fn restore_corrupt_app_db_from(
     Ok(())
 }
 
+async fn restore_app_db_without_corrupt_sidecars(
+    db_path: &Path,
+    backup_dir: &Path,
+) -> crate::Result<bool> {
+    let mut has_sidecars = false;
+    for suffix in ["-wal", "-shm"] {
+        has_sidecars |= sqlite_sidecar_path(db_path, suffix).try_exists()?;
+    }
+    if !has_sidecars {
+        return Ok(false);
+    }
+
+    let staging_path = next_restore_staging_path(db_path).await?;
+    tokio::fs::copy(db_path, &staging_path).await?;
+    let healthy_main = matches!(
+        check_database_integrity(&staging_path).await?,
+        IntegrityStatus::Healthy
+    ) && is_app_database(&staging_path).await?;
+    if !healthy_main {
+        cleanup_staged_database(&staging_path).await;
+        return Ok(false);
+    }
+
+    crate::util::io::create_dir_all(backup_dir).await?;
+    let corrupt_path = next_corrupt_database_path(backup_dir).await?;
+    if let Err(error) = archive_database_files(db_path, &corrupt_path).await {
+        cleanup_staged_database(&staging_path).await;
+        return Err(error);
+    }
+    if let Err(error) = tokio::fs::rename(&staging_path, db_path).await {
+        restore_archived_database_files(&corrupt_path, db_path).await?;
+        cleanup_staged_database(&staging_path).await;
+        return Err(error.into());
+    }
+
+    tracing::warn!(
+        database = %db_path.display(),
+        corrupt_archive = %corrupt_path.display(),
+        "Recovered app database by removing corrupt SQLite sidecars"
+    );
+    Ok(true)
+}
+
 async fn check_database_integrity(
     db_path: &Path,
 ) -> crate::Result<IntegrityStatus> {
@@ -200,7 +247,7 @@ async fn is_app_database(db_path: &Path) -> crate::Result<bool> {
     Ok(table_count == REQUIRED_APP_DB_TABLES.len() as i64)
 }
 
-async fn archive_database_files(
+pub(crate) async fn archive_database_files(
     db_path: &Path,
     archive_path: &Path,
 ) -> crate::Result<()> {
@@ -226,7 +273,7 @@ async fn archive_database_files(
     Ok(())
 }
 
-async fn restore_archived_database_files(
+pub(crate) async fn restore_archived_database_files(
     archive_path: &Path,
     db_path: &Path,
 ) -> crate::Result<()> {
@@ -285,7 +332,9 @@ fn sqlite_sidecar_path(db_path: &Path, suffix: &str) -> PathBuf {
     PathBuf::from(path)
 }
 
-async fn remove_database_sidecars(db_path: &Path) -> crate::Result<()> {
+pub(crate) async fn remove_database_sidecars(
+    db_path: &Path,
+) -> crate::Result<()> {
     for suffix in ["-wal", "-shm"] {
         let path = sqlite_sidecar_path(db_path, suffix);
         match tokio::fs::remove_file(path).await {
@@ -766,6 +815,45 @@ mod tests {
         assert_eq!(tokio::fs::read(&db_path).await.unwrap(), corrupt_bytes);
     }
 
+    #[tokio::test]
+    async fn corrupt_sidecars_recover_from_the_healthy_main_database() {
+        let temp = tempfile::tempdir().unwrap();
+        let db_path = temp.path().join("release").join("app.db");
+        let backup_dir =
+            temp.path().join("Backups").join("app-db").join("release");
+        tokio::fs::create_dir_all(db_path.parent().unwrap())
+            .await
+            .unwrap();
+        create_test_app_db(&db_path, "release").await;
+        tokio::fs::write(sqlite_sidecar_path(&db_path, "-wal"), b"bad wal")
+            .await
+            .unwrap();
+        tokio::fs::write(sqlite_sidecar_path(&db_path, "-shm"), b"bad shm")
+            .await
+            .unwrap();
+
+        assert!(
+            restore_app_db_without_corrupt_sidecars(&db_path, &backup_dir)
+                .await
+                .unwrap()
+        );
+
+        assert_eq!(read_marker(&db_path).await, "release");
+        assert!(!sqlite_sidecar_path(&db_path, "-wal").exists());
+        assert!(!sqlite_sidecar_path(&db_path, "-shm").exists());
+        let mut entries = tokio::fs::read_dir(&backup_dir).await.unwrap();
+        let mut archived_database = false;
+        let mut archived_wal = false;
+        let mut archived_shm = false;
+        while let Some(entry) = entries.next_entry().await.unwrap() {
+            let name = entry.file_name().to_string_lossy().into_owned();
+            archived_database |= name.ends_with(".db");
+            archived_wal |= name.ends_with(".db-wal");
+            archived_shm |= name.ends_with(".db-shm");
+        }
+        assert!(archived_database && archived_wal && archived_shm);
+    }
+
     #[tokio::test]
     async fn update_backup_creates_a_healthy_channel_snapshot() {
         let temp = tempfile::tempdir().unwrap();

packages/app-lib/src/state/instances/adapters/sqlite/content_rows.rs

@@ -16,6 +16,12 @@ use chrono::{DateTime, TimeZone, Utc};
 use sqlx::{Executor, Row, Sqlite, SqlitePool, Transaction};
 use uuid::Uuid;
 
+async fn begin_content_write(
+    pool: &SqlitePool,
+) -> crate::Result<Transaction<'static, Sqlite>> {
+    Ok(pool.begin_with("BEGIN IMMEDIATE").await?)
+}
+
 /// Ensures the instance a content write is about to reference still exists.
 ///
 /// Runs inside the write transaction so a concurrent instance deletion that
@@ -662,7 +668,7 @@ pub(crate) async fn upsert_instance_file_from_parts(
     input: UpsertInstanceFile<'_>,
     pool: &SqlitePool,
 ) -> crate::Result<InstanceFile> {
-    let mut tx = pool.begin().await?;
+    let mut tx = begin_content_write(pool).await?;
     let file =
         upsert_instance_file_from_parts_in_transaction(input, &mut tx).await?;
     tx.commit().await?;
@@ -726,7 +732,7 @@ pub(crate) async fn rename_instance_file(
     enabled: bool,
     pool: &SqlitePool,
 ) -> crate::Result<Option<InstanceFile>> {
-    let mut tx = pool.begin().await?;
+    let mut tx = begin_content_write(pool).await?;
 
     let file = rename_instance_file_in_transaction(
         instance_id,
@@ -1106,7 +1112,7 @@ pub(crate) async fn upsert_content_entry_from_parts(
     input: UpsertContentEntry<'_>,
     pool: &SqlitePool,
 ) -> crate::Result<ContentEntry> {
-    let mut tx = pool.begin().await?;
+    let mut tx = begin_content_write(pool).await?;
     let entry =
         upsert_content_entry_from_parts_in_transaction(input, &mut tx).await?;
     tx.commit().await?;
@@ -1230,7 +1236,7 @@ pub(crate) async fn upsert_content_provider_ref(
     origin: bool,
     pool: &SqlitePool,
 ) -> crate::Result<()> {
-    let mut tx = pool.begin().await?;
+    let mut tx = begin_content_write(pool).await?;
     upsert_content_provider_ref_in_transaction(
         content_entry_id,
         provider_ref,
@@ -2583,6 +2589,7 @@ mod tests {
 				provider TEXT NOT NULL,
 				provider_project_id TEXT NOT NULL,
 				provider_release_id TEXT NULL,
+				provider_file_id TEXT NULL,
 				is_origin INTEGER NOT NULL DEFAULT 0
 			);
 			CREATE UNIQUE INDEX instance_content_provider_refs_identity

packages/app-lib/src/state/instances/commands/apply_content_install.rs

@@ -539,7 +539,7 @@ pub(crate) async fn persist_resolved_plan_dependency_edges(
         .chain(plan.dependencies.iter())
         .collect::<Vec<_>>();
 
-    let mut tx = state.pool.begin().await?;
+    let mut tx = begin_content_write(&state.pool).await?;
     for (index, dependency) in plan.dependencies.iter().enumerate() {
         let Some(parent) = dependency
             .dependent_on_version_id

packages/app-lib/src/state/instances/commands/create_direct_link_instance.rs

@@ -254,8 +254,8 @@ mod tests {
             instance_rows::get_instance_by_id(&instance.id, &state.pool)
                 .await?
                 .expect("instance row");
-        let canonical_root = minecraft.path().canonicalize()?;
-        let canonical_json = json_path.canonicalize()?;
+        let canonical_root = crate::util::io::canonicalize(minecraft.path())?;
+        let canonical_json = crate::util::io::canonicalize(&json_path)?;
         assert_eq!(stored.linked_launcher.as_deref(), Some("generic"));
         assert_eq!(
             stored.linked_launcher_root.as_deref(),

packages/app-lib/src/state/process.rs

@@ -117,8 +117,21 @@ async fn record_post_upgrade_launch_best_effort(
 }
 
 struct LogRingBuffer {
-    lines: VecDeque<String>,
+    lines: VecDeque<SequencedLogLine>,
     byte_len: usize,
+    last_sequence: u64,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct SequencedLogLine {
+    pub sequence: u64,
+    pub message: String,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct LiveLogSnapshot {
+    pub lines: Vec<SequencedLogLine>,
+    pub last_sequence: u64,
 }
 
 impl LogRingBuffer {
@@ -126,25 +139,37 @@ impl LogRingBuffer {
         Self {
             lines: VecDeque::new(),
             byte_len: 0,
+            last_sequence: 0,
         }
     }
 
-    fn push(&mut self, line: String) {
-        let line_len = line.len();
+    fn push(&mut self, message: String) -> u64 {
+        self.last_sequence = self.last_sequence.saturating_add(1);
+        let sequence = self.last_sequence;
+        let line = SequencedLogLine { sequence, message };
+        let line_len = line.message.len();
         while self.lines.len() >= LOG_BUFFER_CAPACITY
             || self.byte_len.saturating_add(line_len) > LOG_BUFFER_BYTE_CAPACITY
         {
             let Some(removed) = self.lines.pop_front() else {
                 break;
             };
-            self.byte_len = self.byte_len.saturating_sub(removed.len());
+            self.byte_len = self.byte_len.saturating_sub(removed.message.len());
         }
         self.byte_len += line_len;
         self.lines.push_back(line);
+        sequence
     }
 
     fn get_all(&self) -> Vec<String> {
-        self.lines.iter().cloned().collect()
+        self.lines.iter().map(|line| line.message.clone()).collect()
+    }
+
+    fn snapshot(&self) -> LiveLogSnapshot {
+        LiveLogSnapshot {
+            lines: self.lines.iter().cloned().collect(),
+            last_sequence: self.last_sequence,
+        }
     }
 
     fn clear(&mut self) {
@@ -157,11 +182,24 @@ static LOG_BUFFERS: LazyLock<DashMap<String, LogRingBuffer>> =
     LazyLock::new(DashMap::new);
 
 pub fn push_log_line(instance_id: &str, line: String) {
-    let line = truncate_live_log_text(&line);
-    LOG_BUFFERS
+    push_log_lines(instance_id, std::iter::once(line));
+}
+
+fn push_log_lines(
+    instance_id: &str,
+    lines: impl IntoIterator<Item = String>,
+) -> Option<(u64, u64)> {
+    let mut buffer = LOG_BUFFERS
         .entry(instance_id.to_string())
-        .or_insert_with(LogRingBuffer::new)
-        .push(line);
+        .or_insert_with(LogRingBuffer::new);
+    let mut first_sequence = None;
+    let mut last_sequence = 0;
+    for line in lines {
+        let sequence = buffer.push(truncate_live_log_text(&line));
+        first_sequence.get_or_insert(sequence);
+        last_sequence = sequence;
+    }
+    first_sequence.map(|first| (first, last_sequence))
 }
 
 fn truncate_live_log_text(value: &str) -> String {
@@ -228,6 +266,16 @@ pub fn get_log_buffer(instance_id: &str) -> Vec<String> {
         .unwrap_or_default()
 }
 
+pub fn get_live_log_snapshot(instance_id: &str) -> LiveLogSnapshot {
+    LOG_BUFFERS
+        .get(instance_id)
+        .map(|buffer| buffer.snapshot())
+        .unwrap_or(LiveLogSnapshot {
+            lines: Vec::new(),
+            last_sequence: 0,
+        })
+}
+
 pub fn clear_log_buffer(instance_id: &str) {
     if let Some(mut buf) = LOG_BUFFERS.get_mut(instance_id) {
         buf.clear();
@@ -920,14 +968,20 @@ impl Process {
         event.throwable =
             event.throwable.as_deref().map(truncate_live_log_text);
 
+        let mut lines = Vec::new();
         if let Some(formatted) = Self::format_log4j_entry(&event) {
-            push_log_line(instance_id, formatted.trim_end().to_string());
+            lines.push(formatted.trim_end().to_string());
         }
         if let Some(ref throwable) = event.throwable {
             for line in throwable.lines().filter(|l| !l.is_empty()) {
-                push_log_line(instance_id, line.to_string());
+                lines.push(line.to_string());
             }
         }
+        let Some((first_sequence, last_sequence)) =
+            push_log_lines(instance_id, lines)
+        else {
+            return;
+        };
 
         #[cfg(feature = "tauri")]
         {
@@ -936,6 +990,8 @@ impl Process {
                     "log",
                     LogPayload {
                         instance_id: instance_id.to_string(),
+                        first_sequence,
+                        last_sequence,
                         event: LogEvent::Log4j(event),
                     },
                 );
@@ -943,13 +999,17 @@ impl Process {
         }
         #[cfg(not(feature = "tauri"))]
         {
-            let _ = (instance_id, event);
+            let _ = (instance_id, event, first_sequence, last_sequence);
         }
     }
 
     fn emit_legacy_log(instance_id: &str, message: &str) {
         let message = truncate_live_log_text(message);
-        push_log_line(instance_id, message.clone());
+        let Some((first_sequence, last_sequence)) =
+            push_log_lines(instance_id, std::iter::once(message.clone()))
+        else {
+            return;
+        };
 
         #[cfg(feature = "tauri")]
         {
@@ -958,6 +1018,8 @@ impl Process {
                     "log",
                     LogPayload {
                         instance_id: instance_id.to_string(),
+                        first_sequence,
+                        last_sequence,
                         event: LogEvent::Legacy { message },
                     },
                 );
@@ -965,7 +1027,7 @@ impl Process {
         }
         #[cfg(not(feature = "tauri"))]
         {
-            let _ = (instance_id, message);
+            let _ = (instance_id, message, first_sequence, last_sequence);
         }
     }
 
@@ -1312,6 +1374,49 @@ fn take_next_log4j_frame(buffer: &mut String) -> Option<String> {
 mod post_upgrade_tests {
     use super::*;
 
+    #[test]
+    fn live_log_snapshot_sequences_batches_and_preserves_position_after_clear()
+    {
+        let instance_id = Uuid::new_v4().to_string();
+        assert_eq!(
+            push_log_lines(
+                &instance_id,
+                ["first".to_string(), "second".to_string()]
+            ),
+            Some((1, 2))
+        );
+        assert_eq!(
+            get_live_log_snapshot(&instance_id),
+            LiveLogSnapshot {
+                lines: vec![
+                    SequencedLogLine {
+                        sequence: 1,
+                        message: "first".to_string(),
+                    },
+                    SequencedLogLine {
+                        sequence: 2,
+                        message: "second".to_string(),
+                    },
+                ],
+                last_sequence: 2,
+            }
+        );
+
+        clear_log_buffer(&instance_id);
+        push_log_line(&instance_id, "third".to_string());
+        assert_eq!(
+            get_live_log_snapshot(&instance_id),
+            LiveLogSnapshot {
+                lines: vec![SequencedLogLine {
+                    sequence: 3,
+                    message: "third".to_string(),
+                }],
+                last_sequence: 3,
+            }
+        );
+        remove_log_buffer(&instance_id);
+    }
+
     #[cfg(windows)]
     #[tokio::test]
     async fn waiting_for_one_process_leaves_registry_available() {

packages/app-lib/src/util/fetch.rs

@@ -958,6 +958,34 @@ fn official_fallback_route(routes: &[DownloadRoute]) -> Option<DownloadRoute> {
         .cloned()
 }
 
+fn integrity_fallback_route(
+    routes: &[DownloadRoute],
+    current_index: usize,
+    terminal_routes: &HashSet<String>,
+) -> Option<DownloadRoute> {
+    let current = routes.get(current_index)?;
+    if !is_official_route(current)
+        && let Some(official) = routes.iter().enumerate().find_map(
+            |(candidate_index, candidate)| {
+                (candidate_index != current_index
+                    && is_official_route(candidate)
+                    && !terminal_routes.contains(&candidate.url))
+                .then(|| candidate.clone())
+            },
+        )
+    {
+        return Some(official);
+    }
+
+    ((current_index + 1)..routes.len())
+        .chain(0..current_index)
+        .find_map(|candidate_index| {
+            let candidate = &routes[candidate_index];
+            (!terminal_routes.contains(&candidate.url))
+                .then(|| candidate.clone())
+        })
+}
+
 fn url_with_base(original: &Url, base: &str, path: &str) -> Option<String> {
     let mut target = Url::parse(base).ok()?;
     target.set_path(path);
@@ -6048,13 +6076,15 @@ async fn download_to_path_inner(
                             );
                             last_error = Some(error);
                             terminal_routes.insert(route.url.clone());
-                            if !is_official_route(route)
-                                && let Some(official) =
-                                    official_fallback_route(&routes)
-                            {
+                            if let Some(fallback) = integrity_fallback_route(
+                                &routes,
+                                route_index,
+                                &terminal_routes,
+                            ) {
                                 remove_if_exists(&part_path).await?;
-                                official_integrity_retry = true;
-                                preferred_route = Some(official);
+                                official_integrity_retry =
+                                    is_official_route(&fallback);
+                                preferred_route = Some(fallback);
                                 break;
                             }
                             if official_integrity_retry {
@@ -6210,6 +6240,9 @@ async fn download_to_path_inner(
                             "File download request failed; trying the next source or retry"
                         );
                         last_error = Some(error);
+                        if can_switch_route {
+                            continue;
+                        }
                         break;
                     }
                     Err(_) => {
@@ -6244,6 +6277,9 @@ async fn download_to_path_inner(
                             "File download stalled before receiving a response"
                         );
                         last_error = Some(error);
+                        if can_switch_route {
+                            continue;
+                        }
                         break;
                     }
                 };
@@ -6346,6 +6382,11 @@ async fn download_to_path_inner(
                         Some(http_version),
                     );
                     last_error = Some(error);
+                    if (terminal_status || cooldown_and_switch)
+                        && can_switch_route
+                    {
+                        continue;
+                    }
                     break;
                 }
 
@@ -6773,19 +6814,24 @@ async fn download_to_path_inner(
                     } else {
                         remove_if_exists(&part_path).await?;
                     }
-                    let official = (!is_official_route(route))
-                        .then(|| official_fallback_route(&routes))
-                        .flatten();
-                    let decision = if official.is_some() {
-                        "fallback_official"
-                    } else if attempts >= 2
-                        || (is_official_route(route)
-                            && official_integrity_retry)
-                    {
-                        "drop_route_after_clean_retry"
-                    } else {
-                        "clear_partial_and_retry"
-                    };
+                    let fallback = integrity_fallback_route(
+                        &routes,
+                        route_index,
+                        &terminal_routes,
+                    );
+                    let decision =
+                        if fallback.as_ref().is_some_and(is_official_route) {
+                            "fallback_official"
+                        } else if fallback.is_some() {
+                            "switch_route"
+                        } else if attempts >= 2
+                            || (is_official_route(route)
+                                && official_integrity_retry)
+                        {
+                            "drop_route_after_clean_retry"
+                        } else {
+                            "clear_partial_and_retry"
+                        };
                     record_download_attempt_failure(
                         &mut attempt_history,
                         route,
@@ -6803,10 +6849,10 @@ async fn download_to_path_inner(
                         ));
                     }
                     last_error = Some(error);
-                    if let Some(official) = official {
+                    if let Some(fallback) = fallback {
                         terminal_routes.insert(route.url.clone());
-                        official_integrity_retry = true;
-                        preferred_route = Some(official);
+                        official_integrity_retry = is_official_route(&fallback);
+                        preferred_route = Some(fallback);
                     } else if (is_official_route(route)
                         && official_integrity_retry)
                         || attempts >= 2
@@ -8121,7 +8167,7 @@ mod tests {
     }
 
     #[test]
-    fn h2_fallback_is_limited_to_one_second() {
+    fn h2_fallback_uses_the_configured_ttl() {
         let _guard = H2_FALLBACK_TEST_LOCK.lock();
         let authority = "h2-cooldown.example:443";
         record_authority_h2_failure(authority);
@@ -8131,7 +8177,8 @@ mod tests {
             .get(authority)
             .map(|until| until.saturating_duration_since(Instant::now()))
             .unwrap();
-        assert!(remaining <= MAX_FAILURE_COOLDOWN);
+        assert!(remaining <= H2_FALLBACK_TTL);
+        assert!(remaining > H2_FALLBACK_TTL - Duration::from_secs(1));
         H2_FALLBACK_AUTHORITIES.lock().remove(authority);
     }
 

packages/ui/src/layouts/shared/console/components/LogViewport.test.ts

@@ -0,0 +1,21 @@
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import test from 'node:test'
+
+const source = readFileSync(
+	new URL('./LogViewport.vue', import.meta.url),
+	'utf8',
+)
+
+test('log rows use content-driven grid height for wrapped lines', () => {
+	assert.match(source, /grid-template-columns:\s*52px minmax\(0, 1fr\)/)
+	assert.match(source, /\.log-line-content\s*\{[^}]*display:\s*block/s)
+	assert.match(
+		source,
+		/\.log-viewport-wrap \.log-line\s*\{[^}]*white-space:\s*pre-wrap/s,
+	)
+	assert.doesNotMatch(
+		source,
+		/content-visibility|contain-intrinsic-size|estimateHeight|heightPrefix/,
+	)
+})

packages/ui/src/layouts/shared/console/components/LogViewport.vue

@@ -6,7 +6,10 @@
 		:style="{ fontSize: fontSize + 'px' }"
 		@scroll="handleScroll"
 	>
-		<div v-if="lines.length === 0" class="flex items-center justify-center h-full">
+		<div
+			v-if="lines.length === 0"
+			class="flex items-center justify-center h-full"
+		>
 			<EmptyState
 				v-if="emptyStateType === 'instance'"
 				:heading="formatMessage(consoleMessages.emptyInstanceTitle)"
@@ -26,22 +29,19 @@
 				v-for="item in lines"
 				:key="item.originalIndex"
 				:data-line="item.originalIndex + 1"
-				class="log-line flex items-stretch whitespace-pre"
+				class="log-line"
 				:class="entryClass(item.line)"
 			>
-				<span
-					class="flex shrink-0 w-[52px] items-center justify-end leading-none text-right text-secondary bg-surface-3 border-r border-solid border-surface-3 select-none overflow-hidden"
-					>{{ item.originalIndex + 1 }}</span
-				>
-				<span
-					class="log-line-content flex-1 px-2 break-all [overflow-wrap:anywhere]"
-					v-html="renderLine(item)"
-				></span>
+				<span class="log-line-number">{{ item.originalIndex + 1 }}</span>
+				<span class="log-line-content" v-html="renderLine(item)"></span>
 			</div>
 		</div>
 
 		<Transition name="scroll-to-bottom-fade">
-			<div v-if="lines.length > 0 && !stickToBottom" class="absolute bottom-4 right-4 z-10">
+			<div
+				v-if="lines.length > 0 && !stickToBottom"
+				class="absolute bottom-4 right-4 z-10"
+			>
 				<ButtonStyled circular type="highlight" size="large">
 					<button aria-label="Scroll to bottom" @click="scrollToBottom">
 						<ChevronDownIcon />
@@ -197,8 +197,35 @@ defineExpose({
 	white-space: pre-wrap;
 }
 
-.log-viewport-wrap .log-line-content {
+.log-line {
+	display: grid;
+	grid-template-columns: 52px minmax(0, 1fr);
+	align-items: stretch;
+	min-height: 1.4em;
+	white-space: pre;
+}
+
+.log-line-number {
+	display: flex;
+	align-items: flex-start;
+	justify-content: flex-end;
+	overflow: hidden;
+	border-right: 1px solid var(--surface-3);
+	background: var(--surface-3);
+	color: var(--color-text-secondary);
+	line-height: inherit;
+	text-align: right;
+	user-select: none;
+}
+
+.log-line-content {
+	display: block;
 	min-width: 0;
+	padding: 0 0.5rem;
+	line-height: inherit;
+	white-space: inherit;
+	word-break: break-all;
+	overflow-wrap: anywhere;
 }
 
 .log-line.entry-error {