dsh-vision-router 2.1.7 → 2.2.1

package/lib/dsh-contract-compat.js

@@ -26,6 +26,220 @@ const VISION_ROUTER_NORMALIZED_BYTES = LEGACY_VISION_ATTACHMENT_BYTES
 const HOST_CAPABILITIES_PATH = '/_dsh/vision-router/host-capabilities'
 const capabilityRouteInstalls = new WeakSet()
 
+function sessionQueryOf(ctx) {
+  if (!ctx || typeof ctx !== 'object') return undefined
+  try {
+    if (typeof ctx.get === 'function') {
+      const query = ctx.get('sessionQuery')
+      if (query && typeof query === 'object') return query
+    }
+  } catch {
+    // A partial/legacy Host may not expose SessionQuery through ctx.get().
+  }
+  try {
+    const query = ctx.sessionQuery
+    return query && typeof query === 'object' ? query : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Build the narrow bounded Session event reader used by durable surface repair.
+ * DSH rc.8+ exposes `sessionQuery.readEvent({ sessionId, seq })`; resolve the
+ * service at call time so Host service replacement/hot reload stays visible.
+ * Missing capability is explicit and lets isolated/legacy callers use their
+ * existing Session-local compatibility fallback. Once the Host advertises the
+ * reader, operational failures propagate instead of silently falling back to
+ * deprecated synchronous Session history.
+ */
+export function createSessionEventReader(ctx) {
+  return async function readSessionEvent(session, seq) {
+    const sessionId = session?.id
+    if (sessionId === undefined || sessionId === null) return { supported: false }
+    if (!Number.isSafeInteger(seq) || seq < 0 || Object.is(seq, -0)) {
+      throw new TypeError(`session event seq must be a non-negative safe integer, got ${String(seq)}`)
+    }
+    const query = sessionQueryOf(ctx)
+    if (!query || typeof query.readEvent !== 'function') return { supported: false }
+    const window = await query.readEvent({ sessionId, seq })
+    const event = window?.target
+    if (!event || typeof event !== 'object') {
+      throw new Error(`sessionQuery.readEvent returned no target for seq ${seq}`)
+    }
+    if (event.seq !== undefined && event.seq !== seq) {
+      throw new Error(`sessionQuery.readEvent returned seq ${String(event.seq)} for requested seq ${seq}`)
+    }
+    return { supported: true, event }
+  }
+}
+
+
+const SESSION_EVENT_TAIL_INITIAL_AFTER = 50
+const SESSION_EVENT_TAIL_MAX_EVENTS = 4096
+const SESSION_EVENT_TAIL_MAX_READS = 128
+
+function sessionQueryCode(error) {
+  return typeof error?.code === 'string' ? error.code : undefined
+}
+
+/**
+ * Read raw Session events strictly after one known committed seq through the
+ * Host-owned bounded `sessionQuery.readEvent()` window contract.
+ *
+ * The reader adapts to deployments that lower SessionQuery's configurable
+ * `readWindowMax`, never materializes the full Session log, and caps both
+ * events and Host reads. Missing capability is explicit. Operational failures
+ * from an advertised capability propagate to the caller; a cap is reported as
+ * `truncated` so routing can fail safe without a synchronous-history fallback.
+ */
+export function createSessionEventTailReader(ctx) {
+  let afterHint = SESSION_EVENT_TAIL_INITIAL_AFTER
+
+  const readWindow = async (query, sessionId, seq) => {
+    let after = afterHint
+    while (true) {
+      try {
+        const request = after > 0 ? { sessionId, seq, after } : { sessionId, seq }
+        const window = await query.readEvent(request)
+        afterHint = after
+        return { window, after }
+      } catch (error) {
+        if (sessionQueryCode(error) !== 'SESSION_QUERY_INVALID_WINDOW' || after <= 0) throw error
+        after = after <= 1 ? 0 : Math.floor(after / 2)
+      }
+    }
+  }
+
+  return async function readSessionEventTail(session, anchorSeq, options = {}) {
+    const sessionId = session?.id
+    if (sessionId === undefined || sessionId === null) return { supported: false }
+    if (!Number.isSafeInteger(anchorSeq) || anchorSeq < 0 || Object.is(anchorSeq, -0)) {
+      throw new TypeError(`session tail anchor seq must be a non-negative safe integer, got ${String(anchorSeq)}`)
+    }
+    const query = sessionQueryOf(ctx)
+    if (!query || typeof query.readEvent !== 'function') return { supported: false }
+
+    const collect = options?.collect !== false
+    const events = []
+    let capturedThroughSeq = anchorSeq
+    let cursor = anchorSeq
+    let inspected = 0
+    let reads = 0
+
+    while (reads < SESSION_EVENT_TAIL_MAX_READS) {
+      let result
+      try {
+        result = await readWindow(query, sessionId, cursor)
+      } catch (error) {
+        if (sessionQueryCode(error) === 'SESSION_QUERY_EVENT_NOT_FOUND' && cursor > anchorSeq) {
+          return { supported: true, events, capturedThroughSeq, truncated: false }
+        }
+        throw error
+      }
+      reads += 1
+
+      const window = result.window
+      const target = window?.target
+      if (!target || typeof target !== 'object' || target.seq !== cursor) {
+        throw new Error(`sessionQuery.readEvent returned an invalid target for seq ${cursor}`)
+      }
+      if (!Array.isArray(window.events) || window.events.length === 0) {
+        throw new Error(`sessionQuery.readEvent returned no event window for seq ${cursor}`)
+      }
+      const windowEvents = window.events
+      let expectedSeq = cursor
+      let endSeq = cursor
+      for (const event of windowEvents) {
+        const seq = event?.seq
+        if (!Number.isSafeInteger(seq) || seq !== expectedSeq) {
+          throw new Error(
+            `sessionQuery.readEvent returned non-contiguous seq ${String(seq)}; expected ${expectedSeq}`,
+          )
+        }
+        expectedSeq += 1
+        endSeq = seq
+        if (seq <= capturedThroughSeq) continue
+        capturedThroughSeq = seq
+        inspected += 1
+        if (collect) events.push(event)
+        if (inspected >= SESSION_EVENT_TAIL_MAX_EVENTS) {
+          return { supported: true, events, capturedThroughSeq, truncated: true }
+        }
+      }
+      if (Number.isSafeInteger(window?.endSeq) && window.endSeq !== endSeq) {
+        throw new Error(
+          `sessionQuery.readEvent returned endSeq ${String(window.endSeq)} for window ending at ${endSeq}`,
+        )
+      }
+
+      if (result.after > 0) {
+        if (endSeq <= cursor || windowEvents.length < result.after + 1) {
+          return { supported: true, events, capturedThroughSeq: Math.max(capturedThroughSeq, endSeq), truncated: false }
+        }
+        cursor = endSeq
+        continue
+      }
+
+      // `readWindowMax: 0` is a valid Host configuration. Walk exact seqs and
+      // use the typed EVENT_NOT_FOUND result as the logical tail sentinel.
+      cursor += 1
+    }
+
+    return { supported: true, events, capturedThroughSeq, truncated: true }
+  }
+}
+
+
+/**
+ * Build the asynchronous Session-log reader used by cold attachment recovery
+ * and batched surface repair. Prefer SessionQuery's observation lease when it
+ * exists: one exact live cut materializes at most one immutable event snapshot,
+ * rather than cloning the whole live corpus once per requested event (#524).
+ * Hosts without that capability retain the released readSession() contract.
+ */
+export function createSessionLogReader(ctx) {
+  return async function readSessionLog(session) {
+    const sessionId = session?.id
+    if (sessionId === undefined || sessionId === null) return { supported: false }
+    const query = sessionQueryOf(ctx)
+    if (!query) return { supported: false }
+
+    if (typeof query.observeSession === 'function') {
+      let observation
+      try {
+        observation = await query.observeSession(sessionId, { projectionMode: 'none' })
+        if (!observation || !Array.isArray(observation.events)) {
+          throw new Error('sessionQuery.observeSession returned no event log')
+        }
+        const observedId = observation.header?.id
+        if (observedId !== undefined && observedId !== sessionId) {
+          throw new Error(
+            `sessionQuery.observeSession returned session ${String(observedId)} for requested ${String(sessionId)}`,
+          )
+        }
+        return { supported: true, events: observation.events }
+      } finally {
+        const dispose = observation?.[Symbol.dispose]
+        if (typeof dispose === 'function') dispose.call(observation)
+      }
+    }
+
+    if (typeof query.readSession !== 'function') return { supported: false }
+    const snapshot = await query.readSession(sessionId)
+    if (!snapshot || !Array.isArray(snapshot.events)) {
+      throw new Error('sessionQuery.readSession returned no event log')
+    }
+    const observedId = snapshot.session?.id
+    if (observedId !== undefined && observedId !== sessionId) {
+      throw new Error(
+        `sessionQuery.readSession returned session ${String(observedId)} for requested ${String(sessionId)}`,
+      )
+    }
+    return { supported: true, events: snapshot.events }
+  }
+}
+
 function attachmentStoreOf(ctx) {
   if (!ctx || typeof ctx !== 'object') return undefined
   try {
@@ -111,6 +325,17 @@ export function hasBatchAttachmentContract(ctx) {
   return !!store && typeof store.saveImages === 'function'
 }
 
+/**
+ * DSH Hosts on the canonical batch-attachment contract also keep the official
+ * DeepSeek provider Host-owned. Later generations add still more request-local
+ * file/image-access seams, so DVR may wrap this provider but must never rebuild
+ * or resurrect it. Keep this semantic fact
+ * centralized so Core does not grow a second Host-generation detector.
+ */
+export function hostOwnsOfficialDeepSeekProvider(ctx) {
+  return hasBatchAttachmentContract(ctx)
+}
+
 function exactAlphaNormalizationDefaults(policy) {
   return !!policy && typeof policy === 'object' &&
     policy.maxPixels === DSH_ALPHA_DEFAULT_NORMALIZED_PIXELS &&

package/lib/dsh-support-window.js

@@ -6,7 +6,7 @@ export const DSH_SUPPORT_WINDOW = Object.freeze({
 
 export const DSH_VERIFICATION_EVIDENCE = Object.freeze({
   exactStable: '0.1.5-rc.2',
-  exactPreview: '0.1.5-alpha.2',
+  exactPreview: '0.1.6-alpha.1',
   stableCanaryDistTag: 'latest',
   previewCanaryDistTag: 'alpha',
 })

package/lib/fetch-wrapper-lifecycle.js

@@ -0,0 +1,56 @@
+// Lifecycle metadata only: no native fetch snapshot, dispatcher, or egress
+// policy is retained here. Weak keys let abandoned wrapper chains be collected.
+const installations = new WeakMap()
+
+function livePreviousDescriptor(descriptor) {
+  let previous = descriptor
+  while (previous && Object.hasOwn(previous, 'value')) {
+    const installation = installations.get(previous.value)
+    if (!installation?.disposed) break
+    previous = installation.previous
+  }
+  return previous
+}
+
+/** Preserve a live accessor-owned pipeline, including middleware recomposition. */
+export function captureFetchDelegate(target = globalThis) {
+  const descriptor = Object.getOwnPropertyDescriptor(target, 'fetch')
+  const current = target.fetch
+  if (typeof current !== 'function' || typeof descriptor?.get !== 'function') return current
+  return (input, init) => Reflect.apply(Reflect.apply(descriptor.get, target, []), target, [input, init])
+}
+
+/**
+ * Publish an already constructed fetch wrapper without calling a foreign
+ * accessor setter. Assignment is unsafe: a pipeline getter may return a
+ * function whose setter adopts our wrapper as its own delegate (#519).
+ *
+ * The caller captures the CURRENT Host chain at installation, never at module
+ * load, and disables its own behavior before restoring. Later Host replacements
+ * remain authoritative. Restore the exact previous descriptor only while our
+ * data property still owns the surface; never feed a wrapper back to a setter.
+ * Non-configurable accessors cannot be composed this way and fail before any
+ * mutation rather than silently bypassing a Host policy or explicit proxy.
+ */
+export function installFetchWrapper(wrapped, target = globalThis) {
+  if (typeof wrapped !== 'function') throw new TypeError('fetch wrapper must be a function')
+  const previous = Object.getOwnPropertyDescriptor(target, 'fetch')
+  if (previous && Object.hasOwn(previous, 'value') && previous.value === wrapped) return () => {}
+  const installed = previous && Object.hasOwn(previous, 'value')
+    ? { ...previous, value: wrapped }
+    : { configurable: true, enumerable: previous?.enumerable ?? true, writable: true, value: wrapped }
+  Object.defineProperty(target, 'fetch', installed)
+  const installation = { previous, disposed: false }
+  installations.set(wrapped, installation)
+  return () => {
+    if (installation.disposed) return
+    installation.disposed = true
+    const current = Object.getOwnPropertyDescriptor(target, 'fetch')
+    if (!current || !Object.hasOwn(current, 'value') || current.value !== wrapped ||
+        current.configurable !== installed.configurable ||
+        current.enumerable !== installed.enumerable || current.writable !== installed.writable) return
+    const restore = livePreviousDescriptor(previous)
+    if (restore) Object.defineProperty(target, 'fetch', restore)
+    else delete target.fetch
+  }
+}

package/lib/image-offload-compat.js

@@ -0,0 +1,38 @@
+function boundedAttachmentId(block) {
+  const attachment = block && typeof block === 'object' ? block.attachment : undefined
+  const raw = attachment && (attachment.attachmentId ?? attachment.id)
+  if (typeof raw !== 'string' || raw.trim() === '') return undefined
+  return raw.trim().slice(0, 256)
+}
+
+/** DSH 0.1.6+ marks durable request-limit omissions on the ImageBlock itself. */
+export function isOffloadedImageBlock(block) {
+  return !!block && block.type === 'image' && block.offloaded === true
+}
+
+export function blocksHaveRetainedImage(content) {
+  if (!Array.isArray(content)) return false
+  for (const block of content) {
+    if (!block || typeof block !== 'object') continue
+    if (block.type === 'image' && block.offloaded !== true) return true
+    if (Array.isArray(block.content) && blocksHaveRetainedImage(block.content)) return true
+  }
+  return false
+}
+
+/**
+ * Dependency-free model-facing placeholder for an image DSH already offloaded.
+ *
+ * Do not import the 0.1.6 `offloadedImageText` helper here: DVR still supports
+ * older Hosts where that export does not exist. The durable attachment stays
+ * available to Vision Router tools, but custom wire serializers must never
+ * read or resend its bytes once the Host projection marks this occurrence.
+ */
+export function offloadedImagePlaceholder(block) {
+  const id = boundedAttachmentId(block)
+  if (id === undefined) {
+    return '[image omitted to fit request image limits; attachment id unavailable]'
+  }
+  return `[image omitted to fit request image limits; attachment ${id}. ` +
+    `To inspect it again, call vision_describe with attachmentIds: [${JSON.stringify(id)}].]`
+}

package/lib/legacy-global-proxy-boundary.js

@@ -1,3 +1,4 @@
+import { captureFetchDelegate, installFetchWrapper } from './fetch-wrapper-lifecycle.js'
 // H2: retain the legacy Host-owned proxy override as a scoped compatibility
 // transport, not as process-wide routing authority. The wrapper is always
 // transparent unless one DVR-owned visual adapter call is active (or the
@@ -184,7 +185,7 @@ function proxyHostsOf(config) {
  * the narrow legacy direct whole-turn fallback above.
  */
 export function installLegacyGlobalProxyBoundary(ctx, config = {}, options = {}) {
-  const originalFetch = typeof options.originalFetch === 'function' ? options.originalFetch : globalThis.fetch
+  const originalFetch = typeof options.originalFetch === 'function' ? options.originalFetch : captureFetchDelegate()
   const importUndici = typeof options.importUndici === 'function' ? options.importUndici : () => import('undici')
   if (typeof originalFetch !== 'function') return () => {}
 
@@ -227,14 +228,14 @@ export function installLegacyGlobalProxyBoundary(ctx, config = {}, options = {})
     })
   }
 
-  globalThis.fetch = scopedFetch
+  const restoreFetch = installFetchWrapper(scopedFetch)
   let disposed = false
   const dispose = () => {
     if (disposed) return
     disposed = true
     active = false
     void dispatcherPool.dispose()
-    if (globalThis.fetch === scopedFetch) globalThis.fetch = originalFetch
+    restoreFetch()
   }
   if (typeof ctx?.effect === 'function') {
     try {

package/lib/local-vision-stabilizer.js

@@ -5,6 +5,7 @@ import path from 'node:path'
 import { promisify } from 'node:util'
 import { sameOriginRequest } from './adversarial-hardening.js'
 import { normalizeRuntimeVisionConfig } from './runtime-config-normalizer.js'
+import { isOffloadedImageBlock, offloadedImagePlaceholder } from './image-offload-compat.js'
 
 /**
  * Narrow runtime guard around the local-vision features merged in #141.
@@ -177,6 +178,10 @@ export function installLocalVisionStabilizer(ctx, config = {}, core) {
       const content = []
       for (const block of message.content) {
         if (block && block.type === 'image' && block.attachment) {
+          if (isOffloadedImageBlock(block)) {
+            content.push({ type: 'text', text: offloadedImagePlaceholder(block) })
+            continue
+          }
           if (!attachments || typeof attachments.readImage !== 'function') continue
           try {
             const stored = await attachments.readImage(block.attachment)
@@ -200,12 +205,16 @@ export function installLocalVisionStabilizer(ctx, config = {}, core) {
             if (nested && nested.type === 'text' && typeof nested.text === 'string') {
               parts.push(nested.text)
             } else if (nested && nested.type === 'image') {
-              const attachment = nested.attachment || {}
-              const id = attachment.attachmentId || attachment.id || 'unknown'
-              parts.push(
-                `[attached image: ${id}] this tool result contained an image; ` +
-                  'inspect it with vision_describe (or re-read it with read_image)',
-              )
+              if (isOffloadedImageBlock(nested)) {
+                parts.push(offloadedImagePlaceholder(nested))
+              } else {
+                const attachment = nested.attachment || {}
+                const id = attachment.attachmentId || attachment.id || 'unknown'
+                parts.push(
+                  `[attached image: ${id}] this tool result contained an image; ` +
+                    'inspect it with vision_describe (or re-read it with read_image)',
+                )
+              }
             }
           }
           if (parts.length > 0) {

package/lib/official-deepseek-catalog.js

@@ -0,0 +1,120 @@
+const catalogStateByAdapter = new WeakMap()
+
+export const OFFICIAL_DEEPSEEK_CATALOG_FRESH_MS = 30_000
+export const OFFICIAL_DEEPSEEK_CATALOG_STALE_IF_ERROR_MS = 10 * 60_000
+export const OFFICIAL_DEEPSEEK_CATALOG_FAILURE_BACKOFF_MS = 5_000
+
+function catalogUnavailable(cause) {
+  const error = new Error('vision-router: the official DeepSeek catalog is temporarily unavailable')
+  error.code = 'OFFICIAL_CATALOG_UNAVAILABLE'
+  if (cause !== undefined) error.cause = cause
+  return error
+}
+
+function normalizedModels(listed) {
+  if (!Array.isArray(listed)) {
+    throw new TypeError('official DeepSeek adapter listModels() did not return an array')
+  }
+  return Object.freeze(
+    listed
+      .filter((entry) => entry && typeof entry.id === 'string' && entry.id !== '')
+      .map((entry) => Object.freeze({ ...entry })),
+  )
+}
+
+/**
+ * Process-local authority for the live official DeepSeek catalog.
+ *
+ * The special DeepSeek vision wrapper must not infer product identity from an
+ * adapter's permissive resolveModel() behavior. Membership therefore remains
+ * fail-closed to a catalog actually observed from the official adapter. A
+ * short fresh cache coalesces duplicate Core/replay reads; a bounded
+ * stale-if-error window keeps transient endpoint failures from taking down a
+ * long-lived session. Cold start and expired-cache failures stay fail-closed.
+ *
+ * State is keyed by adapter identity so Host adapter replacement cannot inherit
+ * another registration's catalog. Nothing is persisted across process restart:
+ * a previous process is not durable authority for a newly started Host.
+ */
+export async function getOfficialDeepSeekCatalog(adapter, {
+  provider = 'deepseek-official',
+  now = Date.now,
+  freshMs = OFFICIAL_DEEPSEEK_CATALOG_FRESH_MS,
+  staleIfErrorMs = OFFICIAL_DEEPSEEK_CATALOG_STALE_IF_ERROR_MS,
+  failureBackoffMs = OFFICIAL_DEEPSEEK_CATALOG_FAILURE_BACKOFF_MS,
+} = {}) {
+  if (!adapter || typeof adapter.listModels !== 'function') {
+    throw catalogUnavailable()
+  }
+
+  let state = catalogStateByAdapter.get(adapter)
+  if (state === undefined) {
+    state = {
+      models: undefined,
+      fetchedAt: 0,
+      inFlight: undefined,
+      failure: undefined,
+      failedAt: 0,
+    }
+    catalogStateByAdapter.set(adapter, state)
+  }
+
+  const currentTime = Number(now())
+  const age =
+    state.models === undefined
+      ? Number.POSITIVE_INFINITY
+      : Math.max(0, currentTime - state.fetchedAt)
+  if (state.models !== undefined && age <= Math.max(0, Number(freshMs) || 0)) {
+    return state.models
+  }
+  if (state.inFlight !== undefined) return state.inFlight
+
+  const failureAge =
+    state.failure === undefined
+      ? Number.POSITIVE_INFINITY
+      : Math.max(0, currentTime - state.failedAt)
+  if (failureAge <= Math.max(0, Number(failureBackoffMs) || 0)) {
+    if (
+      state.models !== undefined
+      && age <= Math.max(0, Number(staleIfErrorMs) || 0)
+    ) {
+      return state.models
+    }
+    throw state.failure
+  }
+
+  const refresh = (async () => {
+    try {
+      const listed = await adapter.listModels(provider)
+      const models = normalizedModels(listed)
+      state.models = models
+      state.fetchedAt = Number(now())
+      state.failure = undefined
+      state.failedAt = 0
+      return models
+    } catch (cause) {
+      const failureTime = Number(now())
+      const error = catalogUnavailable(cause)
+      state.failure = error
+      state.failedAt = failureTime
+      const staleAge =
+        state.models === undefined
+          ? Number.POSITIVE_INFINITY
+          : Math.max(0, failureTime - state.fetchedAt)
+      if (
+        state.models !== undefined
+        && staleAge <= Math.max(0, Number(staleIfErrorMs) || 0)
+      ) {
+        return state.models
+      }
+      throw error
+    }
+  })()
+
+  state.inFlight = refresh
+  try {
+    return await refresh
+  } finally {
+    if (state.inFlight === refresh) state.inFlight = undefined
+  }
+}

package/lib/ollama-cold-start.js

@@ -4,6 +4,7 @@ import {
   readResponseJsonBounded,
 } from './http-body-limit.js'
 import { stripTrailingSlashes } from './string-normalization.js'
+import { blocksHaveRetainedImage } from './image-offload-compat.js'
 
 export const OLLAMA_WARMUP_KEEP_ALIVE = '30m'
 export const OLLAMA_WARMUP_TIMEOUT_MS = 120000
@@ -250,22 +251,9 @@ export function createOllamaWarmupManager({
   return { ensure, background, dispose }
 }
 
-function messagesContainImage(messages, core) {
+function messagesContainImage(messages, _core) {
   if (!Array.isArray(messages)) return false
-  return messages.some((message) => {
-    const content = message && Array.isArray(message.content) ? message.content : []
-    if (typeof core?.blocksHaveImage === 'function') {
-      try { return core.blocksHaveImage(content) } catch { /* fall through */ }
-    }
-    const stack = [...content]
-    while (stack.length > 0) {
-      const block = stack.pop()
-      if (!block || typeof block !== 'object') continue
-      if (block.type === 'image') return true
-      if (Array.isArray(block.content)) stack.push(...block.content)
-    }
-    return false
-  })
+  return messages.some((message) => blocksHaveRetainedImage(message?.content))
 }
 
 function configuredRows(config) {

package/lib/pi-ai-bridge-wire-compat.js

@@ -1,3 +1,4 @@
+import { captureFetchDelegate, installFetchWrapper } from './fetch-wrapper-lifecycle.js'
 import { currentVisionSessionAffinityId } from './session-affinity-runtime.js'
 import { isOfficialOpenCodeGoUrl, openCodeSessionAffinityHeaderForUrl } from './session-affinity.js'
 
@@ -283,7 +284,7 @@ export function applyPiAiBridgeWireFacts(init, body, facts) {
  * wrapper even if another later patch sits above it in the fetch chain.
  */
 export function installPiAiBridgeWireCompat(ctx, logger) {
-  const original = globalThis.fetch
+  const original = captureFetchDelegate()
   if (typeof original !== 'function') return () => {}
   let active = true
   const wrapped = async (input, init) => {
@@ -334,10 +335,10 @@ export function installPiAiBridgeWireCompat(ctx, logger) {
     }
     return Reflect.apply(original, globalThis, [input, patchedInit])
   }
-  globalThis.fetch = wrapped
+  const restoreFetch = installFetchWrapper(wrapped)
   const cleanup = () => {
     active = false
-    if (globalThis.fetch === wrapped) globalThis.fetch = original
+    restoreFetch()
   }
   try {
     ctx?.effect?.(() => cleanup, 'vision-router: pi-ai bridge wire compatibility')

package/lib/pixel-diff-stream.js

@@ -37,12 +37,18 @@ class AsyncByteReader {
 function cellBounds(index, width, height, cols, rows) {
   const cx = index % cols
   const cy = Math.floor(index / cols)
-  const cw = Math.ceil(width / cols)
-  const ch = Math.ceil(height / rows)
-  const x1 = cx * cw
-  const y1 = cy * ch
-  const x2 = Math.min((cx + 1) * cw, width)
-  const y2 = Math.min((cy + 1) * ch, height)
+  // Uniform boundaries mirror the counting map floor(x * cells / extent)
+  // exactly: with cells <= extent (the grid clamp above guarantees it),
+  // ceil(c * extent / cells) rises by at least 1 per cell, so every cell is
+  // non-empty and every pixel lands inside the cell the counters credited
+  // it to. The previous ceil-stride bounds drifted from that map whenever
+  // extent was not a multiple of cells, shifting worst-region boxes and, on
+  // tiny extents, dropping counted pixels from cells whose bounds collapsed
+  // to zero width.
+  const x1 = Math.ceil((cx * width) / cols)
+  const y1 = Math.ceil((cy * height) / rows)
+  const x2 = Math.ceil(((cx + 1) * width) / cols)
+  const y2 = Math.ceil(((cy + 1) * height) / rows)
   return { x1, y1, x2, y2, total: Math.max(0, x2 - x1) * Math.max(0, y2 - y1) }
 }
 

package/lib/remote-settings-bridge.js

@@ -176,6 +176,24 @@ export async function authorizeRemoteSettingsAfterRiskConfirmation(settings, pay
   }
 }
 
+/**
+ * Register the dedicated settings channel against the active DSH Connection
+ * trust contract. rc.8 requires a per-channel `trusted-host` policy. Newer
+ * Connection carriers expose `requestRejection()` and authenticate every
+ * dedicated RPC route before dispatch, while `rpc.handle()` accepts only the
+ * channel and handler. Feature-detect the carrier-owned trust fence rather
+ * than passing a security-looking argument that modern Hosts do not consume.
+ */
+export function registerVisionRouterRemoteSettingsChannel(connection, handler) {
+  if (!connection || typeof connection !== 'object' || !connection.rpc || typeof connection.rpc.handle !== 'function') {
+    throw new TypeError('Vision Router remote settings requires DSH Connection RPC handle()')
+  }
+  if (typeof connection.requestRejection === 'function') {
+    return connection.rpc.handle(REMOTE_SETTINGS_CHANNEL, handler)
+  }
+  return connection.rpc.handle(REMOTE_SETTINGS_CHANNEL, handler, { authority: 'trusted-host' })
+}
+
 export function createVisionRouterRemoteSettingsHandler(settings, logger) {
   return async (endpoint, payload) => {
     if (endpoint === 'describe') {
@@ -225,7 +243,7 @@ export function installVisionRouterRemoteSettingsBridge(ctx, logger) {
   ctx.inject(['settings', 'connection', 'webServer'], (remoteCtx) => {
     const handler = createVisionRouterRemoteSettingsHandler(remoteCtx.settings, logger ?? remoteCtx.logger)
     remoteCtx.effect(
-      () => remoteCtx.connection.rpc.handle(REMOTE_SETTINGS_CHANNEL, handler, { authority: 'trusted-host' }),
+      () => registerVisionRouterRemoteSettingsChannel(remoteCtx.connection, handler),
       'vision-router: opt-in remote settings channel',
     )
   })