android: the boot chain goes out in one round, and a census that holds it there

Thirty rounds of onMount had never been read end to end, and read end to end
it was a queue: two dozen commands with a critical path ten deep, because
Tauri's `listen` is an invoke like any other. loadLibrary asked for five
independent SQLite reads one behind the other, bindSlsk registered eight
listeners one behind the other, and watchLibrary and the player's bindEvents
did two each. None of them depended on anything before them. They go out in
one round now — the same commands, critical path 10 to 3, and ten of them
used to leave in the shell's own first turn where twenty-three do now — and
in a rig that runs the real store modules with the bridge instrumented,
lib.loaded lands at 53 ms instead of 85 at a 6 ms round trip and 62 instead
of 148 at 20 ms. Those are a desktop rig's milliseconds with the round trip
swept rather than measured; the phone's own numbers are unproven until the
walk prints bootMs and bootLibMs.

The behaviour is meant to be identical. loadLibrary's only movable part was
lib.error, which has two writers and used to be decided by the order they were
awaited in; the two messages are now carried out of the round and applied in
that same order, so a failing library still shows the library's message. Every
combination of which of the five reads fails, over six latency shapes, comes
out identical to the old code. bindSlsk still does not return until every
handler is up, so connectStored cannot let a fast connected state land with
nobody listening, and bindEvents still hands back the transport's unlisten and
still rejects only when the transport is the one that failed.

src/lib/boot.js is the project's first launch instrument — one counter every
invoke and every listen passes, sealed at the first frame the shell paints and
never re-opened, so a probe landing a second and a half later still reads the
launch. perf.mjs measures frames; nothing measured the launch. The mock walk's
Home step now holds a budget against it and both walks print bootCalls,
bootSync, bootMs and bootLibMs on every step. bootSync is the clause with no
clock in it: a call that waits on the one before it can only issue its first
in the shell's own turn, so a chain put back in a queue falls under the floor
whatever the machine is doing. A bootCalls of -2 means __ss.boot is not there
at all, which is the census itself being broken rather than the app.

One import line goes with it: Sheet.svelte's `import * as api`, the only one
of the ten dead imports this round turned up whose reason is the bundle at
all. Rollup already drops an unreferenced NAMED import, so a dead name on an
import line is hygiene rather than bytes; a namespace import is the one shape
tree-shaking cannot see through, and this one was dead. It frees nothing on
its own — twenty-nine other files in the phone's graph hold the same module
the same way, so api.js is pinned into the chunk whatever Sheet.svelte does —
but it is the only one of the ten that belongs to a round about weight. The
nine that are drift go out with the sweep in the round after this one.

Two things were looked at and left alone, both written down in ANDROID.md
rather than half-done. Home's per-artist catalog walk is the deepest chain in
the app, and that serial walk is the Deezer and MusicBrainz pacing, not an
oversight. And the follows really are read twice at launch, but the obvious
guard does not work: Home's effect calls loadHome with force the first time
they land, so the guard would never fire. One small local read, left for a
round that can do it properly.

src/mobile/player.svelte.js

@@ -593,15 +593,18 @@ export async function bindEvents() {
     document.addEventListener("visibilitychange", () => { if (document.hidden) writeSession(); });
     window.addEventListener("pagehide", writeSession);
     setInterval(() => { if (player.status === "playing") writeSession(); }, 10_000);
-    try {
-        await listen("soulseek:stream", (ev) => {
-            const p = ev.payload || {};
-            if (!current()?.t?.stream) return;
-            player.stream = { received: p.received || 0, total: p.total || 0, done: !!p.done, failed: p.failed || null };
-            if (p.failed) setErr("The stream from " + current().t.stream.username + " failed: " + p.failed);
-        });
-    } catch { /* not a phone */ }
-    return await listen("soulseek:player", (ev) => {
+    /* Two subscriptions in one round, for the same reason as everywhere
+       else this round: `listen` is an invoke, so one behind the other is
+       two bridge round trips at launch. Both are in flight from here; they
+       are awaited together at the end, so neither can reject with nobody
+       listening. */
+    const streamSub = listen("soulseek:stream", (ev) => {
+        const p = ev.payload || {};
+        if (!current()?.t?.stream) return;
+        player.stream = { received: p.received || 0, total: p.total || 0, done: !!p.done, failed: p.failed || null };
+        if (p.failed) setErr("The stream from " + current().t.stream.username + " failed: " + p.failed);
+    });
+    const transportSub = listen("soulseek:player", (ev) => {
         const p = ev.payload || {};
         switch (p.kind) {
             case "playing": player.status = "playing"; player.needsResource = false; mediaSync(); break;
@@ -627,6 +630,12 @@ export async function bindEvents() {
                 break;
         }
     });
+    /* the stream listener is still allowed to have nothing behind it (a
+       desktop build, the mock without the bus); the transport's failure is
+       still the one the shell shows, and the unlisten handed back is still
+       the transport's — the one onMount stores and calls on teardown. */
+    const [, unlisten] = await Promise.all([streamSub.catch(() => { /* not a phone */ }), transportSub]);
+    return unlisten;
 }
 
 /* ── the session ─────────────────────────────────────────────────────── */