diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index fd70e4c93..b7125ce10 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -210,6 +210,25 @@ jobs:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: bash scripts/sonarcloud-sync.sh
 
+  sonar-pr-comment:
+    name: SonarCloud PR Comment
+    runs-on: ubuntu-latest
+    needs: sonar
+    if: github.event_name == 'pull_request'
+    permissions:
+      contents: read
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+        with:
+          fetch-depth: 0
+      - name: Post SonarCloud findings to PR
+        env:
+          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_PR_NUMBER: ${{ github.event.pull_request.number }}
+        run: bash scripts/sonarcloud-pr-comment.sh
+
   dockerfile:
     name: Dockerfile Lint
     runs-on: ubuntu-latest
diff --git a/.husky/pre-commit b/.husky/pre-commit
index a26c42987..729f545af 100644
--- a/.husky/pre-commit
+++ b/.husky/pre-commit
@@ -3,6 +3,16 @@ fallow audit --format json --quiet --explain --gate-marker agent || exit 1
 
 pnpm --filter drop lint-staged && pnpm --filter drop typecheck
 
+# Check shell scripts
+changed_sh=$(git diff --cached --name-only --diff-filter=ACM -- '*.sh')
+if [ -n "$changed_sh" ]; then
+  if command -v shellcheck >/dev/null 2>&1; then
+    echo "$changed_sh" | xargs shellcheck --severity=warning || exit 1
+  else
+    echo "shellcheck not installed — skipping shell script checks"
+  fi
+fi
+
 # Check Rust formatting on changed .rs files, filtered by workspace
 changed_rs=$(git diff --cached --name-only --diff-filter=ACM -- '*.rs')
 if [ -n "$changed_rs" ]; then
diff --git a/Dockerfile b/Dockerfile
index d35d33a22..704b7d353 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -34,7 +34,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     && rm -rf /var/lib/apt/lists/*
 WORKDIR /build
 COPY . .
-RUN cargo build --release --manifest-path ./torrential/Cargo.toml
+RUN cargo build --locked --release --manifest-path ./torrential/Cargo.toml
 
 ### BUILD APP
 FROM base AS build-system
diff --git a/desktop/main/components/GameOptions/ProtonSelector.vue b/desktop/main/components/GameOptions/ProtonSelector.vue
index 39806d3a4..2c8bf0a0a 100644
--- a/desktop/main/components/GameOptions/ProtonSelector.vue
+++ b/desktop/main/components/GameOptions/ProtonSelector.vue
@@ -1,24 +1,14 @@
 <template>
-  <Listbox
-    as="div"
-    v-model="model.overrideProtonPath"
-    class="mt-6"
-  >
-    <ListboxLabel class="block text-sm/6 font-medium text-white"
-      >Proton override</ListboxLabel
-    >
+  <Listbox as="div" v-model="model.overrideProtonPath" class="mt-6">
+    <ListboxLabel class="block text-sm/6 font-medium text-white">Proton override</ListboxLabel>
     <div class="relative mt-2">
       <ListboxButton
         class="grid w-full cursor-default grid-cols-1 rounded-md bg-white/5 py-1.5 pr-2 pl-3 text-left text-white outline-1 -outline-offset-1 outline-white/10 focus-visible:outline-2 focus-visible:-outline-offset-2 focus-visible:outline-blue-500 sm:text-sm/6"
       >
-        <span
-          v-if="currentProtonPath"
-          class="col-start-1 row-start-1 truncate pr-6"
+        <span v-if="currentProtonPath" class="col-start-1 row-start-1 truncate pr-6"
           >{{ currentProtonPath.name }} ({{ currentProtonPath.path }})</span
         >
-        <span
-          v-else
-          class="col-start-1 row-start-1 truncate pr-6 italic text-zinc-400"
+        <span v-else class="col-start-1 row-start-1 truncate pr-6 italic text-zinc-400"
           >No override configured</span
         >
         <ChevronUpDownIcon
@@ -35,22 +25,14 @@
         <ListboxOptions
           class="absolute z-10 mt-1 max-h-60 w-full overflow-auto rounded-md bg-zinc-800 py-1 text-base outline-1 -outline-offset-1 outline-white/10 sm:text-sm"
         >
-          <ListboxOption
-            as="template"
-            :value="undefined"
-            v-slot="{ active, selected }"
-          >
+          <ListboxOption as="template" :value="undefined" v-slot="{ active, selected }">
             <li
               :class="[
                 active ? 'bg-blue-500 text-white outline-hidden' : 'text-white',
                 'relative cursor-default py-2 pr-9 pl-3 select-none',
               ]"
             >
-              <span
-                :class="[
-                  selected ? 'font-semibold' : 'font-normal',
-                  'block truncate italic',
-                ]"
+              <span :class="[selected ? 'font-semibold' : 'font-normal', 'block truncate italic']"
                 >Use global default</span
               >
 
@@ -65,90 +47,106 @@
               </span>
             </li>
           </ListboxOption>
-          <h1 class="text-white text-sm font-semibold bg-zinc-900 py-2 px-2">
-            Auto-discovered
-          </h1>
+          <h1 class="text-white text-sm font-semibold bg-zinc-900 py-2 px-2">Auto-discovered</h1>
+          <template v-if="protonPaths.autodiscovered.length > 0">
+            <ListboxOption
+              as="template"
+              v-for="proton in protonPaths.autodiscovered"
+              :key="proton.path"
+              :value="proton.path"
+              v-slot="{ active, selected }"
+            >
+              <li
+                :class="[
+                  active ? 'bg-blue-500 text-white outline-hidden' : 'text-white',
+                  'relative cursor-default py-2 pr-9 pl-3 select-none',
+                ]"
+              >
+                <span :class="[selected ? 'font-semibold' : 'font-normal', 'block truncate']"
+                  >{{ proton.name }} ({{ proton.path }})</span
+                >
+
+                <span
+                  v-if="selected"
+                  :class="[
+                    active ? 'text-white' : 'text-blue-400',
+                    'absolute inset-y-0 right-0 flex items-center pr-4',
+                  ]"
+                >
+                  <CheckIcon class="size-5" aria-hidden="true" />
+                </span>
+              </li>
+            </ListboxOption>
+          </template>
           <ListboxOption
+            v-else
             as="template"
-            v-if="protonPaths.autodiscovered.length > 0"
-            v-for="proton in protonPaths.autodiscovered"
-            :key="proton.path"
-            :value="proton.path"
-            v-slot="{ active, selected }"
+            disabled
+            :value="null"
+            v-slot="{ active }"
           >
             <li
               :class="[
-                active ? 'bg-blue-500 text-white outline-hidden' : 'text-white',
-                'relative cursor-default py-2 pr-9 pl-3 select-none',
+                active ? 'bg-zinc-800' : '',
+                'italic text-zinc-400 py-2 pr-9 pl-3',
               ]"
             >
-              <span
+              No auto-discovered layers.
+            </li>
+          </ListboxOption>
+          <h1 class="text-white text-sm font-semibold bg-zinc-900 py-2 px-2">Manually added</h1>
+          <template v-if="protonPaths.custom.length > 0">
+            <ListboxOption
+              as="template"
+              v-for="proton in protonPaths.custom"
+              :key="proton.path"
+              :value="proton.path"
+              v-slot="{ active, selected }"
+            >
+              <li
                 :class="[
-                  selected ? 'font-semibold' : 'font-normal',
-                  'block truncate',
+                  active ? 'bg-blue-500 text-white outline-hidden' : 'text-white',
+                  'relative cursor-default py-2 pr-9 pl-3 select-none',
                 ]"
-                >{{ proton.name }} ({{ proton.path }})</span
               >
+                <span :class="[selected ? 'font-semibold' : 'font-normal', 'block truncate']"
+                  >{{ proton.name }} ({{ proton.path }})</span
+                >
 
-              <span
-                v-if="selected"
-                :class="[
-                  active ? 'text-white' : 'text-blue-400',
-                  'absolute inset-y-0 right-0 flex items-center pr-4',
-                ]"
-              >
-                <CheckIcon class="size-5" aria-hidden="true" />
-              </span>
-            </li>
-          </ListboxOption>
-          <li v-else class="italic text-zinc-400 py-2 pr-9 pl-3">
-            No auto-discovered layers.
-          </li>
-          <h1 class="text-white text-sm font-semibold bg-zinc-900 py-2 px-2">
-            Manually added
-          </h1>
+                <span
+                  v-if="selected"
+                  :class="[
+                    active ? 'text-white' : 'text-blue-400',
+                    'absolute inset-y-0 right-0 flex items-center pr-4',
+                  ]"
+                >
+                  <CheckIcon class="size-5" aria-hidden="true" />
+                </span>
+              </li>
+            </ListboxOption>
+          </template>
           <ListboxOption
+            v-else
             as="template"
-            v-if="protonPaths.custom.length > 0"
-            v-for="proton in protonPaths.custom"
-            :key="proton.path"
-            :value="proton.path"
-            v-slot="{ active, selected }"
+            disabled
+            :value="null"
+            v-slot="{ active }"
           >
             <li
               :class="[
-                active ? 'bg-blue-500 text-white outline-hidden' : 'text-white',
-                'relative cursor-default py-2 pr-9 pl-3 select-none',
+                active ? 'bg-zinc-800' : '',
+                'italic text-zinc-400 py-2 pr-9 pl-3',
               ]"
             >
-              <span
-                :class="[
-                  selected ? 'font-semibold' : 'font-normal',
-                  'block truncate',
-                ]"
-                >{{ proton.name }} ({{ proton.path }})</span
-              >
-
-              <span
-                v-if="selected"
-                :class="[
-                  active ? 'text-white' : 'text-blue-400',
-                  'absolute inset-y-0 right-0 flex items-center pr-4',
-                ]"
-              >
-                <CheckIcon class="size-5" aria-hidden="true" />
-              </span>
+              No manually added layers.
             </li>
           </ListboxOption>
-          <li v-else class="italic text-zinc-400 py-2 pr-9 pl-3">
-            No manually added layers.
-          </li>
         </ListboxOptions>
       </transition>
     </div>
     <p class="mt-2 text-sm text-zinc-400" id="launch-description">
-      Override the Proton layer used to launch this game. You can add or remove
-      your custom Proton layer paths in
+      Override the Proton layer used to launch this game. You can add or remove your custom Proton
+      layer paths in
       <PageWidget to="/settings/compat">
         <WrenchIcon class="size-3" />
         Settings </PageWidget
@@ -181,9 +179,7 @@ const protonPaths = await invoke<{
 }>("fetch_proton_paths");
 const currentProtonPath = computed(
   () =>
-    protonPaths.autodiscovered.find(
-      (v) => v.path == model.value.overrideProtonPath,
-    ) ??
+    protonPaths.autodiscovered.find((v) => v.path == model.value.overrideProtonPath) ??
     protonPaths.custom.find((v) => v.path == model.value.overrideProtonPath),
 );
 </script>
diff --git a/desktop/main/composables/current-page-engine.ts b/desktop/main/composables/current-page-engine.ts
index 0990195c0..6e2ccf28f 100644
--- a/desktop/main/composables/current-page-engine.ts
+++ b/desktop/main/composables/current-page-engine.ts
@@ -14,7 +14,7 @@ export const useCurrentNavigationIndex = (
       .map((e, i) => ({ ...e, index: i }))
       .filter((e) => to.fullPath.startsWith(e.prefix));
     const bestOption = validOptions
-      .sort((a, b) => b.route.length - a.route.length)
+      .toSorted((a, b) => b.route.length - a.route.length)
       .at(0);
 
     return bestOption?.index ?? -1;
diff --git a/desktop/main/pages/settings/index.vue b/desktop/main/pages/settings/index.vue
index 752718c38..b1f5a43b0 100644
--- a/desktop/main/pages/settings/index.vue
+++ b/desktop/main/pages/settings/index.vue
@@ -1,16 +1,12 @@
 <template>
   <div class="border-b border-zinc-700 py-5">
-    <h3 class="text-base font-semibold font-display leading-6 text-zinc-100">
-      General
-    </h3>
+    <h3 class="text-base font-semibold font-display leading-6 text-zinc-100">General</h3>
   </div>
 
   <div class="mt-5 space-y-8">
     <div class="flex flex-row items-center justify-between">
       <div>
-        <h3 class="text-sm font-medium leading-6 text-zinc-100">
-          Start with system
-        </h3>
+        <h3 class="text-sm font-medium leading-6 text-zinc-100">Start with system</h3>
         <p class="mt-1 text-sm leading-6 text-zinc-400">
           Drop will automatically start when you log into your computer
         </p>
@@ -42,9 +38,12 @@ defineProps<{}>();
 const autostartEnabled = ref<boolean>(false);
 
 // Load initial state
-invoke("get_autostart_enabled").then((enabled) => {
-  autostartEnabled.value = enabled as boolean;
-});
+try {
+  const initialAutostart = await invoke<boolean>("get_autostart_enabled");
+  autostartEnabled.value = initialAutostart;
+} catch {
+  // Keep default false if IPC fails
+}
 
 // Watch for changes and update autostart
 watch(autostartEnabled, async (newValue: boolean) => {
diff --git a/desktop/src-tauri/download_manager/src/download_manager_builder.rs b/desktop/src-tauri/download_manager/src/download_manager_builder.rs
index cbc0dba7c..187cc90ef 100644
--- a/desktop/src-tauri/download_manager/src/download_manager_builder.rs
+++ b/desktop/src-tauri/download_manager/src/download_manager_builder.rs
@@ -224,6 +224,68 @@ impl DownloadManagerBuilder {
         send!(self.sender, DownloadManagerSignal::UpdateUIQueue);
     }
 
+    async fn ensure_other_downloads_queued(
+        registry: &HashMap<DownloadableMetadata, DownloadAgent>,
+        active_meta: &DownloadableMetadata,
+        app_handle: &AppHandle,
+    ) {
+        for agent in registry.values() {
+            if agent.metadata() != *active_meta && agent.status() != DownloadStatus::Queued {
+                agent.on_queued(app_handle);
+            }
+        }
+    }
+
+    async fn run_download_loop(
+        download_agent: DownloadAgent,
+        sender: tokio::sync::mpsc::Sender<DownloadManagerSignal>,
+        app_handle: AppHandle,
+    ) {
+        loop {
+            match download_agent.download(&app_handle).await {
+                Ok(true) => {}
+                Ok(false) => return,
+                Err(e) => {
+                    error!("download {:?} has error {}", download_agent.metadata(), &e);
+                    download_agent.on_error(&app_handle, &e);
+                    send!(sender, DownloadManagerSignal::Error(e));
+                    return;
+                }
+            }
+
+            if download_agent.control_flag().get() == DownloadThreadControlFlag::Stop {
+                return;
+            }
+
+            match download_agent.validate(&app_handle) {
+                Ok(true) => {
+                    download_agent.on_complete(&app_handle).await;
+                    send!(
+                        sender,
+                        DownloadManagerSignal::Completed(download_agent.metadata())
+                    );
+                    send!(sender, DownloadManagerSignal::UpdateUIQueue);
+                    return;
+                }
+                Ok(false) => {}
+                Err(e) => {
+                    error!(
+                        "download {:?} has validation error {}",
+                        download_agent.metadata(),
+                        &e
+                    );
+                    download_agent.on_error(&app_handle, &e);
+                    send!(sender, DownloadManagerSignal::Error(e));
+                    return;
+                }
+            }
+
+            if download_agent.control_flag().get() == DownloadThreadControlFlag::Stop {
+                return;
+            }
+        }
+    }
+
     async fn manage_go_signal(&mut self) {
         debug!("got signal Go");
         if self.download_agent_registry.is_empty() {
@@ -248,80 +310,30 @@ impl DownloadManagerBuilder {
             .unwrap()
             .clone();
 
-        let status = download_agent.status();
-
         // This download is already going
-        if status != DownloadStatus::Queued {
+        if download_agent.status() != DownloadStatus::Queued {
             return;
         }
 
-        // Ensure all others are marked as queued
-        for agent in self.download_agent_registry.values() {
-            if agent.metadata() != agent_data && agent.status() != DownloadStatus::Queued {
-                agent.on_queued(&self.app_handle);
-            }
-        }
+        Self::ensure_other_downloads_queued(
+            &self.download_agent_registry,
+            &agent_data,
+            &self.app_handle,
+        )
+        .await;
 
         info!("starting download for {agent_data:?}");
         self.active_control_flag = Some(download_agent.control_flag());
 
         let sender = self.sender.clone();
-
-        let mut download_thread_lock = lock!(self.current_download_thread);
         let app_handle = self.app_handle.clone();
 
-        *download_thread_lock = Some(tauri::async_runtime::spawn(async move {
-            loop {
-                let download_result = match download_agent.download(&app_handle).await {
-                    // Ok(true) is for completed and exited properly
-                    Ok(v) => v,
-                    Err(e) => {
-                        error!("download {:?} has error {}", download_agent.metadata(), &e);
-                        download_agent.on_error(&app_handle, &e);
-                        send!(sender, DownloadManagerSignal::Error(e));
-                        return;
-                    }
-                };
-
-                // If the download gets canceled
-                // immediately return, on_cancelled gets called for us earlier
-                if !download_result {
-                    return;
-                }
-
-                if download_agent.control_flag().get() == DownloadThreadControlFlag::Stop {
-                    return;
-                }
-
-                let validate_result = match download_agent.validate(&app_handle) {
-                    Ok(v) => v,
-                    Err(e) => {
-                        error!(
-                            "download {:?} has validation error {}",
-                            download_agent.metadata(),
-                            &e
-                        );
-                        download_agent.on_error(&app_handle, &e);
-                        send!(sender, DownloadManagerSignal::Error(e));
-                        return;
-                    }
-                };
-
-                if download_agent.control_flag().get() == DownloadThreadControlFlag::Stop {
-                    return;
-                }
-
-                if validate_result {
-                    download_agent.on_complete(&app_handle).await;
-                    send!(
-                        sender,
-                        DownloadManagerSignal::Completed(download_agent.metadata())
-                    );
-                    send!(sender, DownloadManagerSignal::UpdateUIQueue);
-                    return;
-                }
-            }
-        }));
+        let mut download_thread_lock = lock!(self.current_download_thread);
+        *download_thread_lock = Some(tauri::async_runtime::spawn(Self::run_download_loop(
+            download_agent,
+            sender,
+            app_handle,
+        )));
 
         self.set_status(DownloadManagerStatus::Downloading);
         let active_control_flag = self.active_control_flag.clone().unwrap();
diff --git a/desktop/src-tauri/games/src/downloads/download_agent.rs b/desktop/src-tauri/games/src/downloads/download_agent.rs
index 9718ca272..e15c6b8c4 100644
--- a/desktop/src-tauri/games/src/downloads/download_agent.rs
+++ b/desktop/src-tauri/games/src/downloads/download_agent.rs
@@ -69,6 +69,53 @@ impl Debug for GameDownloadAgent {
     }
 }
 
+async fn process_single_chunk(
+    metadata_id: String,
+    version_id: String,
+    chunk_id: String,
+    depot: String,
+    key: [u8; 16],
+    chunk_data: ChunkData,
+    file_list: HashMap<String, String>,
+    base_path: PathBuf,
+    control_flag: DownloadThreadControl,
+    dl_handle: ProgressHandle,
+    disk_handle: ProgressHandle,
+    permit: impl std::ops::Drop,
+) -> Result<Option<String>, ApplicationDownloadError> {
+    for i in 0..RETRY_COUNT {
+        match download_game_chunk(
+            &metadata_id,
+            &version_id,
+            &chunk_id,
+            &depot,
+            &key,
+            &chunk_data,
+            &file_list,
+            &base_path,
+            &control_flag,
+            &dl_handle,
+            &disk_handle,
+        )
+        .await
+        {
+            Ok(true) => {
+                drop(permit);
+                return Ok(Some(chunk_id));
+            }
+            Ok(false) => return Ok(None),
+            Err(e) => {
+                warn!("got error for chunk id {}: {e:?}", chunk_id);
+                if i == RETRY_COUNT - 1 {
+                    warn!("retry logic failed, not re-attempting.");
+                    return Err(e);
+                }
+            }
+        }
+    }
+    Ok(None)
+}
+
 impl GameDownloadAgent {
     pub async fn new(
         metadata: DownloadableMetadata,
@@ -273,82 +320,100 @@ impl GameDownloadAgent {
         self.disk_progress.reset();
     }
 
+    fn cleanup_filetree(
+        base_path: &Path,
+        file_list: &HashMap<String, String>,
+    ) -> Result<(), io::Error> {
+        let current_file_tree = Self::scan_filetree_static(base_path)?;
+        for file in current_file_tree {
+            let filename = file
+                .strip_prefix(base_path)
+                .map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "strip_prefix failed"))?
+                .to_string_lossy()
+                .to_string();
+            if !file_list.contains_key(&filename) && filename != ".dropdata" {
+                debug!("deleted {}", file.display());
+                remove_file(file)?;
+            }
+        }
+        Ok(())
+    }
+
+    fn scan_filetree_static(path: &Path) -> Result<Vec<PathBuf>, io::Error> {
+        if !path.is_dir() {
+            return Ok(vec![path.into()]);
+        }
+        let subdirs = path.read_dir()?;
+        let mut results = Vec::new();
+        for subdir in subdirs {
+            let subdir = subdir?;
+            let subfiles = Self::scan_filetree_static(&subdir.path())?;
+            results.extend(subfiles);
+        }
+        Ok(results)
+    }
+
+    fn collect_output(
+        outputs: &mut Vec<String>,
+        value: Result<Option<String>, ApplicationDownloadError>,
+    ) -> Result<(), ApplicationDownloadError> {
+        match value {
+            Ok(Some(chunk_id)) => {
+                outputs.push(chunk_id);
+                Ok(())
+            }
+            Ok(None) => Ok(()),
+            Err(err) => Err(err),
+        }
+    }
+
     async fn run(&self) -> Result<bool, ApplicationDownloadError> {
         self.depot_manager.sync_depots().await?;
         info!("synced depots");
         self.setup_progress();
         info!("setup progress objects");
-        let manifests_chunks: Vec<(String, HashMap<String, ChunkData>, [u8; 16])> = {
+
+        let (manifests_chunks, file_list, chunk_len) = {
             let dl_info = lock!(self.dl_info);
-            dl_info
-                .as_ref()
-                .unwrap()
+            let dl_info = dl_info.as_ref().unwrap();
+            let chunks: Vec<(String, HashMap<String, ChunkData>, [u8; 16])> = dl_info
                 .manifests
                 .iter()
                 .map(|v| (v.0.clone(), v.1.chunks.clone(), v.1.key))
-                .collect()
-        };
-        let file_list = {
-            let dl_info = lock!(self.dl_info);
-            dl_info.as_ref().unwrap().file_list.clone()
-        };
-        let mut completed_chunks = {
-            let completed_chunks = lock!(self.dropdata.contexts);
-            completed_chunks.clone()
+                .collect();
+            let chunk_len = chunks.iter().map(|v| v.1.len()).sum::<usize>();
+            (chunks, dl_info.file_list.clone(), chunk_len)
         };
+
+        let completed_chunks = lock!(self.dropdata.contexts).clone();
         info!("started with {} existing chunks", completed_chunks.len());
-        let chunk_len = manifests_chunks.iter().map(|v| v.1.len()).sum::<usize>();
+
         let mut max_download_threads = borrow_db_checked().settings.max_download_threads;
         if max_download_threads == 0 {
             max_download_threads = 1;
         }
 
-        let file_list = &file_list;
-        let base_path = &self.dropdata.base_path;
-        let current_file_tree = self.scan_filetree(base_path)?;
-
-        for file in current_file_tree {
-            let filename = file.strip_prefix(base_path)?.to_string_lossy().to_string();
-            let needed = file_list.contains_key(&filename) || filename == ".dropdata";
-            if !needed {
-                debug!("deleted {}", file.display());
-                remove_file(file)?;
-            }
-        }
-
-        let local_completed_chunks = completed_chunks.clone();
+        Self::cleanup_filetree(&self.dropdata.base_path, &file_list)?;
 
+        let mut completed_chunks = completed_chunks.clone();
         let mut chunk_completions = FuturesUnordered::new();
-
         let mut outputs = Vec::new();
-
-        let mut handle_output =
-            |value: Result<Option<String>, ApplicationDownloadError>| match value {
-                Ok(value) => {
-                    if let Some(chunk_id) = value {
-                        outputs.push(chunk_id);
-                    }
-                    Ok(())
-                }
-                Err(err) => Err(err),
-            };
-
         let mut index = 0;
+
         for (version_id, chunks, key) in manifests_chunks.into_iter() {
-            let version_id = &version_id;
             for (chunk_id, chunk_data) in chunks.into_iter() {
-                let download_progress_handle = ProgressHandle::new(
+                let dl_handle = ProgressHandle::new(
                     self.download_progress.get(index),
                     self.download_progress.clone(),
                 );
-                let disk_progress_handle =
+                let disk_handle =
                     ProgressHandle::new(self.disk_progress.get(index), self.disk_progress.clone());
                 index += 1;
 
-                let chunk_length = chunk_data.files.iter().map(|v| v.length).sum();
-
-                if *local_completed_chunks.get(&chunk_id).unwrap_or(&false) {
-                    download_progress_handle.skip(chunk_length);
+                let chunk_length: usize = chunk_data.files.iter().map(|v| v.length).sum();
+                if *completed_chunks.get(&chunk_id).unwrap_or(&false) {
+                    dl_handle.skip(chunk_length);
+                    disk_handle.skip(chunk_length);
                     continue;
                 }
 
@@ -357,88 +422,58 @@ impl GameDownloadAgent {
                     .next_depot(&self.metadata.id, &self.metadata.version)
                 {
                     Ok(v) => v,
-                    Err(err) => {
-                        return Err(err.into());
-                    }
+                    Err(err) => return Err(err.into()),
                 };
 
-                let local_version_id = version_id.clone();
                 while chunk_completions.len() >= max_download_threads {
-                    handle_output(
+                    Self::collect_output(
+                        &mut outputs,
                         chunk_completions
                             .next()
                             .await
                             .expect("max download threads is zero?"),
                     )?;
                 }
-                chunk_completions.push(async move {
-                    for i in 0..RETRY_COUNT {
-                        match download_game_chunk(
-                            &self.metadata.id,
-                            &local_version_id,
-                            &chunk_id,
-                            &depot,
-                            &key,
-                            &chunk_data,
-                            file_list,
-                            base_path,
-                            &self.control_flag,
-                            &download_progress_handle,
-                            &disk_progress_handle,
-                        )
-                        .await
-                        {
-                            Ok(true) => {
-                                drop(permit);
-                                return Ok(Some(chunk_id.clone()));
-                            }
-                            Ok(false) => return Ok(None),
-                            Err(e) => {
-                                warn!("got error for chunk id {}: {e:?}", chunk_id);
-
-                                let retry = true; /*matches!(
-                                &e,
-                                ApplicationDownloadError::Communication(_)
-                                | ApplicationDownloadError::Checksum
-                                | ApplicationDownloadError::Lock
-                                | ApplicationDownloadError::IoError(_)
-                                );*/
-
-                                if i == RETRY_COUNT - 1 || !retry {
-                                    warn!("retry logic failed, not re-attempting.");
-                                    return Err(e);
-                                }
-                            }
-                        }
-                    }
-                    Ok(None)
-                });
+
+                chunk_completions.push(Box::pin(process_single_chunk(
+                    self.metadata.id.clone(),
+                    version_id.clone(),
+                    chunk_id.clone(),
+                    depot,
+                    key,
+                    chunk_data,
+                    file_list.clone(),
+                    self.dropdata.base_path.clone(),
+                    self.control_flag.clone(),
+                    dl_handle,
+                    disk_handle,
+                    permit,
+                )));
             }
         }
 
         while let Some(value) = chunk_completions.next().await {
-            handle_output(value)?
+            Self::collect_output(&mut outputs, value)?;
         }
 
-        for completed_chunk in outputs {
-            completed_chunks.insert(completed_chunk, true);
+        for completed in &outputs {
+            completed_chunks.insert(completed.clone(), true);
         }
 
-        let drop_data_chunks = completed_chunks
+        let drop_data_chunks: Vec<(String, bool)> = completed_chunks
             .iter()
-            .map(|v| (v.0.to_string(), *v.1))
-            .collect::<Vec<(String, bool)>>();
+            .map(|(k, v)| (k.clone(), *v))
+            .collect();
 
         self.dropdata.set_contexts(&drop_data_chunks);
         self.dropdata.write();
 
         info!("completed {} chunks", drop_data_chunks.len());
 
-        // If there are any contexts left which are false
         if completed_chunks.len() != chunk_len {
             info!(
                 "download agent for {} exited without completing ({}/{})",
-                self.metadata.id.clone(),
+                self.metadata.id,
                 completed_chunks.len(),
                 chunk_len,
             );
diff --git a/desktop/src-tauri/games/src/downloads/download_logic.rs b/desktop/src-tauri/games/src/downloads/download_logic.rs
index d80bff934..d0d84a0f7 100644
--- a/desktop/src-tauri/games/src/downloads/download_logic.rs
+++ b/desktop/src-tauri/games/src/downloads/download_logic.rs
@@ -13,7 +13,7 @@ use download_manager::util::download_thread_control_flag::{
     DownloadThreadControl, DownloadThreadControlFlag,
 };
 use download_manager::util::progress_object::ProgressHandle;
-use droplet_types::ChunkData;
+use droplet_types::{ChunkData, FileEntry};
 use futures_util::StreamExt as _;
 use log::{debug, info};
 use remote::auth::generate_authorization_header;
@@ -28,6 +28,73 @@ const READ_BUF_LEN: usize = 1024 * 1024;
 
 type Aes128Ctr64LE = ctr::Ctr64LE<aes::Aes128>;
 
+#[cfg(unix)]
+fn set_file_permissions(
+    file: &FileEntry,
+    path: &Path,
+    file_handle: Option<tokio::fs::File>,
+) -> Result<(), ApplicationDownloadError> {
+    drop(file_handle);
+    let perm = if file.permissions == 0 {
+        0o744
+    } else {
+        file.permissions
+    };
+    let permissions = Permissions::from_mode(perm);
+    set_permissions(path, permissions).map_err(|e| ApplicationDownloadError::IoError(Arc::new(e)))
+}
+
+#[cfg(not(unix))]
+fn set_file_permissions(
+    _file: &FileEntry,
+    _path: &Path,
+    _file_handle: Option<tokio::fs::File>,
+) -> Result<(), ApplicationDownloadError> {
+    Ok(())
+}
+
+fn is_paused(control_flag: &DownloadThreadControl) -> bool {
+    control_flag.get() == DownloadThreadControlFlag::Stop
+}
+
+async fn fetch_chunk_response(
+    game_id: &str,
+    version_id: &str,
+    chunk_id: &str,
+    depot: &str,
+) -> Result<reqwest::Response, ApplicationDownloadError> {
+    let header = generate_authorization_header();
+    let url = Url::parse(depot)
+        .map_err(|v| ApplicationDownloadError::DownloadError(v.into()))?
+        .join(&format!("content/{}/{}/{}", game_id, version_id, chunk_id))
+        .map_err(|v| ApplicationDownloadError::DownloadError(v.into()))?;
+
+    DROP_CLIENT_ASYNC
+        .get(url)
+        .header("Authorization", header)
+        .send()
+        .await
+        .map_err(|e| ApplicationDownloadError::Communication(e.into()))
+}
+
+async fn handle_non_200_response(
+    response: reqwest::Response,
+) -> Result<bool, ApplicationDownloadError> {
+    info!("chunk request got status code: {}", response.status());
+    let raw_res = response.text().await.map_err(|e| {
+        ApplicationDownloadError::Communication(RemoteAccessError::FetchErrorLegacy(e.into()))
+    })?;
+    info!("{raw_res}");
+    if let Ok(err) = serde_json::from_str::<DropServerError>(&raw_res) {
+        return Err(ApplicationDownloadError::Communication(
+            RemoteAccessError::InvalidResponse(err),
+        ));
+    }
+    Err(ApplicationDownloadError::Communication(
+        RemoteAccessError::UnparseableResponse(raw_res),
+    ))
+}
+
 #[allow(clippy::too_many_arguments)]
 pub async fn download_game_chunk(
     game_id: &str,
@@ -44,64 +111,33 @@ pub async fn download_game_chunk(
     // How much we're writing to disk
     disk_progress: &ProgressHandle,
 ) -> Result<bool, ApplicationDownloadError> {
-    // If we're paused
-    if control_flag.get() == DownloadThreadControlFlag::Stop {
+    if is_paused(control_flag) {
         download_progress.set(0);
         disk_progress.set(0);
         return Ok(false);
     }
 
-    let start = Instant::now();
-
-    let header = generate_authorization_header();
-
-    let url = Url::parse(depot)
-        .map_err(|v| ApplicationDownloadError::DownloadError(v.into()))?
-        .join(&format!("content/{}/{}/{}", game_id, version_id, chunk_id))
-        .map_err(|v| ApplicationDownloadError::DownloadError(v.into()))?;
-
-    let response = DROP_CLIENT_ASYNC
-        .get(url)
-        .header("Authorization", header)
-        .send()
-        .await
-        .map_err(|e| ApplicationDownloadError::Communication(e.into()))?;
+    let response = fetch_chunk_response(game_id, version_id, chunk_id, depot).await?;
 
     if response.status() != 200 {
-        info!("chunk request got status code: {}", response.status());
-        let raw_res = response.text().await.map_err(|e| {
-            ApplicationDownloadError::Communication(RemoteAccessError::FetchErrorLegacy(e.into()))
-        })?;
-        info!("{raw_res}");
-        if let Ok(err) = serde_json::from_str::<DropServerError>(&raw_res) {
-            return Err(ApplicationDownloadError::Communication(
-                RemoteAccessError::InvalidResponse(err),
-            ));
-        }
-        return Err(ApplicationDownloadError::Communication(
-            RemoteAccessError::UnparseableResponse(raw_res),
-        ));
+        return handle_non_200_response(response).await;
     }
 
-    if control_flag.get() == DownloadThreadControlFlag::Stop {
+    if is_paused(control_flag) {
         download_progress.set(0);
         disk_progress.set(0);
         return Ok(false);
     }
 
-    let timestep = start.elapsed().as_millis();
-
-    debug!("took {}ms to start downloading", timestep);
-
     let stream = response
         .bytes_stream()
         .map(|v| v.map_err(std::io::Error::other));
     let mut stream_reader = StreamReader::new(stream);
-    //let mut stream_reader = response;
 
     let mut hasher = sha2::Sha256::new();
     let mut cipher = Aes128Ctr64LE::new(key.into(), &chunk_data.iv.into());
     let mut read_buf = vec![0u8; READ_BUF_LEN];
+
     for file in &chunk_data.files {
         let should_write = file_list
             .get(&file.filename)
@@ -111,18 +147,18 @@ pub async fn download_game_chunk(
         if let Some(parent) = path.parent() {
             std::fs::create_dir_all(parent)?;
         }
+
         let mut file_handle = if should_write {
-            let mut file_handle = tokio::fs::OpenOptions::new()
+            let mut fh = tokio::fs::OpenOptions::new()
                 .truncate(false)
                 .write(true)
                 .append(false)
                 .create(true)
                 .open(&path)
                 .await?;
-            file_handle
-                .seek(SeekFrom::Start(file.start.try_into().unwrap()))
+            fh.seek(SeekFrom::Start(file.start.try_into().unwrap()))
                 .await?;
-            Some(file_handle)
+            Some(fh)
         } else {
             None
         };
@@ -137,27 +173,17 @@ pub async fn download_game_chunk(
 
             cipher.apply_keystream(&mut read_buf[0..amount]);
             hasher.update(&read_buf[0..amount]);
-            if let Some(file_handle) = &mut file_handle {
-                file_handle.write_all(&read_buf[0..amount]).await?;
+            if let Some(fh) = &mut file_handle {
+                fh.write_all(&read_buf[0..amount]).await?;
                 disk_progress.add(amount);
             }
         }
 
-        #[cfg(unix)]
-        {
-            drop(file_handle);
-            let permissions = if file.permissions == 0 {
-                0o744
-            } else {
-                file.permissions
-            };
-            let permissions = Permissions::from_mode(permissions);
-            set_permissions(path, permissions)
-                .map_err(|e| ApplicationDownloadError::IoError(Arc::new(e)))?;
-        }
+        set_file_permissions(file, &path, file_handle)?;
 
-        if control_flag.get() == DownloadThreadControlFlag::Stop {
+        if is_paused(control_flag) {
             download_progress.set(0);
+            disk_progress.set(0);
             return Ok(false);
         }
     }
diff --git a/desktop/src-tauri/remote/src/utils.rs b/desktop/src-tauri/remote/src/utils.rs
index 7f05ebc02..08b17a9b4 100644
--- a/desktop/src-tauri/remote/src/utils.rs
+++ b/desktop/src-tauri/remote/src/utils.rs
@@ -1,6 +1,7 @@
 use std::{
     fs::{self, File},
     io::Read,
+    path::Path,
     sync::LazyLock,
     time::Duration,
 };
@@ -36,6 +37,30 @@ pub static DROP_APP_HANDLE: LazyLock<Mutex<Option<AppHandle>>> = LazyLock::new(|
 
 struct AutoOfflineMiddleware;
 
+async fn transition_online(app_handle: &tauri::AppHandle, url: &url::Url) {
+    let state = app_handle.state::<std::sync::nonpoison::Mutex<AppState>>();
+    let state_lock = state.try_lock();
+    if let Ok(mut state_lock) = state_lock {
+        if state_lock.status == AppStatus::Offline {
+            state_lock.status = AppStatus::SignedIn;
+            app_handle
+                .emit("update_state", &*state_lock)
+                .expect("failed to emit state update");
+        }
+    } else {
+        warn!("failed to lock app state - {}", url.as_str());
+    }
+}
+
+async fn transition_offline(app_handle: &tauri::AppHandle) {
+    let state = app_handle.state::<std::sync::nonpoison::Mutex<AppState>>();
+    let mut state_lock = state.lock();
+    state_lock.status = AppStatus::Offline;
+    app_handle
+        .emit("update_state", &*state_lock)
+        .expect("failed to emit state update");
+}
+
 #[async_trait::async_trait]
 impl Middleware for AutoOfflineMiddleware {
     async fn handle(
@@ -49,106 +74,86 @@ impl Middleware for AutoOfflineMiddleware {
         match res {
             Ok(res) => {
                 tauri::async_runtime::spawn(async move {
-                    let lock = DROP_APP_HANDLE.lock().await;
-                    if let Some(app_handle) = &*lock {
-                        let state = app_handle.state::<std::sync::nonpoison::Mutex<AppState>>();
-                        let state_lock = state.try_lock();
-                        if let Ok(mut state_lock) = state_lock {
-                            if state_lock.status == AppStatus::Offline {
-                                state_lock.status = AppStatus::SignedIn;
-                                app_handle
-                                    .emit("update_state", &*state_lock)
-                                    .expect("failed to emit state update");
-                            }
-                        } else {
-                            warn!("failed to lock app state - {}", url.as_str());
-                        }
-                    };
+                    let handle = DROP_APP_HANDLE.lock().await;
+                    if let Some(app_handle) = &*handle {
+                        transition_online(app_handle, &url).await;
+                    }
                 });
-
                 Ok(res)
             }
-            Err(err) => match err {
-                Error::Middleware(error) => Err(Error::Middleware(error)),
-                Error::Reqwest(error) => {
+            Err(err) => {
+                if let Error::Reqwest(ref error) = err {
                     if error.is_connect() {
-                        // Spawn to defer this action - the state will most likely be locked
                         tauri::async_runtime::spawn(async move {
-                            let lock = DROP_APP_HANDLE.lock().await;
-                            if let Some(app_handle) = &*lock {
-                                let state =
-                                    app_handle.state::<std::sync::nonpoison::Mutex<AppState>>();
-                                let mut state_lock = state.lock();
-                                state_lock.status = AppStatus::Offline;
-                                app_handle
-                                    .emit("update_state", &*state_lock)
-                                    .expect("failed to emit state update");
-                            };
+                            let handle = DROP_APP_HANDLE.lock().await;
+                            if let Some(app_handle) = &*handle {
+                                transition_offline(app_handle).await;
+                            }
                         });
-                    };
-                    Err(Error::Reqwest(error))
+                    }
                 }
-            },
+                Err(err)
+            }
+        }
+    }
+}
+
+fn process_cert_file(path: &Path, certs: &mut Vec<Certificate>) {
+    let mut buf = Vec::new();
+    let mut file = match File::open(path) {
+        Ok(f) => f,
+        Err(e) => {
+            warn!("Failed to open file at {} with error {}", path.display(), e);
+            return;
+        }
+    };
+    if let Err(e) = file.read_to_end(&mut buf) {
+        warn!(
+            "Failed to read certificate file {} with error {}",
+            path.display(),
+            e
+        );
+        return;
+    }
+
+    match Certificate::from_pem_bundle(&buf) {
+        Ok(certificates) => {
+            let count_before = certs.len();
+            certs.extend(certificates);
+            info!(
+                "added {} certificate(s) from {}",
+                certs.len() - count_before,
+                path.file_name().unwrap().to_string_lossy()
+            );
         }
+        Err(e) => warn!(
+            "Invalid certificate file {} with error {}",
+            path.display(),
+            e
+        ),
     }
 }
 
 fn fetch_certificates() -> Vec<Certificate> {
     let certificate_dir = DATA_ROOT_DIR.join("certificates");
-
     let mut certs = Vec::new();
-    match fs::read_dir(certificate_dir) {
-        Ok(c) => {
-            for entry in c {
-                match entry {
-                    Ok(c) => {
-                        let mut buf = Vec::new();
-                        match File::open(c.path()) {
-                            Ok(f) => f,
-                            Err(e) => {
-                                warn!(
-                                    "Failed to open file at {} with error {}",
-                                    c.path().display(),
-                                    e
-                                );
-                                continue;
-                            }
-                        }
-                        .read_to_end(&mut buf)
-                        .unwrap_or_else(|e| {
-                            panic!(
-                                "Failed to read to end of certificate file {} with error {}",
-                                c.path().display(),
-                                e
-                            )
-                        });
 
-                        match Certificate::from_pem_bundle(&buf) {
-                            Ok(certificates) => {
-                                for cert in certificates {
-                                    certs.push(cert);
-                                }
-                                info!(
-                                    "added {} certificate(s) from {}",
-                                    certs.len(),
-                                    c.file_name().display()
-                                );
-                            }
-                            Err(e) => warn!(
-                                "Invalid certificate file {} with error {}",
-                                c.path().display(),
-                                e
-                            ),
-                        }
-                    }
-                    Err(_) => todo!(),
-                }
-            }
-        }
+    let dir = match fs::read_dir(certificate_dir) {
+        Ok(d) => d,
         Err(e) => {
             debug!("not loading certificates due to error: {e}");
+            return certs;
         }
     };
+
+    for entry in dir {
+        let entry = match entry {
+            Ok(e) => e,
+            Err(_) => continue,
+        };
+        process_cert_file(&entry.path(), &mut certs);
+    }
+
     certs
 }
 
diff --git a/desktop/src-tauri/src/lib.rs b/desktop/src-tauri/src/lib.rs
index b12c21c71..17905267e 100644
--- a/desktop/src-tauri/src/lib.rs
+++ b/desktop/src-tauri/src/lib.rs
@@ -201,10 +201,151 @@ pub fn custom_panic_handler(e: &PanicHookInfo) -> Option<()> {
     Some(())
 }
 
+fn setup_tray(app: &tauri::App, menu: &tauri::menu::Menu<tauri::Wry>) {
+    let tray = TrayIconBuilder::new()
+        .icon(
+            app.default_window_icon()
+                .expect("Failed to get default window icon")
+                .clone(),
+        )
+        .menu(menu)
+        .on_menu_event(|app, event| match event.id.as_ref() {
+            "open" => {
+                app.webview_windows()
+                    .get("frontend")
+                    .expect("Failed to get webview")
+                    .show()
+                    .expect("Failed to show window");
+            }
+            "quit" => {
+                app.exit(0);
+            }
+            _ => {
+                warn!("menu event not handled: {:?}", event.id);
+            }
+        })
+        .build(app);
+
+    if let Err(e) = tray {
+        warn!("failed to set up system tray icon, disabling tray: {e}");
+        TRAY_DISABLED.store(true, Ordering::Relaxed);
+    }
+}
+
+fn check_tray_support() {
+    if env::var("NO_TRAY_ICON").is_ok_and(|value| value.to_lowercase() == "true") {
+        TRAY_DISABLED.store(true, Ordering::Relaxed);
+    } else if !tray_icon_supported() {
+        warn!("appindicator library not available at runtime, disabling system tray icon");
+        TRAY_DISABLED.store(true, Ordering::Relaxed);
+    }
+}
+
+fn build_menu(app: &tauri::App) -> tauri::menu::Menu<tauri::Wry> {
+    let open_menu_item = MenuItem::with_id(app, "open", "Open", true, None::<&str>)
+        .expect("Failed to generate open menu item");
+
+    let sep = PredefinedMenuItem::separator(app).expect("Failed to generate menu separator item");
+
+    let quit_menu_item = MenuItem::with_id(app, "quit", "Quit", true, None::<&str>)
+        .expect("Failed to generate quit menu item");
+
+    Menu::with_items(app, &[&open_menu_item, &sep, &quit_menu_item])
+        .expect("Failed to generate menu")
+}
+
+fn setup_deep_link_handler(handle: tauri::AppHandle) {
+    tauri::AppHandle::clone(&handle)
+        .deep_link()
+        .on_open_url(move |event| {
+            debug!("handling drop:// url");
+            let binding = event.urls();
+            let url = match binding.first() {
+                Some(url) => url,
+                None => {
+                    warn!("No value recieved from deep link. Is this a drop server?");
+                    return;
+                }
+            };
+            if let Some("handshake") = url.host_str() {
+                tauri::async_runtime::spawn(recieve_handshake(
+                    handle.clone(),
+                    url.path().to_string(),
+                ));
+            }
+        });
+}
+
+fn check_corrupted_database(app: &tauri::App) {
+    let mut db_handle = borrow_db_mut_checked();
+    if let Some(original) = db_handle.prev_database.take() {
+        let canonicalised = match original.canonicalize() {
+            Ok(o) => o,
+            Err(_) => original,
+        };
+        warn!(
+            "Database corrupted. Original file at {}",
+            canonicalised.display()
+        );
+        app.dialog()
+            .message(format!(
+                "Database corrupted. A copy has been saved at: {}",
+                canonicalised.display()
+            ))
+            .title("Database corrupted")
+            .show(|_| {});
+    }
+}
+
+async fn initialize_app(app: &mut tauri::App<tauri::Wry>, handle: tauri::AppHandle) {
+    let state = setup(handle.clone()).await;
+    info!("initialized drop client");
+    app.manage(Mutex::new(state));
+
+    {
+        let mut app_handle_lock = DROP_APP_HANDLE.lock().await;
+        app_handle_lock.replace(handle.clone());
+    };
+
+    {
+        use tauri_plugin_deep_link::DeepLinkExt;
+        let _ = app.deep_link().register_all();
+        debug!("registered all pre-defined deep links");
+    }
+
+    let handle_clone = app.handle().clone();
+    let width = 1536.0;
+    let height = 864.0;
+
+    let main_window = WindowBuilder::new(&handle_clone, "main")
+        .title("Drop Desktop App")
+        .min_inner_size(1000.0, 500.0)
+        .inner_size(width, height)
+        .decorations(false)
+        .shadow(false)
+        .build()
+        .expect("failed to build main window");
+
+    main_window
+        .add_child(
+            WebviewBuilder::new("frontend", WebviewUrl::App("main".into())).auto_resize(),
+            LogicalPosition::new(0., 0.),
+            LogicalSize::new(width, height),
+        )
+        .expect("failed to create frontend webview");
+
+    setup_deep_link_handler(handle);
+    check_tray_support();
+
+    let menu = build_menu(app);
+    run_on_tray(|| setup_tray(app, &menu));
+    check_corrupted_database(app);
+
+    tokio::spawn(async move { scheduler_task().await });
+}
+
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
-    // let global_span = span!(Level::TRACE, "global_span");
-    // let _enter = global_span.enter();
     std::panic::set_hook(Box::new(|e| {
         let _ = custom_panic_handler(e);
         println!("{e}");
@@ -287,153 +428,7 @@ pub fn run() {
         ))
         .setup(|app| {
             let handle = app.handle().clone();
-
-            tauri::async_runtime::block_on(async move {
-                let state = setup(handle.clone()).await;
-                info!("initialized drop client");
-                app.manage(Mutex::new(state));
-
-                let global_app_handle = handle;
-                {
-                    let mut app_handle_lock = DROP_APP_HANDLE.lock().await;
-                    app_handle_lock.replace(global_app_handle);
-                };
-
-                {
-                    use tauri_plugin_deep_link::DeepLinkExt;
-                    let _ = app.deep_link().register_all();
-                    debug!("registered all pre-defined deep links");
-                }
-
-                let handle = app.handle().clone();
-
-                let width = 1536.0;
-                let height = 864.0;
-
-                let main_window = WindowBuilder::new(&handle, "main")
-                    .title("Drop Desktop App")
-                    .min_inner_size(1000.0, 500.0)
-                    .inner_size(width, height)
-                    .decorations(false)
-                    .shadow(false)
-                    .build()
-                    .expect("failed to build main window");
-
-                main_window
-                    .add_child(
-                        WebviewBuilder::new("frontend", WebviewUrl::App("main".into()))
-                            .auto_resize(),
-                        LogicalPosition::new(0., 0.),
-                        LogicalSize::new(width, height),
-                    )
-                    .expect("failed to create frontend webview");
-
-                app.deep_link().on_open_url(move |event| {
-                    debug!("handling drop:// url");
-                    let binding = event.urls();
-                    let url = match binding.first() {
-                        Some(url) => url,
-                        None => {
-                            warn!("No value recieved from deep link. Is this a drop server?");
-                            return;
-                        }
-                    };
-                    if let Some("handshake") = url.host_str() {
-                        tauri::async_runtime::spawn(recieve_handshake(
-                            handle.clone(),
-                            url.path().to_string(),
-                        ));
-                    }
-                });
-                let open_menu_item = MenuItem::with_id(app, "open", "Open", true, None::<&str>)
-                    .expect("Failed to generate open menu item");
-
-                let sep = PredefinedMenuItem::separator(app)
-                    .expect("Failed to generate menu separator item");
-
-                let quit_menu_item = MenuItem::with_id(app, "quit", "Quit", true, None::<&str>)
-                    .expect("Failed to generate quit menu item");
-
-                let menu = Menu::with_items(
-                    app,
-                    &[
-                        &open_menu_item,
-                        &sep,
-                        /*
-                        &MenuItem::with_id(app, "show_library", "Library", true, None::<&str>)?,
-                        &MenuItem::with_id(app, "show_settings", "Settings", true, None::<&str>)?,
-                        &PredefinedMenuItem::separator(app)?,
-                         */
-                        &quit_menu_item,
-                    ],
-                )
-                .expect("Failed to generate menu");
-
-                if env::var("NO_TRAY_ICON").is_ok_and(|value| value.to_lowercase() == "true") {
-                    TRAY_DISABLED.store(true, Ordering::Relaxed);
-                } else if !tray_icon_supported() {
-                    warn!(
-                        "appindicator library not available at runtime, disabling system tray icon"
-                    );
-                    TRAY_DISABLED.store(true, Ordering::Relaxed);
-                }
-
-                run_on_tray(|| {
-                    let tray = TrayIconBuilder::new()
-                        .icon(
-                            app.default_window_icon()
-                                .expect("Failed to get default window icon")
-                                .clone(),
-                        )
-                        .menu(&menu)
-                        .on_menu_event(|app, event| match event.id.as_ref() {
-                            "open" => {
-                                app.webview_windows()
-                                    .get("frontend")
-                                    .expect("Failed to get webview")
-                                    .show()
-                                    .expect("Failed to show window");
-                            }
-                            "quit" => {
-                                app.exit(0);
-                            }
-
-                            _ => {
-                                warn!("menu event not handled: {:?}", event.id);
-                            }
-                        })
-                        .build(app);
-
-                    if let Err(e) = tray {
-                        warn!("failed to set up system tray icon, disabling tray: {e}");
-                        TRAY_DISABLED.store(true, Ordering::Relaxed);
-                    }
-                });
-
-                {
-                    let mut db_handle = borrow_db_mut_checked();
-                    if let Some(original) = db_handle.prev_database.take() {
-                        let canonicalised = match original.canonicalize() {
-                            Ok(o) => o,
-                            Err(_) => original,
-                        };
-                        warn!(
-                            "Database corrupted. Original file at {}",
-                            canonicalised.display()
-                        );
-                        app.dialog()
-                            .message(format!(
-                                "Database corrupted. A copy has been saved at: {}",
-                                canonicalised.display()
-                            ))
-                            .title("Database corrupted")
-                            .show(|_| {});
-                    }
-                }
-
-                tokio::spawn(async move { scheduler_task().await });
-            });
-
+            tauri::async_runtime::block_on(initialize_app(app, handle));
             Ok(())
         })
         .register_asynchronous_uri_scheme_protocol("object", move |_ctx, request, responder| {
diff --git a/libraries/droplet/src/manifest.rs b/libraries/droplet/src/manifest.rs
index a8bd97efb..a034e6c78 100644
--- a/libraries/droplet/src/manifest.rs
+++ b/libraries/droplet/src/manifest.rs
@@ -79,6 +79,74 @@ where
     })
 }
 
+fn push_chunk(
+    chunks: &mut Vec<Vec<(VersionFile, u64, u64)>>,
+    chunk: &mut Vec<(VersionFile, u64, u64)>,
+) {
+    chunks.push(std::mem::take(chunk));
+    println!("Chunks: {}", chunks.len());
+}
+
+fn collect_whole_files(
+    version_file: VersionFile,
+    current_chunk: &mut Vec<(VersionFile, u64, u64)>,
+    chunks: &mut Vec<Vec<(VersionFile, u64, u64)>>,
+) {
+    let version_file_size = version_file.size;
+
+    if version_file_size >= CHUNK_SIZE {
+        chunks.push(vec![(version_file, 0, version_file_size)]);
+        println!("Chunks: {}", chunks.len());
+        return;
+    }
+
+    let current_chunk_size = current_chunk
+        .iter()
+        .map(|(_, _, length)| *length)
+        .sum::<u64>();
+
+    current_chunk.push((version_file, 0, version_file_size));
+    if current_chunk_size + version_file_size >= CHUNK_SIZE {
+        push_chunk(chunks, current_chunk);
+    }
+}
+
+fn collect_split_files(
+    version_file: VersionFile,
+    current_chunk: &mut Vec<(VersionFile, u64, u64)>,
+    chunks: &mut Vec<Vec<(VersionFile, u64, u64)>>,
+) {
+    let version_file_size = version_file.size;
+    let current_chunk_size = current_chunk
+        .iter()
+        .map(|(_, _, length)| *length)
+        .sum::<u64>();
+
+    // Enough space for it to be put in immediately
+    if version_file_size + current_chunk_size < CHUNK_SIZE {
+        current_chunk.push((version_file, 0, version_file_size));
+        return;
+    }
+
+    let bytes_free_in_existing_chunk = CHUNK_SIZE - current_chunk_size;
+    current_chunk.push((version_file.clone(), 0, bytes_free_in_existing_chunk));
+    push_chunk(chunks, current_chunk);
+
+    // Loop over remaining data and create sufficient chunks to use it
+    let mut offset = bytes_free_in_existing_chunk;
+    while offset < version_file_size {
+        let length = CHUNK_SIZE.min(version_file_size - offset);
+        if length == CHUNK_SIZE {
+            chunks.push(vec![(version_file.clone(), offset, length)]);
+            println!("Chunks: {}", chunks.len());
+        } else {
+            current_chunk.push((version_file.clone(), offset, length));
+            println!("Chunks: {}", chunks.len());
+        }
+        offset += length;
+    }
+}
+
 fn organise_files(
     files: Vec<VersionFile>,
     require_whole_files: bool,
@@ -88,55 +156,13 @@ fn organise_files(
 
     for version_file in files {
         if current_chunk.len() >= MAX_FILE_COUNT {
-            // Pop current chunk
-            chunks.push(std::mem::take(&mut current_chunk));
-            println!("Chunks: {}", chunks.len());
+            push_chunk(&mut chunks, &mut current_chunk);
         }
-        let current_chunk_size = current_chunk
-            .iter()
-            .map(|(_, _, length)| *length)
-            .sum::<u64>();
-        let version_file_size = version_file.size;
 
         if require_whole_files {
-            // If the current chunk is larger than chunk size, there's no point adding
-            // it to the current_chunk. Just push it by itself
-            if version_file_size >= CHUNK_SIZE {
-                chunks.push(vec![(version_file, 0, version_file_size)]);
-                println!("Chunks: {}", chunks.len());
-                continue;
-            }
-
-            current_chunk.push((version_file, 0, version_file_size));
-            if current_chunk_size + version_file_size >= CHUNK_SIZE {
-                // Pop current chunk
-                chunks.push(std::mem::take(&mut current_chunk));
-                println!("Chunks: {}", chunks.len());
-            }
+            collect_whole_files(version_file, &mut current_chunk, &mut chunks);
         } else {
-            // Enough space for it to be put in immediately
-            if version_file_size + current_chunk_size < CHUNK_SIZE {
-                current_chunk.push((version_file, 0, version_file_size));
-                continue;
-            }
-
-            let bytes_free_in_existing_chunk = CHUNK_SIZE - current_chunk_size;
-            current_chunk.push((version_file.clone(), 0, bytes_free_in_existing_chunk));
-            chunks.push(std::mem::take(&mut current_chunk));
-
-            // Loop over remaining data and create sufficient chunks to use it
-            let mut offset = bytes_free_in_existing_chunk;
-            while offset < version_file_size {
-                let length = CHUNK_SIZE.min(version_file_size - offset);
-                if length == CHUNK_SIZE {
-                    chunks.push(vec![(version_file.clone(), offset, length)]);
-                    println!("Chunks: {}", chunks.len());
-                } else {
-                    current_chunk.push((version_file.clone(), offset, length));
-                    println!("Chunks: {}", chunks.len());
-                }
-                offset += length;
-            }
+            collect_split_files(version_file, &mut current_chunk, &mut chunks);
         }
     }
     if current_chunk.is_empty().not() {
diff --git a/libraries/libarchive/Cargo.lock b/libraries/libarchive/Cargo.lock
new file mode 100644
index 000000000..3c8bec270
--- /dev/null
+++ b/libraries/libarchive/Cargo.lock
@@ -0,0 +1,33 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "libarchive-drop"
+version = "0.1.1"
+dependencies = [
+ "libarchive3-sys",
+ "libc",
+]
+
+[[package]]
+name = "libarchive3-sys"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3cd3beae8f59a4c7a806523269b5392037577c150446e88d684dfa6de6031ca7"
+dependencies = [
+ "libc",
+ "pkg-config",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.189"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
+
+[[package]]
+name = "pkg-config"
+version = "0.3.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e"
diff --git a/libraries/native_model/Cargo.lock b/libraries/native_model/Cargo.lock
new file mode 100644
index 000000000..aaaec4228
--- /dev/null
+++ b/libraries/native_model/Cargo.lock
@@ -0,0 +1,897 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "alloca"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5a7d05ea6aea7e9e64d25b9156ba2fee3fdd659e34e41063cd2fc7cd020d7f4"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "anes"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
+
+[[package]]
+name = "anstyle"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
+
+[[package]]
+name = "anyhow"
+version = "1.0.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
+
+[[package]]
+name = "atomic-polyfill"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8cf2bce30dfe09ef0bfaef228b9d414faaf7e563035494d7fe092dba54b300f4"
+dependencies = [
+ "critical-section",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+
+[[package]]
+name = "bincode"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bincode"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740"
+dependencies = [
+ "bincode_derive",
+ "serde",
+ "unty",
+]
+
+[[package]]
+name = "bincode_derive"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf95709a440f45e986983918d0e8a1f30a9b1df04918fc828670606804ac3c09"
+dependencies = [
+ "virtue",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.20.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "cast"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
+
+[[package]]
+name = "cc"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5add81bb678e6cb321aff7fa0dc7689ad82b112dbc032cea19f91d6b8e3582b9"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "ciborium"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
+dependencies = [
+ "ciborium-io",
+ "ciborium-ll",
+ "serde",
+]
+
+[[package]]
+name = "ciborium-io"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
+
+[[package]]
+name = "ciborium-ll"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
+dependencies = [
+ "ciborium-io",
+ "half",
+]
+
+[[package]]
+name = "clap"
+version = "4.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91e0c145792ef73a6ad36d27c75ac09f1832222a3c209689d90f534685ee5b7"
+dependencies = [
+ "clap_builder",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f09628afdcc538b57f3c6341e9c8e9970f18e4a481690a64974d7023bd33548b"
+dependencies = [
+ "anstyle",
+ "clap_lex",
+]
+
+[[package]]
+name = "clap_lex"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
+
+[[package]]
+name = "cobs"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1"
+dependencies = [
+ "thiserror",
+]
+
+[[package]]
+name = "criterion"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "950046b2aa2492f9a536f5f4f9a3de7b9e2476e575e05bd6c333371add4d98f3"
+dependencies = [
+ "alloca",
+ "anes",
+ "cast",
+ "ciborium",
+ "clap",
+ "criterion-plot",
+ "itertools",
+ "num-traits",
+ "oorandom",
+ "page_size",
+ "plotters",
+ "rayon",
+ "regex",
+ "serde",
+ "serde_json",
+ "tinytemplate",
+ "walkdir",
+]
+
+[[package]]
+name = "criterion-plot"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8d80a2f4f5b554395e47b5d8305bc3d27813bacb73493eb1001e8f76dae29ea"
+dependencies = [
+ "cast",
+ "itertools",
+]
+
+[[package]]
+name = "critical-section"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b"
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5181e0de7b61eb03a81e347d6dd8797bae9da5146707b51077e2d71a54ec0ceb"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d6914041f254d6e9176c01941b21115dcfb7089e55135a35411081bd106ef3f"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61803da095bee82a81bb1a452ecc25d3b2f1416d1897eb86430c6159ef717c17"
+
+[[package]]
+name = "crunchy"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
+
+[[package]]
+name = "doc-comment"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "780955b8b195a21ab8e4ac6b60dd1dbdcec1dc6c51c0617964b08c81785e12c9"
+
+[[package]]
+name = "either"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e5e8f6c15a24b9a3ee5efec809ccd006d3b30e8b3bb63c39af737c7f87daa1d"
+
+[[package]]
+name = "embedded-io"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced"
+
+[[package]]
+name = "embedded-io"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d"
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "futures-core"
+version = "0.3.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2cd50c473c80f6d7c3670a752354b8e569b1a7cbfdc0419ec88e5edad85e0dc7"
+
+[[package]]
+name = "futures-task"
+version = "0.3.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b231ed28831efb4a61a08580c4bc233ec56bc009f4cd8f52da2c3cb97df0c109"
+
+[[package]]
+name = "futures-util"
+version = "0.3.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a77a90a256fce34da66415271e30f94ee91c57b04b8a2c042d9cf3220179deaa"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "pin-project-lite",
+ "slab",
+]
+
+[[package]]
+name = "half"
+version = "2.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+ "zerocopy",
+]
+
+[[package]]
+name = "hash32"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
+name = "heapless"
+version = "0.7.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdc6457c0eb62c71aac4bc17216026d8410337c4126773b9c5daba343f17964f"
+dependencies = [
+ "atomic-polyfill",
+ "hash32",
+ "rustc_version",
+ "serde",
+ "spin",
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "js-sys"
+version = "0.3.103"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53b44bfcdb3f8d5837a46dae1ca9660a837176eee74a28b229bc626816589102"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.189"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
+
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"
+
+[[package]]
+name = "memchr"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
+
+[[package]]
+name = "native_model"
+version = "0.6.4"
+dependencies = [
+ "anyhow",
+ "bincode 1.3.3",
+ "bincode 2.0.1",
+ "criterion",
+ "doc-comment",
+ "log",
+ "native_model_macro",
+ "postcard",
+ "rmp-serde",
+ "serde",
+ "serde_json",
+ "thiserror",
+ "zerocopy",
+]
+
+[[package]]
+name = "native_model_macro"
+version = "0.6.4"
+dependencies = [
+ "log",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "oorandom"
+version = "11.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
+
+[[package]]
+name = "page_size"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+
+[[package]]
+name = "plotters"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747"
+dependencies = [
+ "num-traits",
+ "plotters-backend",
+ "plotters-svg",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "plotters-backend"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a"
+
+[[package]]
+name = "plotters-svg"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670"
+dependencies = [
+ "plotters-backend",
+]
+
+[[package]]
+name = "postcard"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24"
+dependencies = [
+ "cobs",
+ "embedded-io 0.4.0",
+ "embedded-io 0.6.1",
+ "heapless",
+ "serde",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rayon"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "regex"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fcfdb36bda0c880c5931cdc7a2bcdc8ba4556847b9d912bca70bc94708711ad"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
+
+[[package]]
+name = "rmp"
+version = "0.8.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ba8be72d372b2c9b35542551678538b562e7cf86c3315773cae48dfbfe7790c"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "rmp-serde"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72f81bee8c8ef9b577d1681a70ebbc962c232461e397b22c208c43c04b67a155"
+dependencies = [
+ "rmp",
+ "serde",
+]
+
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "semver"
+version = "1.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
+
+[[package]]
+name = "serde"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.3",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.151"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "shlex"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
+
+[[package]]
+name = "slab"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "spin"
+version = "0.9.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3763264f6b73151db08c50ff20d7d8a0b8796e021cdea7ceedad07b80155fa0e"
+dependencies = [
+ "lock_api",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
+[[package]]
+name = "syn"
+version = "2.0.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "3.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53e9bae58849f64dfa4f5d5ae372c8341f7305f82a3868709269343628b659a3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09a43598840e33d5b0331f38c5e30d13bb11c11210a4b58f0d9b18a5a5eefcd9"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43cbfe0cf76104d42a574802844187e84a305e531ed54455f11fbde0f10541cd"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.3",
+]
+
+[[package]]
+name = "tinytemplate"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unty"
+version = "0.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae"
+
+[[package]]
+name = "virtue"
+version = "0.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1"
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b067c0c11094aef6b7a801c1e34a26affafdf3d051dba08456b868789aaf9a4"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "167ce5e579f6bcf889c4f7175a8a5a585de84e8ff93976ce393efa5f2837aab1"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3997c7839262f4ef12cf90b818d6340c18e80f263f1a94bf157d0ec4420380e"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc1b4cb0cc549fcf58d7dfc081778139b3d283a081644e833e84682ad71cea24"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.103"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8622dcb61c0bcc9fffa6938bed81210af2da9a7e4a1a834b2e37a59b6dfb6141"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5a105cd7b140f6eeec8acff2ea38135d3cab283ada58540f629fe51e46696eb"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fe976fb70c78cd64cccfe3a6fc142244e8a77b70959b30faf9d0ac37ee228eb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "zmij"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
diff --git a/libraries/native_model/tests_crate/Cargo.lock b/libraries/native_model/tests_crate/Cargo.lock
new file mode 100644
index 000000000..6632c6fab
--- /dev/null
+++ b/libraries/native_model/tests_crate/Cargo.lock
@@ -0,0 +1,338 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "anyhow"
+version = "1.0.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
+
+[[package]]
+name = "atomic-polyfill"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8cf2bce30dfe09ef0bfaef228b9d414faaf7e563035494d7fe092dba54b300f4"
+dependencies = [
+ "critical-section",
+]
+
+[[package]]
+name = "bincode"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bincode"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740"
+dependencies = [
+ "bincode_derive",
+ "serde",
+ "unty",
+]
+
+[[package]]
+name = "bincode_derive"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf95709a440f45e986983918d0e8a1f30a9b1df04918fc828670606804ac3c09"
+dependencies = [
+ "virtue",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "cobs"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1"
+dependencies = [
+ "thiserror",
+]
+
+[[package]]
+name = "critical-section"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b"
+
+[[package]]
+name = "doc-comment"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "780955b8b195a21ab8e4ac6b60dd1dbdcec1dc6c51c0617964b08c81785e12c9"
+
+[[package]]
+name = "embedded-io"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced"
+
+[[package]]
+name = "embedded-io"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d"
+
+[[package]]
+name = "hash32"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
+name = "heapless"
+version = "0.7.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdc6457c0eb62c71aac4bc17216026d8410337c4126773b9c5daba343f17964f"
+dependencies = [
+ "atomic-polyfill",
+ "hash32",
+ "rustc_version",
+ "serde",
+ "spin",
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"
+
+[[package]]
+name = "native_model"
+version = "0.6.4"
+dependencies = [
+ "anyhow",
+ "bincode 1.3.3",
+ "bincode 2.0.1",
+ "doc-comment",
+ "log",
+ "native_model_macro",
+ "postcard",
+ "serde",
+ "thiserror",
+ "zerocopy",
+]
+
+[[package]]
+name = "native_model_macro"
+version = "0.6.4"
+dependencies = [
+ "log",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "postcard"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24"
+dependencies = [
+ "cobs",
+ "embedded-io 0.4.0",
+ "embedded-io 0.6.1",
+ "heapless",
+ "serde",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "semver"
+version = "1.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
+
+[[package]]
+name = "serde"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.3",
+]
+
+[[package]]
+name = "spin"
+version = "0.9.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3763264f6b73151db08c50ff20d7d8a0b8796e021cdea7ceedad07b80155fa0e"
+dependencies = [
+ "lock_api",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
+[[package]]
+name = "syn"
+version = "2.0.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "3.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53e9bae58849f64dfa4f5d5ae372c8341f7305f82a3868709269343628b659a3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tests_crate"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "bincode 2.0.1",
+ "native_model",
+ "postcard",
+ "serde",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09a43598840e33d5b0331f38c5e30d13bb11c11210a4b58f0d9b18a5a5eefcd9"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43cbfe0cf76104d42a574802844187e84a305e531ed54455f11fbde0f10541cd"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.3",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unty"
+version = "0.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae"
+
+[[package]]
+name = "virtue"
+version = "0.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1"
+
+[[package]]
+name = "zerocopy"
+version = "0.8.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5a105cd7b140f6eeec8acff2ea38135d3cab283ada58540f629fe51e46696eb"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fe976fb70c78cd64cccfe3a6fc142244e8a77b70959b30faf9d0ac37ee228eb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
diff --git a/scripts/sonarcloud-pr-comment.sh b/scripts/sonarcloud-pr-comment.sh
new file mode 100644
index 000000000..f939ff136
--- /dev/null
+++ b/scripts/sonarcloud-pr-comment.sh
@@ -0,0 +1,262 @@
+#!/usr/bin/env bash
+# ==============================================================================
+# sonarcloud-pr-comment.sh — Post SonarCloud findings as PR comment
+# ==============================================================================
+#
+# Queries SonarCloud for unresolved issues on the current PR and posts a
+# summary comment with links to existing GitHub issues.
+#
+# Usage:
+#   ./scripts/sonarcloud-pr-comment.sh
+#
+# Environment:
+#   SONAR_TOKEN          Required. SonarCloud API token
+#   GH_TOKEN             GitHub API token (falls back to GITHUB_TOKEN)
+#   SONAR_PROJECT_KEY    SonarCloud project key (default: BillyOutlast_drop)
+#   GITHUB_REPOSITORY    GitHub repo (default: BillyOutlast/drop)
+#   GITHUB_PR_NUMBER     PR number (auto-detected from GitHub context)
+# ==============================================================================
+
+set -euo pipefail
+
+# ---- Configuration -----------------------------------------------------------
+
+SONAR_PROJECT_KEY="${SONAR_PROJECT_KEY:-BillyOutlast_drop}"
+GITHUB_REPOSITORY="${GITHUB_REPOSITORY:-BillyOutlast/drop}"
+GH_TOKEN="${GH_TOKEN:-${GITHUB_TOKEN:-}}"
+
+# Auto-detect PR number from GitHub context
+if [[ -z "${GITHUB_PR_NUMBER:-}" ]]; then
+  if [[ -n "${GITHUB_REF:-}" && "$GITHUB_REF" =~ ^refs/pull/([0-9]+)/merge$ ]]; then
+    GITHUB_PR_NUMBER="${BASH_REMATCH[1]}"
+  else
+    echo "ERROR: GITHUB_PR_NUMBER not set and cannot auto-detect from GITHUB_REF" >&2
+    exit 1
+  fi
+fi
+
+SONAR_API="https://sonarcloud.io/api/issues/search"
+SEVERITIES="BLOCKER,CRITICAL,MAJOR"
+PAGE_SIZE=100
+
+# --- Validation ---------------------------------------------------------------
+
+if [[ -z "${SONAR_TOKEN:-}" ]]; then
+  echo "FATAL: SONAR_TOKEN is not set" >&2
+  exit 1
+fi
+
+if [[ -z "$GH_TOKEN" ]]; then
+  echo "FATAL: GH_TOKEN or GITHUB_TOKEN is not set" >&2
+  exit 1
+fi
+
+if ! command -v jq &>/dev/null; then
+  echo "FATAL: jq is required but not installed" >&2
+  exit 1
+fi
+
+if ! command -v gh &>/dev/null; then
+  echo "FATAL: gh (GitHub CLI) is required but not installed" >&2
+  exit 1
+fi
+
+# --- Helpers ------------------------------------------------------------------
+
+log() { echo "[$(date '+%H:%M:%S')] $*"; }
+
+# --- Step 1: Fetch unresolved issues from SonarCloud -------------------------
+
+log "Fetching unresolved issues from SonarCloud (project: ${SONAR_PROJECT_KEY})..."
+
+SONAR_RESPONSE=$(curl -sS -f \
+  -H "Authorization: Bearer ${SONAR_TOKEN}" \
+  "${SONAR_API}?componentKeys=${SONAR_PROJECT_KEY}&resolved=false&severities=${SEVERITIES}&ps=${PAGE_SIZE}&p=1") || {
+    log "SonarCloud API request failed, skipping comment"
+    exit 0
+  }
+
+TOTAL=$(echo "$SONAR_RESPONSE" | jq -r '.total // 0')
+TOTAL_PAGES=$(( (TOTAL + PAGE_SIZE - 1) / PAGE_SIZE ))
+log "Found ${TOTAL} unresolved issues across ${TOTAL_PAGES} page(s) (BLOCKER/CRITICAL/MAJOR)"
+
+if [[ "$TOTAL" -eq 0 ]]; then
+  log "No unresolved issues — posting success comment"
+  COMMENT_BODY="## SonarCloud Analysis ✅\n\nNo BLOCKER, CRITICAL, or MAJOR issues found."
+  echo -e "$COMMENT_BODY" | gh pr comment "$GITHUB_PR_NUMBER" \
+    --repo "$GITHUB_REPOSITORY" \
+    --body-file - 2>/dev/null || log "Failed to post comment"
+  exit 0
+fi
+
+# Fetch remaining pages if needed
+if [[ "$TOTAL_PAGES" -gt 1 ]]; then
+  ALL_ISSUES=$(echo "$SONAR_RESPONSE" | jq '.issues')
+  PAGE=2
+  while [[ "$PAGE" -le "$TOTAL_PAGES" ]]; do
+    log "Fetching page ${PAGE}/${TOTAL_PAGES}..."
+    PAGE_RESPONSE=$(curl -sS -f \
+      -H "Authorization: Bearer ${SONAR_TOKEN}" \
+      "${SONAR_API}?componentKeys=${SONAR_PROJECT_KEY}&resolved=false&severities=${SEVERITIES}&ps=${PAGE_SIZE}&p=${PAGE}") || {
+        log "SonarCloud API request failed on page ${PAGE}, skipping remaining pages"
+        break
+      }
+    ALL_ISSUES=$(echo "$ALL_ISSUES $(echo "$PAGE_RESPONSE" | jq '.issues')" | jq -s 'add')
+    PAGE=$((PAGE + 1))
+  done
+  SONAR_RESPONSE=$(echo "$SONAR_RESPONSE" | jq --argjson issues "$ALL_ISSUES" '.issues = $issues')
+fi
+
+# --- Step 2: Group issues by severity ----------------------------------------
+
+BLOCKER_COUNT=$(echo "$SONAR_RESPONSE" | jq '[.issues[] | select(.severity == "BLOCKER")] | length')
+CRITICAL_COUNT=$(echo "$SONAR_RESPONSE" | jq '[.issues[] | select(.severity == "CRITICAL")] | length')
+MAJOR_COUNT=$(echo "$SONAR_RESPONSE" | jq '[.issues[] | select(.severity == "MAJOR")] | length')
+
+# --- Step 3: Build current finding keys set -----------------------------------
+
+CURRENT_KEYS=$(echo "$SONAR_RESPONSE" | jq -c '[.issues[].key] | unique')
+log "Current finding keys: $(echo "$CURRENT_KEYS" | jq 'length') unique keys"
+
+# --- Step 4: Fetch existing GitHub issues and match to current findings -------
+
+log "Fetching existing GitHub issues with 'sonarcloud' label..."
+EXISTING_ISSUES=$(gh issue list \
+  --repo "$GITHUB_REPOSITORY" \
+  --label sonarcloud \
+  --state open \
+  --json number,title,body \
+  --limit 100 2>/dev/null || echo "[]")
+
+EXISTING_COUNT=$(echo "$EXISTING_ISSUES" | jq 'length')
+log "Found ${EXISTING_COUNT} existing sonarcloud issues"
+
+MATCHED_ISSUES=$(echo "$EXISTING_ISSUES" | jq -c --argjson currentKeys "$CURRENT_KEYS" '
+  [.[] | select(
+    (.body // "") as $b |
+    ($b | capture("sonarcloud-keys:\\s*(?<keys>[A-Za-z0-9,._-]+)"; "i").keys // "" | split(",") | map(gsub("^\\s+|\\s+$"; ""))) as $issueKeys |
+    ($currentKeys - ($currentKeys - $issueKeys)) | length > 0
+  ) | {number: .number, title: .title}]
+')
+
+MATCHED_COUNT=$(echo "$MATCHED_ISSUES" | jq 'length')
+log "Matched ${MATCHED_COUNT} issues to current findings"
+
+# --- Step 4: Build PR comment ------------------------------------------------
+
+COMMENT_BODY="## SonarCloud Analysis\n\n"
+COMMENT_BODY+="### Summary\n\n"
+COMMENT_BODY+="| Severity | Count |\n"
+COMMENT_BODY+="|----------|-------|\n"
+
+if [[ "$BLOCKER_COUNT" -gt 0 ]]; then
+  COMMENT_BODY+="| 🔴 BLOCKER | ${BLOCKER_COUNT} |\n"
+fi
+if [[ "$CRITICAL_COUNT" -gt 0 ]]; then
+  COMMENT_BODY+="| 🟠 CRITICAL | ${CRITICAL_COUNT} |\n"
+fi
+if [[ "$MAJOR_COUNT" -gt 0 ]]; then
+  COMMENT_BODY+="| 🟡 MAJOR | ${MAJOR_COUNT} |\n"
+fi
+
+COMMENT_BODY+="\n**Total**: ${TOTAL} issues\n\n"
+
+# Add top 5 issues by severity
+COMMENT_BODY+="### Top Issues\n\n"
+COMMENT_BODY+="| File | Line | Rule | Severity |\n"
+COMMENT_BODY+="|------|------|------|----------|\n"
+
+TOP_ISSUES=$(echo "$SONAR_RESPONSE" | jq -r '
+  .issues
+  | sort_by(
+      if .severity == "BLOCKER" then 0
+      elif .severity == "CRITICAL" then 1
+      elif .severity == "MAJOR" then 2
+      else 3 end
+    )
+  | .[0:5]
+  | .[]
+  | "| \(.component | split(":") | last) | \(.line // "-") | \(.rule | split(":") | last) | \(.severity) |"
+' 2>/dev/null || echo "")
+
+if [[ -n "$TOP_ISSUES" ]]; then
+  COMMENT_BODY+="${TOP_ISSUES}\n"
+else
+  COMMENT_BODY+="| No issues found | - | - | - |\n"
+fi
+
+COMMENT_BODY+="\n### Tracking\n\n"
+
+if [[ "$MATCHED_COUNT" -gt 0 ]]; then
+  COMMENT_BODY+="Existing GitHub issues tracking these findings:\n\n"
+  while IFS= read -r line; do
+    COMMENT_BODY+="${line}\n"
+  done < <(echo "$MATCHED_ISSUES" | jq -r '.[] | "- #\(.number): \(.title)"' | head -10)
+
+  if [[ "$MATCHED_COUNT" -gt 10 ]]; then
+    COMMENT_BODY+="- ... and $((MATCHED_COUNT - 10)) more\n"
+  fi
+else
+  COMMENT_BODY+="No existing GitHub issues found for these findings. Run \`./scripts/sonarcloud-sync.sh\` to create tracking issues.\n"
+fi
+
+COMMENT_BODY+="\n---\n\n"
+COMMENT_BODY+="*Full analysis: [SonarCloud Dashboard](https://sonarcloud.io/project/overview?id=${SONAR_PROJECT_KEY})*\n"
+COMMENT_BODY+="*To create tracking issues: \`./scripts/sonarcloud-sync.sh --backfill\`*\n\n"
+
+log "Fetching quality gate status..."
+QG_RESPONSE=$(curl -sS -f \
+  -H "Authorization: Bearer ${SONAR_TOKEN}" \
+  "https://sonarcloud.io/api/qualitygates/project_status?projectKey=${SONAR_PROJECT_KEY}&pullRequest=${GITHUB_PR_NUMBER}" 2>/dev/null || echo '{"projectStatus":{"status":"UNKNOWN","conditions":[]}}')
+
+log "Fetching files needing coverage..."
+COVERAGE_RESPONSE=$(curl -sS -f \
+  -H "Authorization: Bearer ${SONAR_TOKEN}" \
+  "https://sonarcloud.io/api/measures/component_tree?component=${SONAR_PROJECT_KEY}&metricKeys=new_coverage,new_uncovered_lines&qualifiers=FIL&ps=15&pullRequest=${GITHUB_PR_NUMBER}" 2>/dev/null || echo '{"components":[]}')
+
+COMMENT_BODY+="<details>\n<summary>📋 JSON Summary (for AI agents)</summary>\n\n"
+COMMENT_BODY+="\`\`\`json\n"
+
+JSON_SUMMARY=$(echo "$SONAR_RESPONSE" | jq \
+  --arg project "$SONAR_PROJECT_KEY" \
+  --arg pr "$GITHUB_PR_NUMBER" \
+  --argjson qg "$(echo "$QG_RESPONSE" | jq '{gateStatus: .projectStatus.status, failedConditions: [.projectStatus.conditions[]? | select(.status == "ERROR") | {metric: .metricKey, actual: .actualValue, threshold: .errorThreshold}]}')" \
+  --argjson coverage "$(echo "$COVERAGE_RESPONSE" | jq '[.components[]? | {file: (.path // .name), coverage: (.measures[]? | select(.metric == "new_coverage") | .value // "0.0"), uncovered: (.measures[]? | select(.metric == "new_uncovered_lines") | .value // "0")}]')" \
+  '{
+  project: $project,
+  pullRequest: ($pr | tonumber),
+  qualityGate: $qg,
+  filesNeedingCoverage: $coverage,
+  totalIssues: .total,
+  summary: {
+    blocker: [.issues[] | select(.severity == "BLOCKER")] | length,
+    critical: [.issues[] | select(.severity == "CRITICAL")] | length,
+    major: [.issues[] | select(.severity == "MAJOR")] | length
+  },
+  issues: [.issues[] | {
+    key: .key,
+    rule: .rule,
+    severity: .severity,
+    message: .message,
+    component: (.component | split(":") | last),
+    line: .line,
+    url: ("https://sonarcloud.io/project/issues?id=" + $project + "&issues=" + .key + "&open=" + .key)
+  }]
+}')
+
+COMMENT_BODY+="${JSON_SUMMARY}\n"
+COMMENT_BODY+="\`\`\`\n\n"
+COMMENT_BODY+="</details>"
+
+# --- Step 5: Post comment to PR ----------------------------------------------
+
+log "Posting comment to PR #${GITHUB_PR_NUMBER}..."
+
+echo -e "$COMMENT_BODY" | gh pr comment "$GITHUB_PR_NUMBER" \
+  --repo "$GITHUB_REPOSITORY" \
+  --body-file - 2>/dev/null || {
+    log "Failed to post comment to PR"
+    exit 1
+  }
+
+log "Comment posted successfully to PR #${GITHUB_PR_NUMBER}"
diff --git a/scripts/sonarcloud-sync.sh b/scripts/sonarcloud-sync.sh
index 74456ac76..8703e1472 100644
--- a/scripts/sonarcloud-sync.sh
+++ b/scripts/sonarcloud-sync.sh
@@ -306,6 +306,7 @@ determine_labels() {
   case "$severity" in
     BLOCKER|CRITICAL) labels="${labels},critical" ;;
     MAJOR)            labels="${labels},major" ;;
+    *)                labels="${labels},other" ;;
   esac
 
   echo "$labels"
diff --git a/server/components/GameCarousel.vue b/server/components/GameCarousel.vue
index 84d0685ba..4237b9f43 100644
--- a/server/components/GameCarousel.vue
+++ b/server/components/GameCarousel.vue
@@ -52,9 +52,7 @@ const currentComponent = ref<HTMLDivElement>();
 
 const min = computed(() => Math.max(props.min ?? 8, props.items.length));
 const games: Ref<Array<SerializeObject<GameModel> | undefined>> = computed(() =>
-  Array(min.value)
-    .fill(0)
-    .map((_, i) => props.items[i]),
+  new Array(min.value).fill(0).map((_, i) => props.items[i]),
 );
 
 const singlePage = ref(2);
diff --git a/server/components/StoreView.vue b/server/components/StoreView.vue
index 8a263c968..d44b971db 100644
--- a/server/components/StoreView.vue
+++ b/server/components/StoreView.vue
@@ -462,7 +462,8 @@ const filterQuery = computed(() => {
         .map(([k, v]) => `${k}=${v}`)
         .join("&")
     : props.params;
-  return `${query}${extraFilters ? (query ? "&" : "") + extraFilters : ""}`;
+  const separator = query && extraFilters ? "&" : "";
+  return `${query}${separator}${extraFilters ?? ""}`;
 });
 
 const games = ref<Array<SerializeObject<GameModel>>>();
diff --git a/server/composables/current-page-engine.ts b/server/composables/current-page-engine.ts
index 21e6748ea..57125475f 100644
--- a/server/composables/current-page-engine.ts
+++ b/server/composables/current-page-engine.ts
@@ -13,7 +13,7 @@ export const useCurrentNavigationIndex = (
       .map((e, i) => ({ ...e, index: i }))
       .filter((e) => to.fullPath.startsWith(e.prefix));
     const bestOption = validOptions
-      .sort((a, b) => b.route.length - a.route.length)
+      .toSorted((a, b) => b.route.length - a.route.length)
       .at(0);
 
     return bestOption?.index ?? -1;
diff --git a/server/nuxt.config.ts b/server/nuxt.config.ts
index d3867db36..d7b6a9d3b 100644
--- a/server/nuxt.config.ts
+++ b/server/nuxt.config.ts
@@ -32,7 +32,11 @@ const commitHash =
   process.env.BUILD_GIT_REF ??
   execFileSync("git", ["rev-parse", "--short", "HEAD"], {
     encoding: "utf-8",
-  }).trim();
+    env: {
+      ...process.env,
+      PATH: process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin",
+    },
+  }).trim(); // NOSONAR:typescript:S4036 - execFileSync doesn't use shell; PATH explicitly sanitized
 
 console.log(`Drop ${dropVersion} #${commitHash}`);
 
diff --git a/server/pages/admin/users/auth/simple/index.vue b/server/pages/admin/users/auth/simple/index.vue
index 9efd718d4..552333d83 100644
--- a/server/pages/admin/users/auth/simple/index.vue
+++ b/server/pages/admin/users/auth/simple/index.vue
@@ -510,8 +510,8 @@ function invite_wrapper() {
     .then((invitation) => {
       invitations.value.push(invitation);
     })
-    .catch((response) => {
-      const message = response.statusMessage || t("errors.unknown");
+    .catch((error_) => {
+      const message = error_.statusMessage || t("errors.unknown");
       error.value = message;
     })
     .finally(() => {
diff --git a/server/pages/auth/register.vue b/server/pages/auth/register.vue
index 9d2efc5f1..6fcdb009d 100644
--- a/server/pages/auth/register.vue
+++ b/server/pages/auth/register.vue
@@ -270,8 +270,8 @@ function register_wrapper() {
       }
       router.push("/auth/signin");
     })
-    .catch((response) => {
-      const message = response.statusMessage || t("errors.unknown");
+    .catch((error_) => {
+      const message = error_.statusMessage || t("errors.unknown");
       error.value = message;
     })
     .finally(() => {
diff --git a/server/pages/setup.vue b/server/pages/setup.vue
index cc7a1671b..4968c1d4a 100644
--- a/server/pages/setup.vue
+++ b/server/pages/setup.vue
@@ -195,7 +195,7 @@ const actions = ref<
   },
 ]);
 
-const actionsComplete = ref(Array(actions.value.length).fill(false));
+const actionsComplete = ref(new Array(actions.value.length).fill(false));
 
 const finished = computed(() => actionsComplete.value.every(Boolean));
 
diff --git a/server/pages/store/[id]/index.vue b/server/pages/store/[id]/index.vue
index b13758a32..270e01c91 100644
--- a/server/pages/store/[id]/index.vue
+++ b/server/pages/store/[id]/index.vue
@@ -54,11 +54,12 @@
           <table class="min-w-full" aria-label="Game details">
             <tbody>
               <tr>
-                <td
+                <th
+                  scope="row"
                   class="whitespace-nowrap py-4 pl-4 pr-3 text-sm font-medium text-zinc-100 sm:pl-3"
                 >
                   {{ $t("store.released") }}
-                </td>
+                </th>
                 <td class="whitespace-nowrap px-3 py-4 text-sm text-zinc-400">
                   <time datetime="game.mReleased">
                     {{ $d(new Date(game.mReleased), "short") }}
@@ -66,11 +67,12 @@
                 </td>
               </tr>
               <tr>
-                <td
+                <th
+                  scope="row"
                   class="whitespace-nowrap py-4 pl-4 pr-3 text-sm font-medium text-zinc-100 sm:pl-3"
                 >
                   {{ $t("store.platform", platforms.length) }}
-                </td>
+                </th>
                 <td
                   class="whitespace-nowrap inline-flex gap-x-4 px-3 py-4 text-sm text-zinc-400"
                 >
@@ -88,11 +90,12 @@
                 </td>
               </tr>
               <tr>
-                <td
+                <th
+                  scope="row"
                   class="whitespace-nowrap py-4 pl-4 pr-3 text-sm font-medium text-zinc-100 sm:pl-3"
                 >
                   {{ $t("store.size") }}
-                </td>
+                </th>
                 <td
                   v-if="sizes.length > 0"
                   class="whitespace-nowrap inline-flex gap-x-4 px-3 py-4 text-sm text-zinc-400"
@@ -125,11 +128,12 @@
                 </td>
               </tr>
               <tr>
-                <td
+                <th
+                  scope="row"
                   class="whitespace-nowrap py-4 pl-4 pr-3 text-sm font-medium text-zinc-100 sm:pl-3"
                 >
                   {{ $t("store.rating") }}
-                </td>
+                </th>
                 <td
                   class="whitespace-nowrap flex flex-row items-center gap-x-1 px-3 py-4 text-sm text-zinc-400"
                 >
@@ -305,7 +309,7 @@ const isClient = isClientRequest();
 const descriptionHTML = micromark(game.mDescription);
 
 const averageRating = Math.round((rating._avg.mReviewRating ?? 0) * 5);
-const ratingArray = Array(5)
+const ratingArray = new Array(5)
   .fill(null)
   .map((_, i) => i + 1 <= averageRating);
 
diff --git a/server/pages/user/[id]/index.vue b/server/pages/user/[id]/index.vue
index 169e9ac00..080c12779 100644
--- a/server/pages/user/[id]/index.vue
+++ b/server/pages/user/[id]/index.vue
@@ -5,7 +5,7 @@
         v-if="profile?.profilePictureObjectId"
         :src="useObject(profile.profilePictureObjectId)"
         class="w-24 h-24 rounded-md object-cover"
-        :alt="profile?.displayName ?? profile?.username ?? 'Profile picture'"
+        alt=""
       />
       <div>
         <h1 class="text-2xl font-bold font-display text-zinc-100">
diff --git a/server/server/api/v1/client/game/[id]/versions.get.ts b/server/server/api/v1/client/game/[id]/versions.get.ts
index c59d43205..ad1a83f32 100644
--- a/server/server/api/v1/client/game/[id]/versions.get.ts
+++ b/server/server/api/v1/client/game/[id]/versions.get.ts
@@ -8,8 +8,8 @@ import gameSizeManager from "~/server/internal/gamesize";
 type VersionDownloadOption = {
   gameId: string;
   versionId: string;
-  displayName?: string | undefined;
-  versionPath?: string | undefined;
+  displayName?: string;
+  versionPath?: string;
   platform: Platform;
   size: GameVersionSize;
   requiredContent: Array<{
@@ -109,18 +109,18 @@ export default defineClientEventHandler(async (h3) => {
 
         return platformOptions
           .entries()
-          .map(
-            ([platform, requiredContent]) =>
-              ({
-                gameId: v.gameId,
-                versionId: v.versionId,
-                displayName: v.displayName || undefined,
-                versionPath: v.versionPath || undefined,
-                platform,
-                requiredContent,
-                size: size!,
-              }) satisfies VersionDownloadOption,
-          )
+          .map(([platform, requiredContent]) => {
+            const option: VersionDownloadOption = {
+              gameId: v.gameId,
+              versionId: v.versionId,
+              platform,
+              requiredContent,
+              size: size!,
+            };
+            if (v.displayName) option.displayName = v.displayName;
+            if (v.versionPath) option.versionPath = v.versionPath;
+            return option;
+          })
           .toArray();
       }),
     )
diff --git a/server/server/internal/auth/base32/index.js b/server/server/internal/auth/base32/index.js
index ca05acd8a..2a2aa4ed7 100644
--- a/server/server/internal/auth/base32/index.js
+++ b/server/server/internal/auth/base32/index.js
@@ -68,7 +68,7 @@ export function b32e(u8a) {
   console.assert(u8a instanceof Uint8Array, u8a.constructor);
   const len = u8a.length,
     rem = len % 5;
-  const u5s = Array.from(Array((len - rem) / 5), (_, i) =>
+  const u5s = Array.from(new Array((len - rem) / 5), (_, i) =>
     u8a.subarray(i * 5, i * 5 + 5),
   );
   const pad = b32pad[rem];
diff --git a/server/server/internal/auth/oidc/index.ts b/server/server/internal/auth/oidc/index.ts
index 018701c95..070f0faa0 100644
--- a/server/server/internal/auth/oidc/index.ts
+++ b/server/server/internal/auth/oidc/index.ts
@@ -102,6 +102,7 @@ const OIDCLogoutTokenV1 = type({
   iat: "number",
   jti: "string",
   events: type({
+    // NOSONAR:S5332 - OIDC standard schema URI, not an HTTP endpoint
     "http://schemas.openid.net/event/backchannel-logout": "object",
   }),
   sid: "string?", // session ID
diff --git a/server/server/internal/config/application-configuration.ts b/server/server/internal/config/application-configuration.ts
index 3655c33df..2fd2692fd 100644
--- a/server/server/internal/config/application-configuration.ts
+++ b/server/server/internal/config/application-configuration.ts
@@ -10,9 +10,14 @@ class ApplicationConfiguration {
   private async save() {
     await this.init();
 
+    const settings = this.currentApplicationSettings;
+    if (!settings) {
+      throw new Error("Application settings not initialized");
+    }
+
     const deepAppConfigCopy: Omit<ApplicationSettingsModel, "timestamp"> & {
       timestamp?: Date;
-    } = JSON.parse(JSON.stringify(this.currentApplicationSettings));
+    } = structuredClone(settings);
 
     delete deepAppConfigCopy["timestamp"];
 
diff --git a/server/server/internal/library/index.ts b/server/server/internal/library/index.ts
index 99aacb444..50568087e 100644
--- a/server/server/internal/library/index.ts
+++ b/server/server/internal/library/index.ts
@@ -378,7 +378,7 @@ class LibraryManager {
       );
     }
 
-    const sortedOptions = options.sort((a, b) => b.match - a.match);
+    const sortedOptions = options.toSorted((a, b) => b.match - a.match);
 
     return sortedOptions;
   }
diff --git a/server/server/internal/library/manifest/index.ts b/server/server/internal/library/manifest/index.ts
index f9f6bedbe..da300b4ae 100644
--- a/server/server/internal/library/manifest/index.ts
+++ b/server/server/internal/library/manifest/index.ts
@@ -1,13 +1,13 @@
 import type { JsonValue } from "@prisma/client/runtime/client";
 import cacheHandler from "../../cache";
 import prisma from "../../db/database";
-import { castManifest, type DropletManifest } from "./utils";
+import { castManifest, type V2Manifest } from "./utils";
 
 export type DownloadManifestDetails = {
   /***
    * Version ID to manifest
    */
-  manifests: { [key: string]: DropletManifest };
+  manifests: { [key: string]: V2Manifest };
   /***
    * File name to version ID
    */
@@ -69,7 +69,7 @@ function buildVersionManifests(
   fileList: Map<string, string>,
   existingChunks: DownloadManifestDetails | undefined,
 ) {
-  const manifests = new Map<string, DropletManifest>();
+  const manifests = new Map<string, V2Manifest>();
   let installSize = 0;
   let downloadSize = 0;
 
diff --git a/server/server/internal/library/manifest/utils.ts b/server/server/internal/library/manifest/utils.ts
index f32efd0cd..0d3dea4a4 100644
--- a/server/server/internal/library/manifest/utils.ts
+++ b/server/server/internal/library/manifest/utils.ts
@@ -1,7 +1,5 @@
 import type { JsonValue } from "@prisma/client/runtime/client";
 
-export type DropletManifest = V2Manifest;
-
 export type V2Manifest = {
   version: "2";
   size: number;
@@ -22,6 +20,9 @@ export type V2FileEntry = {
   permissions: number;
 };
 
-export function castManifest(manifest: JsonValue): DropletManifest {
-  return JSON.parse(manifest as string) as DropletManifest;
+export function castManifest(manifest: JsonValue): V2Manifest {
+  if (typeof manifest === "string") {
+    return JSON.parse(manifest) as V2Manifest;
+  }
+  return manifest as V2Manifest;
 }
diff --git a/server/server/internal/metadata/igdb.ts b/server/server/internal/metadata/igdb.ts
index 4595cc28a..adea78fe0 100644
--- a/server/server/internal/metadata/igdb.ts
+++ b/server/server/internal/metadata/igdb.ts
@@ -651,34 +651,33 @@ export class IGDBProvider implements MetadataProvider {
       `where name = "${query}"; fields *; limit 1;`,
     );
 
-    for (const company of response) {
-      const logo = createObject(await this.getCompanyLogoURl(company.logo));
-
-      let company_url = "";
-      for (const companySite of company.websites) {
-        const companySiteRes = await this.request<IGDBCompanyWebsite>(
-          "company_websites",
-          `where id = ${companySite}; fields *;`,
-        );
-
-        for (const site of companySiteRes) {
-          if (company_url.length <= 0) company_url = site.url;
-        }
+    const company = response[0];
+    if (!company) return undefined;
+
+    const logo = createObject(await this.getCompanyLogoURl(company.logo));
+
+    let company_url = "";
+    for (const companySite of company.websites) {
+      const companySiteRes = await this.request<IGDBCompanyWebsite>(
+        "company_websites",
+        `where id = ${companySite}; fields *;`,
+      );
+
+      for (const site of companySiteRes) {
+        if (company_url.length <= 0) company_url = site.url;
       }
-      const metadata: CompanyMetadata = {
-        id: "" + company.id,
-        name: company.name,
-        shortDescription: this.trimMessage(company.description, 280),
-        description: company.description,
-        website: company_url,
-
-        logo: logo,
-        banner: logo,
-      };
-
-      return metadata;
     }
+    const metadata: CompanyMetadata = {
+      id: "" + company.id,
+      name: company.name,
+      shortDescription: this.trimMessage(company.description, 280),
+      description: company.description,
+      website: company_url,
+
+      logo: logo,
+      banner: logo,
+    };
 
-    return undefined;
+    return metadata;
   }
 }
diff --git a/server/server/internal/metadata/pcgamingwiki.ts b/server/server/internal/metadata/pcgamingwiki.ts
index bd9b14a6f..5088ba933 100644
--- a/server/server/internal/metadata/pcgamingwiki.ts
+++ b/server/server/internal/metadata/pcgamingwiki.ts
@@ -337,7 +337,7 @@ export class PCGamingWikiProvider implements MetadataProvider {
     if (websiteStr === undefined || websiteStr === null) return "";
 
     // string comes in format: "[https://www.gamesci.com.cn www.gamesci.com.cn]"
-    return websiteStr.replaceAll(/\[|]/g, "").split(" ")[0] ?? "";
+    return websiteStr.replaceAll(/[\[\]]/g, "").split(" ")[0] ?? ""; // eslint-disable-line no-useless-escape
   }
 
   private compileTags(game: PCGamingWikiGame): string[] {
diff --git a/server/server/internal/metadata/steam.ts b/server/server/internal/metadata/steam.ts
index c06723752..c2fe3317c 100644
--- a/server/server/internal/metadata/steam.ts
+++ b/server/server/internal/metadata/steam.ts
@@ -627,9 +627,9 @@ export class SteamProvider implements MetadataProvider {
 
   private _extractUrl(html: string): string | undefined {
     const curatorUrlRegex =
-      /<a[^>]*class\s*=\s*["'][^"']*curator_url[^"']*["'][^>]*href\s*=\s*["']https:\/\/steamcommunity\.com\/linkfilter\/\?u=([^"'&]+)["']/i;
+      /<a[^>]*class\s*=\s*"[^"]*curator_url[^"]*"[^>]*href\s*=\s*"https:\/\/steamcommunity\.com\/linkfilter\/\?u=([^"&]+)"/i;
     const linkfilterRegex =
-      /<a[^>]*href\s*=\s*["']https:\/\/steamcommunity\.com\/linkfilter\/\?u=([^"'&]+)["'][^>]*(?:target=["']_blank["']|rel=["'][^"']*["'])/i;
+      /<a[^>]*href\s*=\s*"https:\/\/steamcommunity\.com\/linkfilter\/\?u=([^"&]+)"[^>]*(?:target="_blank"|rel="[^"]*")/i;
 
     let curatorUrlMatch = curatorUrlRegex.exec(html);
     curatorUrlMatch ??= linkfilterRegex.exec(html);
@@ -646,7 +646,7 @@ export class SteamProvider implements MetadataProvider {
 
   private _extractBanner(html: string): string | undefined {
     const bannerRegex =
-      /background-image:\s*url\(['"]([^'"]*?(?:\/clan\/\d+|\/app\/\d+|background|header)[^'"]*?)['"][^}]*\)/i;
+      /background-image:\s*url\(['"]([^'"]*?(?:\/(?:clan|app)\/\d+|background|header)[^'"]*?)['"][^}]*\)/i;
     const backgroundImageRegex =
       /style\s*=\s*["'][^"']*background-image:\s*url\(([^)]+)\)[^"']*/i;
 
diff --git a/server/server/internal/objects/fsBackend.ts b/server/server/internal/objects/fsBackend.ts
index 80875fe7a..8b9dd3c67 100644
--- a/server/server/internal/objects/fsBackend.ts
+++ b/server/server/internal/objects/fsBackend.ts
@@ -1,4 +1,4 @@
-import type { ObjectMetadata, ObjectReference, Source } from "./objectHandler";
+import type { ObjectMetadata, Source } from "./objectHandler";
 import { ObjectBackend, objectMetadata } from "./objectHandler";
 
 import fs from "node:fs";
@@ -30,12 +30,12 @@ export class FsObjectBackend extends ObjectBackend {
     fs.mkdirSync(this.baseMetadataPath, { recursive: true });
   }
 
-  async fetch(id: ObjectReference) {
+  async fetch(id: string) {
     const objectPath = path.join(this.baseObjectPath, id);
     if (!fs.existsSync(objectPath)) return undefined;
     return fs.createReadStream(objectPath);
   }
-  async write(id: ObjectReference, source: Source): Promise<boolean> {
+  async write(id: string, source: Source): Promise<boolean> {
     const objectPath = path.join(this.baseObjectPath, id);
     if (!fs.existsSync(objectPath)) return false;
 
@@ -56,7 +56,7 @@ export class FsObjectBackend extends ObjectBackend {
 
     return false;
   }
-  async startWriteStream(id: ObjectReference) {
+  async startWriteStream(id: string) {
     const objectPath = path.join(this.baseObjectPath, id);
     if (!fs.existsSync(objectPath)) return undefined;
     // remove item from cache
@@ -67,7 +67,7 @@ export class FsObjectBackend extends ObjectBackend {
     id: string,
     source: Source,
     metadata: ObjectMetadata,
-  ): Promise<ObjectReference | undefined> {
+  ): Promise<string | undefined> {
     const objectPath = path.join(this.baseObjectPath, id);
     const metadataPath = path.join(this.baseMetadataPath, `${id}.json`);
     if (fs.existsSync(objectPath) || fs.existsSync(metadataPath))
@@ -100,7 +100,7 @@ export class FsObjectBackend extends ObjectBackend {
     if (!stream) throw new Error("Could not create write stream");
     return stream;
   }
-  async delete(id: ObjectReference): Promise<boolean> {
+  async delete(id: string): Promise<boolean> {
     const objectPath = path.join(this.baseObjectPath, id);
     if (!fs.existsSync(objectPath)) return false;
 
@@ -124,9 +124,7 @@ export class FsObjectBackend extends ObjectBackend {
     await this.hashStore.delete(id);
     return true;
   }
-  async fetchMetadata(
-    id: ObjectReference,
-  ): Promise<ObjectMetadata | undefined> {
+  async fetchMetadata(id: string): Promise<ObjectMetadata | undefined> {
     const cacheResult = await this.metadataCache.get(id);
     if (cacheResult !== null) return cacheResult;
 
@@ -144,17 +142,14 @@ export class FsObjectBackend extends ObjectBackend {
     await this.metadataCache.set(id, metadata);
     return metadata;
   }
-  async writeMetadata(
-    id: ObjectReference,
-    metadata: ObjectMetadata,
-  ): Promise<boolean> {
+  async writeMetadata(id: string, metadata: ObjectMetadata): Promise<boolean> {
     const metadataPath = path.join(this.baseMetadataPath, `${id}.json`);
     if (!fs.existsSync(metadataPath)) return false;
     fs.writeFileSync(metadataPath, JSON.stringify(metadata));
     await this.metadataCache.set(id, metadata);
     return true;
   }
-  async fetchHash(id: ObjectReference): Promise<string | undefined> {
+  async fetchHash(id: string): Promise<string | undefined> {
     const cacheResult = await this.hashStore.get(id);
     if (cacheResult !== null) return cacheResult;
 
@@ -229,7 +224,7 @@ class FsHashStore {
    * @param id
    * @returns
    */
-  async get(id: ObjectReference) {
+  async get(id: string) {
     const cacheRes = await this.cache.get(id);
     if (cacheRes !== null) {
       return cacheRes;
@@ -252,7 +247,7 @@ class FsHashStore {
    * Saves hash of object
    * @param id
    */
-  async save(id: ObjectReference, hash: string) {
+  async save(id: string, hash: string) {
     await prisma.objectHash.upsert({
       where: {
         id,
@@ -272,7 +267,7 @@ class FsHashStore {
    * Hash is no longer valid for whatever reason
    * @param id
    */
-  async delete(id: ObjectReference) {
+  async delete(id: string) {
     await this.cache.remove(id);
     await prisma.objectHash.deleteMany({
       where: {
diff --git a/server/server/internal/objects/objectHandler.ts b/server/server/internal/objects/objectHandler.ts
index 3cd792897..998bc0e30 100644
--- a/server/server/internal/objects/objectHandler.ts
+++ b/server/server/internal/objects/objectHandler.ts
@@ -21,7 +21,7 @@ import type { Writable } from "node:stream";
 import { Readable } from "node:stream";
 import { getMimeType as getMimeTypeStream } from "stream-mime-type";
 
-export type ObjectReference = string;
+/** An object identifier string */
 
 export const objectMetadata = type({
   mime: "string",
@@ -50,27 +50,25 @@ export type Source = Readable | Buffer;
 export abstract class ObjectBackend {
   // Interface functions, not designed to be called directly.
   // They don't check permissions to provide any utilities
-  abstract fetch(id: ObjectReference): Promise<Source | undefined>;
-  abstract write(id: ObjectReference, source: Source): Promise<boolean>;
-  abstract startWriteStream(id: ObjectReference): Promise<Writable | undefined>;
+  abstract fetch(id: string): Promise<Source | undefined>;
+  abstract write(id: string, source: Source): Promise<boolean>;
+  abstract startWriteStream(id: string): Promise<Writable | undefined>;
   abstract create(
     id: string,
     source: Source,
     metadata: ObjectMetadata,
-  ): Promise<ObjectReference | undefined>;
+  ): Promise<string | undefined>;
   abstract createWithWriteStream(
     id: string,
     metadata: ObjectMetadata,
   ): Promise<Writable | undefined>;
-  abstract delete(id: ObjectReference): Promise<boolean>;
-  abstract fetchMetadata(
-    id: ObjectReference,
-  ): Promise<ObjectMetadata | undefined>;
+  abstract delete(id: string): Promise<boolean>;
+  abstract fetchMetadata(id: string): Promise<ObjectMetadata | undefined>;
   abstract writeMetadata(
-    id: ObjectReference,
+    id: string,
     metadata: ObjectMetadata,
   ): Promise<boolean>;
-  abstract fetchHash(id: ObjectReference): Promise<string | undefined>;
+  abstract fetchHash(id: string): Promise<string | undefined>;
   abstract listAll(): Promise<string[]>;
   abstract cleanupMetadata(taskLogger: pino.Logger): Promise<void>;
 }
@@ -162,7 +160,7 @@ export class ObjectHandler {
    * @param userId user to check, or act as anon user
    * @returns
    */
-  async fetchWithPermissions(id: ObjectReference, userId?: string) {
+  async fetchWithPermissions(id: string, userId?: string) {
     const metadata = await this.backend.fetchMetadata(id);
     if (!metadata) return;
 
@@ -184,7 +182,7 @@ export class ObjectHandler {
    * @param id object id
    * @returns
    */
-  async fetchHash(id: ObjectReference) {
+  async fetchHash(id: string) {
     return await this.backend.fetchHash(id);
   }
 
@@ -201,7 +199,7 @@ export class ObjectHandler {
    * And if we actually have permission to write, it fetches it then.
    */
   async writeWithPermissions(
-    id: ObjectReference,
+    id: string,
     sourceFetcher: () => Promise<Source>,
     userId?: string,
   ) {
@@ -228,7 +226,7 @@ export class ObjectHandler {
    * @param userId user to check, or act as anon user
    * @returns
    */
-  async deleteWithPermission(id: ObjectReference, userId?: string) {
+  async deleteWithPermission(id: string, userId?: string) {
     const metadata = await this.backend.fetchMetadata(id);
     if (!metadata) return false;
 
@@ -248,7 +246,7 @@ export class ObjectHandler {
    * @param id
    * @returns
    */
-  async deleteAsSystem(id: ObjectReference) {
+  async deleteAsSystem(id: string) {
     return await this.backend.delete(id);
   }
 
diff --git a/server/server/internal/services/services/nginx.ts b/server/server/internal/services/services/nginx.ts
index 1e5d92aa2..10cc1cf68 100644
--- a/server/server/internal/services/services/nginx.ts
+++ b/server/server/internal/services/services/nginx.ts
@@ -1,15 +1,19 @@
-import { spawn, execSync } from "node:child_process";
+import { spawn } from "node:child_process";
 import { Service } from "..";
 import { systemConfig } from "../../config/sys-conf";
 import path from "node:path";
 import fs from "node:fs";
 
 function resolveNginxPath(): string {
-  try {
-    return execSync("which nginx", { encoding: "utf-8" }).trim();
-  } catch {
-    return "nginx";
+  const knownPaths = [
+    "/usr/sbin/nginx",
+    "/usr/local/bin/nginx",
+    "/usr/bin/nginx",
+  ];
+  for (const p of knownPaths) {
+    if (fs.existsSync(p)) return p;
   }
+  return "nginx";
 }
 
 export const NGINX_SERVICE = new Service(
diff --git a/server/server/internal/services/torrential/index.ts b/server/server/internal/services/torrential/index.ts
index 2f9bb26a4..b1651da98 100644
--- a/server/server/internal/services/torrential/index.ts
+++ b/server/server/internal/services/torrential/index.ts
@@ -1,4 +1,4 @@
-import { spawn, execSync } from "node:child_process";
+import { spawn } from "node:child_process";
 import { Service } from "..";
 import fs from "node:fs";
 import path from "node:path";
@@ -58,14 +58,9 @@ export class TorrentialService extends Service<unknown> {
             logger.info(
               "torrential detected in development mode - building from source",
             );
-            let cargoPath = "cargo";
-            try {
-              cargoPath = execSync("which cargo", { encoding: "utf-8" }).trim();
-            } catch (e) {
-              logger.warn(
-                `could not locate cargo via which: ${(e as Error).message}`,
-              );
-            }
+            const cargoPaths = ["/usr/local/bin/cargo", "/usr/bin/cargo"];
+            const cargoPath =
+              cargoPaths.find((p) => fs.existsSync(p)) ?? "cargo";
             // sonarcloud-disable-next-line typescript:S4036
             return spawn(
               cargoPath,
@@ -78,7 +73,7 @@ export class TorrentialService extends Service<unknown> {
               {
                 env: {
                   ...process.env,
-                  PATH: "/usr/local/bin:/usr/bin:/bin",
+                  PATH: process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin",
                 },
               },
             );
@@ -99,13 +94,19 @@ export class TorrentialService extends Service<unknown> {
         const envPath = process.env.TORRENTIAL_PATH;
         if (envPath) return spawn(envPath, [], {});
 
-        let torrentialPath = "torrential";
-        try {
-          torrentialPath = execSync("which torrential", {
-            encoding: "utf-8",
-          }).trim();
-        } catch {
-          /* ignore */
+        let torrentialPath: string | null = null;
+        const knownTorrentialPaths = [
+          "/usr/local/bin/torrential",
+          "/usr/bin/torrential",
+        ];
+        for (const p of knownTorrentialPaths) {
+          if (fs.existsSync(p)) {
+            torrentialPath = p;
+            break;
+          }
+        }
+        if (!torrentialPath) {
+          throw new Error("torrential not found in any known path");
         }
         return spawn(torrentialPath, [], {});
       },
diff --git a/server/server/internal/session/filter.ts b/server/server/internal/session/filter.ts
index 572ceba66..a895ff013 100644
--- a/server/server/internal/session/filter.ts
+++ b/server/server/internal/session/filter.ts
@@ -1,4 +1,32 @@
-import type { SessionWithToken, SessionSearchTerms } from "./types";
+import type { OIDCData, SessionWithToken, SessionSearchTerms } from "./types";
+
+function matchesOidc(session: SessionWithToken, oidc: OIDCData): boolean {
+  if (!session.oidc) {
+    return false;
+  }
+  for (const [key, value] of Object.entries(oidc)) {
+    if (
+      JSON.stringify(
+        (session.oidc as unknown as Record<string, unknown>)[key],
+      ) !== JSON.stringify(value)
+    ) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function matchesData(
+  session: SessionWithToken,
+  data: Record<string, unknown>,
+): boolean {
+  for (const [key, value] of Object.entries(data)) {
+    if (JSON.stringify(session.data[key]) !== JSON.stringify(value)) {
+      return false;
+    }
+  }
+  return true;
+}
 
 /**
  * Checks if a session matches the given search criteria.
@@ -20,25 +48,12 @@ export function sessionMatchesFilter(
     }
   }
 
-  if (options.oidc) {
-    if (!session.oidc) {
-      return false;
-    }
-    for (const [key, value] of Object.entries(options.oidc)) {
-      if (
-        JSON.stringify(
-          (session.oidc as unknown as Record<string, unknown>)[key],
-        ) !== JSON.stringify(value)
-      ) {
-        return false;
-      }
-    }
+  if (options.oidc && !matchesOidc(session, options.oidc)) {
+    return false;
   }
 
-  for (const [key, value] of Object.entries(options.data || {})) {
-    if (JSON.stringify(session.data[key]) !== JSON.stringify(value)) {
-      return false;
-    }
+  if (options.data && !matchesData(session, options.data)) {
+    return false;
   }
 
   return true;
diff --git a/server/server/internal/utils/prioritylist.ts b/server/server/internal/utils/prioritylist.ts
index fa1cb1845..b96f9c2ae 100644
--- a/server/server/internal/utils/prioritylist.ts
+++ b/server/server/internal/utils/prioritylist.ts
@@ -30,7 +30,7 @@ export class PriorityList<T> {
     }
 
     const sorted = this.source
-      .sort((a, b) => {
+      .toSorted((a, b) => {
         if (a.priority == b.priority) {
           return a.addedIndex - b.addedIndex;
         }
diff --git a/server/server/routes/auth/oidc.get.ts b/server/server/routes/auth/oidc.get.ts
index 8ba7c7418..53b3c5161 100644
--- a/server/server/routes/auth/oidc.get.ts
+++ b/server/server/routes/auth/oidc.get.ts
@@ -9,17 +9,20 @@ defineRouteMeta({
 });
 
 export default defineEventHandler((h3) => {
-  const redirect = getQuery(h3).redirect?.toString();
+  const redirectParam = getQuery(h3).redirect?.toString();
 
   const enabledAuthManagers = authManager.getAuthProviders();
-  if (!enabledAuthManagers.OpenID)
-    return sendRedirect(
-      h3,
-      `/auth/signin${redirect ? `?redirect=${encodeURIComponent(redirect)}` : ""}`,
-    );
+  if (!enabledAuthManagers.OpenID) {
+    const signinRedirect = redirectParam
+      ? `?redirect=${encodeURIComponent(redirectParam)}`
+      : "";
+    return sendRedirect(h3, `/auth/signin${signinRedirect}`);
+  }
 
   const manager = enabledAuthManagers.OpenID;
-  const { redirectUrl } = manager.generateAuthSession({ redirect });
+  const { redirectUrl } = manager.generateAuthSession({
+    redirect: redirectParam,
+  });
 
   return sendRedirect(h3, redirectUrl);
 });
diff --git a/server/test/unit/library/manifest-utils.test.ts b/server/test/unit/library/manifest-utils.test.ts
new file mode 100644
index 000000000..4c941e4bb
--- /dev/null
+++ b/server/test/unit/library/manifest-utils.test.ts
@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import {
+  castManifest,
+  type V2Manifest,
+} from "../../../server/internal/library/manifest/utils";
+
+describe("castManifest", () => {
+  const mockManifest: V2Manifest = {
+    version: "2",
+    size: 1024,
+    key: [1, 2, 3],
+    chunks: {
+      chunk1: {
+        files: [
+          { filename: "test.txt", start: 0, length: 100, permissions: 420 },
+        ],
+        checksum: "abc123",
+        iv: [4, 5, 6],
+      },
+    },
+  };
+
+  it("parses a JSON string into V2Manifest", () => {
+    const json = JSON.stringify(mockManifest);
+    const result = castManifest(json);
+    expect(result.version).toBe("2");
+    expect(result.size).toBe(1024);
+    expect(result.chunks.chunk1.files[0].filename).toBe("test.txt");
+  });
+
+  it("returns the object directly when already an object", () => {
+    const result = castManifest(mockManifest);
+    expect(result).toBe(mockManifest);
+    expect(result.version).toBe("2");
+  });
+
+  it("handles an empty string manifest", () => {
+    expect(() => castManifest("")).toThrow();
+  });
+
+  it("handles invalid JSON string", () => {
+    expect(() => castManifest("not-json")).toThrow();
+  });
+});
diff --git a/sites/promo/src/components/comparison.tsx b/sites/promo/src/components/comparison.tsx
index b3e6cafe5..7c0e2a3f6 100644
--- a/sites/promo/src/components/comparison.tsx
+++ b/sites/promo/src/components/comparison.tsx
@@ -12,6 +12,30 @@ import { Menu, MenuButton, MenuItem, MenuItems } from "@headlessui/react";
 import { CheckIcon, ChevronUpDownIcon, MinusIcon } from "@heroicons/react/16/solid";
 import { useSearchParams } from "next/navigation";
 import type React from "react";
+
+function renderComparisonValue(value: unknown, projectName: string): React.ReactNode {
+  if (typeof value === "function") {
+    return <>{value()}</>;
+  }
+  if (value === true) {
+    return (
+      <>
+        <CheckIcon className="size-4 fill-green-600" />
+        <span className="sr-only">Included in {projectName}</span>
+      </>
+    );
+  }
+  if (value === false || value === undefined) {
+    return (
+      <>
+        <MinusIcon className="size-4 fill-gray-400" />
+        <span className="sr-only">Not included in {projectName}</span>
+      </>
+    );
+  }
+  return <div className="text-xs text-zinc-400">{String(value)}</div>;
+}
+
 function DropLogo() {
   return (
     <div className="relative -mb-1 inline-flex items-center justify-center gap-x-1">
@@ -52,7 +76,7 @@ function GameVaultPlus() {
   return (
     <div className="inline-flex items-center gap-x-1 rounded-full bg-zinc-800 px-2 py-1 text-xs">
       <img src="/icons/gamevault-plus.png" alt="" className="size-4" />
-      GameVault+
+      <span>GameVault+</span>
     </div>
   );
 }
@@ -254,10 +278,7 @@ function Header() {
     <Container className="mt-16">
       <Heading as="h1" className="leading-12">
         What&apos;s the{" "}
-        <span className="rounded-xl bg-zinc-900 px-3 py-2 font-mono text-zinc-300">
-          git&nbsp;diff
-        </span>
-        ?
+        <span className="rounded-xl bg-zinc-900 px-3 py-2 font-mono text-zinc-300">git diff</span>?
       </Heading>
       <Lead className="mt-6 max-w-3xl">
         A breakdown between the different projects available to you, put together by the Drop OSS
@@ -306,8 +327,8 @@ function ProjectCard({ tier }: { readonly tier: (typeof projects)[number] }) {
           <div className="mt-8">
             <h3 className="text-sm/6 font-medium text-zinc-100">Key features:</h3>
             <ul className="mt-3 space-y-3">
-              {tier.highlights.map((props, featureIndex) => (
-                <FeatureItem key={featureIndex} {...props} />
+              {tier.highlights.map((props) => (
+                <FeatureItem key={props.description} {...props} />
               ))}
             </ul>
           </div>
@@ -322,15 +343,15 @@ function ProjectCard({ tier }: { readonly tier: (typeof projects)[number] }) {
  *
  * @param selectedProject - The project whose comparison column is highlighted and selected on small screens.
  */
+function onlyUnique<T>(value: T, index: number, array: Array<T>) {
+  return array.indexOf(value) === index;
+}
+
 function ProjectTable({
   selectedProject,
 }: {
   readonly selectedProject: (typeof projects)[number];
 }) {
-  function onlyUnique<T>(value: T, index: number, array: Array<T>) {
-    return array.indexOf(value) === index;
-  }
-
   const sections = projects
     .flatMap((e) => Object.keys(e.features))
     .filter((v, i, a) => onlyUnique(v, i, a));
@@ -447,36 +468,13 @@ function ProjectTable({
                 {projects.map((project) => {
                   let value = project.features[section]?.[name];
 
-                  function renderValue() {
-                    if (typeof value === "function") {
-                      return <>{value()}</>;
-                    }
-                    if (value === true) {
-                      return (
-                        <>
-                          <CheckIcon className="size-4 fill-green-600" />
-                          <span className="sr-only">Included in {project.name}</span>
-                        </>
-                      );
-                    }
-                    if (value === false || value === undefined) {
-                      return (
-                        <>
-                          <MinusIcon className="size-4 fill-gray-400" />
-                          <span className="sr-only">Not included in {project.name}</span>
-                        </>
-                      );
-                    }
-                    return <div className="text-xs text-zinc-400">{value}</div>;
-                  }
-
                   return (
                     <td
                       key={project.slug}
                       data-selected={selectedProject === project ? true : undefined}
                       className="p-4 data-selected:table-cell max-sm:hidden"
                     >
-                      {renderValue()}
+                      {renderComparisonValue(value, project.name)}
                     </td>
                   );
                 })}
diff --git a/sites/promo/src/components/gallery-modal.tsx b/sites/promo/src/components/gallery-modal.tsx
index 03681150e..da55da7b4 100644
--- a/sites/promo/src/components/gallery-modal.tsx
+++ b/sites/promo/src/components/gallery-modal.tsx
@@ -132,7 +132,7 @@ export default function GalleryModal({
             transition
             className="relative m-8 transform overflow-hidden rounded-lg bg-white text-left shadow-xl transition-all data-closed:translate-y-4 data-closed:opacity-0 data-enter:duration-300 data-enter:ease-out data-leave:duration-200 data-leave:ease-in data-closed:sm:translate-y-0 data-closed:sm:scale-95"
           >
-            <img src={img} alt="Gallery image" className="max-h-[90vh] w-full" />
+            <img src={img} alt="Screenshot" className="max-h-[90vh] w-full" />
             <button
               type="button"
               className="absolute top-0 right-0 m-4 cursor-pointer rounded-xl bg-zinc-900 p-2 text-zinc-100 outline outline-zinc-700 hover:text-zinc-400"
diff --git a/sites/promo/src/components/linked-avatars.tsx b/sites/promo/src/components/linked-avatars.tsx
index 30aa7cbf6..6ca9e5000 100644
--- a/sites/promo/src/components/linked-avatars.tsx
+++ b/sites/promo/src/components/linked-avatars.tsx
@@ -20,7 +20,7 @@ function Rings() {
         "mask-[linear-gradient(to_bottom,black_90%,transparent),radial-gradient(circle,rgba(0,0,0,1)_0%,rgba(0,0,0,0)_100%)] mask-intersect",
       )}
     >
-      {Array.from(Array(42).keys()).map((n) => (
+      {Array.from(new Array(42).keys()).map((n) => (
         <motion.circle
           variants={{
             idle: {
diff --git a/sites/promo/src/components/map.tsx b/sites/promo/src/components/map.tsx
index 7436d2ae9..711de2a95 100644
--- a/sites/promo/src/components/map.tsx
+++ b/sites/promo/src/components/map.tsx
@@ -50,7 +50,7 @@ function Marker({
 /**
  * Renders an animated map with location markers.
  */
-export function Map() {
+export function WorldMap() {
   return (
     <div aria-hidden="true" className="relative size-full">
       <div className="absolute inset-0 bg-[url(/map.png)] mask-[linear-gradient(to_bottom,black_50%,transparent)] bg-size-[530px_430px] bg-position-[center_-75px] bg-no-repeat" />
diff --git a/sites/promo/src/components/sponsors.tsx b/sites/promo/src/components/sponsors.tsx
index faa6364ce..5ac75530d 100644
--- a/sites/promo/src/components/sponsors.tsx
+++ b/sites/promo/src/components/sponsors.tsx
@@ -97,18 +97,15 @@ function SponsorCard({
 }
 
 function CallToAction() {
-  return <div />;
   return (
-    <div>
-      <p className="max-w-sm text-sm/6 text-gray-600">
-        Join the best sellers in the business and start using Radiant to hit your targets today.
-      </p>
+    <div className="space-y-4">
+      <p className="max-w-sm text-sm/6 text-gray-600">Support Drop OSS on Open Collective.</p>
       <div className="mt-2">
         <Link
-          href="#"
+          href="https://opencollective.com/drop-oss"
           className="inline-flex items-center gap-2 text-sm/6 font-medium text-pink-600"
         >
-          Get started
+          Become a sponsor
           <ArrowLongRightIcon className="size-5" />
         </Link>
       </div>
@@ -240,15 +237,15 @@ export function Sponsors() {
           "[--scroll-padding:max(--spacing(6),calc((100vw-(var(--container-2xl)))/2))] lg:[--scroll-padding:max(--spacing(8),calc((100vw-(var(--container-7xl)))/2))]",
         ])}
       >
-        {sponsors?.map(({ image, name, from }, testimonialIndex) => (
+        {sponsors?.map(({ image, name, from }, i) => (
           <SponsorCard
-            key={testimonialIndex}
+            key={`${name}-${from}`}
             name={name}
             from={from}
             img={image}
             bounds={bounds}
             scrollX={scrollX}
-            onClick={() => scrollTo(testimonialIndex)}
+            onClick={() => scrollTo(i)}
           />
         ))}
         <div className="w-2xl shrink-0 sm:w-216" />
@@ -257,11 +254,11 @@ export function Sponsors() {
         <div className="flex justify-between">
           <CallToAction />
           <div className="hidden sm:flex sm:gap-2">
-            {sponsors?.map(({ name }, i) => (
+            {sponsors?.map(({ name }, j) => (
               <Headless.Button
-                key={i}
-                onClick={() => scrollTo(i)}
-                data-active={activeIndex === i ? true : undefined}
+                key={name}
+                onClick={() => scrollTo(j)}
+                data-active={activeIndex === j ? true : undefined}
                 aria-label={`Scroll to sponsorship from ${name}`}
                 className={clsx(
                   "size-2.5 cursor-pointer rounded-full border border-transparent bg-zinc-600 transition",