@linxin666/dsh-ssh 0.3.24 → 0.4.1

package/src/client/settings-binding.ts

@@ -0,0 +1,165 @@
+/**
+ * Settings reader of the dsh-ssh browser half.
+ *
+ * The plugin's browser half owns one preference: the xterm `fontFamily` the
+ * panel applies to its terminals. Under the 0.1.7 settings model that field
+ * belongs to the plugin's own profile entry (its Cordis Config schema), and
+ * the browser surface addresses settings as one form per profile entry id — so
+ * the entry has to be resolved before its section can be read:
+ *
+ * - the family binder (`ctx.get('webUiSettings')`, published while
+ *   dsh-web-settings is loaded) resolves the dsh-ssh namespace to its entry id
+ *   through the Host bridge and hands back the native shared form;
+ * - without that group the shared configuration forms serve the form directly,
+ *   and the entry is recognised by the one field this plugin's own schema
+ *   declares: the entry whose resolved section carries `terminalFontFamily`.
+ */
+
+import type { Context as ClientContext } from '@deepseek-ai/cordis'
+import type { ConfigForm, ConfigFormSnapshot, ConfigForms } from '@deepseek-ai/dsh-client-ui-settings/client'
+
+/** Domain-owned description of one settings namespace a family surface binds. */
+export interface ConfigFormSpec<T> {
+  /** Settings namespace the surface edits. */
+  namespace: string
+  /**
+   * Narrow one wire section; undefined keeps the section the Host resolved.
+   * The shared form already validates against the namespace's serialized
+   * schema, so a decoder exists only to narrow beyond it.
+   */
+  decode?: (section: unknown) => T | undefined
+}
+
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    /**
+     * Optional family settings binder provided by dsh-web-settings; absent when
+     * that group plugin is not installed, so callers fall back to the shared
+     * configuration forms service (`ctx.configForms`).
+     */
+    webUiSettings?: { bind<S>(spec: ConfigFormSpec<S>): ConfigForm<S> }
+  }
+}
+
+/** The read face this plugin needs from its own settings entry. */
+export interface SettingsReader<T> {
+  /** @returns the current snapshot (stable reference until the next change). */
+  getSnapshot(): ConfigFormSnapshot<T>
+  /** Observe snapshot replacements. */
+  subscribe(listener: () => void): () => void
+}
+
+/** A reader plus the release of every subscription it installed. */
+export interface SettingsBinding<T> extends SettingsReader<T> {
+  /** Release the reader's subscriptions; later calls are no-ops. */
+  dispose(): void
+}
+
+/**
+ * The snapshot a reader reports before the Host has answered with this
+ * plugin's entry: nothing is readable yet, and no write is attempted.
+ */
+const PENDING_SNAPSHOT: ConfigFormSnapshot<never> = {
+  status: 'loading',
+  value: undefined,
+  base: undefined,
+  user: undefined,
+  revision: undefined,
+  writable: false,
+  mode: 'host',
+}
+
+/** Whether one Host namespace section carries a field this plugin's schema declares. */
+function carriesField(section: unknown, field: string): boolean {
+  return typeof section === 'object' && section !== null && Object.hasOwn(section, field)
+}
+
+/**
+ * Reader over the shared configuration forms service.
+ *
+ * The 0.1.7 surface carries no package identity, so this plugin recognises its
+ * own entry by the field its Config schema declares. The entry list arrives
+ * asynchronously with the shared describe mirror, and an id the Host has not
+ * answered with yet is not evidence of absence: the reader re-resolves on every
+ * mirror change and reports `loading` until it holds a form.
+ */
+class SharedFormsReader<T> implements SettingsReader<T> {
+  private readonly listeners = new Set<() => void>()
+  private readonly unsubscribeMirror: () => void
+  private unsubscribeForm: (() => void) | undefined
+  private form: ConfigForm<T> | undefined
+  private snapshot: ConfigFormSnapshot<T> = PENDING_SNAPSHOT as ConfigFormSnapshot<T>
+
+  /**
+   * @param forms - the shared configuration forms service (`ctx.configForms`).
+   * @param field - the field this plugin's own schema declares, which is what identifies its entry.
+   */
+  constructor(private readonly forms: ConfigForms, private readonly field: string) {
+    this.unsubscribeMirror = forms.describe().subscribe(() => {
+      this.bind()
+      this.publish()
+    })
+    this.bind()
+  }
+
+  getSnapshot(): ConfigFormSnapshot<T> {
+    return this.snapshot
+  }
+
+  subscribe(listener: () => void): () => void {
+    this.listeners.add(listener)
+    return () => {
+      this.listeners.delete(listener)
+    }
+  }
+
+  /** Release the mirror and form subscriptions and drop every listener. */
+  dispose(): void {
+    this.unsubscribeMirror()
+    this.unsubscribeForm?.()
+    this.unsubscribeForm = undefined
+    this.listeners.clear()
+  }
+
+  /** Bind the entry form once the shared mirror names this plugin's entry. */
+  private bind(): void {
+    if (this.form !== undefined) return
+    const namespaces = this.forms.describe().getSnapshot().view?.namespaces
+    const entry = namespaces?.find(candidate => carriesField(candidate.value, this.field))
+    if (entry === undefined) return
+    const form = this.forms.get<T>(entry.ns)
+    // A service that answers no form for its own served entry leaves the reader
+    // unbound; it retries on the next mirror answer rather than failing a boot.
+    if (form === undefined) return
+    this.form = form
+    this.snapshot = form.getSnapshot()
+    this.unsubscribeForm = form.subscribe(() => {
+      this.snapshot = form.getSnapshot()
+      this.publish()
+    })
+  }
+
+  private publish(): void {
+    for (const listener of this.listeners) listener()
+  }
+}
+
+/**
+ * Bind this plugin's settings reader.
+ * @param ctx - client context carrying the family binder and/or the shared forms service.
+ * @param namespace - the family settings namespace this plugin owns.
+ * @param field - the field this plugin's own schema declares, used to recognise its entry when the family binder is absent.
+ * @returns the reader and the release of its subscriptions.
+ */
+export function bindSettingsReader<T>(ctx: ClientContext, namespace: string, field: string): SettingsBinding<T> {
+  const family = ctx.get('webUiSettings')
+  if (family !== undefined) {
+    const form = family.bind<T>({ namespace })
+    return {
+      getSnapshot: () => form.getSnapshot(),
+      subscribe: listener => form.subscribe(listener),
+      dispose: () => {},
+    }
+  }
+  return new SharedFormsReader<T>(ctx.configForms, field)
+}

package/src/client/sidebar-entry-core.ts

@@ -16,33 +16,6 @@
  */
 import { subscribeBodyInvalidations } from './body-mutations.ts'
 
-/**
- * One trailing action button seated at the entry row's right edge (e.g. a
- * refresh command or a collapse chevron). Rows with actions switch from the
- * classic single-button structure to a container with a main button plus the
- * action buttons (nested interactive elements are invalid HTML); rows without
- * actions keep the classic structure untouched.
- */
-export interface SidebarEntryAction {
-  /** Stable id stamped as data-dsh-entry-action="<id>" (CSS hooks and tests). */
-  id: string
-  /** Inline icon markup while the row is active (always, when inactiveIcon is unset). */
-  icon: string
-  /**
-   * Optional icon while the row is inactive. Setting it makes the action a
-   * state mirror (a collapse chevron): the core swaps the icon and stamps
-   * aria-expanded on every active-state change. Requires the active bridge.
-   */
-  inactiveIcon?: string
-  /** Localized accessible label (aria-label + title); receives the active state. */
-  label(active: boolean): string
-  /**
-   * Click handler; receives the button so the caller can drive transient
-   * affordances (a refresh cooldown) without a re-render.
-   */
-  onClick(button: HTMLButtonElement): void
-}
-
 /** Per-package configuration for one sidebar entry row. */
 export interface SidebarEntryOptions {
   /** Full attribute name identifying the injected row (idempotency key), e.g. 'data-dsh-ssh-entry'. */
@@ -74,12 +47,6 @@ export interface SidebarEntryOptions {
   refresh?: { subscribe(listener: () => void): () => void }
   /** Click action (open/toggle the owning panel). */
   onToggle(): void
-  /**
-   * Optional trailing action buttons at the row's right edge. Requires the
-   * package CSS to seat entryMain / entryAction; empty keeps the classic
-   * single-button row.
-   */
-  actions?: readonly SidebarEntryAction[]
   /** Family-block position: 'before' inserts ahead of sibling plugin rows, 'after' behind them. */
   position: 'before' | 'after'
   /**
@@ -118,11 +85,9 @@ function newSessionButton(root: HTMLElement): HTMLButtonElement | undefined {
 }
 
 /** Build the entry row (detached; inserted once the shell is up). */
-function createEntry(options: SidebarEntryOptions): { entry: HTMLElement; applyLabel: () => void; setOpen: (open: boolean) => void } {
-  const actions = options.actions ?? []
-  const composite = actions.length > 0
-  const entry = document.createElement(composite ? 'div' : 'button') as HTMLElement
-  if (!composite) (entry as HTMLButtonElement).type = 'button'
+function createEntry(options: SidebarEntryOptions): { entry: HTMLElement; applyLabel: () => void } {
+  const entry = document.createElement('button')
+  entry.type = 'button'
   entry.setAttribute(options.rowAttribute, '')
   if (options.plugin !== undefined) {
     entry.setAttribute('data-dsh-plugin', options.plugin)
@@ -134,62 +99,15 @@ function createEntry(options: SidebarEntryOptions): { entry: HTMLElement; applyL
   const iconSpan = document.createElement('span')
   iconSpan.className = options.css['entryIcon'] ?? ''
   iconSpan.innerHTML = options.icon
-  // The main hit area: the classic row IS the button; with trailing actions
-  // the row becomes a container and the main area its own button, so the row
-  // never nests interactive elements.
-  const main = composite ? document.createElement('button') : (entry as HTMLButtonElement)
-  if (composite) {
-    main.type = 'button'
-    main.className = options.css['entryMain'] ?? ''
-    main.append(iconSpan, labelSpan)
-    entry.append(main)
-  } else {
-    entry.append(iconSpan, labelSpan)
-  }
-  const actionButtons: { action: SidebarEntryAction; button: HTMLButtonElement }[] = []
-  for (const action of actions) {
-    const button = document.createElement('button')
-    button.type = 'button'
-    button.className = options.css['entryAction'] ?? ''
-    button.setAttribute('data-dsh-entry-action', action.id)
-    button.innerHTML = action.icon
-    button.addEventListener('click', () => { action.onClick(button) })
-    entry.append(button)
-    actionButtons.push({ action, button })
-  }
-  let open = false
-  const applyActions = (): void => {
-    for (const { action, button } of actionButtons) {
-      button.innerHTML = open || action.inactiveIcon === undefined ? action.icon : action.inactiveIcon
-      const text = action.label(open)
-      button.setAttribute('aria-label', text)
-      button.setAttribute('title', text)
-      if (action.inactiveIcon !== undefined) button.setAttribute('aria-expanded', String(open))
-    }
-  }
+  entry.append(iconSpan, labelSpan)
   const applyLabel = (): void => {
-    main.setAttribute('aria-label', options.label())
-    if (options.tooltip !== undefined) main.setAttribute('title', options.tooltip())
+    entry.setAttribute('aria-label', options.label())
+    if (options.tooltip !== undefined) entry.setAttribute('title', options.tooltip())
     labelSpan.textContent = options.label()
-    applyActions()
   }
   applyLabel()
-  main.addEventListener('click', options.onToggle)
-  if (composite) {
-    // The old row was clickable edge to edge; keep the padding between the
-    // main area and the action buttons a toggle target as well.
-    entry.addEventListener('click', (event) => {
-      if (event.target === entry) options.onToggle()
-    })
-  }
-  return {
-    entry,
-    applyLabel,
-    setOpen: (next: boolean) => {
-      open = next
-      applyActions()
-    },
-  }
+  entry.addEventListener('click', options.onToggle)
+  return { entry, applyLabel }
 }
 
 /** Re-insert the entry after the New Session row (before the browser region). */
@@ -231,7 +149,7 @@ export function mountSidebarEntry(options: SidebarEntryOptions): () => void {
   if (typeof document !== 'undefined' && document.querySelector(options.rowSelector) !== null) {
     return () => {}
   }
-  const { entry, applyLabel, setOpen } = createEntry(options)
+  const { entry, applyLabel } = createEntry(options)
   let root: HTMLElement | undefined
   let placed = false
   let unsubscribeRefresh: (() => void) | undefined
@@ -299,10 +217,8 @@ export function mountSidebarEntry(options: SidebarEntryOptions): () => void {
   // row permanently highlighted — delete the attribute instead.
   const unsubscribeActive = options.active === undefined ? undefined : (() => {
     const syncActive = (): void => {
-      const open = options.active!.isOpen()
-      if (open) entry.dataset.active = 'true'
+      if (options.active!.isOpen()) entry.dataset.active = 'true'
       else delete entry.dataset.active
-      setOpen(open)
     }
     const unsubscribe = options.active.subscribe(syncActive)
     syncActive()

package/src/client/sidebar-entry.ts

@@ -16,8 +16,8 @@ import { mountSidebarEntry as mountSharedSidebarEntry } from './sidebar-entry-co
 /** Stable data attribute identifying the injected entry row. */
 export const ENTRY_SELECTOR = '[data-dsh-ssh-entry]'
 
-/** Inline terminal glyph sized to the shell's current sidebar navigation icons. */
-const ICON = '<svg viewBox="0 0 16 16" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect x="1.75" y="2.25" width="12.5" height="11.5" rx="1.75"/><path d="M4.25 5.25l2.75 2.75-2.75 2.75"/><path d="M8.5 10.75h3.25"/></svg>'
+/** Inline terminal glyph sized to the shell's panel-row navigation icons. */
+const ICON = '<svg viewBox="0 0 16 16" width="16" height="16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect x="1.75" y="2.25" width="12.5" height="11.5" rx="1.75"/><path d="M4.25 5.25l2.75 2.75-2.75 2.75"/><path d="M8.5 10.75h3.25"/></svg>'
 
 /** Locale-change subscription the shared core asks for (ctx.locale.subscribe shape). */
 export interface LocaleRefreshSource { subscribe(listener: () => void): () => void }

package/src/http.ts

@@ -2,7 +2,9 @@
 /**
  * Shared JSON body/response helpers for the host route families: one strict
  * bounded body reader, one lenient bounded body reader, one JSON object
- * narrow, and one JSON writer. Previously these were copy-pasted across the
+ * narrow, one JSON writer, and the outbound request-init helper that keeps a
+ * host fetch body decodable (withIdentityEncoding). Previously the readers
+ * were copy-pasted across the
  * package route files (routes.ts, update-routes.ts, mobile-api.ts, and each
  * family's route module) with drifting contracts: body caps ranging 4 KiB to
  * 1 MiB and four distinct overflow behaviors (reject, undefined, null, throw).
@@ -88,6 +90,26 @@ export function asJsonObject(value: unknown): Record<string, unknown> | undefine
   return isJsonObject(value) ? value : undefined
 }
 
+/**
+ * Request init that asks a remote origin for an uncompressed body.
+ *
+ * The DSH host boots `@deepseek-ai/dsh-http-proxy`, whose top-level import of
+ * the npm `undici` copy replaces the legacy `undici.globalDispatcher.1` slot
+ * Node's built-in `fetch()` reads. That cross-major wrapper drops the
+ * `content-encoding` header and automatic decompression, so a plain fetch
+ * resolves to raw gzip/brotli/zstd bytes — compressed noise no JSON or text
+ * consumer can read. Every host fetch that parses a remote body must request
+ * identity encoding. Caller headers survive; `accept-encoding` is forced to
+ * `identity` because a caller value has no decoder behind it in this host.
+ * @param init - the caller's request init (signal, headers, method, ...).
+ * @returns a copy with `accept-encoding: identity` merged in.
+ */
+export function withIdentityEncoding(init: RequestInit = {}): RequestInit {
+  const headers = new Headers(init.headers)
+  headers.set('accept-encoding', 'identity')
+  return { ...init, headers }
+}
+
 /**
  * Write one JSON response. Default headers are the family defaults
  * (content-type and referrer-policy); caller headers are appended or

package/src/index.ts

@@ -8,9 +8,8 @@
  * no dsh source changes.
  */
 
-import type { Context } from '@deepseek-ai/cordis'
-import type { SettingsNamespace } from '@deepseek-ai/dsh-settings'
-import z from 'schemastery'
+import type { Context, Fiber } from '@deepseek-ai/cordis'
+import z from '@deepseek-ai/schemastery'
 import type {} from '@deepseek-ai/dsh-host-webserver'
 import type {} from '@deepseek-ai/dsh-system-prompt'
 import type {} from '@deepseek-ai/dsh-tools'
@@ -26,18 +25,23 @@ export const name = 'ssh'
 /** Services required before the SSH surfaces can mount. */
 export const inject = ['webServer', 'tools', 'systemPrompt']
 
-/**
- * Settings namespace of the SSH capability — the section the web settings
- * surface edits. Spelled here rather than imported: the browser half spells
- * the same value and must not depend on a Host package.
- */
-export const SSH_SETTINGS_NAMESPACE = 'dsh-ssh' as SettingsNamespace
+declare module '@deepseek-ai/cordis' {
+  interface Events {
+    /**
+     * Volatile config values were committed into the running instance without a
+     * remount (cordis-plugin-loader); dispatched to the owning fiber only.
+     * @param paths - the changed config paths, as key arrays.
+     * @mode emit
+     */
+    'loader/volatile-update'(paths: readonly (readonly string[])[]): void
+  }
+}
 
-/** Plugin config, validated by the same-named schemastery schema. */
+/** Plugin config as a profile patch declares it, before schema resolution. */
 export interface Config {
   /**
-   * When true (default), a system-prompt section announces the SSH plugin to
-   * every agent (tools + host store). Set false to keep it silent.
+   * When true, a system-prompt section announces the SSH plugin to every agent
+   * (tools + host store). Off by default to keep prompts clean.
    */
   announceToAgent?: boolean
   /** Master switch for the plugin (routes, tools, prompt section). */
@@ -51,14 +55,67 @@ export interface Config {
   terminalFontFamily?: string
 }
 
-export const Config: z<Config> = z.object({
-  announceToAgent: z.boolean().default(false),
-  enabled: z.boolean().default(true),
-  terminalFontFamily: z.string().default(''),
+/** The stable reference a `volatile()` config field resolves to; its owner updates it in place. */
+interface ConfigRef<T> {
+  /** @returns the field's current value. */
+  get(): T
+}
+
+/** One resolved config field: a live reference, or a plain value from a hand-built context. */
+type ConfigField<T> = ConfigRef<T> | T
+
+/** The config the Host hands to {@link apply} — the runtime face of {@link Config}. */
+export interface ResolvedConfig {
+  announceToAgent?: ConfigField<boolean>
+  enabled?: ConfigField<boolean>
+  terminalFontFamily?: ConfigField<string>
+}
+
+/**
+ * Plugin config schema. Under the 0.1.7 settings model this schema IS the
+ * entry's settings page: the Host derives one form per profile entry from it
+ * and serves it through the shared configuration forms. Every field is
+ * `volatile()`, which is what puts it on that page and what lets an edit reach
+ * a running instance without a remount: the loader commits the new value into
+ * the field's reference and announces `loader/volatile-update` on this fiber.
+ */
+export const Config = z.object({
+  announceToAgent: z.boolean().default(false).volatile(),
+  enabled: z.boolean().default(true).volatile(),
+  terminalFontFamily: z.string().default('').volatile(),
 })
 
-/** Schema default, re-read for hand-built test contexts (the loader applies them normally). */
+/** Schema defaults, re-read for hand-built test contexts (the loader applies them normally). */
 const DEFAULT_ANNOUNCE = false
+const DEFAULT_ENABLED = true
+
+/** Read one resolved config field, following the live reference the schema produces. */
+function readConfigField<T>(field: ConfigField<T> | undefined, fallback: T): T {
+  if (field === undefined) return fallback
+  if (typeof field === 'object' && field !== null && typeof (field as ConfigRef<T>).get === 'function') {
+    const value = (field as ConfigRef<T>).get()
+    return value === undefined ? fallback : value
+  }
+  return field as T
+}
+
+/**
+ * The loader's own record of the profile entry this instance was activated
+ * from, which carries the row's raw config — the user's own declaration, as
+ * opposed to the schema defaults and the inherited bundle layers. Absent on a
+ * host without the loader, which reads as "the profile declares nothing".
+ */
+interface LoaderEntry {
+  options?: { config?: unknown }
+}
+
+/** Raw config the profile declares for this entry, when the loader exposes it. */
+function profileConfig(ctx: Context): Record<string, unknown> | undefined {
+  const entry = (ctx.fiber as Fiber & { entry?: LoaderEntry }).entry
+  const config = entry?.options?.config
+  if (typeof config !== 'object' || config === null || Array.isArray(config)) return undefined
+  return config as Record<string, unknown>
+}
 
 /** Order of the announcement section within the tool-guidance band. */
 const SECTION_ORDER = 150
@@ -73,28 +130,22 @@ export const SSH_GUIDANCE = '本机已安装 dsh-ssh 插件（DSH 远程 SSH 运
  */
 export const apply = mountOnce('@linxin666/dsh-ssh', applyImpl)
 
-function applyImpl(ctx: Context, config?: Config): void {
-  // The live source the surfaces read: the settings section once the web
-  // settings surface is served, the composition entry otherwise.
-  let current: () => Config = () => config ?? {}
-  let isSettingsBound = false
-
+function applyImpl(ctx: Context, config?: ResolvedConfig): void {
   const store = new HostStore()
   const engine = new SshEngine(store)
   ctx.effect(() => () => { engine.dispose() }, 'dsh-ssh: engine')
 
-  const resolve = (): Config => {
-    const value = current()
-    let enabled = value.enabled ?? true
-    // When dsh-ssh was seeded with enabled: false (e.g. from an aggregate profile line),
-    // but the user has never explicitly configured settings (not bound yet)
-    // AND already has active host records in dsh-ssh.json, keep the plugin enabled so
+  const resolve = (): { announceToAgent: boolean; enabled: boolean } => {
+    let enabled = readConfigField(config?.enabled, DEFAULT_ENABLED)
+    // When dsh-ssh was seeded with enabled: false (e.g. from an aggregate profile
+    // line), but the profile's own entry config never set the switch AND the user
+    // already has active host records in dsh-ssh.json, keep the plugin enabled so
     // existing users are not broken upon upgrade (#1250).
-    if (enabled === false && !isSettingsBound && store.list().length > 0) {
+    if (enabled === false && profileConfig(ctx)?.enabled === undefined && store.list().length > 0) {
       enabled = true
     }
     return {
-      announceToAgent: value.announceToAgent ?? DEFAULT_ANNOUNCE,
+      announceToAgent: readConfigField(config?.announceToAgent, DEFAULT_ANNOUNCE),
       enabled,
     }
   }
@@ -117,7 +168,7 @@ function applyImpl(ctx: Context, config?: Config): void {
   // System-prompt announcement.
   let disposeSection: (() => void) | undefined
 
-  // Register (or drop) every surface to match the current source. Each group
+  // Register (or drop) every surface to match the resolved config. Each group
   // is kept under one disposer: re-registering first tears the old one down
   // so duplicate-name registrations never throw.
   const sync = (): void => {
@@ -162,29 +213,11 @@ function applyImpl(ctx: Context, config?: Config): void {
     )
   }
 
-  ctx.inject(['settings'], (settingsCtx) => {
-    try {
-      if (typeof settingsCtx.settings?.installSection === 'function') {
-        settingsCtx.settings.installSection(ctx, SSH_SETTINGS_NAMESPACE, Config, config ?? {}, {
-          setSource: (source) => {
-            isSettingsBound = true
-            current = source
-            sync()
-          },
-          onChange: sync,
-        })
-      } else if (typeof settingsCtx.settings?.register === 'function') {
-        const scope = settingsCtx.settings.register(SSH_SETTINGS_NAMESPACE, Config, { base: config ?? {} })
-        isSettingsBound = true
-        current = () => scope?.get?.() ?? (config ?? {})
-        scope?.watch?.(() => { sync() })
-      }
-    } catch {
-      // Defensive fallback against settings registration differences
-    }
-  })
+  // A settings edit is committed into this instance's config references and
+  // announced on the owning fiber (the entry is not remounted), so the
+  // surfaces are re-derived from the new values here.
+  ctx.on('loader/volatile-update', () => { sync() })
 
-  // Initial registration from the composition entry (covers deployments with
-  // no settings service, whose installSection never fires its hooks).
+  // Initial registration from the config the Host activated this row with.
   sync()
 }