@dsh-cove/dsh-web-all 0.0.0-stage → 0.4.3

package/src/host/services/playwright-sessions/manager.ts

@@ -0,0 +1,239 @@
+/**
+ * Per-session browser registry.
+ *
+ * Lazily creates one {@link SessionBrowser} per conversation and keeps the
+ * mapping stable while the session stays active: a session's first playwright
+ * tool call spawns its browser, every later call reuses it, and no other
+ * session can ever see it. Failure to create a handle removes the entry so the
+ * next call retries instead of wedging the session.
+ *
+ * Lifecycle guards (both optional via config):
+ * - idle TTL — unused browsers are disposed after `idleTimeoutMs`
+ * - concurrency cap — creating a new browser may dispose the least-recently
+ *   used idle browser so at most `maxConcurrentBrowsers` stay alive
+ */
+
+import type { SessionBrowser } from './child.ts'
+
+export type SessionBrowserFactory = (sessionId: string) => Promise<SessionBrowser>
+
+export interface SessionBrowserManagerOptions {
+  /**
+   * Dispose a browser after this many milliseconds with no get/call.
+   * `0` disables idle eviction. Default is set by the plugin apply site.
+   */
+  idleTimeoutMs: number
+  /**
+   * Soft cap on live browsers. Creating one more may dispose the LRU idle
+   * entry. `0` disables the cap.
+   */
+  maxConcurrentBrowsers: number
+  /** Optional clock for tests. */
+  now?: () => number
+  /** Optional timer hooks for tests. */
+  setTimeout?: (fn: () => void, ms: number) => ReturnType<typeof setTimeout>
+  clearTimeout?: (handle: ReturnType<typeof setTimeout>) => void
+  /**
+   * Called after a session browser process is disposed (idle TTL, concurrency
+   * eviction, browser_close, or disposeAll). Used for disk profile GC.
+   */
+  onDispose?: (sessionId: string) => void | Promise<void>
+}
+
+interface Entry {
+  browser: Promise<SessionBrowser>
+  lastUsedAt: number
+  idleTimer?: ReturnType<typeof setTimeout>
+  /** In-flight tool-call count; idle eviction skips busy entries. */
+  busy: number
+}
+
+export class SessionBrowserManager {
+  private readonly sessions = new Map<string, Entry>()
+  private readonly now: () => number
+  private readonly setTimeoutFn: (fn: () => void, ms: number) => ReturnType<typeof setTimeout>
+  private readonly clearTimeoutFn: (handle: ReturnType<typeof setTimeout>) => void
+
+  constructor(
+    private readonly factory: SessionBrowserFactory,
+    private readonly options: SessionBrowserManagerOptions,
+  ) {
+    this.now = options.now ?? Date.now
+    this.setTimeoutFn = options.setTimeout ?? setTimeout
+    this.clearTimeoutFn = options.clearTimeout ?? clearTimeout
+  }
+
+  /** Resolve the browser for one session, creating it on first use. */
+  async get(sessionId: string): Promise<SessionBrowser> {
+    let entry = this.sessions.get(sessionId)
+    if (entry === undefined) {
+      await this.ensureCapacity(sessionId)
+      const browser = this.factory(sessionId).catch((error: unknown) => {
+        this.sessions.delete(sessionId)
+        throw error
+      })
+      entry = { browser, lastUsedAt: this.now(), busy: 0 }
+      this.sessions.set(sessionId, entry)
+      this.armIdleTimer(sessionId, entry)
+    } else {
+      this.touch(sessionId)
+    }
+    return this.wrap(sessionId, await entry.browser)
+  }
+
+  /** Number of sessions that have (or are creating) a browser. */
+  get size(): number {
+    return this.sessions.size
+  }
+
+  /** Every session id currently tracked. */
+  ids(): string[] {
+    return [...this.sessions.keys()]
+  }
+
+  /** Whether a session currently owns (or is creating) a browser connection. */
+  has(sessionId: string): boolean {
+    return this.sessions.has(sessionId)
+  }
+
+  /**
+   * The host-owned persistent context of a session browser, when one exists
+   * AND was created in liveView mode (dual-owner). Never creates a browser:
+   * the live-view upgrade must not spawn a browser just because a client
+   * opened the view.
+   */
+  contextOf(sessionId: string): Promise<SessionBrowser['context']> {
+    const entry = this.sessions.get(sessionId)
+    if (entry === undefined) return Promise.resolve(null)
+    return entry.browser.then(browser => browser.context ?? null, () => null)
+  }
+
+  /** Dispose one session browser and drop it from the registry. */
+  async dispose(sessionId: string): Promise<void> {
+    const entry = this.sessions.get(sessionId)
+    if (entry === undefined) return
+    this.clearIdleTimer(entry)
+    this.sessions.delete(sessionId)
+    try {
+      await (await entry.browser).dispose()
+    } catch {
+      // A failed creation leaves no browser to dispose.
+    }
+    try {
+      await this.options.onDispose?.(sessionId)
+    } catch {
+      // Disk GC failures must not block browser lifecycle.
+    }
+  }
+
+  /** Close and dispose every session browser; the registry empties. */
+  async disposeAll(): Promise<void> {
+    const ids = [...this.sessions.keys()]
+    await Promise.allSettled(ids.map((id) => this.dispose(id)))
+  }
+
+  /**
+   * Wrap call so each use refreshes the idle timer and marks the entry busy
+   * (idle eviction will not steal a browser mid-call).
+   */
+  private wrap(sessionId: string, browser: SessionBrowser): SessionBrowser {
+    return {
+      sessionId: browser.sessionId,
+      profileDir: browser.profileDir,
+      outputDir: browser.outputDir,
+      call: async (rawName, args, signal) => {
+        this.beginUse(sessionId)
+        try {
+          return await browser.call(rawName, args, signal)
+        } finally {
+          this.endUse(sessionId)
+        }
+      },
+      close: () => browser.close(),
+      dispose: () => browser.dispose(),
+    }
+  }
+
+  private beginUse(sessionId: string): void {
+    const entry = this.sessions.get(sessionId)
+    if (entry === undefined) return
+    entry.busy += 1
+    this.touch(sessionId)
+  }
+
+  private endUse(sessionId: string): void {
+    const entry = this.sessions.get(sessionId)
+    if (entry === undefined) return
+    entry.busy = Math.max(0, entry.busy - 1)
+    this.touch(sessionId)
+  }
+
+  private touch(sessionId: string): void {
+    const entry = this.sessions.get(sessionId)
+    if (entry === undefined) return
+    entry.lastUsedAt = this.now()
+    this.armIdleTimer(sessionId, entry)
+  }
+
+  private armIdleTimer(sessionId: string, entry: Entry): void {
+    this.clearIdleTimer(entry)
+    const idleTimeoutMs = this.options.idleTimeoutMs
+    if (idleTimeoutMs <= 0) return
+    entry.idleTimer = this.setTimeoutFn(() => {
+      void this.disposeIdle(sessionId)
+    }, idleTimeoutMs)
+  }
+
+  private clearIdleTimer(entry: Entry): void {
+    if (entry.idleTimer === undefined) return
+    this.clearTimeoutFn(entry.idleTimer)
+    entry.idleTimer = undefined
+  }
+
+  /** Idle timer fired: dispose only if still idle and not busy. */
+  private async disposeIdle(sessionId: string): Promise<void> {
+    const entry = this.sessions.get(sessionId)
+    if (entry === undefined) return
+    if (entry.busy > 0) {
+      this.armIdleTimer(sessionId, entry)
+      return
+    }
+    const idleTimeoutMs = this.options.idleTimeoutMs
+    if (idleTimeoutMs > 0 && this.now() - entry.lastUsedAt < idleTimeoutMs) {
+      this.armIdleTimer(sessionId, entry)
+      return
+    }
+    await this.dispose(sessionId)
+  }
+
+  /**
+   * Before creating `incomingId`, dispose LRU idle browsers until under the
+   * concurrency cap. Busy browsers are skipped; if every other browser is
+   * busy and the cap is still reached, the absolute LRU (including busy) is
+   * force-disposed so a new session can start.
+   */
+  private async ensureCapacity(incomingId: string): Promise<void> {
+    const max = this.options.maxConcurrentBrowsers
+    if (max <= 0) return
+    while (this.sessions.size >= max) {
+      const victim = this.pickEvictionVictim(incomingId, /*preferIdle*/ true)
+        ?? this.pickEvictionVictim(incomingId, /*preferIdle*/ false)
+      if (victim === undefined) return
+      await this.dispose(victim)
+    }
+  }
+
+  private pickEvictionVictim(incomingId: string, preferIdle: boolean): string | undefined {
+    let bestId: string | undefined
+    let bestUsed = Number.POSITIVE_INFINITY
+    for (const [id, entry] of this.sessions) {
+      if (id === incomingId) continue
+      if (preferIdle && entry.busy > 0) continue
+      if (entry.lastUsedAt < bestUsed) {
+        bestUsed = entry.lastUsedAt
+        bestId = id
+      }
+    }
+    return bestId
+  }
+}

package/src/host/services/playwright-sessions/profile-gc.ts

@@ -0,0 +1,97 @@
+/**
+ * Disk GC for per-session Playwright profiles under `sessionsRoot`.
+ *
+ * Process-level idle eviction already stops Chromium/MCP children; this module
+ * reclaims the leftover profile directories (cookies, cache, screenshots) that
+ * otherwise grow without bound under `$DSH_HOME/playwright-sessions/`.
+ */
+
+import { existsSync, readdirSync, rmSync, statSync } from 'node:fs'
+import { join } from 'node:path'
+import { sanitizePlaywrightSessionKey } from '../../../core/playwright-sessions/names.ts'
+
+export interface PruneProfilesOptions {
+  /** Absolute root that holds one directory per session. */
+  sessionsRoot: string
+  /**
+   * Delete a profile directory when its mtime is older than this many ms.
+   * `0` disables age-based pruning.
+   */
+  maxAgeMs: number
+  /** Session ids whose live browsers must not be deleted. */
+  keepSessionIds?: Iterable<string>
+  /** Optional clock for tests. */
+  now?: () => number
+}
+
+export interface PruneProfilesResult {
+  removed: string[]
+  skippedLive: string[]
+  errors: string[]
+}
+
+/** Resolve the on-disk profile directory for one durable session id. */
+export function profileDirFor(sessionsRoot: string, sessionId: string): string {
+  return join(sessionsRoot, sanitizePlaywrightSessionKey(sessionId))
+}
+
+/** Best-effort recursive remove of one session profile directory. */
+export function removeProfileDir(sessionsRoot: string, sessionId: string): boolean {
+  const dir = profileDirFor(sessionsRoot, sessionId)
+  if (!existsSync(dir)) return false
+  rmSync(dir, { recursive: true, force: true })
+  return true
+}
+
+/**
+ * Delete stale profile directories under `sessionsRoot`.
+ *
+ * A directory is removed when:
+ * - it is a direct child of `sessionsRoot`, and
+ * - its mtime is older than `maxAgeMs` (when maxAgeMs > 0), and
+ * - its basename is not the sanitized key of any id in `keepSessionIds`.
+ */
+export function pruneStaleProfiles(options: PruneProfilesOptions): PruneProfilesResult {
+  const removed: string[] = []
+  const skippedLive: string[] = []
+  const errors: string[] = []
+  const now = options.now ?? Date.now
+  const keep = new Set(
+    [...(options.keepSessionIds ?? [])].map((id) => sanitizePlaywrightSessionKey(id)),
+  )
+
+  if (!existsSync(options.sessionsRoot)) {
+    return { removed, skippedLive, errors }
+  }
+  if (options.maxAgeMs <= 0) {
+    return { removed, skippedLive, errors }
+  }
+
+  const cutoff = now() - options.maxAgeMs
+  let entries: string[]
+  try {
+    entries = readdirSync(options.sessionsRoot)
+  } catch (err) {
+    errors.push(String(err))
+    return { removed, skippedLive, errors }
+  }
+
+  for (const name of entries) {
+    if (keep.has(name)) {
+      skippedLive.push(name)
+      continue
+    }
+    const full = join(options.sessionsRoot, name)
+    try {
+      const st = statSync(full)
+      if (!st.isDirectory()) continue
+      if (st.mtimeMs >= cutoff) continue
+      rmSync(full, { recursive: true, force: true })
+      removed.push(name)
+    } catch (err) {
+      errors.push(`${name}: ${String(err)}`)
+    }
+  }
+
+  return { removed, skippedLive, errors }
+}

package/src/host/services/playwright-sessions/routes.ts

@@ -0,0 +1,90 @@
+/** Loopback and same-origin control plane for the attended Chrome lease. */
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import type { Context } from '@deepseek-ai/cordis'
+import type { WebRoute } from '@deepseek-ai/dsh-host-webserver'
+import { PLAYWRIGHT_CONTROL_API_PREFIX, PlaywrightControlError } from '../../../core/playwright-sessions/control.ts'
+import { isLoopbackRequest } from '../access-trust/trust.ts'
+import { accessTrustOf } from '../access-trust/index.ts'
+import type { PlaywrightSessionsController } from './controller.ts'
+
+/**
+ * The strict loopback core fence for this control plane: a loopback socket,
+ * a loopback Host, and same-origin browser markers. The route family is mounted
+ * with the shared host access fence (see `registerPlaywrightControlRoutes`), so
+ * the deployment's canonical browser entry reaches the host's Chrome through an
+ * authenticated session; this predicate stays available for the loopback-only
+ * callers and tests.
+ */
+function trusted(request: IncomingMessage): boolean {
+  return isLoopbackRequest(request)
+}
+
+function json(response: ServerResponse, status: number, body: unknown): void {
+  response.writeHead(status, {
+    'content-type': 'application/json; charset=utf-8',
+    'cache-control': 'no-store',
+    'x-content-type-options': 'nosniff',
+    'referrer-policy': 'no-referrer',
+  })
+  response.end(JSON.stringify(body))
+}
+
+async function body(request: IncomingMessage, maxBytes = 16 * 1024): Promise<Record<string, unknown> | null> {
+  const chunks: Buffer[] = []
+  let size = 0
+  for await (const chunk of request) {
+    const value = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
+    size += value.length
+    if (size > maxBytes) return null
+    chunks.push(value)
+  }
+  try {
+    const parsed = JSON.parse(Buffer.concat(chunks).toString('utf8'))
+    return typeof parsed === 'object' && parsed !== null ? parsed as Record<string, unknown> : null
+  } catch { return null }
+}
+
+export function makePlaywrightControlRoutes(
+  controller: PlaywrightSessionsController,
+  isTrusted: (request: IncomingMessage) => boolean = trusted,
+): WebRoute[] {
+  const handler = async (request: IncomingMessage, response: ServerResponse): Promise<void> => {
+    if (!isTrusted(request)) { json(response, 403, { ok: false, error: { code: 'forbidden', message: 'loopback same-origin access only' } }); return }
+    const url = new URL(request.url ?? '/', 'http://dsh.local')
+    try {
+      if (url.pathname === `${PLAYWRIGHT_CONTROL_API_PREFIX}/status` && request.method === 'GET') {
+        const sessionId = url.searchParams.get('sessionId')
+        if (!sessionId) throw new PlaywrightControlError('bad-request', 'sessionId is required')
+        json(response, 200, { ok: true, value: controller.status(sessionId) })
+        return
+      }
+      if ((url.pathname === `${PLAYWRIGHT_CONTROL_API_PREFIX}/connect` || url.pathname === `${PLAYWRIGHT_CONTROL_API_PREFIX}/disconnect`) && request.method === 'POST') {
+        if (!String(request.headers['content-type'] ?? '').toLowerCase().startsWith('application/json')) {
+          json(response, 415, { ok: false, error: { code: 'bad-request', message: 'application/json required' } })
+          return
+        }
+        const input = await body(request)
+        if (typeof input?.['sessionId'] !== 'string' || input['sessionId'] === '') throw new PlaywrightControlError('bad-request', 'sessionId is required')
+        const value = url.pathname.endsWith('/connect')
+          ? await controller.connect(input['sessionId'])
+          : await controller.disconnect(input['sessionId'])
+        json(response, 200, { ok: true, value })
+        return
+      }
+      json(response, 404, { ok: false, error: { code: 'not-found', message: 'unknown route' } })
+    } catch (error) {
+      const code = error instanceof PlaywrightControlError ? error.code : 'internal'
+      const status = code === 'forbidden' ? 403 : code === 'not-found' ? 404 : code === 'busy' || code === 'not-owner' || code === 'wrong-mode' ? 409 : code === 'bad-request' ? 400 : code === 'connect-failed' ? 502 : 500
+      json(response, status, { ok: false, error: { code, message: error instanceof Error ? error.message : String(error) } })
+    }
+  }
+  return [{ kind: 'prefix', path: PLAYWRIGHT_CONTROL_API_PREFIX, handler }]
+}
+
+export function registerPlaywrightControlRoutes(ctx: Context, controller: PlaywrightSessionsController): () => void {
+  const isTrusted = accessTrustOf(ctx).isTrusted
+  const disposers = makePlaywrightControlRoutes(controller, isTrusted).map(route => ctx.webServer.register(route))
+  return () => { for (const dispose of disposers.reverse()) dispose() }
+}
+
+export { trusted as trustedPlaywrightControlRequest }

package/src/host/services/remote-access/boot-scripts.ts

@@ -0,0 +1,118 @@
+/**
+ * Index boot scripts and wire constants of the remote-access domain.
+ *
+ * The deployment's canonical entry (browser -> reverse proxy -> loopback
+ * `dsh web`) is a plain-HTTP origin. Two browser facts follow, and both are
+ * fixed here for every entry, whether or not the optional server-mode gateway
+ * is mounted:
+ *
+ * 1. `crypto.randomUUID` does not exist outside a secure context. The DSH
+ *    client mints RPC ids with it, so the polyfill is injected into every
+ *    served index document (issue #1024).
+ * 2. `navigator.clipboard` does not exist either, because the Clipboard API is
+ *    secure-context gated. Upstream DSH copy affordances call
+ *    `navigator.clipboard.writeText` without a fallback, so a copy button
+ *    throws on a remote page while working on the loopback page. The shim backs
+ *    `writeText` with the legacy `document.execCommand('copy')` path and never
+ *    replaces a real clipboard object.
+ *
+ * Host ownership is per request instead of a static row: the index document
+ * points at {@link HOST_ACCESS_BOOT_PATH} with a parser-blocking
+ * `<script src>`, whose handler decides from the request Host whether this page
+ * may claim the Host (`__DSH_TRANSPORT__.ownsHost`). Without the claim the DSH
+ * client keeps the whole settings plane in a process-local memory store and
+ * renders Settings -> Models as "settings are unavailable in this browser",
+ * while the provider directory, the account page and the config-file entry all
+ * stay empty.
+ * @module dsh-web-all/host/services/remote-access/boot-scripts
+ */
+
+/**
+ * Parser-blocking boot script path; the handler decides per request.
+ * Re-exported from `core/remote-access/paths.ts`, the single home the browser
+ * half reads too.
+ */
+export {
+  HOST_ACCESS_BOOT_PATH,
+  HOST_ACCESS_MARKER_COOKIE,
+  HOST_ACCESS_MARKER_MAX_AGE_SECONDS,
+  HOST_ACCESS_MARKER_VALUE,
+  HOST_ACCESS_SESSION_PATH,
+} from '../../../core/remote-access/paths.ts'
+
+/**
+ * `crypto.randomUUID` polyfill for non-secure contexts. Kept byte-compatible
+ * with the script the server-mode gateway used to inject, so the two renderers
+ * cannot drift.
+ */
+export const UUID_POLYFILL_SCRIPT = [
+  '(function(){',
+  'var g=typeof globalThis!=="undefined"?globalThis:typeof window!=="undefined"?window:self;',
+  'if(typeof g.crypto==="undefined"){g.crypto={};}',
+  'if(typeof g.crypto.randomUUID!=="function"){',
+  'g.crypto.randomUUID=function(){',
+  'var a=new Uint8Array(16);',
+  'if(g.crypto.getRandomValues){g.crypto.getRandomValues(a);}',
+  'else{for(var j=0;j<16;j++){a[j]=Math.random()*256|0;}}',
+  'a[6]=(a[6]&0x0f)|0x40;',
+  'a[8]=(a[8]&0x3f)|0x80;',
+  'var h="",x="0123456789abcdef";',
+  'for(var i=0;i<16;i++){h+=x[a[i]>>4]+x[a[i]&0x0f];',
+  'if(i===3||i===5||i===7||i===9)h+="-";}',
+  'return h;',
+  '};',
+  '}',
+  '})();',
+].join('')
+
+/**
+ * `navigator.clipboard` shim for non-secure contexts. Only installed when the
+ * platform exposes no clipboard at all, so a secure-context page keeps the real
+ * API. `readText` cannot be polyfilled from a page (the paste event is the only
+ * read path), so it rejects instead of throwing synchronously; callers that
+ * already fall back on rejection keep working.
+ */
+export const CLIPBOARD_SHIM_SCRIPT = [
+  '(function(){',
+  'try{',
+  'var n=typeof navigator!=="undefined"?navigator:undefined;',
+  'if(n===undefined||n.clipboard!==undefined)return;',
+  'var writeText=function(text){return new Promise(function(resolve,reject){',
+  'try{',
+  'var area=document.createElement("textarea");',
+  'area.value=String(text);',
+  'area.setAttribute("readonly","");',
+  'area.style.position="fixed";',
+  'area.style.top="-1000px";',
+  'document.body.appendChild(area);',
+  'area.select();',
+  'var ok=document.execCommand("copy");',
+  'document.body.removeChild(area);',
+  'if(ok){resolve();}else{reject(new Error("clipboard write is unavailable on this origin"));}',
+  '}catch(e){reject(e);}',
+  '});};',
+  'var readText=function(){return Promise.reject(new Error("clipboard read is unavailable on this origin"));};',
+  'var shim={writeText:writeText,readText:readText};',
+  'try{Object.defineProperty(Navigator.prototype,"clipboard",{get:function(){return shim;},configurable:true});}',
+  'catch(e){try{Object.defineProperty(n,"clipboard",{value:shim,configurable:true});}catch(e2){}}',
+  '}catch(e){}',
+  '})();',
+].join('')
+
+/**
+ * Boot script body served for one admission decision.
+ * @param admitted - whether the requesting Host passed the host access fence.
+ * @returns an inline script claiming Host ownership, or a no-op script.
+ */
+export function hostAccessBootScript(admitted: boolean): string {
+  if (!admitted) return '/* web-all: this host is not a declared browser entry; the page keeps the memory settings plane */\n'
+  return [
+    '(function(){',
+    'try{',
+    'var t=globalThis.__DSH_TRANSPORT__||{};',
+    't.ownsHost=true;',
+    'globalThis.__DSH_TRANSPORT__=t;',
+    '}catch(e){}',
+    '})();',
+  ].join('')
+}

package/src/host/services/remote-access/index.ts

@@ -0,0 +1,62 @@
+/**
+ * Remote-access service domain: the two pieces every reverse-proxied
+ * deployment needs regardless of whether the optional server-mode gateway is
+ * mounted.
+ *
+ * - the per-request Host-ownership boot script and the authority posture
+ *   readout (`./routes.ts`);
+ * - the index boot rows every entry shares: the parser-blocking ownership
+ *   script, the `crypto.randomUUID` polyfill and the `navigator.clipboard`
+ *   shim (`./boot-scripts.ts`).
+ *
+ * The ownership decision is the shared host access fence, so this domain can
+ * never claim more than the privileged panels already allow. Fail-closed: when
+ * the fence service is missing, `accessTrustOf` falls back to the strict
+ * loopback rule and only a loopback page (which already owns the Host) is
+ * admitted.
+ * @module dsh-web-all/host/services/remote-access
+ */
+
+import type { Context } from '@deepseek-ai/cordis'
+import type { IncomingMessage } from 'node:http'
+import type {} from '@deepseek-ai/dsh-host-webserver'
+import { accessTrustOf, browserSessionPredicateOf, trustedAuthoritiesOf } from '../access-trust/index.ts'
+import { CLIPBOARD_SHIM_SCRIPT, HOST_ACCESS_BOOT_PATH, UUID_POLYFILL_SCRIPT } from './boot-scripts.ts'
+import { makeRemoteAccessRoutes, type RemoteAccessDeps } from './routes.ts'
+import { registerResources } from '../resources.ts'
+
+export {
+  CLIPBOARD_SHIM_SCRIPT,
+  HOST_ACCESS_BOOT_PATH,
+  HOST_ACCESS_MARKER_COOKIE,
+  HOST_ACCESS_MARKER_MAX_AGE_SECONDS,
+  HOST_ACCESS_MARKER_VALUE,
+  HOST_ACCESS_SESSION_PATH,
+  UUID_POLYFILL_SCRIPT,
+  hostAccessBootScript,
+} from './boot-scripts.ts'
+export { makeRemoteAccessRoutes, type RemoteAccessDeps } from './routes.ts'
+
+/**
+ * Mount the service domain.
+ * @param ctx - host plugin context.
+ * @returns the disposer releasing the routes and the injection rows.
+ */
+export function register(ctx: Context): () => void {
+  const deps: RemoteAccessDeps = {
+    isTrusted: (request: IncomingMessage): boolean => accessTrustOf(ctx).isTrusted(request),
+    trustedAuthorities: () => trustedAuthoritiesOf(ctx),
+    isAuthenticated: (request: IncomingMessage): boolean => browserSessionPredicateOf(ctx)?.(request) === true,
+  }
+  return registerResources(own => {
+  for (const route of makeRemoteAccessRoutes(deps)) own(ctx.webServer.register(route))
+
+  // Row order is execution order: the parser-blocking ownership script runs
+  // first, then the two inline shims the plain-HTTP origin needs.
+  own(ctx.on('webserver/index-inject', (table) => {
+    table.push({ kind: 'script-src', placement: 'head', src: HOST_ACCESS_BOOT_PATH })
+    table.push({ kind: 'script', placement: 'head', text: UUID_POLYFILL_SCRIPT })
+    table.push({ kind: 'script', placement: 'head', text: CLIPBOARD_SHIM_SCRIPT })
+  }))
+  })
+}