fix: address sixth round of PR review findings

VcRedistStep: per-year markers now also encode architecture (`$year-x86` /
`$year-x64`, plus `legacy-x86` / `legacy-x64` for yearless paths). Without
this, an x86-only install (e.g. vc_redist.x86.exe for 2015) wrote a year-only
marker that incorrectly suppressed the matching x64 install on a later game.
Yearless redists (A:\redist\vcredist_*, A:\_CommonRedist\VC_redist.*) are
similarly distinguished. archKey() inspects the win path for x64/amd64/wow64/
x86_64 hints (and explicit .x64./.x86. filenames) and defaults to x86 for
ambiguous paths. Round-5 archless markers are migrated as `_$year-x86` only —
conservative: any actual x64 install will re-run once. appliesTo no longer
short-circuits on the coarse game-dir VCREDIST_INSTALLED marker when per-year/
arch markers indicate a missing (year, arch) pair; the game-dir marker is now
only a fallback when no per-year markers exist or containerRoot is null.

WinHandler.GET_PROCESS dispatch: each listener invocation (slot listener and
each multi-listener entry) is now wrapped in try/catch so one bad listener
can't kill the worker thread. Same fix applied to the listProcesses() send-
failure broadcast.

WinHandler.exec(String): handle quoted paths. A leading `"` triggers quoted-
path parsing (filename = quoted substring; parameters = trimmed remainder);
unquoted commands still split on the first whitespace. Without this,
"C:\Program Files (x86)\Steam\steam.exe" -shutdown shredded into a bogus
filename of "C:\Program".

XServerScreen.requestWineProcessSnapshot: distinguish request/send failure
from a legitimate empty process list. WinHandler.listProcesses() emits
(0, 0, null) only when sendPacket() fails — Wine itself never broadcasts
empty. Added ProcessSnapshotException, listener completes deferred
exceptionally on (count==0 && info==null), await maps it to null so
isSteamExeAlive(null) == true keeps the polling loop alive instead of
falsely concluding Steam exited.

WinHandler + XServerScreen: add a snapshot-collection mutex
(processSnapshotMutex). Both Kotlin pollers (requestWineProcessSnapshot and
startExitWatchForUnmappedGameWindow) now serialize their add-listener →
listProcesses → await → remove-listener sequence so concurrent listProcesses
calls don't cross-pollute each other's deferreds. Multi-listener support is
preserved for long-running watchers; only the per-iteration snapshot is
serialized.

LudusaviRegistry.ensureLoaded: extend the empty-set guard to the disk-cache
fallback. A poisoned `{}` cache file (e.g., one written before the round-5
empty-fetch guard shipped) used to populate memoryCache with emptyMap(),
after which the fast path short-circuited forever. Now: if the parsed disk
cache is empty, log and delete the poisoned file (best-effort), fall through
to null so the next ensureLoaded retries the fetch. Parser exceptions still
leave the file alone.

WindowManager.reapLeakedClientWindows: add the 1x1 parent-size predicate to
match the compositor's full orphan-chain marker (dd3987b). Without it, a
legitimate window whose parent happens to be blank-class+pid==0 but is NOT
a 1x1 orphanage stub could still be reaped.

PluviaMain SDK bridge prompt: drop the dead `persisted` boolean computed in
onConfirmClick / onActionClick (round-5 changed every relaunch(...) to
relaunch(true), so the Boolean is no longer read). Side effects and the
existing onFailure Timber.w log are preserved.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: TideGear

app/src/main/java/app/gamenative/ui/PluviaMain.kt

@@ -821,12 +821,13 @@ fun PluviaMain(
                     val rec = runCatching {
                         SteamUtils.getRecommendedSdkCloudSaveSubdirAsync(context, gameId)
                     }.getOrNull()
-                    val persisted = rec != null && runCatching {
-                        val container = ContainerUtils.getContainer(context, state.launchedAppId)
-                        container.sdkCloudSaveSubdir = rec.subdir
-                        container.saveData()
-                    }.onFailure { Timber.w(it, "Failed to persist sdkCloudSaveSubdir=${rec.subdir}") }
-                        .isSuccess
+                    if (rec != null) {
+                        runCatching {
+                            val container = ContainerUtils.getContainer(context, state.launchedAppId)
+                            container.sdkCloudSaveSubdir = rec.subdir
+                            container.saveData()
+                        }.onFailure { Timber.w(it, "Failed to persist sdkCloudSaveSubdir=${rec.subdir}") }
+                    }
                     withContext(Dispatchers.Main) { relaunch(true) }
                 }
             }
@@ -841,12 +842,11 @@ fun PluviaMain(
                 // Don't ask again for this game.
                 msgDialogState = MessageDialogState(false)
                 CoroutineScope(Dispatchers.IO).launch {
-                    val persisted = runCatching {
+                    runCatching {
                         val container = ContainerUtils.getContainer(context, state.launchedAppId)
                         container.putExtra("sdkCloudBridgePromptDismissed", "1")
                         container.saveData()
                     }.onFailure { Timber.w(it, "Failed to persist sdkCloudBridgePromptDismissed") }
-                        .isSuccess
                     withContext(Dispatchers.Main) { relaunch(true) }
                 }
             }

app/src/main/java/app/gamenative/ui/screen/xserver/XServerScreen.kt

@@ -177,6 +177,7 @@ import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
 import kotlinx.coroutines.withTimeoutOrNull
 import org.json.JSONException
@@ -310,20 +311,27 @@ private fun buildEssentialProcessAllowlist(): Set<String> {
     return (essentialServices + CORE_WINE_PROCESSES).toSet()
 }
 
+private class ProcessSnapshotException(msg: String) : Exception(msg)
+
 private suspend fun requestWineProcessSnapshot(winHandler: WinHandler): List<ProcessInfo>? {
     val lock = Any()
     var currentList = mutableListOf<ProcessInfo>()
     var expectedCount = 0
     val deferred = CompletableDeferred<List<ProcessInfo>?>()
 
-    // Register via add/removeOnGetProcessInfoListener so we don't clobber
-    // other concurrent watchers (e.g. startExitWatchForUnmappedGameWindow,
-    // or another awaitSteamShutdown poll on the same WinHandler) that also
-    // need process-info events.
     val listener = OnGetProcessInfoListener { index, count, processInfo ->
         synchronized(lock) {
+            // (0, 0, null) is only emitted by WinHandler.listProcesses() when
+            // the underlying UDP send fails; wine itself never broadcasts an
+            // empty list. Treating it as a successful empty snapshot would let
+            // awaitSteamShutdown conclude Steam exited on a transient send
+            // failure, so surface it as an exception instead.
             if (count == 0 && processInfo == null) {
-                if (!deferred.isCompleted) deferred.complete(emptyList())
+                if (!deferred.isCompleted) {
+                    deferred.completeExceptionally(
+                        ProcessSnapshotException("request/send failure"),
+                    )
+                }
                 return@synchronized
             }
             if (index == 0) {
@@ -343,14 +351,23 @@ private suspend fun requestWineProcessSnapshot(winHandler: WinHandler): List<Pro
         }
     }
 
-    return try {
+    // Serialize the add/list/await/remove sequence against any other concurrent
+    // snapshot caller; the wire protocol broadcasts GET_PROCESS responses to
+    // every registered listener with no request id to disambiguate.
+    return winHandler.processSnapshotMutex.withLock {
         winHandler.addOnGetProcessInfoListener(listener)
-        winHandler.listProcesses()
-        withTimeoutOrNull(EXIT_PROCESS_RESPONSE_TIMEOUT_MS) {
-            deferred.await()
+        try {
+            winHandler.listProcesses()
+            withTimeoutOrNull(EXIT_PROCESS_RESPONSE_TIMEOUT_MS) {
+                try {
+                    deferred.await()
+                } catch (e: ProcessSnapshotException) {
+                    null
+                }
+            }
+        } finally {
+            winHandler.removeOnGetProcessInfoListener(listener)
         }
-    } finally {
-        winHandler.removeOnGetProcessInfoListener(listener)
     }
 }
 
@@ -859,12 +876,17 @@ fun XServerScreen(
                 val startTime = System.currentTimeMillis()
                 while (System.currentTimeMillis() - startTime < EXIT_PROCESS_TIMEOUT_MS) {
                     val deferred = CompletableDeferred<List<ProcessInfo>?>()
-                    synchronized(lock) {
-                        pendingSnapshot = deferred
-                    }
-                    winHandler.listProcesses()
-                    val snapshot = withTimeoutOrNull(EXIT_PROCESS_RESPONSE_TIMEOUT_MS) {
-                        deferred.await()
+                    // Serialize against any other listProcesses-driven caller so a
+                    // concurrent awaitSteamShutdown poll doesn't deliver its
+                    // GET_PROCESS responses into this watcher's pending snapshot.
+                    val snapshot = winHandler.processSnapshotMutex.withLock {
+                        synchronized(lock) {
+                            pendingSnapshot = deferred
+                        }
+                        winHandler.listProcesses()
+                        withTimeoutOrNull(EXIT_PROCESS_RESPONSE_TIMEOUT_MS) {
+                            deferred.await()
+                        }
                     }
                     if (snapshot != null) {
                         val hasNonEssential = snapshot.any {

app/src/main/java/app/gamenative/utils/LudusaviRegistry.kt

@@ -93,9 +93,19 @@ object LudusaviRegistry {
                 if (cacheFile.isFile) {
                     runCatching { parseCacheJson(cacheFile.readText()) }
                         .onSuccess {
-                            memoryCache = it
-                            Timber.w("LudusaviRegistry: using stale disk cache (${it.size} entries) after fetch failure")
-                            return@withLock it
+                            // Mirror the empty-fetch guard above: a 0-entry disk cache is a
+                            // poisoned/stale artifact (e.g. a `{}` file from before this guard
+                            // shipped). Promoting it to memoryCache would let the fast path
+                            // short-circuit forever. Delete the file so a future fetch can
+                            // replace it, and fall through to return null.
+                            if (it.isEmpty()) {
+                                Timber.w("LudusaviRegistry: disk cache parsed to 0 entries; deleting poisoned file")
+                                runCatching { cacheFile.delete() }
+                            } else {
+                                memoryCache = it
+                                Timber.w("LudusaviRegistry: using stale disk cache (${it.size} entries) after fetch failure")
+                                return@withLock it
+                            }
                         }
                 }
                 return@withLock null

app/src/main/java/app/gamenative/utils/preInstallSteps/VcRedistStep.kt

@@ -69,26 +69,32 @@ object VcRedistStep : PreInstallStep {
         gameDirPath: String,
     ): Boolean {
         // vcredist installs system-wide into the Wine prefix, not per-game. We
-        // track installed years at the container root (one marker per year)
-        // so reinstalling the game (which wipes the game dir) doesn't force a
-        // redundant re-run, while still detecting when a *different* game
-        // bundles a year we have not yet installed.
+        // track installed years/arches at the container root (one marker per
+        // year+arch) so reinstalling the game (which wipes the game dir)
+        // doesn't force a redundant re-run, while still detecting when a
+        // *different* game bundles a year/arch we have not yet installed.
         val gameDir = File(gameDirPath)
         val required = requiredVersions(gameDir)
         if (required.isEmpty()) {
-            // Nothing to install: treat the step as satisfied.
             return false
         }
         val containerRoot = container.rootDir?.absolutePath
         migrateLegacyContainerMarker(containerRoot, required)
+        migrateLegacyArchlessMarkers(containerRoot)
         val installed = installedVersions(containerRoot)
+        if (containerRoot != null && installed.isNotEmpty()) {
+            // Per-year/arch markers are the source of truth here. The coarse
+            // game-dir marker is ignored — if anything required is missing we
+            // must run buildCommand for the missing set.
+            return required.any { it !in installed }
+        }
         val missing = required - installed
         if (missing.isEmpty()) {
-            // All required years already covered by container-level markers.
             return false
         }
-        // Fall back to the legacy game-dir marker so an in-flight install
-        // that already ran for this exact game directory still short-circuits.
+        // No per-year markers to consult: fall back to the legacy game-dir
+        // marker so an in-flight install that already ran for this exact game
+        // directory still short-circuits.
         return !MarkerUtils.hasMarker(gameDirPath, Marker.VCREDIST_INSTALLED)
     }
 
@@ -125,6 +131,7 @@ object VcRedistStep : PreInstallStep {
         gameDirPath: String,
     ): String? {
         val containerRoot = container.rootDir?.absolutePath
+        migrateLegacyArchlessMarkers(containerRoot)
         val installed = installedVersions(containerRoot)
         val parts = mutableListOf<String>()
         for ((winPath, args) in vcRedistMap) {
@@ -134,11 +141,11 @@ object VcRedistStep : PreInstallStep {
             if (lastSep < 0) continue
             val hostFile = File(gameDir, rest.replace('\\', '/'))
             if (!hostFile.isFile) continue
-            // Skip installer entries for years already installed system-wide
-            // so we don't pop a fresh installer window per launch (the
-            // 963d7999 fix). Years we haven't seen still run.
+            // Skip installer entries for year+arch combos already installed
+            // system-wide so we don't pop a fresh installer window per launch
+            // (the 963d7999 fix). Year+arch combos we haven't seen still run.
             val version = versionKey(winPath)
-            if (version != null && installed.contains(version)) continue
+            if (installed.contains(version)) continue
             parts.add(if (args.isEmpty()) winPath else "$winPath $args")
         }
         return if (parts.isEmpty()) null else parts.joinToString(" & ")
@@ -170,7 +177,7 @@ object VcRedistStep : PreInstallStep {
             if (rest.lastIndexOf('\\') < 0) continue
             val hostFile = File(gameDir, rest.replace('\\', '/'))
             if (!hostFile.isFile) continue
-            versionKey(winPath)?.let { out.add(it) }
+            out.add(versionKey(winPath))
         }
         return out
     }
@@ -192,23 +199,55 @@ object VcRedistStep : PreInstallStep {
     }
 
     /**
-     * Map an installer's Windows path to a stable version key. Recognises
-     * year-suffixed folders ("2005".."2022"). Paths with no clear year
-     * (legacy `A:\redist\…`, root-level `A:\_CommonRedist\VC_redist.*`) map
-     * to "legacy" so they are still tracked, just with a single shared key.
+     * Map an installer's Windows path to a stable "$year-$arch" key (or
+     * "legacy-$arch" when no year is present). x86 and x64 installers from
+     * the same year get distinct keys so installing one does not mask the
+     * other. When no architecture hint is detectable we default to x86,
+     * matching the most common older redistributable layout.
      */
-    private fun versionKey(winPath: String): String? {
+    private fun versionKey(winPath: String): String {
         val lower = winPath.lowercase()
+        val arch = archKey(lower)
         for (year in YEAR_KEYS) {
             if (lower.contains("\\$year\\") || lower.contains("\\msvc$year\\") ||
                 lower.contains("\\msvc${year}_x64\\")
             ) {
-                return year
+                return "$year-$arch"
+            }
+        }
+        return "legacy-$arch"
+    }
+
+    private fun archKey(lowerWinPath: String): String {
+        val x64Hints = listOf("x64", "amd64", "wow64", "x86_64", "_x64\\", ".x64.")
+        if (x64Hints.any { lowerWinPath.contains(it) }) return "x64"
+        if (lowerWinPath.contains("x86") || lowerWinPath.contains(".x86.")) return "x86"
+        return "x86"
+    }
+
+    /**
+     * One-time upgrade for markers written by the prior round-5 fix that were
+     * keyed by year only (e.g. `.vcredist_installed_2005`, `.vcredist_installed_legacy`).
+     * We don't know which arch was actually installed back then, so we
+     * conservatively claim only x86 coverage; if x64 was also installed it
+     * will be re-run on the next launch (one redundant installer at most).
+     */
+    private fun migrateLegacyArchlessMarkers(containerRoot: String?) {
+        if (containerRoot == null) return
+        val dir = File(containerRoot)
+        val files = dir.listFiles() ?: return
+        for (f in files) {
+            if (!f.isFile) continue
+            val name = f.name
+            if (!name.startsWith(PER_VERSION_MARKER_PREFIX)) continue
+            val suffix = name.substring(PER_VERSION_MARKER_PREFIX.length)
+            if (suffix.contains('-')) continue
+            val migrated = File(containerRoot, "$PER_VERSION_MARKER_PREFIX$suffix-x86")
+            if (!migrated.exists()) {
+                runCatching { migrated.createNewFile() }
             }
+            runCatching { f.delete() }
         }
-        // Generic / yearless installers — track under a shared key so they
-        // don't all collapse to "no key" and bypass the marker check.
-        return "legacy"
     }
 
     private val YEAR_KEYS = listOf(

app/src/main/java/com/winlator/winhandler/WinHandler.java

@@ -293,9 +293,24 @@ public void exec(String command) {
         if (command2.isEmpty()) {
             return;
         }
-        String[] cmdList = command2.split(" ", 2);
-        final String filename = cmdList[0];
-        final String parameters = cmdList.length > 1 ? cmdList[1] : "";
+        final String filename;
+        final String parameters;
+        // A naive split(" ", 2) would shred Windows paths like
+        // "C:\Program Files (x86)\Steam\steam.exe" -shutdown.
+        if (command2.charAt(0) == '"') {
+            int closing = command2.indexOf('"', 1);
+            if (closing > 0) {
+                filename = command2.substring(1, closing);
+                parameters = command2.substring(closing + 1).trim();
+            } else {
+                filename = command2.substring(1);
+                parameters = "";
+            }
+        } else {
+            String[] cmdList = command2.split(" ", 2);
+            filename = cmdList[0];
+            parameters = cmdList.length > 1 ? cmdList[1] : "";
+        }
         exec(filename, parameters);
     }
 
@@ -345,10 +360,18 @@ public void listProcesses() {
             if (!sendPacket(CLIENT_PORT)) {
                 OnGetProcessInfoListener slotListener = this.onGetProcessInfoListener;
                 if (slotListener != null) {
-                    slotListener.onGetProcessInfo(0, 0, null);
+                    try {
+                        slotListener.onGetProcessInfo(0, 0, null);
+                    } catch (Throwable t) {
+                        Log.w(TAG, "process info listener threw", t);
+                    }
                 }
                 for (OnGetProcessInfoListener l : extraProcessInfoListeners) {
-                    l.onGetProcessInfo(0, 0, null);
+                    try {
+                        l.onGetProcessInfo(0, 0, null);
+                    } catch (Throwable t) {
+                        Log.w(TAG, "process info listener threw", t);
+                    }
                 }
             }
         });
@@ -470,6 +493,26 @@ public void removeOnGetProcessInfoListener(OnGetProcessInfoListener listener) {
         extraProcessInfoListeners.remove(listener);
     }
 
+    /**
+     * Coordinates listProcesses-driven snapshot collection so events from one
+     * snapshot don't bleed into another concurrent snapshot's listener. The
+     * wire protocol has no request id to disambiguate broadcast responses, so
+     * a serializing primitive is the cheapest fix that preserves the existing
+     * GET_PROCESS packet format.
+     *
+     * <p>Callers that wrap an {@code addOnGetProcessInfoListener} /
+     * {@code listProcesses} / await / {@code removeOnGetProcessInfoListener}
+     * sequence should hold this lock for the duration of the sequence.
+     * Long-running listeners that don't drive listProcesses themselves don't
+     * need to acquire it.
+     *
+     * <p>Exposed as a {@link kotlinx.coroutines.sync.Mutex} so Kotlin callers
+     * can suspend on it without binding to a thread, which a JVM monitor would
+     * forbid across coroutine suspension points.
+     */
+    public final kotlinx.coroutines.sync.Mutex processSnapshotMutex =
+            kotlinx.coroutines.sync.MutexKt.Mutex(false);
+
     private void startSendThread() {
         Executors.newSingleThreadExecutor().execute(() -> {
             while (this.running) {
@@ -532,11 +575,21 @@ private void handleRequest(byte requestCode, final int port) throws IOException
                 this.receiveData.get(bytes);
                 String name = StringUtils.fromANSIString(bytes);
                 ProcessInfo info = new ProcessInfo(pid, name, memoryUsage, affinityMask, wow64Process);
+                // Isolate each listener so a misbehaving consumer can't kill the
+                // receive thread and break future polling for everyone else.
                 if (this.onGetProcessInfoListener != null) {
-                    this.onGetProcessInfoListener.onGetProcessInfo(index, numProcesses, info);
+                    try {
+                        this.onGetProcessInfoListener.onGetProcessInfo(index, numProcesses, info);
+                    } catch (Throwable t) {
+                        Log.w(TAG, "process info listener threw", t);
+                    }
                 }
                 for (OnGetProcessInfoListener l : extraProcessInfoListeners) {
-                    l.onGetProcessInfo(index, numProcesses, info);
+                    try {
+                        l.onGetProcessInfo(index, numProcesses, info);
+                    } catch (Throwable t) {
+                        Log.w(TAG, "process info listener threw", t);
+                    }
                 }
                 return;
             case RequestCodes.GET_GAMEPAD: