@linxin666/dsh-remote-web-ui 0.1.20 → 0.2.1

package/src/mobile/views/App.test.tsx

@@ -0,0 +1,62 @@
+// @vitest-environment jsdom
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { cleanup, render, screen, waitFor } from '@testing-library/react'
+import { RpcTransportError } from '../rpc.ts'
+
+const api = vi.hoisted(() => ({
+  fetchMobilePreferences: vi.fn(),
+  history: vi.fn(),
+  listSessions: vi.fn(),
+  listWorkspaces: vi.fn(),
+  prompt: vi.fn(),
+}))
+
+vi.mock('../api.ts', () => api)
+vi.mock('../mux.ts', () => ({
+  MuxClient: class {
+    start(): void {}
+    stop(): void {}
+    observe(): void {}
+  },
+}))
+vi.mock('./WorkspaceView.tsx', () => ({ WorkspaceView: () => <div>workspace-ready</div> }))
+vi.mock('./SessionListView.tsx', () => ({ SessionListView: () => <div>sessions-ready</div> }))
+vi.mock('./ChatView.tsx', () => ({ ChatView: () => <div>chat-ready</div> }))
+
+import { App, mobilePairStateForError } from './App.tsx'
+
+afterEach(() => {
+  cleanup()
+  vi.clearAllMocks()
+})
+
+describe('mobile paired-device gate', () => {
+  it('distinguishes a missing paired cookie from a transport outage', () => {
+    expect(mobilePairStateForError(new RpcTransportError('HTTP 403'))).toBe('unpaired')
+    expect(mobilePairStateForError(new RpcTransportError('HTTP 503'))).toBe('unavailable')
+    expect(mobilePairStateForError(new Error('offline'))).toBe('unavailable')
+  })
+
+  it('keeps a valid paired context usable after a failed QR token', async () => {
+    api.fetchMobilePreferences.mockResolvedValue({ mobileEnterToSend: true })
+    render(<App initialPairError="配对链接已被使用。" />)
+
+    await waitFor(() => expect(screen.getByText('workspace-ready')).toBeDefined())
+    expect(screen.queryByRole('alert')).toBeNull()
+  })
+
+  it('shows the pairing screen only when the mobile gateway rejects the device', async () => {
+    api.fetchMobilePreferences.mockRejectedValue(new RpcTransportError('HTTP 403'))
+    render(<App initialPairError="配对链接已被使用。" />)
+
+    await waitFor(() => expect(screen.getByRole('alert').textContent).toContain('配对链接已被使用。'))
+  })
+
+  it('shows a retryable connection failure rather than mounting remote views on outage', async () => {
+    api.fetchMobilePreferences.mockRejectedValue(new RpcTransportError('HTTP 503'))
+    render(<App />)
+
+    await waitFor(() => expect(screen.getByRole('alert').textContent).toContain('无法连接到运行中的 DSH host。'))
+    expect(screen.queryByText('workspace-ready')).toBeNull()
+  })
+})

package/src/mobile/views/App.tsx

@@ -7,12 +7,13 @@
 
 import { useCallback, useEffect, useRef, useState } from 'react'
 import type { WorkspaceView as WorkspaceRow } from '@deepseek-ai/dsh-host-apiproxy/api/workspace'
-import { history as fetchHistory, listSessions, listWorkspaces, prompt } from '../api.ts'
+import { fetchMobilePreferences, history as fetchHistory, listSessions, listWorkspaces, prompt } from '../api.ts'
 import { MuxClient } from '../mux.ts'
 import { RpcCallError, RpcTransportError } from '../rpc.ts'
 import { ChatView } from './ChatView.tsx'
 import { SessionListView } from './SessionListView.tsx'
 import { WorkspaceView as WorkspaceRoster } from './WorkspaceView.tsx'
+import { PairRequiredView } from '../PairRequiredView.tsx'
 
 /** One navigation level. */
 type Route =
@@ -71,11 +72,57 @@ export function formatTime(epochMs: number): string {
   return `${String(date.getMonth() + 1)}月${String(date.getDate())}日 ${clock}`
 }
 
-/**
- * The surface root.
- * @returns the app tree.
- */
-export function App() {
+/** Props accepted by the mobile root before it begins paired-device RPC calls. */
+export interface AppProps {
+  initialPairError?: string
+}
+
+/** Whether the mobile gateway rejected this browser for lack of a paired cookie. */
+export function isUnpairedMobileError(error: unknown): boolean {
+  return error instanceof RpcTransportError && error.message === 'HTTP 403'
+}
+
+/** The result of probing the paired-device-only mobile preference endpoint. */
+export type MobilePairState = 'checking' | 'paired' | 'unpaired' | 'unavailable'
+
+/** Classify an initial mobile preference failure without treating outage as authorization. */
+export function mobilePairStateForError(error: unknown): Extract<MobilePairState, 'unpaired' | 'unavailable'> {
+  return isUnpairedMobileError(error) ? 'unpaired' : 'unavailable'
+}
+
+/** Gate the independent mobile bundle until its own browser context is paired. */
+export function App({ initialPairError }: AppProps) {
+  const [pairState, setPairState] = useState<MobilePairState>('checking')
+
+  useEffect(() => {
+    let current = true
+    void fetchMobilePreferences().then(
+      () => { if (current) setPairState('paired') },
+      (error: unknown) => { if (current) setPairState(mobilePairStateForError(error)) },
+    )
+    return () => { current = false }
+  }, [])
+
+  if (pairState === 'checking') {
+    return <main className="mobile mobile-empty"><p className="mobile-muted">正在连接...</p></main>
+  }
+  if (pairState === 'unpaired') {
+    return <PairRequiredView initialError={initialPairError} onPaired={(path) => { window.location.replace(path) }} />
+  }
+  if (pairState === 'unavailable') {
+    return (
+      <main className="mobile mobile-empty">
+        <p className="mobile-error" role="alert">无法连接到运行中的 DSH host。</p>
+        <button className="mobile-new" type="button" onClick={() => { window.location.reload() }}>重试</button>
+      </main>
+    )
+  }
+
+  return <PairedApp />
+}
+
+/** The existing remote mobile surface, mounted only after device pairing succeeds. */
+function PairedApp() {
   const [route, setRoute] = useState<Route>({ kind: 'workspaces' })
   const [initialWorkspaceId, setInitialWorkspaceId] = useState<string | undefined>(
     () => mobileWorkspaceTarget(window.location.search),

package/src/mobile/views/ChatView.tsx

@@ -11,13 +11,13 @@
  *   permission pickers, both as bottom sheets.
  */
 
-import { useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from 'react'
+import { memo, useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from 'react'
 import type { MuxFrame } from '@deepseek-ai/dsh-host-apiproxy/api/events'
 import type { SessionModels } from '@deepseek-ai/dsh-host-apiproxy/api/sessions'
 import { loadHistory, prompt, type SessionView } from './App.tsx'
 import { errorText, formatTime, staleHostHint } from './App.tsx'
 import { fetchMobilePreferences, models, selectModel, sendCommand } from '../api.ts'
-import { foldEvents, type RenderMessage, type ToolCallInfo, type WireEvent } from '../messages.ts'
+import { EventFolder, foldEvents, type RenderMessage, type ToolCallInfo, type WireEvent } from '../messages.ts'
 import { renderMarkdown } from '../markdown.ts'
 import { MuxClient } from '../mux.ts'
 import { ThemeToggle } from '../theme-toggle.tsx'
@@ -144,6 +144,8 @@ export function ChatView({ session, mux, onBack }: ChatViewProps) {
   const tailLoadingRef = useRef(true)
   /** Live session events buffered while the initial tail page loads. */
   const liveBufferRef = useRef<WireEvent[]>([])
+  /** Incremental folder for this session's stream (indexes stay hot across events). */
+  const folderRef = useRef<EventFolder | undefined>(undefined)
   /** True once the live buffer hit its cap (oldest events were dropped). */
   const liveBufferOverflowRef = useRef(false)
 
@@ -188,6 +190,7 @@ export function ChatView({ session, mux, onBack }: ChatViewProps) {
     tailLoadingRef.current = true
     liveBufferRef.current = []
     liveBufferOverflowRef.current = false
+    folderRef.current = undefined
     setLoading(true)
     setError(undefined)
     setMessages([])
@@ -199,7 +202,9 @@ export function ChatView({ session, mux, onBack }: ChatViewProps) {
         const buffered = liveBufferRef.current
         liveBufferRef.current = []
         tailLoadingRef.current = false
-        setMessages(foldEvents(buffered, foldEvents(page.events.map(eventOf))))
+        const folder = new EventFolder(foldEvents(page.events.map(eventOf)))
+        folderRef.current = folder
+        setMessages(folder.fold(buffered))
         setHasOlder(page.hasMore)
         setLoading(false)
         // The history-tail projection baseline seeds the permission picker.
@@ -215,7 +220,9 @@ export function ChatView({ session, mux, onBack }: ChatViewProps) {
           void loadHistory(session.sessionId, undefined, controller.signal).then(
             (fresh) => {
               if (cancelled) return
-              setMessages(previous => foldEvents(fresh.events.map(eventOf), previous))
+              const folder = folderRef.current
+              const freshEvents = fresh.events.map(eventOf)
+              setMessages(previous => folder === undefined ? foldEvents(freshEvents, previous) : folder.fold(freshEvents))
               liveBufferOverflowRef.current = false
             },
             (reason: unknown) => {
@@ -231,7 +238,10 @@ export function ChatView({ session, mux, onBack }: ChatViewProps) {
         const buffered = liveBufferRef.current
         liveBufferRef.current = []
         tailLoadingRef.current = false
-        if (buffered.length > 0) setMessages(foldEvents(buffered))
+        if (buffered.length > 0) {
+          const folder = folderRef.current
+          setMessages(folder === undefined ? foldEvents(buffered) : folder.fold(buffered))
+        }
         setError(errorText(reason))
         setLoading(false)
       },
@@ -274,7 +284,10 @@ export function ChatView({ session, mux, onBack }: ChatViewProps) {
           liveBufferRef.current.push(event)
           return
         }
-        setMessages(previous => foldEvents([event], previous))
+        setMessages(previous => {
+          const folder = folderRef.current
+          return folder === undefined ? foldEvents([event], previous) : folder.fold([event])
+        })
         return
       }
       // Live projection pushes keep the permission picker current.
@@ -330,7 +343,13 @@ export function ChatView({ session, mux, onBack }: ChatViewProps) {
         pendingRef.current = false
         setLoading(false)
         const older = foldEvents(page.events.map(eventOf))
-        setMessages(previous => [...older, ...previous])
+        const folder = folderRef.current
+        if (folder === undefined) {
+          setMessages(previous => [...older, ...previous])
+        } else {
+          folder.prepend(older)
+          setMessages(folder.snapshot())
+        }
         setHasOlder(page.hasMore)
       },
       (reason: unknown) => {
@@ -481,8 +500,12 @@ export function ChatView({ session, mux, onBack }: ChatViewProps) {
 
 /* ── message rows ─────────────────────────────────────────────────────── */
 
-/** One rendered message row (user bubble or assistant bubble with folds). */
-function MessageRow({ message, showToolCalls, showSystemMessages }: {
+/**
+ * One rendered message row (user bubble or assistant bubble with folds).
+ * Memoized: live streaming updates exactly one message object per frame, so
+ * unchanged rows skip re-rendering their markdown/sub-components.
+ */
+const MessageRow = memo(function MessageRow({ message, showToolCalls, showSystemMessages }: {
   message: RenderMessage
   showToolCalls: boolean
   showSystemMessages: boolean
@@ -510,7 +533,7 @@ function MessageRow({ message, showToolCalls, showSystemMessages }: {
       <span className="chat-msg-time">{formatTime(message.time)}</span>
     </div>
   )
-}
+})
 
 /** Collapsed-by-default reasoning disclosure (web-UI Think-row parity). */
 function ReasoningDisclosure({ text, pending }: { text: string; pending: boolean }) {

package/src/mobile/views/SessionListView.test.tsx

@@ -10,12 +10,14 @@ import { type SessionView } from './App.tsx'
 vi.mock('../api.ts', () => ({
   listSessions: vi.fn(),
   listWorkspaces: vi.fn(),
+  listAgentPresets: vi.fn(),
   createSession: vi.fn(),
 }))
-import { createSession, listSessions, listWorkspaces } from '../api.ts'
+import { createSession, listAgentPresets, listSessions, listWorkspaces } from '../api.ts'
 
 const listSessionsMock = vi.mocked(listSessions)
 const listWorkspacesMock = vi.mocked(listWorkspaces)
+const listAgentPresetsMock = vi.mocked(listAgentPresets)
 const createSessionMock = vi.mocked(createSession)
 
 const workspace: WorkspaceRow = {
@@ -49,6 +51,7 @@ function renderList(props: Partial<SessionListViewProps> = {}): void {
 beforeEach(() => {
   listSessionsMock.mockResolvedValue({ items: [], hasMore: false })
   listWorkspacesMock.mockResolvedValue([workspace])
+  listAgentPresetsMock.mockResolvedValue({ presets: [], authorable: false, hasDocument: false })
   createSessionMock.mockResolvedValue({ sessionId: 's-new' })
 })
 
@@ -111,6 +114,71 @@ describe('SessionListView creation', () => {
     expect(await screen.findByText('新会话')).toBeTruthy()
   })
 
+  it('creates the session with the selected agent preset', async () => {
+    listAgentPresetsMock.mockResolvedValue({
+      presets: [
+        { id: 'router-standard', name: 'Router Standard', trust: 'system', isDefault: true },
+        { id: 'router-spec', name: 'Router Spec', description: '规格驱动模式', trust: 'system', isDefault: false },
+      ],
+      authorable: false,
+      hasDocument: false,
+    })
+    renderList()
+
+    const picker = await screen.findByRole('combobox', { name: 'Agent 模式' })
+    expect((picker as HTMLSelectElement).value).toBe('router-standard')
+    fireEvent.change(picker, { target: { value: 'router-spec' } })
+    fireEvent.click(screen.getByRole('button', { name: '+ 新建会话' }))
+
+    await waitFor(() => {
+      expect(createSessionMock).toHaveBeenCalledWith({ workspaceId: 'w-1', agentPreset: 'router-spec' })
+    })
+    expect(await screen.findByText('规格驱动模式')).toBeTruthy()
+  })
+
+  it('skips a broken default preset and disables it in the picker', async () => {
+    listAgentPresetsMock.mockResolvedValue({
+      presets: [
+        { id: 'broken-default', trust: 'system', isDefault: true, broken: 'missing plugin' },
+        { id: 'local-router', name: 'Local Router', trust: 'user', isDefault: false },
+      ],
+      authorable: false,
+      hasDocument: false,
+    })
+    renderList()
+
+    const picker = await screen.findByRole('combobox', { name: 'Agent 模式' }) as HTMLSelectElement
+    expect(picker.value).toBe('local-router')
+    expect(screen.getByRole('option', { name: 'broken-default（默认）（不可用）' }).hasAttribute('disabled')).toBe(true)
+    expect(screen.getByRole('option', { name: 'Local Router（本地）' })).toBeTruthy()
+  })
+
+  it('keeps default session creation available when the preset roster fails', async () => {
+    listAgentPresetsMock.mockRejectedValue(new Error('preset roster unavailable'))
+    renderList()
+    await screen.findByText(/还没有会话/)
+
+    const button = await screen.findByRole('button', { name: '+ 新建会话' })
+    await waitFor(() => { expect(button.hasAttribute('disabled')).toBe(false) })
+    fireEvent.click(button)
+
+    await waitFor(() => {
+      expect(createSessionMock).toHaveBeenCalledWith({ workspaceId: 'w-1' })
+    })
+  })
+
+  it('waits for the preset roster before enabling session creation', async () => {
+    let resolvePresets: (value: Awaited<ReturnType<typeof listAgentPresets>>) => void = () => {}
+    listAgentPresetsMock.mockReturnValue(new Promise(resolve => { resolvePresets = resolve }))
+    renderList()
+
+    const button = screen.getByRole('button', { name: '+ 新建会话' })
+    expect(button.hasAttribute('disabled')).toBe(true)
+
+    resolvePresets({ presets: [], authorable: false, hasDocument: false })
+    await waitFor(() => { expect(button.hasAttribute('disabled')).toBe(false) })
+  })
+
   it('keeps the button disabled while a creation is in flight', async () => {
     let resolveCreate: (value: { sessionId: string }) => void = () => {}
     createSessionMock.mockReturnValue(new Promise(resolve => { resolveCreate = resolve }))

package/src/mobile/views/SessionListView.tsx

@@ -13,8 +13,9 @@
 
 import { useCallback, useEffect, useRef, useState } from 'react'
 import type { WorkspaceView as WorkspaceRow } from '@deepseek-ai/dsh-host-apiproxy/api/workspace'
+import type { AgentPresetEntry } from '@deepseek-ai/dsh-host-apiproxy/api/agent-presets'
 import type { SessionSummary } from '@deepseek-ai/dsh-host-apiproxy/api/sessions'
-import { createSession, listSessions, listWorkspaces } from '../api.ts'
+import { createSession, listAgentPresets, listSessions, listWorkspaces } from '../api.ts'
 import { errorText, formatTime, staleHostHint, toSessionView, type SessionView } from './App.tsx'
 import { ThemeToggle } from '../theme-toggle.tsx'
 
@@ -45,6 +46,9 @@ export function SessionListView({ workspace, onBack, onPick }: SessionListViewPr
   const [error, setError] = useState<string | undefined>(undefined)
   const [creating, setCreating] = useState(false)
   const [createError, setCreateError] = useState<string | undefined>(undefined)
+  const [presets, setPresets] = useState<readonly AgentPresetEntry[]>([])
+  const [selectedPreset, setSelectedPreset] = useState<string | undefined>(undefined)
+  const [presetsLoading, setPresetsLoading] = useState(true)
   const cursorRef = useRef<string | undefined>(undefined)
   const busyRef = useRef(false)
 
@@ -74,6 +78,27 @@ export function SessionListView({ workspace, onBack, onPick }: SessionListViewPr
     return () => { cancelled = true }
   }, [workspace])
 
+  useEffect(() => {
+    let cancelled = false
+    setPresets([])
+    setSelectedPreset(undefined)
+    setPresetsLoading(true)
+    void listAgentPresets().then(
+      (roster) => {
+        if (cancelled) return
+        const usable = roster.presets.filter(preset => preset.broken === undefined)
+        setPresets(roster.presets)
+        setSelectedPreset((usable.find(preset => preset.isDefault) ?? usable[0])?.id)
+        setPresetsLoading(false)
+      },
+      () => {
+        if (cancelled) return
+        setPresetsLoading(false)
+      },
+    )
+    return () => { cancelled = true }
+  }, [workspace])
+
   /** Pull the next page and append the rows that belong to this workspace. */
   const loadMore = useCallback(() => {
     if (busyRef.current) return
@@ -102,7 +127,10 @@ export function SessionListView({ workspace, onBack, onPick }: SessionListViewPr
     if (creating) return
     setCreating(true)
     setCreateError(undefined)
-    void createSession({ workspaceId: workspace.workspaceId }).then(
+    void createSession({
+      workspaceId: workspace.workspaceId,
+      ...(selectedPreset !== undefined ? { agentPreset: selectedPreset } : {}),
+    }).then(
       (created) => {
         setCreating(false)
         const view: SessionView = {
@@ -120,9 +148,10 @@ export function SessionListView({ workspace, onBack, onPick }: SessionListViewPr
         setCreateError(errorText(reason))
       },
     )
-  }, [creating, workspace, onPick])
+  }, [creating, workspace, onPick, selectedPreset])
 
   const createHint = createError !== undefined ? staleHostHint(createError) : undefined
+  const selectedPresetEntry = presets.find(preset => preset.id === selectedPreset)
 
   return (
     <div className="mobile">
@@ -132,11 +161,35 @@ export function SessionListView({ workspace, onBack, onPick }: SessionListViewPr
         <ThemeToggle />
       </header>
       {error !== undefined && <p className="mobile-error mobile-pad">{error}</p>}
-      <div className="mobile-pad">
+      <div className="mobile-create mobile-pad">
+        {presets.length > 0 && (
+          <label className="mobile-preset">
+            <span className="mobile-presetLabel">Agent 模式</span>
+            <select
+              className="mobile-presetSelect"
+              value={selectedPreset ?? ''}
+              disabled={selectedPreset === undefined}
+              onChange={(event) => { setSelectedPreset(event.target.value) }}
+            >
+              {selectedPreset === undefined && <option value="">无可用 Agent 模式</option>}
+              {presets.map(preset => (
+                <option key={preset.id} value={preset.id} disabled={preset.broken !== undefined}>
+                  {preset.name ?? preset.id}
+                  {preset.isDefault ? '（默认）' : ''}
+                  {preset.trust === 'user' ? '（本地）' : ''}
+                  {preset.broken !== undefined ? '（不可用）' : ''}
+                </option>
+              ))}
+            </select>
+          </label>
+        )}
+        {selectedPresetEntry?.description !== undefined && (
+          <p className="mobile-presetDescription">{selectedPresetEntry.description}</p>
+        )}
         <button
           type="button"
           className="mobile-new"
-          disabled={creating}
+          disabled={creating || presetsLoading}
           onClick={() => { void handleCreate() }}
         >
           {creating ? '创建中…' : '+ 新建会话'}

package/src/mobile/views/WorkspaceView.tsx

@@ -27,6 +27,8 @@ export interface WorkspaceViewProps {
 export function WorkspaceView({ initialWorkspaceId, onPick }: WorkspaceViewProps) {
   const [items, setItems] = useState<WorkspaceRow[] | undefined>(undefined)
   const [error, setError] = useState<string | undefined>(undefined)
+  // Bumped by the retry button to re-run the roster fetch effect.
+  const [reload, setReload] = useState(0)
 
   useEffect(() => {
     let cancelled = false
@@ -48,7 +50,7 @@ export function WorkspaceView({ initialWorkspaceId, onPick }: WorkspaceViewProps
       },
     )
     return () => { cancelled = true }
-  }, [initialWorkspaceId, onPick])
+  }, [initialWorkspaceId, onPick, reload])
 
   if (error !== undefined) {
     return (
@@ -59,7 +61,7 @@ export function WorkspaceView({ initialWorkspaceId, onPick }: WorkspaceViewProps
         </header>
         <div className="mobile-empty">
           <p className="mobile-error">加载失败：{error}</p>
-          <button type="button" className="mobile-button" onClick={() => { setError(undefined); setItems(undefined) }}>
+          <button type="button" className="mobile-button" onClick={() => { setError(undefined); setItems(undefined); setReload(n => n + 1) }}>
             重试
           </button>
         </div>

package/src/mobile-api.ts

@@ -28,9 +28,16 @@ import type { PairingService } from './pairing.ts'
 import { readBoundedJson, writeJson } from './http.ts'
 import { readCookie } from './gate.ts'
 
-/** Methods the phone surface may call. Everything else is refused. */
+/**
+ * Methods the phone surface may call. Everything else is refused HERE — but
+ * note the paired-device cookie also passes the global api/gate for the full
+ * ApiProxy surface (gate.ts), so a paired phone is a full-control credential:
+ * the allowlist only constrains this /m/api proxy, not the cookie's reach.
+ * stop() revokes every device; there is no per-device revocation yet.
+ */
 const MOBILE_ALLOWLIST = new Set([
   'workspace.list',
+  'agentPreset.list',
   'session.create',
   'session.list',
   'session.history',
@@ -292,6 +299,7 @@ async function dispatch(apiProxy: ApiProxy, method: string, payload: unknown, rp
     result: response.result,
   })
   if (method === 'workspace.list') return wrap(await apiProxy.workspace.list(request as never))
+  if (method === 'agentPreset.list') return wrap(await apiProxy.agentPresets.list(request as never))
   if (method === 'session.create') return wrap(await apiProxy.sessions.create(request as never))
   if (method === 'session.history') return wrap(await apiProxy.sessions.history(request as never))
   if (method === 'session.search') return wrap(await apiProxy.sessions.search(request as never, signal ?? new AbortController().signal))

package/src/mobile-pwa.ts

@@ -0,0 +1,19 @@
+/** PWA registration for the standalone /m mobile surface. */
+export const MOBILE_PWA_SCOPE = '/m/'
+export const MOBILE_SERVICE_WORKER_URL = '/m/service-worker.js'
+
+/** Register the mobile shell worker when the current browser supports it. */
+export async function registerMobilePwa(
+  serviceWorker: Pick<ServiceWorkerContainer, 'register'> | undefined = typeof navigator === 'undefined' ? undefined : navigator.serviceWorker,
+): Promise<void> {
+  if (serviceWorker === undefined) return
+
+  try {
+    await serviceWorker.register(MOBILE_SERVICE_WORKER_URL, {
+      scope: MOBILE_PWA_SCOPE,
+      updateViaCache: 'none',
+    })
+  } catch {
+    // HTTP LAN origins cannot register workers; the online mobile UI still works.
+  }
+}