@linxin666/dsh-remote-web-ui 0.3.6 → 0.3.10

package/src/client/RemoteEntry.tsx

@@ -9,7 +9,7 @@
  */
 import { useCallback, useEffect, useRef, useState } from 'react'
 import { createPortal } from 'react-dom'
-import type { PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots'
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots'
 import type { PairingPhase } from '../pairing.ts'
 import { RemotePanel, type PanelState } from './RemotePanel.tsx'
 import { copyText, issuePair, revokePair, stopPair, type DeviceFrame, type IssueResponse, type PairStateFrame, type TunnelStatusFrame } from './pair-api.ts'
@@ -17,8 +17,11 @@ import { PhoneIcon } from './PhoneIcon.tsx'
 import { UpdateEntry } from './UpdateEntry.tsx'
 import css from './remote.module.css'
 
-/** Entry props: the sidebar column state + the standard locale seat. */
-export type RemoteEntryProps = PropsRuntime<'sidebar.remote'> & PropsLocale<'remote'>
+/** Entry props: the sidebar column state and the standard locale seat. */
+export type RemoteEntryProps = PropsLocale<'remote'> & {
+  /** Whether the sidebar renders wide content (false = 56px rail). */
+  wide: boolean
+}
 
 /**
  * Apply one status frame onto the current state: the ready state mirrors
@@ -49,7 +52,7 @@ function mergeFrame(state: PanelState, frame: PairStateFrame): PanelState {
  * @param props - composed slot props (contract in this package).
  * @returns the entry element tree.
  */
-export function RemoteEntry({ wide, useWorkspaces, t }: RemoteEntryProps) {
+export function RemoteEntry({ wide, t }: RemoteEntryProps) {
   const [open, setOpen] = useState(false)
   const [state, setState] = useState<PanelState>({ kind: 'lan-required' })
   // Latest-state mirror for the EventSource callback: transition detection
@@ -57,17 +60,13 @@ export function RemoteEntry({ wide, useWorkspaces, t }: RemoteEntryProps) {
   // pure), so mint decisions read this ref instead.
   const stateRef = useRef(state)
   useEffect(() => { stateRef.current = state }, [state])
-  const [copied, setCopied] = useState<'phone' | 'desktop' | undefined>(undefined)
+  const [copied, setCopied] = useState<boolean>(false)
   const eventSource = useRef<EventSource | undefined>(undefined)
   // Generation counter for the open flow: closing (or re-opening) the panel
   // bumps it, so an in-flight issue() that resolves after a close does not
   // spawn a stray EventSource.
   const openSeq = useRef(0)
 
-  // The current workspace (the recent-workspace projection the shell's New
-  // Session flow targets) — the deep-link target for the phone.
-  const workspaceId = useWorkspaces(s => s.recentWorkspaceId)
-
   const closeEventSource = useCallback(() => {
     eventSource.current?.close()
     eventSource.current = undefined
@@ -76,7 +75,7 @@ export function RemoteEntry({ wide, useWorkspaces, t }: RemoteEntryProps) {
   const mint = useCallback(async (address?: string): Promise<PanelState> => {
     let result: IssueResponse
     try {
-      result = await issuePair(workspaceId, address)
+      result = await issuePair(address)
     } catch {
       // Fetch/network failure: show an explicit state instead of silently
       // leaving the panel on its initial banner.
@@ -108,7 +107,7 @@ export function RemoteEntry({ wide, useWorkspaces, t }: RemoteEntryProps) {
       address: address ?? result.lanAddresses[0] ?? '',
       lanAddresses: result.lanAddresses,
     }
-  }, [workspaceId])
+  }, [])
 
   const openPanel = useCallback(async (): Promise<void> => {
     const seq = ++openSeq.current
@@ -207,11 +206,11 @@ export function RemoteEntry({ wide, useWorkspaces, t }: RemoteEntryProps) {
     void mint().then(setState)
   }, [mint])
 
-  const handleCopy = useCallback((target: 'phone' | 'desktop', url: string) => {
+  const handleCopy = useCallback((url: string) => {
     void copyText(url).then((ok) => {
       if (!ok) return
-      setCopied(target)
-      window.setTimeout(() => { setCopied(undefined) }, 1500)
+      setCopied(true)
+      window.setTimeout(() => { setCopied(false) }, 1500)
     })
   }, [])
 

package/src/client/RemotePanel.tsx

@@ -12,7 +12,6 @@ import {
 import type { TranslateNS } from '@deepseek-ai/dsh-client-ui-slots'
 import type { PairingPhase } from '../pairing.ts'
 import {
-  desktopPairUrl,
   formatClock,
   formatLastSeen,
   type DeviceFrame,
@@ -55,11 +54,11 @@ export type PanelState =
 export interface RemotePanelProps {
   t: TranslateNS<'remote'>
   state: PanelState
-  copied: 'phone' | 'desktop' | undefined
+  copied: boolean
   onClose(): void
   onStop(): void
   onRefresh(): void
-  onCopy(target: 'phone' | 'desktop', url: string): void
+  onCopy(url: string): void
   /** Re-mint the QR against a different LAN address. */
   onPickAddress(address: string): void
   /** Re-mint the QR against the configured public (tunneled) base. */
@@ -147,22 +146,12 @@ export function RemotePanel({ t, state, copied, onClose, onStop, onRefresh, onCo
           <div className={css.pairLinks}>
             <div className={css.pairLinkRow}>
               <div className={css.pairLinkText}>
-                <span className={css.pairLinkLabel}>{t('pair.phoneLabel')}</span>
+                <span className={css.pairLinkLabel}>{t('pair.linkLabel')}</span>
                 <code className={css.link} title={state.url}>{state.url}</code>
               </div>
-              <button type="button" className={css.copyLink} onClick={() => onCopy('phone', state.url)}>
+              <button type="button" className={css.copyLink} onClick={() => onCopy(state.url)}>
                 <IconCopyOutline16 size={14} />
-                {copied === 'phone' ? t('action.copied') : t('action.copyPhone')}
-              </button>
-            </div>
-            <div className={css.pairLinkRow}>
-              <div className={css.pairLinkText}>
-                <span className={css.pairLinkLabel}>{t('pair.desktopLabel')}</span>
-                <code className={css.link} title={desktopPairUrl(state.url)}>{desktopPairUrl(state.url)}</code>
-              </div>
-              <button type="button" className={css.copyLink} onClick={() => onCopy('desktop', desktopPairUrl(state.url))}>
-                <IconCopyOutline16 size={14} />
-                {copied === 'desktop' ? t('action.copied') : t('action.copyDesktop')}
+                {copied ? t('action.copied') : t('action.copyLink')}
               </button>
             </div>
           </div>

package/src/client/RemoteSettingsCard.tsx

@@ -4,10 +4,14 @@
  * renders, bound to the `remote-web-ui` settings namespace.
  */
 
+import { useEffect, useState } from 'react'
 import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots'
-import type { SettingsScope, SnapshotStore } from '@deepseek-ai/dsh-client-runtime/client'
+import type { SettingsScope } from '@deepseek-ai/dsh-client-ui-settings/client'
+import type { SnapshotStore } from '@deepseek-ai/dsh-client-store'
 import { PluginSettingsCard, ValueField, BooleanField } from './PluginSettingsCard.tsx'
 import { CardForm, booleanField, numberField, textField, type CardActions, type CardShell, type FieldState as CardFieldState } from './settings-form.ts'
+import { readLanBindStatus, type LanBindFrame } from './pair-api.ts'
+import type { TranslateNS } from '@deepseek-ai/dsh-client-ui-slots'
 
 /** The remote-control fields this card edits (the namespace's full schema). */
 export interface RemoteSettings {
@@ -29,8 +33,11 @@ export interface RemoteSettings {
   publicBaseUrl?: string
   /** When on, the plugin runs its own Cloudflare quick tunnel automatically. */
   autoTunnel?: boolean
-  /** Mobile composer: plain Enter sends; off means Enter inserts a newline. */
-  mobileEnterToSend?: boolean
+  /**
+   * LAN bind toggle: once flipped, the plugin manages the profile patch's
+   * webserver block (0.0.0.0 / 127.0.0.1) and the host firewall rule.
+   */
+  lanBind?: boolean
 }
 
 /** What the remote-control card renders. */
@@ -53,8 +60,8 @@ export interface RemoteSettingsCardState extends CardShell {
   publicBaseUrl: CardFieldState
   /** Auto public tunnel switch. */
   autoTunnel: CardFieldState
-  /** Mobile composer Enter-to-send switch. */
-  mobileEnterToSend: CardFieldState
+  /** LAN bind toggle. */
+  lanBind: CardFieldState
 }
 
 /** The registration-side face the card's slot entry injects. */
@@ -82,7 +89,7 @@ export class RemoteSettingsCardController {
       booleanField('requirePairingForLan'),
       textField('publicBaseUrl'),
       booleanField('autoTunnel'),
-      booleanField('mobileEnterToSend'),
+      booleanField('lanBind'),
     ])
     this.store = this.form.bind(() => this.projection())
   }
@@ -99,7 +106,7 @@ export class RemoteSettingsCardController {
       requirePairingForLan: this.form.field('requirePairingForLan'),
       publicBaseUrl: this.form.field('publicBaseUrl'),
       autoTunnel: this.form.field('autoTunnel'),
-      mobileEnterToSend: this.form.field('mobileEnterToSend'),
+      lanBind: this.form.field('lanBind'),
     }
   }
 
@@ -246,18 +253,70 @@ export function RemoteSettingsCard(props: RemoteSettingsCardProps) {
         onEdit={(text) => { props.edit('autoTunnel', text) }}
         onReset={() => { props.resetField('autoTunnel') }}
       />
+      <LanBindStatus t={t} />
       <BooleanField
-        id="settings-remote-mobile-enter"
-        label={t('settings.mobileEnterToSend')}
-        hint={t('settings.mobileEnterToSendHint')}
+        id="settings-remote-lan-bind"
+        label={t('settings.lanBind')}
+        hint={t('settings.lanBindHint')}
         inheritLabel={t('settings.inherit')}
         onLabel={t('settings.on')}
         offLabel={t('settings.off')}
         {...fieldProps}
-        {...state.mobileEnterToSend}
-        onEdit={(text) => { props.edit('mobileEnterToSend', text) }}
-        onReset={() => { props.resetField('mobileEnterToSend') }}
+        {...state.lanBind}
+        onEdit={(text) => { props.edit('lanBind', text) }}
+        onReset={() => { props.resetField('lanBind') }}
       />
     </PluginSettingsCard>
   )
 }
+
+/**
+ * Live LAN-bind facts above the toggle: the managed block's host, the live
+ * bind, the firewall summary, and the reachable LAN URLs. Polls the
+ * loopback-only status endpoint; a failure (non-loopback origin) renders
+ * nothing — the pairing panel carries the loopback banner instead.
+ */
+function LanBindStatus({ t }: { t: TranslateNS<'remote'> }) {
+  const [frame, setFrame] = useState<LanBindFrame | undefined>(undefined)
+  useEffect(() => {
+    let alive = true
+    const read = (): void => {
+      void readLanBindStatus().then((value) => {
+        if (alive) setFrame(value)
+      }).catch(() => {})
+    }
+    read()
+    const timer = window.setInterval(read, 10_000)
+    return () => {
+      alive = false
+      window.clearInterval(timer)
+    }
+  }, [])
+  if (frame === undefined) return null
+  const lanOn = frame.blockHost === '0.0.0.0'
+  const firewallText = frame.firewall.managed
+    ? t(frame.firewall.ok ? 'lan.firewall.ok' : 'lan.firewall.bad')
+    : t('lan.firewall.unmanaged')
+  const lines: string[] = [
+    t('lan.bind', { host: frame.bindHost, port: String(frame.port) }) + ' · ' + firewallText,
+  ]
+  if (lanOn && frame.lanUrls.length > 0) {
+    lines.push(t('lan.urls', { urls: frame.lanUrls.join('  ') }))
+  }
+  if (!lanOn) {
+    lines.push(t('lan.off'))
+  }
+  if (frame.setting === null) {
+    lines.push(t('lan.untouched'))
+  }
+  if (frame.pendingRestart === true) {
+    lines.push(t('lan.pendingRestart'))
+  }
+  return (
+    <div style={{ display: 'flex', flexDirection: 'column', gap: 2, fontSize: 12, lineHeight: '18px', opacity: 0.85 }}>
+      {lines.map((line, index) => (
+        <div key={index} style={{ wordBreak: 'break-all' }}>{line}</div>
+      ))}
+    </div>
+  )
+}

package/src/client/deep-link.ts

@@ -1,25 +1,19 @@
 /**
- * Phone-side boot flow: the QR link's `pair` + `workspace` parameters.
- * Runs from the client apply on every page load, on any device:
- * - `pair` present → accept the token, then reload so the whole SPA boots
- *   with the device cookie (the accept endpoint is exempt from the pairing
- *   gate; every other /api request needs the cookie).
- * - `workspace` present (and paired) → deep-link: connect that workspace's
- *   session and open it, then strip the parameter.
- * Failure of accept leaves a sessionStorage marker the entry renders as a
- * one-time notice.
+ * Pair boot flow: the QR link's `pair` parameter. Runs from the client
+ * apply on every page load, on any device: `pair` present → accept the
+ * token, then reload so the whole SPA boots with the device cookie (the
+ * accept endpoint is exempt from the pairing gate; every other /api request
+ * needs the cookie). Every device — phone or PC — lands on the same official
+ * Web GUI; phones get the injected portrait adaptation. Failure of accept
+ * leaves a sessionStorage marker the entry renders as a one-time notice.
  */
 
 import type { Context } from '@deepseek-ai/cordis'
-import type { WorkspaceId } from '@deepseek-ai/dsh-client-runtime/client'
 import { acceptPair, readPairParams } from './pair-api.ts'
 
 /** sessionStorage key for the failed-pair notice. */
 export const PAIR_FAILED_MARKER = 'dsh-remote-pair-failed'
 
-/** Poll budget for the runtime services (activation order is unconstrained). */
-const SERVICE_WAIT_MS = 10_000
-
 /**
  * The page-navigation surface the boot flow drives. Browser pages use the
  * default (window.location/history); tests inject a fake.
@@ -51,30 +45,22 @@ export const browserPage: PageSurface = {
   },
 }
 
-/** Whether this browser looks like a phone/tablet (the simplified mobile surface). */
-export function isMobileSurface(): boolean {
-  if (typeof navigator === 'undefined') return false
-  return /Android|iPhone|iPad|iPod|Mobile|mobile/i.test(navigator.userAgent)
-}
-
 /**
- * Run the pair/workspace boot flow for this page load.
- * @param ctx - client root context (workspaces/sessions read at need time).
+ * Run the pair boot flow for this page load.
+ * @param ctx - client root context (unused since the deep-link retirement;
+ * kept for call-site stability).
  * @param search - the current location.search.
  * @param page - the page surface (defaults to the browser).
  */
 export function runPairBootFlow(ctx: Context, search: string, page: PageSurface = browserPage): void {
+  void ctx
   const params = readPairParams(search)
   if (params.pair !== undefined) {
     void runAccept(params.pair, page)
-    return
-  }
-  if (params.workspace !== undefined) {
-    void runDeepLink(ctx, params.workspace, page)
   }
 }
 
-/** Accept the token, then enter the matching desktop/mobile surface. */
+/** Accept the token, then reload into the paired official UI. */
 async function runAccept(token: string, page: PageSurface): Promise<void> {
   let ok = false
   try {
@@ -90,54 +76,7 @@ async function runAccept(token: string, page: PageSurface): Promise<void> {
   url.searchParams.delete('pair')
   page.replaceState(`${url.pathname}${url.search}${url.hash}`)
   if (ok) {
-    // Phones land on the standalone simplified surface (the full desktop UI
-    // is not built for small screens). Keep the workspace target so the
-    // mobile surface can open the intended workspace instead of losing the
-    // QR context at this navigation boundary.
-    if (isMobileSurface()) {
-      url.pathname = '/m/'
-      page.navigate(`${url.pathname}${url.search}${url.hash}`)
-    } else {
-      page.reload()
-    }
+    // Every device reloads into the same official Web GUI at this origin.
+    page.reload()
   }
 }
-
-/**
- * Connect the deep-linked workspace and open its session. Waits for the
- * runtime services AND for the target workspace to appear in the workspace
- * list (both are asynchronous after boot), then connects and opens; gives
- * up silently within the budget — the workspace param is stripped either
- * way, so a late failure cannot loop.
- * @param ctx - client root context.
- * @param workspaceId - the target workspace.
- * @param page - the page surface.
- */
-async function runDeepLink(ctx: Context, workspaceId: string, page: PageSurface): Promise<void> {
-  const target = workspaceId as WorkspaceId
-  const deadline = Date.now() + SERVICE_WAIT_MS
-  while (Date.now() < deadline) {
-    const workspaces = ctx.get('workspaces')
-    const sessions = ctx.get('sessions') as { open(id: string): void } | undefined
-    if (workspaces !== undefined && sessions !== undefined) {
-      const items = workspaces.list.getSnapshot().items
-      if (items.some(item => item.workspaceId === target)) {
-        try {
-          // Open unconditionally: a host-side "current" session may already
-          // exist (multi-client mirroring), but the QR's workspace target is
-          // explicit user intent and must win.
-          const sessionId = await workspaces.connectWorkspace(target)
-          sessions.open(sessionId)
-        } catch {
-          // Unknown workspace or a failed connect: fall through to the
-          // runtime's own default initial selection.
-        }
-        break
-      }
-    }
-    await new Promise(resolve => setTimeout(resolve, 200))
-  }
-  const url = new URL(page.href)
-  url.searchParams.delete('workspace')
-  page.replaceState(`${url.pathname}${url.search}${url.hash}`)
-}

package/src/client/index.ts

@@ -1,21 +1,25 @@
 /**
- * Mobile remote control — browser half. Registers the `remote` dictionaries,
- * the sidebar-foot entry (phone trigger + pairing panel) into the
- * ui-sidebar-declared `sidebar.remote` seat, and runs the phone-side boot
- * flow (pair accept + workspace deep-link + presence heartbeats) plus the
- * one-time failed-pair notice. Export discipline: packages/client/AGENTS.md
- * — the /client surface carries only what cordis loading needs plus types.
+ * Remote control — browser half. Registers the `remote` dictionaries, the
+ * sidebar-foot entry (phone trigger + pairing panel + update trigger), and
+ * the pair boot flow (accept + presence heartbeats) plus the one-time
+ * failed-pair notice. The portrait-touch adaptation of the official UI
+ * starts at module scope (startMobileAdapt) so its focus guard is installed
+ * before the app boots. Export discipline: packages/client/AGENTS.md — the
+ * /client surface carries only what cordis loading needs plus types.
  */
 import { createElement } from 'react'
 import { createRoot } from 'react-dom/client'
-import type { ClientContext, SettingsScope, SettingsScopeSpec } from '@deepseek-ai/dsh-client-runtime/client'
+import type { Context as ClientContext } from '@deepseek-ai/cordis'
+import type { SettingsScope, SettingsScopeSpec } from '@deepseek-ai/dsh-client-ui-settings/client'
 // Type-only: pulls the locale plugin's Context merge (ctx.locale) and the
-// ui-sidebar SlotMap merge (the 'sidebar.remote' hole).
+// ui-sidebar SlotMap merge (the 'sidebar.footer.action' hole).
 import type {} from '@deepseek-ai/dsh-client-locale/client'
 // Type-only: pulls the settings-surface SlotMap merge (the 'settings.section'
 // entry) and the ctx.settingsScope Context merge.
 import type {} from '@deepseek-ai/dsh-client-ui-settings/client'
 import type {} from '@deepseek-ai/dsh-client-ui-sidebar/client'
+// Type-only: pulls the ctx.slots merge (the renderer owns the slot registry since 0.1.2).
+import type {} from '@deepseek-ai/dsh-client-ui-renderer/client'
 import type { ConnectionHandle } from '@deepseek-ai/dsh-client-connection/client'
 import { FooterRemoteEntry } from './FooterRemoteEntry.tsx'
 import { RemoteEntry } from './RemoteEntry.tsx'
@@ -34,6 +38,13 @@ import {
 } from './remote-channel.ts'
 import { FenceNotice } from './FenceNotice.tsx'
 import { reportDailyHeartbeat } from './telemetry.ts'
+import { startMobileAdapt, type RemoteAdaptGlobal } from './mobile-adapt.ts'
+
+// Portrait-touch adaptation of the official UI: installed at module scope so
+// the composer focus guard exists before any app entry mounts React. The
+// layer self-evaluates and reverts with the viewport; the plugin apply below
+// wires its toggleSidebar onto the official layout service.
+startMobileAdapt()
 
 export type { RemoteEntryProps } from './RemoteEntry.tsx'
 export type { PanelState, RemotePanelProps } from './RemotePanel.tsx'
@@ -55,7 +66,6 @@ declare module '@deepseek-ai/dsh-client-ui-slots' {
      * sidebar shell on deployments that carry the feature seat; the shell
      * passes only its column display state.
      */
-    'sidebar.remote': { kind: 'single'; scope: 'root'; owner: SidebarRemoteOwnerProps }
     /**
      * The child slot the Web UI plugin group declares; this card registers
      * into the group instead of the top-level `settings.plugin.item` list.
@@ -119,7 +129,48 @@ export function apply(ctx: ClientContext): void {
     }
   }, 'remote-web-ui: dictionaries')
 
+  // The mobile adapt's whale button expands the collapsed sidebar and the
+  // activation closes the details panel — both through the official layout
+  // service (ctx.layout.toggleSidebar / closeDetails flip the panel state;
+  // the narrow-viewport semantics open the drawer).
+  const layout = ctx.get('layout') as { toggleSidebar?: () => void; closeDetails?: () => void } | undefined
+  const adapt = (window as unknown as { __dshRemoteAdapt?: RemoteAdaptGlobal }).__dshRemoteAdapt
+  // The official layout face throws (by contract) when the root entry has
+  // not mounted yet; these closures also fire from gestures racing that
+  // first mount, so they tolerate the throw instead of surfacing it.
+  const layoutCall = (call: (() => void) | undefined): void => {
+    try {
+      call?.()
+    } catch {
+      // Boot-order throw: the panel action is a no-op before the root entry.
+    }
+  }
+  if (layout !== undefined && adapt !== undefined) {
+    if (typeof layout.toggleSidebar === 'function') {
+      adapt.toggleSidebar = () => {
+        layoutCall(layout.toggleSidebar)
+      }
+    }
+    if (typeof layout.closeDetails === 'function') {
+      adapt.closeDetails = () => {
+        layoutCall(layout.closeDetails)
+      }
+    }
+  }
+  if (adapt !== undefined && adapt.toggleSidebar === null) {
+    // Layout face unavailable (older composition): fall back to clicking the
+    // official rail toggle when it exists.
+    adapt.toggleSidebar = () => {
+      (document.querySelector('[class$="_railFish"] button, [class$="_logoRow"] [class*="_iconButton"]') as HTMLElement | null)?.click()
+    }
+  }
+
   const t = ctx.locale.bind(NS)
+  // Hand the `remote` translate seat to the module-scope adaptation layer:
+  // the whale/compact-picker labels were rendered with the English fallback
+  // before any dictionary existed; the wiring plus the layer's own sync tick
+  // re-render them in the active locale.
+  if (adapt !== undefined) adapt.translate = t
   const binder = ctx.get('webUiSettings') ?? ctx.settingsScope
   const settingsScope = binder.bind<RemoteSettings>({ namespace: REMOTE_WEB_UI_NS })
   const enabled = (): boolean => {
@@ -129,37 +180,29 @@ export function apply(ctx: ClientContext): void {
       : snapshot.status === 'unavailable'
   }
 
-  // Sidebar foot entry: the shell declares 'sidebar.remote' in unconstrained
-  // order, so registration is declaration-aware — slots.inject waits on the
-  // declaration, removes the contribution when it collapses, and re-runs
-  // after a redeclaration. The entry follows the plugin's enabled setting:
-  // toggling it off removes the trigger, toggling it back on re-registers it.
-  ctx.slots.inject('sidebar.remote', () => {
-    let disposeEntry: (() => void) | undefined
-    const syncEntry = (): void => {
-      if (enabled() && disposeEntry === undefined) {
-        try {
-          disposeEntry = ctx.slots.register({ name: 'sidebar.remote', locale: NS }, RemoteEntry)
-        } catch {
-          // ignore registration collision
-        }
-      } else if (!enabled() && disposeEntry !== undefined) {
-        disposeEntry()
-        disposeEntry = undefined
-      }
-    }
-    const unsubscribe = settingsScope.subscribe(syncEntry)
-    syncEntry()
-    return () => {
-      unsubscribe()
-      disposeEntry?.()
-    }
-  })
+  // Master switch for the adaptation layer: the module-scope install runs
+  // before any config is readable, so flip it once the settings snapshot is
+  // bound and on every later change (disabled plugin = no injected surface).
+  // Also replay the pending closeDetails: the first portrait apply ran
+  // before the layout face was wired, so its closeDetails was a no-op and a
+  // restored details panel would otherwise sit hidden until landscape.
+  const syncAdaptEnabled = (): void => {
+    ;(window as unknown as { __dshRemoteAdapt?: RemoteAdaptGlobal }).__dshRemoteAdapt?.setEnabled?.(enabled())
+  }
+  settingsScope.subscribe(syncAdaptEnabled)
+  syncAdaptEnabled()
+  // The replay closes a details panel restored before the wiring; the
+  // layout face throws while the root entry has not mounted yet (a real
+  // boot-order race on slow remote loads), and the plugin's apply world
+  // must survive it — the replay is a best-effort no-op then.
+  try {
+    adapt?.flushCloseDetails?.()
+  } catch {}
 
-  // Current shells declare `sidebar.footer.action` instead of the legacy
-  // `sidebar.remote` seat; this fallback registers the same entry there when
-  // the legacy seat never arrives (declaration-aware: only one of the two
-  // injects ever fires, so the trigger can never render twice).
+  // Sidebar foot entry: the sidebar foot seat is `sidebar.footer.action` in
+  // the 0.1.2 shell composition (the legacy `sidebar.remote` seat is gone
+  // upstream). The pairing link is origin-agnostic, so the entry needs no
+  // workspace source.
   ctx.slots.inject('sidebar.footer.action', () => {
     let disposeEntry: (() => void) | undefined
     const syncEntry = (): void => {