feat(sync): priority lanes for urgent event types + updates polish

Adds a fast-lane / bulk-lane split to the local→remote event sync so
location changes, deaths, vehicle destruction, quantum target, and
session-end events ship every ~5s while the rest drains on the usual
60s cadence. User-tunable via a four-card preset picker (Fast /
Balanced / Resource-saver / Custom) plus raw interval inputs.

Storage: `events.sent_at` replaces the global `sync_cursor` model so
either lane can pick its next batch via `WHERE sent_at IS NULL AND
type [NOT] IN (...)`. Partial index keeps the scan O(unsent). Legacy
DBs are migrated by back-stamping rows below the old cursor.

Sync: `start()` now returns `SyncHandles { bulk, priority }` and
spawns up to two workers sharing the same `kick` Notify. Bulk owns
the idle heartbeat — the priority lane wakes too often to justify
hammering `/v1/auth/me`.

Config + Tauri command: `priority_interval_secs` (default 5) and
`priority_event_types` (default urgent set) added with `#[serde(default)]`
so existing config.toml survives. `set_sync_preset` command applies
the named pair and respawns the workers.

UI: SettingsPane gets a "Sync speed" radio-card section above the
existing intervals, plus a dedicated "Priority interval" input next
to the existing bulk interval and batch size.

Updates surface polish:
- Release-channel dropdown now matches the INPUT_BASE contract used
  by TextInput (`var(--bg)`, `var(--r-sm)`, `var(--font-mono)`,
  `7px 9px`) so it reads as part of the same family. (Native popup
  chrome is still browser-controlled.)
- `ReleaseChannel::default()` returns Live unconditionally instead
  of deriving from `CARGO_PKG_VERSION`. Pre-release binaries no
  longer implicitly opt users into pre-release update channels; the
  Settings dropdown remains the explicit opt-in path.

Author: Nigel Tatschner

apps/tray-ui/src/api.ts

@@ -83,8 +83,82 @@ export interface RemoteSyncConfig {
   api_url: string | null;
   claimed_handle: string | null;
   access_token: string | null;
+  /** How often the BULK lane drains (seconds). Defaults to 60. */
   interval_secs: number;
   batch_size: number;
+  /** How often the PRIORITY lane drains (seconds). Defaults to 5. */
+  priority_interval_secs: number;
+  /**
+   * Event-type strings that ride the fast lane. Empty list disables
+   * the priority lane entirely. Defaults to the canonical urgent set
+   * (location, deaths, vehicle destruction, quantum target, session
+   * end) — see Rust-side `DEFAULT_URGENT_TYPES`.
+   */
+  priority_event_types: string[];
+}
+
+/**
+ * Named sync-speed presets. Pairs of (priority_interval, bulk_interval)
+ * are kept ~10x apart so the fast/bulk ratio stays sensible across
+ * presets. `"custom"` is a UI-only marker: the Rust side returns the
+ * current config unchanged when this is selected — actual numbers
+ * change via `saveConfig` once the user edits a field.
+ */
+export type SyncPreset = 'fast' | 'balanced' | 'resource_saver' | 'custom';
+
+export const SYNC_PRESETS: {
+  id: SyncPreset;
+  label: string;
+  description: string;
+  priorityInterval: number;
+  bulkInterval: number;
+}[] = [
+  {
+    id: 'fast',
+    label: 'Fast',
+    description: 'Priority every 3s, bulk every 30s — snappier "where am I" updates.',
+    priorityInterval: 3,
+    bulkInterval: 30,
+  },
+  {
+    id: 'balanced',
+    label: 'Balanced',
+    description: 'Default. Priority every 5s, bulk every 60s.',
+    priorityInterval: 5,
+    bulkInterval: 60,
+  },
+  {
+    id: 'resource_saver',
+    label: 'Resource saver',
+    description: 'Priority every 30s, bulk every 5min — lowest CPU/network.',
+    priorityInterval: 30,
+    bulkInterval: 300,
+  },
+  {
+    id: 'custom',
+    label: 'Custom',
+    description: 'Pick your own intervals below.',
+    priorityInterval: 0,
+    bulkInterval: 0,
+  },
+];
+
+/**
+ * Match a current `RemoteSyncConfig` to its named preset, if any.
+ * Returns `"custom"` when the intervals don't line up with one of
+ * the canned pairs — the UI uses this to highlight the active radio.
+ */
+export function detectSyncPreset(cfg: RemoteSyncConfig): SyncPreset {
+  for (const p of SYNC_PRESETS) {
+    if (p.id === 'custom') continue;
+    if (
+      cfg.priority_interval_secs === p.priorityInterval &&
+      cfg.interval_secs === p.bulkInterval
+    ) {
+      return p.id;
+    }
+  }
+  return 'custom';
 }
 
 /**
@@ -468,6 +542,14 @@ export const api = {
   getStatus: () => invoke<StatusResponse>('get_status'),
   getConfig: () => invoke<Config>('get_config'),
   saveConfig: (cfg: Config) => invoke<void>('save_config', { cfg }),
+  /**
+   * Apply a named sync-speed preset. Returns the resulting
+   * `RemoteSyncConfig` so callers can refresh local state without a
+   * follow-up `getConfig` round-trip. `"custom"` is a no-op on the
+   * Rust side — handle it UI-side by revealing the raw number inputs.
+   */
+  setSyncPreset: (preset: SyncPreset) =>
+    invoke<RemoteSyncConfig>('set_sync_preset', { preset }),
   getDiscoveredLogs: () => invoke<DiscoveredLog[]>('get_discovered_logs'),
   pairDevice: (apiUrl: string, code: string) =>
     invoke<PairOutcome>('pair_device', { apiUrl, code }),

apps/tray-ui/src/components/SettingsPane.tsx

@@ -3,9 +3,16 @@ import type {
   Config,
   ReleaseChannel,
   RsiCookieStatus,
+  SyncPreset,
   Theme,
 } from '../api';
-import { api, RELEASE_CHANNEL_LABELS, THEMES } from '../api';
+import {
+  api,
+  detectSyncPreset,
+  RELEASE_CHANNEL_LABELS,
+  SYNC_PRESETS,
+  THEMES,
+} from '../api';
 import {
   applyUpdate,
   checkForUpdate,
@@ -464,13 +471,26 @@ export function SettingsPane({ config, onSave }: Props) {
                 updateState.kind === 'installing'
               }
               style={{
-                background: 'var(--bg-2)',
+                // Match the INPUT_BASE pattern from primitives.tsx so
+                // this dropdown sits visually next to the TextInputs
+                // elsewhere on the same card — same surface, radius,
+                // font, and padding contract. The native chrome of
+                // the OPTIONS popup is still browser-controlled
+                // (can't be themed reliably), but the closed-state
+                // control now reads as part of the design system.
+                background: 'var(--bg)',
                 color: 'var(--fg)',
                 border: '1px solid var(--border)',
-                borderRadius: 4,
-                padding: '4px 6px',
+                borderRadius: 'var(--r-sm)',
+                padding: '7px 9px',
+                fontFamily: 'var(--font-mono)',
                 fontSize: 12,
-                fontFamily: 'inherit',
+                outline: 'none',
+                cursor:
+                  updateState.kind === 'checking' ||
+                  updateState.kind === 'installing'
+                    ? 'not-allowed'
+                    : 'pointer',
               }}
             >
               {(Object.keys(RELEASE_CHANNEL_LABELS) as ReleaseChannel[]).map(
@@ -753,14 +773,43 @@ export function SettingsPane({ config, onSave }: Props) {
             )}
           </Field>
 
+          <SyncSpeedSection
+            draft={draft}
+            updateRemote={updateRemote}
+          />
+
           <div
             style={{
               display: 'grid',
-              gridTemplateColumns: '1fr 1fr',
+              gridTemplateColumns: '1fr 1fr 1fr',
               gap: 10,
             }}
           >
-            <Field label="Sync interval">
+            <Field label="Priority interval">
+              <div
+                style={{ display: 'flex', alignItems: 'center', gap: 6 }}
+              >
+                <TextInput
+                  type="number"
+                  min={1}
+                  max={60}
+                  value={draft.remote_sync.priority_interval_secs}
+                  onChange={(e) =>
+                    updateRemote({
+                      priority_interval_secs: Math.max(
+                        1,
+                        Number(e.target.value) || 5,
+                      ),
+                    })
+                  }
+                  style={{ flex: 1 }}
+                />
+                <span style={{ fontSize: 11, color: 'var(--fg-dim)' }}>
+                  sec
+                </span>
+              </div>
+            </Field>
+            <Field label="Bulk interval">
               <div
                 style={{ display: 'flex', alignItems: 'center', gap: 6 }}
               >
@@ -1041,3 +1090,119 @@ function UpdateStatusLine({
       );
   }
 }
+
+interface SyncSpeedSectionProps {
+  draft: Config;
+  updateRemote: (patch: Partial<Config['remote_sync']>) => void;
+}
+
+/**
+ * Radio-card preset picker for sync cadence. The Rust side has a
+ * `set_sync_preset` command but we drive everything through the
+ * existing `updateRemote` flow so the draft stays the single source
+ * of truth — Save commits intervals + the rest in one round-trip.
+ *
+ * The active preset is derived from the current interval pair via
+ * `detectSyncPreset`; a config that doesn't match any named pair
+ * resolves to 'custom' which reveals the raw number inputs (which
+ * are always rendered below anyway — selecting Custom is more of a
+ * visual cue than a mode switch).
+ */
+function SyncSpeedSection({ draft, updateRemote }: SyncSpeedSectionProps) {
+  const active: SyncPreset = detectSyncPreset(draft.remote_sync);
+
+  const onPick = (preset: SyncPreset) => {
+    if (preset === 'custom') {
+      // Custom is a UI marker — keep current intervals as the user
+      // commits to whatever numbers they type below.
+      return;
+    }
+    const choice = SYNC_PRESETS.find((p) => p.id === preset);
+    if (!choice) return;
+    updateRemote({
+      priority_interval_secs: choice.priorityInterval,
+      interval_secs: choice.bulkInterval,
+    });
+  };
+
+  return (
+    <fieldset
+      style={{
+        border: '1px solid var(--border-dim)',
+        borderRadius: 6,
+        padding: '8px 10px',
+        margin: '0 0 10px',
+      }}
+    >
+      <legend
+        style={{
+          padding: '0 6px',
+          fontSize: 11,
+          fontWeight: 600,
+          letterSpacing: 0.4,
+          textTransform: 'uppercase',
+          color: 'var(--fg-dim)',
+        }}
+      >
+        Sync speed
+      </legend>
+      <div
+        role="radiogroup"
+        aria-label="Sync speed preset"
+        style={{
+          display: 'grid',
+          gridTemplateColumns: 'repeat(4, 1fr)',
+          gap: 6,
+        }}
+      >
+        {SYNC_PRESETS.map((p) => {
+          const selected = p.id === active;
+          return (
+            <button
+              key={p.id}
+              type="button"
+              role="radio"
+              aria-checked={selected}
+              onClick={() => onPick(p.id)}
+              style={{
+                background: selected ? 'var(--accent-dim)' : 'transparent',
+                border: `1px solid ${
+                  selected ? 'var(--accent)' : 'var(--border-dim)'
+                }`,
+                borderRadius: 6,
+                padding: '8px 6px',
+                cursor: 'pointer',
+                textAlign: 'left',
+                color: 'var(--fg)',
+                display: 'flex',
+                flexDirection: 'column',
+                gap: 2,
+              }}
+            >
+              <span style={{ fontSize: 12, fontWeight: 600 }}>{p.label}</span>
+              <span style={{ fontSize: 10, color: 'var(--fg-dim)' }}>
+                {p.id === 'custom'
+                  ? 'Pick your own intervals'
+                  : `${p.priorityInterval}s / ${p.bulkInterval}s`}
+              </span>
+            </button>
+          );
+        })}
+      </div>
+      <p
+        style={{
+          margin: '8px 0 0',
+          fontSize: 11,
+          color: 'var(--fg-dim)',
+          lineHeight: 1.4,
+        }}
+      >
+        Priority lane drains{' '}
+        <strong style={{ color: 'var(--fg)' }}>
+          location, deaths, vehicle destruction, quantum target, session end
+        </strong>{' '}
+        on the fast schedule. Everything else waits for the bulk schedule.
+      </p>
+    </fieldset>
+  );
+}

crates/starstats-client/sql/schema.sql

@@ -16,10 +16,28 @@ CREATE TABLE IF NOT EXISTS events (
     -- only ever read/written wholesale (no per-field SQL queries). NULL
     -- means no enrichment has happened for this row yet; that's the
     -- vast-majority case so the storage cost is per-enriched-row only.
-    metadata        TEXT
+    metadata        TEXT,
+    -- Timestamp at which this row was successfully POSTed to the
+    -- StarStats API (and the server returned a 2xx). NULL = still in
+    -- the local outbox. Replaces the global `sync_cursor` model: with
+    -- priority lanes the urgent worker drains specific event_types out
+    -- of monotonic id order, so a single high-water-mark cursor can't
+    -- represent the drain state correctly. Per-row flag lets either
+    -- lane pick its next batch with a simple `WHERE sent_at IS NULL
+    -- [AND type IN (...)]` filter. Existing rows are backfilled at
+    -- migration time from the legacy cursor — see
+    -- `Storage::migrate_events_sent_at`.
+    sent_at         TEXT
 );
 CREATE INDEX IF NOT EXISTS idx_events_type_ts ON events(type, timestamp);
 CREATE INDEX IF NOT EXISTS idx_events_inserted ON events(inserted_at);
+-- The partial index on `events(id) WHERE sent_at IS NULL` is created
+-- by `Storage::migrate_events_sent_at` instead of here. Reason: this
+-- file runs BEFORE the column-add migrations, and SQLite rejects an
+-- index whose WHERE clause references a column that doesn't exist
+-- yet. Keeping the index colocated with the migration also means a
+-- legacy DB that's missing both column and index reaches a
+-- consistent state in one place.
 
 CREATE TABLE IF NOT EXISTS tail_cursor (
     path        TEXT PRIMARY KEY,