dsh-vision-router 2.2.8 → 2.3.0

package/lib/dsh-contract-compat.js

@@ -2,12 +2,17 @@ import { inspectDshHostCapabilities } from './dsh-host-capabilities.js'
 
 /**
  * Compatibility inventory
- * Reason: preserve Vision Router's released behavior across the supported DSH Host window.
- * Host gap: attachment ownership, settings-section and adapter-ownership seams differ across supported Hosts.
- * First needed for: rc.6 minimum support and the later batch-attachment/settings migration.
- * Feature detection: concrete attachment/settings/LLM methods only; never a DSH version string.
- * Removal condition: the minimum supported Host natively provides every seam used below and the legacy profile overlay is outside the support window.
- * Tests: rc6-rc7-compat, rc6-real-settings-persistence, attachment-admission-policy, DSH contract CI.
+ * Reason: preserve the remaining Settings/session/provider ownership and durable
+ * profile migrations across DVR 2.3's supported DSH 0.1.5+ Host window.
+ * Host gap: current supported Hosts still span multiple Settings/session
+ * lifecycle shapes, while historical persisted attachment policy overlays may
+ * survive an in-place Host upgrade.
+ * Feature detection: concrete attachment/settings/session/LLM methods only;
+ * never a DSH version string.
+ * Removal condition: each retained capability bridge has a current-Host or
+ * durable-data consumer; pre-floor Host-only branches are removed in R2.3.
+ * Tests: compatibility contracts, minimum Host Settings persistence,
+ * attachment-admission policy, and DSH contract CI.
  */
 
 const HOST_OWNED_ROUTES = new Set(['deepseek-official', 'deepseek-official-native'])
@@ -654,23 +659,3 @@ export function installHostSettingsCompatibility(ctx, entryConfig, options = {})
     },
   })
 }
-
-/**
- * The minimum-supported host keeps the narrow Termux fallback. A
- * batch-capable attachment service keeps AttachmentId store-owned, so that
- * host context passes through untouched.
- */
-export function attachmentContextForContract(ctx, logger, options = {}) {
-  installDshHostCapabilityDiagnostics(ctx)
-  if (hasBatchAttachmentContract(ctx)) return ctx
-  const install = options.installAndroidAttachmentCompat
-  if (typeof install !== 'function') return ctx
-  return install(ctx, logger, options.android)
-}
-
-// Transitional aliases for external/tests written against the rc.7-era names.
-// New code must consume the capability-named exports above so future DSH
-// releases do not accrete `if (rc8) / if (rc9)` branches.
-export const isRc7ContractRuntime = hasBatchAttachmentContract
-export const protectRc7ProviderOwnership = protectHostProviderOwnership
-export const installRc7SettingsCompatibility = installHostSettingsCompatibility

package/lib/dsh-support-window.js

@@ -1,6 +1,6 @@
 export const DSH_SUPPORT_WINDOW = Object.freeze({
-  dvrTrain: '2.2.x',
-  minimum: '0.1.0-rc.8',
+  dvrTrain: '2.3.x',
+  minimum: '0.1.5',
   currentStable: '0.1.5-rc.3',
 })
 
@@ -49,7 +49,7 @@ export function formatDshSupportWindowLines(capabilities = {}) {
     `  support floor: DVR ${DSH_SUPPORT_WINDOW.dvrTrain} -> DSH ${DSH_SUPPORT_WINDOW.minimum}`,
     'DSH compatibility verification evidence:',
     `  exact stable: ${DSH_VERIFICATION_EVIDENCE.exactStable}`,
-    `  exact next/rc (not a support claim): ${DSH_VERIFICATION_EVIDENCE.exactPreview}`,
+    `  exact supported 0.2.x boundary: ${DSH_VERIFICATION_EVIDENCE.exactPreview}`,
     `  scheduled stable canary: npm dist-tag ${DSH_VERIFICATION_EVIDENCE.stableCanaryDistTag}`,
     `  scheduled next/rc canary: npm dist-tag ${DSH_VERIFICATION_EVIDENCE.nextCanaryDistTag}`,
     `  scheduled alpha/pre-release canary: npm dist-tag ${DSH_VERIFICATION_EVIDENCE.previewCanaryDistTag}`,

package/lib/http-compat.js

@@ -1,4 +1,3 @@
-import { currentVisionProviderTransport } from './vision-provider-transport.js'
 
 const GLM_4V_FLASH = /^glm-4v-flash(?:$|[-_.])/i
 export const DEFAULT_HTTP_ERROR_DETAIL_MAX_BYTES = 64 * 1024
@@ -278,7 +277,7 @@ function nextCompatibilityBody(body, detail) {
  */
 export async function fetchWithOpenAICompatibility(fetchImpl, input, init, context = {}) {
   if (typeof fetchImpl !== 'function') throw new TypeError('fetch implementation is required')
-  const transport = context.active === true ? currentVisionProviderTransport() : undefined
+  const transport = context.active === true ? context.providerTransport : undefined
   const requestFetch = transport
     ? (nextInput, nextInit) => transport.fetch(nextInput, nextInit, {
         providerName: context.providerName,

package/lib/local-remote-settings-permission.js

@@ -173,10 +173,16 @@ export function createVisionRouterLocalPermissionHttpHandler(settings, logger) {
   }
 }
 
-export const LOCAL_PERMISSION_CLIENT_PRELUDE = String.raw`(function(){
-  'use strict';
-  var ENDPOINT = '/_dsh/vision-router/remote-settings-permission';
-  var FIELD = 'allowRemoteSettings';
+/**
+ * Current-product browser boundary for the local allowRemoteSettings control.
+ * Host loader lifecycle compatibility stays outside this owner.
+ */
+export function createLocalRemoteSettingsPermissionClientBoundary(options = {}) {
+  var fetchImpl = options.fetchImpl
+  var ENDPOINT = options.endpoint
+  var FIELD = options.field
+  if (typeof ENDPOINT !== 'string' || ENDPOINT === '') throw new TypeError('local permission boundary requires endpoint')
+  if (typeof FIELD !== 'string' || FIELD === '') throw new TypeError('local permission boundary requires field')
   var scopeCache = typeof WeakMap === 'function' ? new WeakMap() : undefined;
   var binderCache = typeof WeakMap === 'function' ? new WeakMap() : undefined;
   var contextCache = typeof WeakMap === 'function' ? new WeakMap() : undefined;
@@ -189,11 +195,11 @@ export const LOCAL_PERMISSION_CLIENT_PRELUDE = String.raw`(function(){
   }
 
   async function writePermission(operation, value, revision) {
-    if (typeof fetch !== 'function') throw new Error('Vision Router local settings transport is unavailable');
+    if (typeof fetchImpl !== 'function') throw new Error('Vision Router local settings transport is unavailable');
     var payload = { operation: operation };
     if (operation === 'set') payload.value = value;
     if (Number.isInteger(revision) && revision >= 0) payload.expectedRevision = revision;
-    var response = await fetch(ENDPOINT, {
+    var response = await fetchImpl(ENDPOINT, {
       method: 'POST',
       headers: { 'content-type': 'application/json', accept: 'application/json' },
       body: JSON.stringify(payload)
@@ -366,6 +372,26 @@ export const LOCAL_PERMISSION_CLIENT_PRELUDE = String.raw`(function(){
     return wrapped;
   }
 
+
+  return { wrapContext: wrapContext }
+}
+
+export const LOCAL_PERMISSION_CLIENT_BOUNDARY_SOURCE =
+  'var createLocalRemoteSettingsPermissionClientBoundary = (' +
+  createLocalRemoteSettingsPermissionClientBoundary.toString() +
+  ');'
+
+export const LOCAL_PERMISSION_CLIENT_PRELUDE = String.raw`(function(){
+  'use strict';
+  ${LOCAL_PERMISSION_CLIENT_BOUNDARY_SOURCE}
+  var localPermissionBoundary = createLocalRemoteSettingsPermissionClientBoundary({
+    endpoint: '${LOCAL_REMOTE_SETTINGS_PERMISSION_PATH}',
+    field: '${LOCAL_REMOTE_SETTINGS_PERMISSION_FIELD}',
+    fetchImpl: typeof fetch === 'function'
+      ? function(url, options) { return fetch(url, options); }
+      : undefined
+  });
+
   function patchLoader(loader) {
     if (!loader || typeof loader.load !== 'function' || loader.load.__visionRouterLocalPermission) return;
     var original = loader.load;
@@ -379,7 +405,7 @@ export const LOCAL_PERMISSION_CLIENT_PRELUDE = String.raw`(function(){
               var apply = exports.apply;
               var wrappedApply = function(ctx) {
                 var rest = Array.prototype.slice.call(arguments, 1);
-                return apply.apply(exports, [wrapContext(ctx)].concat(rest));
+                return apply.apply(exports, [localPermissionBoundary.wrapContext(ctx)].concat(rest));
               };
               Object.defineProperty(wrappedApply, '__visionRouterLocalPermission', { value: true });
               exports.apply = wrappedApply;

package/lib/maintenance-routes.js

@@ -0,0 +1,136 @@
+import { randomBytes } from 'node:crypto'
+import { createCachedUpdateChecker } from './update-check.js'
+import { detectDshSelfUpdatePlan, runDshPluginUpdate } from './self-update.js'
+
+function json(res, status, body, headers = {}) {
+  res.writeHead(status, {
+    'content-type': 'application/json',
+    ...headers,
+  })
+  res.end(JSON.stringify(body))
+}
+
+/**
+ * Product-maintenance Web routes kept outside the visual Core.
+ *
+ * The supplied context must already carry DVR's Web capability/auth boundary;
+ * this installer deliberately owns only update-product state and the narrow
+ * per-route CSRF/replay checks that existed in Core before extraction.
+ */
+export function installVisionMaintenanceRoutes(ctx, options = {}) {
+  if (!ctx || typeof ctx.inject !== 'function') return
+  const logger = options.logger ?? ctx.logger
+  const updateChecker = options.updateChecker ?? createCachedUpdateChecker({
+    fetchImpl: (...args) => globalThis.fetch(...args),
+  })
+  const selfUpdatePlan = options.selfUpdatePlan ?? detectDshSelfUpdatePlan()
+  const updateRunner = options.runUpdate ?? runDshPluginUpdate
+  const tokenFactory = options.tokenFactory ?? (() => randomBytes(24).toString('base64url'))
+  let selfUpdateToken = tokenFactory()
+  let selfUpdateInFlight
+
+  const updateResultForClient = (result) => ({
+    ...result,
+    autoUpdate: {
+      supported: selfUpdatePlan.available === true,
+      method: selfUpdatePlan.available === true ? selfUpdatePlan.method : undefined,
+      profile: selfUpdatePlan.profile,
+      reason: selfUpdatePlan.available === true ? undefined : selfUpdatePlan.reason,
+      token:
+        selfUpdatePlan.available === true &&
+        result &&
+        result.ok === true &&
+        result.updateAvailable === true
+          ? selfUpdateToken
+          : undefined,
+    },
+  })
+
+  void updateChecker.check(false).then((result) => {
+    if (result && result.ok === true && result.updateAvailable === true) {
+      logger?.info?.(
+        'vision-router: update available %s -> %s',
+        result.currentVersion,
+        result.latestVersion,
+      )
+    }
+  })
+
+  ctx.inject(['webServer'], (webCtx) => {
+    webCtx.effect(
+      () => webCtx.webServer.register({
+        kind: 'exact',
+        path: '/_dsh/vision-router/update-check',
+        handler: async (req, res) => {
+          if (req.method !== 'GET') {
+            res.setHeader('Allow', 'GET')
+            res.writeHead(405)
+            res.end()
+            return
+          }
+          const force = /(?:[?&])force=1(?:&|$)/.test(String(req.url ?? ''))
+          const result = await updateChecker.check(force)
+          json(res, 200, updateResultForClient(result), { 'cache-control': 'no-store' })
+        },
+      }),
+      'vision-router: update-check route',
+    )
+
+    webCtx.effect(
+      () => webCtx.webServer.register({
+        kind: 'exact',
+        path: '/_dsh/vision-router/self-update',
+        handler: async (req, res) => {
+          if (req.method !== 'POST') {
+            res.setHeader('Allow', 'POST')
+            res.writeHead(405)
+            res.end()
+            return
+          }
+          const fetchSite = String(req.headers?.['sec-fetch-site'] ?? '')
+          if (fetchSite && fetchSite !== 'same-origin' && fetchSite !== 'none') {
+            json(res, 403, { ok: false, error: 'cross-origin update request rejected' })
+            return
+          }
+          const token = String(req.headers?.['x-dsh-vision-router-update-token'] ?? '')
+          if (!token || token !== selfUpdateToken) {
+            json(res, 403, { ok: false, error: 'invalid update token' })
+            return
+          }
+          if (selfUpdatePlan.available !== true) {
+            json(res, 409, { ok: false, error: 'automatic update is not safe for this DSH launch' })
+            return
+          }
+          try {
+            const fresh = await updateChecker.check(true)
+            if (!fresh || fresh.ok !== true) {
+              json(res, 502, { ok: false, error: fresh?.error || 'could not refresh update metadata' })
+              return
+            }
+            if (fresh.updateAvailable !== true) {
+              json(res, 409, { ok: false, error: 'no newer version is currently available' })
+              return
+            }
+            if (!selfUpdateInFlight) {
+              const pending = updateRunner(selfUpdatePlan, { targetVersion: fresh.latestVersion })
+              selfUpdateInFlight = pending
+              void pending.then(
+                () => { if (selfUpdateInFlight === pending) selfUpdateInFlight = undefined },
+                () => { if (selfUpdateInFlight === pending) selfUpdateInFlight = undefined },
+              )
+            }
+            const result = await selfUpdateInFlight
+            selfUpdateToken = tokenFactory()
+            json(res, 200, result, { 'cache-control': 'no-store' })
+          } catch (error) {
+            json(res, 500, {
+              ok: false,
+              error: error && error.message ? error.message : String(error),
+            })
+          }
+        },
+      }),
+      'vision-router: self-update route',
+    )
+  })
+}

package/lib/public-config.js

@@ -0,0 +1,57 @@
+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
+
+/**
+ * Compose DVR's public product settings onto the mature Core schema.
+ *
+ * Schemastery object schemas expose set() as the supported replacement seam.
+ * Mutating the supplied object is deliberate: Core later registers this exact
+ * Config identity with Settings, so a cloned/public-only schema would let the
+ * 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
+}

package/lib/public-entry.js

@@ -2,10 +2,7 @@ import './abort-signal-compat.js'
 import * as base from '../entry.js'
 import { createVisionToggleRootHardening } from './vision-toggle-root-hardening.js'
 import { contextWithVisionRoutingTopologyRefresh } from './vision-routing-topology-refresh.js'
-import {
-  createVisionProviderTransport,
-  installVisionProviderTransport,
-} from './vision-provider-transport.js'
+import { createVisionProviderTransport } from './vision-provider-transport.js'
 import { installLegacyGlobalProxyBoundary } from './legacy-global-proxy-boundary.js'
 import { installDsh017SettingsCompatibility } from './dsh-settings-017-compat.js'
 import { installDsh017RootLocalSettingsTransport } from './web/dsh-settings-017-root-transport.js'
@@ -59,12 +56,10 @@ export function apply(ctx, config = {}) {
     ctx: hardening.ctx,
     config: () => liveVisionConfig(hardening.ctx, config),
   })
-  const releaseTransportRegistry = installVisionProviderTransport(transport)
   let transportReleased = false
   const releaseTransport = () => {
     if (transportReleased) return
     transportReleased = true
-    releaseTransportRegistry()
     void transport.dispose()
   }
   try {
@@ -72,7 +67,7 @@ export function apply(ctx, config = {}) {
       () => releaseTransport,
       'vision-router: provider transport',
     )
-    const result = base.apply(runtimeCtx, hardening.config)
+    const result = base.apply(runtimeCtx, hardening.config, { providerTransport: transport })
     installLegacyGlobalProxyBoundary(runtimeCtx, hardening.config)
     hardening.installClientBoundary()
     return result

package/lib/remote-settings-bridge.js

@@ -138,6 +138,17 @@ function conflictResult(error) {
   }
 }
 
+/**
+ * PRODUCT CONTRACT (2.3+): remote-settings enablement is reminder-only.
+ *
+ * `acceptedRisk === true` is an acknowledgement bit for the UX flow, not an
+ * authentication/authorization credential, proof of local presence, challenge
+ * response, one-time secret, or administrator approval. Do not strengthen this
+ * endpoint into a second security gate unless the product policy is explicitly
+ * changed. The real capability boundary is the narrow remote mutable-field
+ * allow-list plus the fields that remain local-only. The historical RPC/function
+ * name uses "authorize"; do not infer security-auth semantics from that name.
+ */
 export async function authorizeRemoteSettingsAfterRiskConfirmation(settings, payload, logger) {
   if (!payload || typeof payload !== 'object' || Array.isArray(payload) || payload.acceptedRisk !== true) {
     return badRequest('acceptedRisk must be true')

package/lib/remote-settings-risk-client-boundary.js

@@ -0,0 +1,155 @@
+/**
+ * Current-product remote Settings risk behavior shared by every browser
+ * attachment lifecycle. Host loader/version compatibility stays outside this owner.
+ *
+ * PRODUCT CONTRACT (2.3+): acceptedRisk is reminder/friction only. It is not
+ * authentication, authorization, local-presence proof, or a credential.
+ */
+export function createRemoteSettingsRiskClientBoundary(options = {}) {
+  var confirmImpl = options.confirmImpl
+  var alertImpl = options.alertImpl
+  var locale = options.locale
+  var location = options.location
+  var normalizeLoopback = options.normalizeLoopback === true
+  var connectionCache = typeof WeakMap === 'function' ? new WeakMap() : undefined
+  var rpcCache = typeof WeakMap === 'function' ? new WeakMap() : undefined
+  var contextCache = typeof WeakMap === 'function' ? new WeakMap() : undefined
+  var authorizationByRpc = typeof WeakMap === 'function' ? new WeakMap() : undefined
+  var CHANNEL = '/vision-router-settings'
+  var AUTHORIZE_ENDPOINT = 'authorize'
+
+  function localeValue() {
+    try {
+      var value = typeof locale === 'function' ? locale() : locale
+      return String(value || '').toLowerCase()
+    } catch (_) {
+      return ''
+    }
+  }
+
+  function chineseLocale() {
+    var lang = localeValue()
+    return lang === '' || lang.indexOf('zh') === 0
+  }
+
+  function riskMessage() {
+    return chineseLocale()
+      ? '启用远程设置？\n\n当前页面通过远程地址访问 DSH。启用后，能够访问此 trusted host 的客户端可以修改 Vision Router 已开放的设置。\n\nDSH trustedHosts 不是身份认证，请仅在你信任当前网络和访问者时继续。API Key、HTTP Provider 凭据、本地 Ollama / LM Studio、产物路径等未列入远程白名单的敏感配置仍不会开放。\n\n确定要允许远程修改设置吗？'
+      : 'Enable remote settings?\n\nThis page is accessing DSH through a remote address. After enabling this, clients that can reach this trusted host can change the Vision Router settings exposed by the remote allow-list.\n\nDSH trustedHosts is not authentication. Continue only if you trust the current network and its users. Sensitive settings outside the remote allow-list, including API keys, HTTP-provider credentials, local Ollama / LM Studio, and artifact paths, remain unavailable remotely.\n\nAllow remote settings?'
+  }
+
+  function isLoopbackLocation(locationLike) {
+    var hostname = locationLike && typeof locationLike.hostname === 'string'
+      ? locationLike.hostname.toLowerCase().replace(/^\[|\]$/g, '')
+      : ''
+    var protocol = locationLike && typeof locationLike.protocol === 'string'
+      ? locationLike.protocol.toLowerCase()
+      : ''
+    if (protocol === 'dsh-app:' && hostname === 'app') return true
+    if (hostname === 'localhost' || hostname.endsWith('.localhost') || hostname === '::1') return true
+    return /^127(?:\.\d{1,3}){3}$/.test(hostname)
+  }
+
+  function currentLocation() {
+    try { return typeof location === 'function' ? location() : location }
+    catch (_) { return undefined }
+  }
+
+  function isPermissionDisabledDescribe(channel, endpoint, result) {
+    return channel === CHANNEL
+      && endpoint === 'describe'
+      && result && result.ok === true
+      && result.value && result.value.enabled !== true
+      && result.value.reason === 'permission-disabled'
+  }
+
+  async function authorizeAndRefresh(target, call) {
+    var existing = authorizationByRpc && authorizationByRpc.get(target)
+    if (existing) return existing
+    var pending = (async function() {
+      if (typeof confirmImpl !== 'function' || confirmImpl(riskMessage()) !== true) return undefined
+      var authorized = await call.call(target, CHANNEL, AUTHORIZE_ENDPOINT, { acceptedRisk: true })
+      if (!authorized || authorized.ok !== true) {
+        var message = authorized && authorized.error && authorized.error.message
+          ? authorized.error.message
+          : 'Vision Router could not enable remote settings.'
+        try { if (typeof alertImpl === 'function') alertImpl(message) } catch (_) {}
+        return undefined
+      }
+      return call.call(target, CHANNEL, 'describe', {})
+    })()
+    if (authorizationByRpc) authorizationByRpc.set(target, pending)
+    try { return await pending }
+    finally {
+      if (authorizationByRpc && authorizationByRpc.get(target) === pending) {
+        authorizationByRpc.delete(target)
+      }
+    }
+  }
+
+  function wrapRpc(rpc) {
+    if (!rpc || (typeof rpc !== 'object' && typeof rpc !== 'function')) return rpc
+    if (rpcCache && rpcCache.has(rpc)) return rpcCache.get(rpc)
+    var wrapped = new Proxy(rpc, {
+      get: function(target, property) {
+        if (property === 'call') {
+          var call = Reflect.get(target, property, target)
+          if (typeof call !== 'function') return call
+          return async function(channel, endpoint) {
+            var result = await call.apply(target, arguments)
+            if (!isPermissionDisabledDescribe(channel, endpoint, result)) return result
+            var refreshed = await authorizeAndRefresh(target, call)
+            return refreshed || result
+          }
+        }
+        var value = Reflect.get(target, property, target)
+        return typeof value === 'function' ? value.bind(target) : value
+      }
+    })
+    if (rpcCache) rpcCache.set(rpc, wrapped)
+    return wrapped
+  }
+
+  function wrapConnection(connection) {
+    if (!connection || (typeof connection !== 'object' && typeof connection !== 'function')) return connection
+    if (connectionCache && connectionCache.has(connection)) return connectionCache.get(connection)
+    var wrapped = new Proxy(connection, {
+      get: function(target, property) {
+        if (property === 'isLoopback' && normalizeLoopback && isLoopbackLocation(currentLocation())) return true
+        if (property === 'rpc') return wrapRpc(Reflect.get(target, property, target))
+        var value = Reflect.get(target, property, target)
+        return typeof value === 'function' ? value.bind(target) : value
+      }
+    })
+    if (connectionCache) connectionCache.set(connection, wrapped)
+    return wrapped
+  }
+
+  function wrapContext(ctx) {
+    if (!ctx || typeof ctx !== 'object') return ctx
+    if (contextCache && contextCache.has(ctx)) return contextCache.get(ctx)
+    var wrapped = new Proxy(ctx, {
+      get: function(target, property) {
+        if (property === 'get') {
+          var get = Reflect.get(target, property, target)
+          if (typeof get !== 'function') return get
+          return function(name) {
+            var value = get.apply(target, arguments)
+            return name === 'connection' ? wrapConnection(value) : value
+          }
+        }
+        var value = Reflect.get(target, property, target)
+        return typeof value === 'function' ? value.bind(target) : value
+      }
+    })
+    if (contextCache) contextCache.set(ctx, wrapped)
+    return wrapped
+  }
+
+  return { wrapContext: wrapContext }
+}
+
+export const REMOTE_SETTINGS_RISK_CLIENT_BOUNDARY_SOURCE =
+  'var createRemoteSettingsRiskClientBoundary = (' +
+  createRemoteSettingsRiskClientBoundary.toString() +
+  ');'