dsh-vision-router 2.3.0 → 3.0.0

package/lib/proxy-dispatcher-pool.js

@@ -1,96 +1,155 @@
-async function closeDispatcher(dispatcher) {
-  if (!dispatcher || (typeof dispatcher !== 'object' && typeof dispatcher !== 'function')) return
-  try {
-    if (typeof dispatcher.close === 'function') {
-      await dispatcher.close()
-      return
-    }
-    if (typeof dispatcher.destroy === 'function') await dispatcher.destroy()
-  } catch {
-    // Cleanup must not turn a completed request into an unload failure.
-  }
+import { proxyDispatcherLike, } from './proxy-routing.js';
+function objectRecord(value) {
+    return value !== null && (typeof value === 'object' || typeof value === 'function')
+        ? value
+        : undefined;
 }
-
-export function createProxyDispatcherPool({ importUndici = () => import('undici'), label = 'vision proxy transport' } = {}) {
-  let cachedEntry
-  let disposed = false
-  let disposePromise
-  const liveEntries = new Set()
-
-  const maybeCloseEntry = (entry) => {
-    if (!entry.obsolete || entry.refs !== 0 || !entry.dispatcher || entry.closing) return
-    entry.closing = Promise.resolve().then(() => closeDispatcher(entry.dispatcher)).finally(() => {
-      liveEntries.delete(entry)
-      entry.resolveDone()
-    })
-  }
-  const retireEntry = (entry) => {
-    if (!entry || entry.obsolete) return
-    entry.obsolete = true
-    maybeCloseEntry(entry)
-  }
-  const createEntry = (proxyUrl) => {
-    let resolveDone
-    const entry = {
-      proxyUrl, refs: 0, obsolete: false, dispatcher: undefined, getGlobalDispatcher: undefined, closing: undefined,
-      done: new Promise((resolve) => { resolveDone = resolve }), resolveDone: () => resolveDone(), promise: undefined,
-    }
-    liveEntries.add(entry)
-    entry.promise = Promise.resolve().then(() => importUndici()).then(({ ProxyAgent, getGlobalDispatcher }) => {
-      if (typeof ProxyAgent !== 'function') throw new Error(`${label}: undici ProxyAgent is unavailable`)
-      if (typeof getGlobalDispatcher !== 'function') throw new Error(`${label}: undici getGlobalDispatcher is unavailable`)
-      entry.getGlobalDispatcher = getGlobalDispatcher
-      entry.dispatcher = new ProxyAgent(proxyUrl)
-      maybeCloseEntry(entry)
-      return entry.dispatcher
-    }).catch((error) => {
-      if (cachedEntry === entry) cachedEntry = undefined
-      liveEntries.delete(entry)
-      entry.resolveDone()
-      throw error
-    })
-    return entry
-  }
-  const reconcile = (proxyUrl) => {
-    if (cachedEntry && cachedEntry.proxyUrl !== proxyUrl) {
-      const previous = cachedEntry
-      cachedEntry = undefined
-      retireEntry(previous)
-    }
-  }
-  const acquire = async (proxyUrl) => {
-    if (disposed) throw new Error(`${label}: dispatcher pool is disposed`)
-    let entry = cachedEntry
-    if (!entry || entry.proxyUrl !== proxyUrl || entry.obsolete) {
-      if (entry) retireEntry(entry)
-      entry = createEntry(proxyUrl)
-      cachedEntry = entry
-    }
-    entry.refs += 1
+async function closeDispatcher(dispatcher) {
+    const value = objectRecord(dispatcher);
+    if (value === undefined)
+        return;
     try {
-      const dispatcher = await entry.promise
-      let released = false
-      return { dispatcher, getGlobalDispatcher: entry.getGlobalDispatcher, release() {
-        if (released) return
-        released = true
-        entry.refs = Math.max(0, entry.refs - 1)
-        maybeCloseEntry(entry)
-      } }
-    } catch (error) {
-      entry.refs = Math.max(0, entry.refs - 1)
-      maybeCloseEntry(entry)
-      throw error
+        if (typeof value.close === 'function') {
+            await value.close.call(dispatcher);
+            return;
+        }
+        if (typeof value.destroy === 'function')
+            await value.destroy.call(dispatcher);
     }
-  }
-  const dispose = () => {
-    if (disposePromise) return disposePromise
-    disposed = true
-    const current = cachedEntry
-    cachedEntry = undefined
-    retireEntry(current)
-    for (const entry of liveEntries) retireEntry(entry)
-    disposePromise = Promise.all([...liveEntries].map((entry) => entry.done)).then(() => undefined)
-    return disposePromise
-  }
-  return Object.freeze({ acquire, reconcile, dispose })
+    catch {
+        // Cleanup must not turn a completed request into an unload failure.
+    }
+}
+export function createProxyDispatcherPool({ importUndici = () => import('undici'), label = 'vision proxy transport', } = {}) {
+    let cachedEntry;
+    let disposed = false;
+    let disposePromise;
+    const liveEntries = new Set();
+    const maybeCloseEntry = (entry) => {
+        if (!entry.obsolete || entry.refs !== 0 || !entry.dispatcher || entry.closing)
+            return;
+        entry.closing = Promise.resolve()
+            .then(() => closeDispatcher(entry.dispatcher))
+            .finally(() => {
+            liveEntries.delete(entry);
+            entry.resolveDone();
+        });
+    };
+    const retireEntry = (entry) => {
+        if (!entry || entry.obsolete)
+            return;
+        entry.obsolete = true;
+        maybeCloseEntry(entry);
+    };
+    const createEntry = (proxyUrl) => {
+        let resolveDone;
+        const done = new Promise((resolve) => { resolveDone = resolve; });
+        const entry = {
+            proxyUrl,
+            refs: 0,
+            obsolete: false,
+            dispatcher: undefined,
+            getGlobalDispatcher: undefined,
+            closing: undefined,
+            done,
+            resolveDone,
+            promise: undefined,
+        };
+        liveEntries.add(entry);
+        entry.promise = Promise.resolve()
+            .then(importUndici)
+            .then((moduleValue) => {
+            const module = objectRecord(moduleValue);
+            const ProxyAgent = module?.ProxyAgent;
+            const getGlobalDispatcher = module?.getGlobalDispatcher;
+            if (typeof ProxyAgent !== 'function') {
+                throw new Error(`${label}: undici ProxyAgent is unavailable`);
+            }
+            if (typeof getGlobalDispatcher !== 'function') {
+                throw new Error(`${label}: undici getGlobalDispatcher is unavailable`);
+            }
+            const Constructor = ProxyAgent;
+            const dispatcher = new Constructor(proxyUrl);
+            if (!proxyDispatcherLike(dispatcher)) {
+                throw new Error(`${label}: undici ProxyAgent has no dispatcher contract`);
+            }
+            entry.getGlobalDispatcher = () => {
+                const globalDispatcher = getGlobalDispatcher.call(moduleValue);
+                if (!proxyDispatcherLike(globalDispatcher)) {
+                    throw new Error(`${label}: undici global dispatcher has no dispatcher contract`);
+                }
+                return globalDispatcher;
+            };
+            entry.dispatcher = dispatcher;
+            maybeCloseEntry(entry);
+            return entry.dispatcher;
+        })
+            .catch((error) => {
+            if (cachedEntry === entry)
+                cachedEntry = undefined;
+            liveEntries.delete(entry);
+            entry.resolveDone();
+            throw error;
+        });
+        return entry;
+    };
+    const reconcile = (proxyUrl) => {
+        if (cachedEntry && cachedEntry.proxyUrl !== proxyUrl) {
+            const previous = cachedEntry;
+            cachedEntry = undefined;
+            retireEntry(previous);
+        }
+    };
+    const acquire = async (proxyUrl) => {
+        if (disposed)
+            throw new Error(`${label}: dispatcher pool is disposed`);
+        let entry = cachedEntry;
+        if (!entry || entry.proxyUrl !== proxyUrl || entry.obsolete) {
+            if (entry)
+                retireEntry(entry);
+            entry = createEntry(proxyUrl);
+            cachedEntry = entry;
+        }
+        entry.refs += 1;
+        try {
+            const promise = entry.promise;
+            if (!promise)
+                throw new Error(`${label}: dispatcher entry failed to initialize`);
+            const dispatcher = await promise;
+            const getGlobalDispatcher = entry.getGlobalDispatcher;
+            if (!getGlobalDispatcher) {
+                throw new Error(`${label}: global dispatcher accessor is unavailable`);
+            }
+            let released = false;
+            return {
+                dispatcher,
+                getGlobalDispatcher,
+                release() {
+                    if (released)
+                        return;
+                    released = true;
+                    entry.refs = Math.max(0, entry.refs - 1);
+                    maybeCloseEntry(entry);
+                },
+            };
+        }
+        catch (error) {
+            entry.refs = Math.max(0, entry.refs - 1);
+            maybeCloseEntry(entry);
+            throw error;
+        }
+    };
+    const dispose = () => {
+        if (disposePromise)
+            return disposePromise;
+        disposed = true;
+        const current = cachedEntry;
+        cachedEntry = undefined;
+        retireEntry(current);
+        for (const entry of liveEntries)
+            retireEntry(entry);
+        disposePromise = Promise.all([...liveEntries].map((entry) => entry.done)).then(() => undefined);
+        return disposePromise;
+    };
+    return Object.freeze({ acquire, reconcile, dispose });
 }

package/lib/proxy-routing.js

@@ -1,76 +1,100 @@
-import { domainToASCII } from 'node:url'
-
+import { URL, domainToASCII } from 'node:url';
 function objectLike(value) {
-  return value !== null && (typeof value === 'object' || typeof value === 'function')
+    return value !== null && (typeof value === 'object' || typeof value === 'function');
 }
-
 /** True only when the user explicitly configured a Vision Router proxy override. */
 export function visionProxyOverrideConfigured(config = {}) {
-  const value = config && typeof config === 'object' ? config.proxy : undefined
-  return typeof value === 'string' && value.trim() !== ''
+    const value = objectLike(config)
+        ? config.proxy
+        : undefined;
+    return typeof value === 'string' && value.trim() !== '';
 }
-
 /**
  * Canonicalize a configured/request hostname for proxy admission only.
  * Persisted settings stay untouched; this removes DNS presentation differences
  * (case, one trailing dot and Unicode) without broadening the suffix policy.
  */
 export function canonicalProxyHost(value) {
-  let host = String(value ?? '').trim()
-  if (host === '') return ''
-  if (host.endsWith('.')) host = host.slice(0, -1)
-  if (host === '') return ''
-
-  // WHATWG URL.hostname keeps IPv6 literals bracketed. domainToASCII does not
-  // accept a bare IPv6 literal, so preserve the bracketed spelling and only
-  // case-fold it. Proxy hosts are otherwise DNS names and can be IDNA-folded.
-  if (host.startsWith('[') && host.endsWith(']')) return host.toLowerCase()
-  const ascii = domainToASCII(host)
-  return (ascii || host).toLowerCase()
+    let host = String(value ?? '').trim();
+    if (host === '')
+        return '';
+    if (host.endsWith('.'))
+        host = host.slice(0, -1);
+    if (host === '')
+        return '';
+    // WHATWG URL.hostname keeps IPv6 literals bracketed. domainToASCII does not
+    // accept a bare IPv6 literal, so preserve the bracketed spelling and only
+    // case-fold it. Proxy hosts are otherwise DNS names and can be IDNA-folded.
+    if (host.startsWith('[') && host.endsWith(']'))
+        return host.toLowerCase();
+    const ascii = domainToASCII(host);
+    return (ascii || host).toLowerCase();
 }
-
 /** Exact host or subdomain match using one shared proxy-host interpretation. */
-export function proxyHostMatchesAny(hostname, hosts) {
-  const host = canonicalProxyHost(hostname)
-  if (host === '') return false
-  return (hosts ?? []).some((raw) => {
-    const candidate = canonicalProxyHost(raw)
-    return candidate !== '' && (host === candidate || host.endsWith(`.${candidate}`))
-  })
+export function proxyHostMatchesAny(hostname, hosts = []) {
+    const host = canonicalProxyHost(hostname);
+    if (host === '')
+        return false;
+    return hosts.some((raw) => {
+        const candidate = canonicalProxyHost(raw);
+        return candidate !== '' && (host === candidate || host.endsWith(`.${candidate}`));
+    });
 }
-
 export function proxyDispatcherLike(value) {
-  return objectLike(value) && typeof value.dispatch === 'function'
+    return objectLike(value)
+        && typeof value.dispatch === 'function';
 }
-
 function proxyDispatchOriginUrl(options) {
-  try {
-    const origin = options?.origin
-    if (origin instanceof URL) return origin
-    if (origin !== undefined && origin !== null) return new URL(String(origin))
-  } catch {
-    // Unknown dispatcher shapes never authorize the plugin proxy.
-  }
-  return undefined
+    try {
+        const origin = objectLike(options)
+            ? options.origin
+            : undefined;
+        if (origin instanceof URL)
+            return origin;
+        if (origin !== undefined && origin !== null)
+            return new URL(String(origin));
+    }
+    catch {
+        // Unknown dispatcher shapes never authorize the plugin proxy.
+    }
+    return undefined;
 }
-
 /**
  * Preserve Fetch/Undici redirect semantics while keeping proxyHosts an upper
  * bound on every hop after a request has entered the DVR proxy override.
  * The fallback dispatcher is borrowed, never owned or closed by this selector.
  */
 export function createPerHopProxyDispatcher(proxyDispatcher, fallbackDispatcher, proxyHosts = []) {
-  if (!proxyDispatcherLike(proxyDispatcher) || !proxyDispatcherLike(fallbackDispatcher)) {
-    throw new TypeError('vision proxy hop selector requires proxy and fallback dispatchers')
-  }
-  const hosts = [...proxyHosts]
-  return Object.freeze({
-    dispatch(options, handler) {
-      const url = proxyDispatchOriginUrl(options)
-      const target = url && proxyHostMatchesAny(url.hostname, hosts)
-        ? proxyDispatcher
-        : fallbackDispatcher
-      return target.dispatch(options, handler)
-    },
-  })
+    if (!proxyDispatcherLike(proxyDispatcher) || !proxyDispatcherLike(fallbackDispatcher)) {
+        throw new TypeError('vision proxy hop selector requires proxy and fallback dispatchers');
+    }
+    const hosts = [...proxyHosts];
+    const proxy = proxyDispatcher;
+    const fallback = fallbackDispatcher;
+    // Fetch types model a full Undici Dispatcher, while fetch dispatch itself
+    // consumes the dispatch() seam. A Host dispatcher may expose dispatch as a
+    // frozen/non-configurable own property; using that borrowed object directly
+    // as a Proxy target would make an overriding get trap violate ECMAScript
+    // Proxy invariants. Use a neutral shell with the same prototype instead.
+    //
+    // Every non-dispatch read still resolves against and binds to the real
+    // fallback Dispatcher, so the wrapper does not become a second owner for
+    // close/destroy/event state and instanceof-style prototype checks remain
+    // compatible with the borrowed dispatcher.
+    const shell = Object.create(Object.getPrototypeOf(fallback));
+    return new Proxy(shell, {
+        get(_target, property) {
+            if (property === 'dispatch') {
+                return (options, handler) => {
+                    const url = proxyDispatchOriginUrl(options);
+                    const selected = url && proxyHostMatchesAny(url.hostname, hosts)
+                        ? proxy
+                        : fallback;
+                    return selected.dispatch(options, handler);
+                };
+            }
+            const value = Reflect.get(fallback, property, fallback);
+            return typeof value === 'function' ? value.bind(fallback) : value;
+        },
+    });
 }

package/lib/proxy-url-compat.js

@@ -1,12 +1,5 @@
-/**
- * Project the persisted proxy setting into the syntax accepted by Undici.
- *
- * Older Vision Router settings copy explicitly recommended `socks5h://`.
- * Keep that persisted user intent untouched and translate only at the runtime
- * dispatcher boundary. Deliberately do not validate or reinterpret any other
- * proxy scheme here: Undici remains the execution authority.
- */
 export function effectiveProxyUrlForUndici(value) {
-  if (typeof value !== 'string') return value
-  return value.replace(/^(\s*)socks5h:/i, '$1socks5:')
+    if (typeof value !== 'string')
+        return value;
+    return value.replace(/^(\s*)socks5h:/i, '$1socks5:');
 }

package/lib/public-config.js

@@ -1,10 +1,8 @@
-import z from '@deepseek-ai/schemastery'
-
+import z from '@deepseek-ai/schemastery';
 // Increment whenever the browser-visible settings contract gains a field whose
 // absence changes write semantics. The resolved schema also publishes this as
 // a read-only-by-convention handshake for browser/Host compatibility checks.
-export const SETTINGS_CONTRACT_REVISION = 7
-
+export const SETTINGS_CONTRACT_REVISION = 7;
 /**
  * Compose DVR's public product settings onto the mature Core schema.
  *
@@ -14,44 +12,25 @@ export const SETTINGS_CONTRACT_REVISION = 7
  * exported contract and runtime validation drift apart.
  */
 export function composePublicVisionConfig(coreConfig) {
-  if (!coreConfig || typeof coreConfig.set !== 'function') {
-    throw new TypeError('Vision Router public config requires a Schemastery object schema')
-  }
-
-  coreConfig.set('progressiveTools', z.boolean().default(false))
-
-  // Keep provider/task/turn timeout layers coherent. The whole-turn budget is
-  // an optional safety cap: 0 remains unlimited for long-running agent turns.
-  coreConfig.set(
-    'visionTaskTimeoutMs',
-    z.number().step(1000).min(1000).max(180000).default(120000),
-  )
-  coreConfig.set('visionTurnBudgetMs', z.number().step(1000).min(0).max(600000).default(0))
-
-  // Both visible settings entry points edit the same Host-owned namespace.
-  coreConfig.set('visionDepth', z.union(['fast', 'standard', 'deep', 'custom']).default('standard'))
-  coreConfig.set('visionDepthMaxCalls', z.number().step(1).min(0).max(100).default(0))
-
-  // Product semantics: ordered remains the safe default. Auto execution and
-  // background measurement each require explicit live user authority.
-  coreConfig.set('routingMode', z.union(['ordered', 'auto']).default('ordered'))
-  coreConfig.set(
-    'routingPreference',
-    z.union(['balanced', 'quality', 'speed', 'local']).default('balanced'),
-  )
-  coreConfig.set(
-    'backgroundBenchmarking',
-    z.union(['local-free', 'all', 'off']).default('off'),
-  )
-
-  // Remote Settings remains an explicit opt-in product permission. The remote
-  // risk dialog is a reminder/acknowledgement, not a server-side auth proof.
-  coreConfig.set('allowRemoteSettings', z.boolean().default(false))
-
-  coreConfig.set(
-    'settingsContractRevision',
-    z.number().step(1).min(1).max(SETTINGS_CONTRACT_REVISION).default(SETTINGS_CONTRACT_REVISION),
-  )
-
-  return coreConfig
+    if (!coreConfig || typeof coreConfig.set !== 'function') {
+        throw new TypeError('Vision Router public config requires a Schemastery object schema');
+    }
+    coreConfig.set('progressiveTools', z.boolean().default(false));
+    // Keep provider/task/turn timeout layers coherent. The whole-turn budget is
+    // an optional safety cap: 0 remains unlimited for long-running agent turns.
+    coreConfig.set('visionTaskTimeoutMs', z.number().step(1000).min(1000).max(180000).default(120000));
+    coreConfig.set('visionTurnBudgetMs', z.number().step(1000).min(0).max(600000).default(0));
+    // Both visible settings entry points edit the same Host-owned namespace.
+    coreConfig.set('visionDepth', z.union(['fast', 'standard', 'deep', 'custom']).default('standard'));
+    coreConfig.set('visionDepthMaxCalls', z.number().step(1).min(0).max(100).default(0));
+    // Product semantics: ordered remains the safe default. Auto execution and
+    // background measurement each require explicit live user authority.
+    coreConfig.set('routingMode', z.union(['ordered', 'auto']).default('ordered'));
+    coreConfig.set('routingPreference', z.union(['balanced', 'quality', 'speed', 'local']).default('balanced'));
+    coreConfig.set('backgroundBenchmarking', z.union(['local-free', 'all', 'off']).default('off'));
+    // Remote Settings remains an explicit opt-in product permission. The remote
+    // risk dialog is a reminder/acknowledgement, not a server-side auth proof.
+    coreConfig.set('allowRemoteSettings', z.boolean().default(false));
+    coreConfig.set('settingsContractRevision', z.number().step(1).min(1).max(SETTINGS_CONTRACT_REVISION).default(SETTINGS_CONTRACT_REVISION));
+    return coreConfig;
 }

package/lib/public-entry.d.ts

@@ -0,0 +1,148 @@
+import '@deepseek-ai/schemastery'
+
+export const name: 'vision-router'
+export const inject: readonly ['tools', 'llm']
+export const SETTINGS_CONTRACT_REVISION: 7
+
+export const Config: Schemastery<
+  Record<string, unknown>,
+  Record<string, unknown>
+>
+
+/**
+ * Minimum Cordis shape the plugin requires at the package root.
+ *
+ * Every supported DSH Host line mounts a Cordis lifecycle context, so this is a
+ * precondition rather than an optional capability: cords are installed through
+ * `ctx.effect()`, and a generation that cannot own its cleanup is refused
+ * instead of publishing routes, wrappers or global mutations without an owner.
+ */
+export interface CordisLifecycleContext {
+  readonly effect: (...args: any[]) => unknown
+}
+
+/**
+ * Install the plugin on a Cordis plugin context.
+ *
+ * @param ctx Host plugin context. Must expose `effect()`, otherwise a
+ *   `TypeError` is thrown before anything is published.
+ * @throws {TypeError} when `ctx.effect` is not callable.
+ */
+export function apply(
+  ctx: CordisLifecycleContext,
+  config?: Record<string, unknown>,
+): unknown
+
+export interface LegacySessionSurfaceReplacementIntent {
+  readonly surfaceOp: Readonly<{
+    op: 'replace'
+    start: number
+    end: number
+  }>
+  readonly sourceEventSeqs: readonly [number]
+}
+
+export interface CurrentSessionSurfaceReplacementIntent {
+  readonly surfaceOp: Readonly<{
+    op: 'replace'
+    startSeq: number
+    endSeq: number
+  }>
+  readonly sourceEventSeqs: readonly [number]
+}
+
+export type SessionSurfaceReplacementIntent =
+  | LegacySessionSurfaceReplacementIntent
+  | CurrentSessionSurfaceReplacementIntent
+
+/**
+ * Build the Host-owned Session surface replacement intent for one exact node.
+ *
+ * @param seq Non-negative safe integer sequence number. `-0`, fractional,
+ *   `NaN` and `Infinity` are rejected.
+ * @throws {TypeError} when `seq` is not a non-negative safe integer.
+ */
+export function sessionSurfaceReplacementIntent(
+  session: unknown,
+  seq: number,
+): SessionSurfaceReplacementIntent | undefined
+
+export interface VisionAttachmentAdmissionLogger {
+  info?: (message: string, ...args: unknown[]) => unknown
+  warn?: (message: string, ...args: unknown[]) => unknown
+}
+
+export interface VisionAttachmentAdmissionOptions {
+  readonly maxImageDimension?: number
+  readonly normalizedImageMaxPixels?: number
+  readonly normalizedImageMaxDimension?: number
+  readonly normalizedImageMaxBytes?: number
+}
+
+export interface VisionAttachmentAdmissionResult {
+  readonly changed: boolean
+  readonly reason: string
+  readonly limits?: Readonly<Record<string, unknown>>
+  readonly normalizationPolicy?: Readonly<Record<string, unknown>>
+}
+
+export function hasBatchAttachmentContract(ctx: unknown): boolean
+
+export function hostOwnsOfficialDeepSeekProvider(ctx: unknown): boolean
+
+export function ensureVisionAttachmentAdmissionPolicy(
+  ctx: unknown,
+  logger?: VisionAttachmentAdmissionLogger,
+  options?: VisionAttachmentAdmissionOptions,
+): VisionAttachmentAdmissionResult
+
+export function installVisionAttachmentAdmissionPolicy(
+  ctx: unknown,
+  logger?: VisionAttachmentAdmissionLogger,
+  options?: VisionAttachmentAdmissionOptions,
+): VisionAttachmentAdmissionResult
+
+/**
+ * Service reads this helper performs on the given context.
+ *
+ * `llm` is read through the non-owning `get()` probe when the context provides
+ * one; a context without it must not throw on an unresolved `llm` property.
+ */
+export interface HostOwnershipContext {
+  readonly get?: (name: string) => unknown
+  readonly llm?: unknown
+}
+
+export function protectHostProviderOwnership<Context extends HostOwnershipContext>(
+  ctx: Context,
+): Context
+
+export interface HostSettingsCompatibilityOptions {
+  readonly namespace: string
+  readonly Config: unknown
+  readonly installSettingsSection?: (
+    ctx: unknown,
+    namespace: unknown,
+    Config: unknown,
+    entryConfig: Record<string, unknown>,
+    hooks: unknown,
+  ) => unknown
+}
+
+/** Context shape required to register and own the compatibility settings section. */
+export interface HostSettingsCompatibilityContext {
+  readonly inject?: (...args: any[]) => unknown
+}
+
+/**
+ * Present DVR's settings face on Hosts whose Settings service predates the
+ * current contract.
+ *
+ * @throws {TypeError} when `ctx.inject` is not callable, before any settings
+ *   section or watcher is registered.
+ */
+export function installHostSettingsCompatibility<Context extends HostSettingsCompatibilityContext>(
+  ctx: Context,
+  entryConfig: Record<string, unknown>,
+  options: HostSettingsCompatibilityOptions,
+): Context