dsh-vision-router 2.1.6 → 2.2.0

package/lib/artifact-boundary.js

@@ -1,6 +1,8 @@
 import { createVisionArtifactStore } from './vision-artifact-store.js'
 
 export {
+  ARTIFACT_HANDOFF_RUN_ID,
+  ARTIFACT_RUNS_DIR,
   DEFAULT_ARTIFACTS_DIR,
   normalizeArtifactsDir,
 } from './artifact-io.js'
@@ -23,3 +25,12 @@ export function resolveArtifactTarget(workspace, artifactsDir, relativePath, dep
 export function writeArtifactFile(workspace, artifactsDir, relativePath, data, deps = {}) {
   return createVisionArtifactStore({ workspace, artifactsDir, deps }).publish(relativePath, data)
 }
+
+/**
+ * Persistent writer for file-path handoffs such as vision_materialize. It uses
+ * the same store boundary but publishes under one stable reserved managed run,
+ * so later tools can reference it without losing retention governance.
+ */
+export function writePersistentArtifactFile(workspace, artifactsDir, relativePath, data, deps = {}) {
+  return createVisionArtifactStore({ workspace, artifactsDir, deps }).publishPersistent(relativePath, data)
+}

package/lib/artifact-io.js

@@ -1,5 +1,5 @@
 import { randomUUID } from 'node:crypto'
-import { lstat, mkdir, realpath, rename, unlink, writeFile } from 'node:fs/promises'
+import { lstat, mkdir, realpath, rename, unlink, utimes, writeFile } from 'node:fs/promises'
 import path from 'node:path'
 import {
   currentVisionTurnBudget,
@@ -12,6 +12,7 @@ import {
 
 export const DEFAULT_ARTIFACTS_DIR = '.dsh-vision-router/artifacts'
 export const ARTIFACT_RUNS_DIR = '.runs'
+export const ARTIFACT_HANDOFF_RUN_ID = '.vision-run-handoff'
 
 function isPathInside(root, candidate) {
   const relative = path.relative(root, candidate)
@@ -99,7 +100,7 @@ async function safeLstat(target, lstatImpl) {
  * existing symlink is rejected even when it points somewhere else inside the
  * workspace. Artifacts outside a managed run keep their original root layout.
  */
-export async function resolveArtifactTarget(workspace, artifactsDir, relativePath, deps = {}) {
+async function resolveArtifactTargetForRun(workspace, artifactsDir, relativePath, deps = {}, runId) {
   const realpathImpl = deps.realpath ?? realpath
   const mkdirImpl = deps.mkdir ?? mkdir
   const lstatImpl = deps.lstat ?? lstat
@@ -108,7 +109,6 @@ export async function resolveArtifactTarget(workspace, artifactsDir, relativePat
   const workspaceReal = await realpathImpl(path.resolve(String(workspace ?? '')))
   throwIfVisionAborted()
   const relativeBase = normalizeArtifactsDir(artifactsDir)
-  const runId = currentArtifactRunId()
   const requestedTarget = normalizeRelativeArtifactPath(relativePath)
   const relativeTarget = runId
     ? normalizeRelativeArtifactPath(path.join(ARTIFACT_RUNS_DIR, runId, requestedTarget))
@@ -119,6 +119,7 @@ export async function resolveArtifactTarget(workspace, artifactsDir, relativePat
   }
 
   const lexicalRunsBase = runId ? path.resolve(lexicalBase, ARTIFACT_RUNS_DIR) : undefined
+  const lexicalRunBase = runId ? path.resolve(lexicalRunsBase, runId) : undefined
   if (lexicalRunsBase && !isPathInside(lexicalBase, lexicalRunsBase)) {
     throw new Error('vision-router: managed artifact runs must stay inside the artifacts directory')
   }
@@ -155,6 +156,7 @@ export async function resolveArtifactTarget(workspace, artifactsDir, relativePat
   }
 
   let runsBaseReal
+  let runBaseReal
   if (lexicalRunsBase) {
     const after = await safeLstat(lexicalRunsBase, lstatImpl)
     throwIfVisionAborted()
@@ -166,6 +168,16 @@ export async function resolveArtifactTarget(workspace, artifactsDir, relativePat
     if (!isPathInside(artifactsBaseReal, runsBaseReal)) {
       throw new Error('vision-router: managed artifact runs directory escapes the artifacts directory')
     }
+    const runInfo = await safeLstat(lexicalRunBase, lstatImpl)
+    throwIfVisionAborted()
+    if (!runInfo?.isDirectory?.() || runInfo.isSymbolicLink?.()) {
+      throw new Error('vision-router: managed artifact run must be a real directory')
+    }
+    runBaseReal = await realpathImpl(lexicalRunBase)
+    throwIfVisionAborted()
+    if (!isPathInside(runsBaseReal, runBaseReal)) {
+      throw new Error('vision-router: managed artifact run escapes the runs directory')
+    }
   }
 
   const target = path.join(parentReal, path.basename(lexicalTarget))
@@ -174,15 +186,33 @@ export async function resolveArtifactTarget(workspace, artifactsDir, relativePat
   if (existing?.isDirectory?.()) {
     throw new Error('vision-router: artifact target is a directory')
   }
-  return { target, parentReal, artifactsBaseReal, runsBaseReal, existing, runId }
+  return { target, parentReal, artifactsBaseReal, runsBaseReal, runBaseReal, existing, runId }
 }
 
-/** Hardened atomic publication primitive used by VisionArtifactStore. */
-export async function writeArtifactFile(workspace, artifactsDir, relativePath, data, deps = {}) {
+export function resolveArtifactTarget(workspace, artifactsDir, relativePath, deps = {}) {
+  return resolveArtifactTargetForRun(
+    workspace, artifactsDir, relativePath, deps, currentArtifactRunId(),
+  )
+}
+
+/**
+ * Resolve a stable cross-tool handoff artifact even when the caller is inside
+ * a random managed per-tool run. Handoff files share one reserved managed run,
+ * so their path is deterministic enough for later tool calls while existing
+ * retention still bounds their lifetime and total bytes.
+ */
+export function resolvePersistentArtifactTarget(workspace, artifactsDir, relativePath, deps = {}) {
+  return resolveArtifactTargetForRun(
+    workspace, artifactsDir, relativePath, deps, ARTIFACT_HANDOFF_RUN_ID,
+  )
+}
+
+async function writeArtifactFileForRun(workspace, artifactsDir, relativePath, data, deps, runId) {
   const writeFileImpl = deps.writeFile ?? writeFile
   const renameImpl = deps.rename ?? rename
   const unlinkImpl = deps.unlink ?? unlink
-  const resolved = await resolveArtifactTarget(workspace, artifactsDir, relativePath, deps)
+  const utimesImpl = deps.utimes ?? utimes
+  const resolved = await resolveArtifactTargetForRun(workspace, artifactsDir, relativePath, deps, runId)
   const temp = path.join(
     resolved.parentReal,
     `.dsh-vision-router-${process.pid}-${randomUUID()}.tmp`,
@@ -202,6 +232,11 @@ export async function writeArtifactFile(workspace, artifactsDir, relativePath, d
     }
     await renameImpl(temp, resolved.target)
     published = true
+    if (resolved.runId === ARTIFACT_HANDOFF_RUN_ID && resolved.runBaseReal) {
+      const touchedAt = new Date()
+      await utimesImpl(resolved.runBaseReal, touchedAt, touchedAt)
+      throwIfVisionAborted()
+    }
     if (resolved.runId) {
       // New managed runs live under `.runs`, so retention scans that directory
       // directly. Also schedule the old artifact root so pre-P2-B direct
@@ -218,3 +253,21 @@ export async function writeArtifactFile(workspace, artifactsDir, relativePath, d
     }
   }
 }
+
+/** Hardened atomic publication primitive used by VisionArtifactStore. */
+export async function writeArtifactFile(workspace, artifactsDir, relativePath, data, deps = {}) {
+  return writeArtifactFileForRun(
+    workspace, artifactsDir, relativePath, data, deps, currentArtifactRunId(),
+  )
+}
+
+/**
+ * Publish a stable workspace handoff artifact under the reserved managed run
+ * while preserving the exact same containment, symlink, cancellation, atomic
+ * write and retention checks as writeArtifactFile.
+ */
+export async function writePersistentArtifactFile(workspace, artifactsDir, relativePath, data, deps = {}) {
+  return writeArtifactFileForRun(
+    workspace, artifactsDir, relativePath, data, deps, ARTIFACT_HANDOFF_RUN_ID,
+  )
+}

package/lib/catalog-corrections.js

@@ -17,6 +17,7 @@ import {
 import { stripTrailingSlashes } from './string-normalization.js'
 import { currentVisionProviderTransport } from './vision-provider-transport.js'
 import { directSessionAffinityHeaders } from './session-affinity.js'
+import { isOffloadedImageBlock, offloadedImagePlaceholder } from './image-offload-compat.js'
 
 export const CATALOG_ROUTING_CORRECTIONS = [
   {
@@ -109,6 +110,10 @@ async function convertBlocks(blocks, bytesOf, depth = 0) {
     if (block.type === 'text' && typeof block.text === 'string' && block.text !== '') {
       out.push({ type: 'text', text: block.text })
     } else if (block.type === 'image') {
+      if (isOffloadedImageBlock(block)) {
+        out.push({ type: 'text', text: offloadedImagePlaceholder(block) })
+        continue
+      }
       if (typeof bytesOf !== 'function') continue
       let bytes
       try {

package/lib/client.js

@@ -231,14 +231,15 @@ window.__ModuleLoader__.load({
         '本地后端不受影响，仍在最前。关闭时保持既有顺序（付费在前、免费补全在后）。',
       hintDesktopScreenshot: '允许模型按需截取桌面屏幕用于识图。默认关闭；开启后才提供 vision_screenshot 工具。macOS 在保存开启时会立即触发一次屏幕录制授权检查；如果已经授权，系统不会重复弹窗。',
       hintStealth:
-        '只作用于官方 DeepSeek 路由：接管后模型选择器保持原样。需在 profile 补丁层 ' +
-        '（cordis.patch.yml）禁用官方 llm-deepseek 行后才真正接管；官方行还在时 ' +
-        '插件自动回退为选择器里的「自动识图」包装路由。opencode 等自定义路由与隐身模式无关，' +
-        '它们默认由「自动创建 + 自动识图模型组」处理；只有要限制范围时才用下方手动包装。改动后需重启 dsh 生效。',
+        '只作用于官方 DeepSeek 路由。新版 DSH 中官方 provider 始终归 Host 所有，Vision Router 只使用「+ 自动识图」' +
+        '包装，不再要求你禁用 llm-deepseek；旧版 Host 仍保留官方行缺失时的历史接管兼容。opencode 等自定义路由' +
+        '默认自动包装，只有要限制范围时才用下方手动包装。',
       stealthOfficialDeadHint:
-        '提示：检测到官方 DeepSeek 行当前被禁用（profile 补丁层），所以即使关闭隐身模式，' +
-        '本插件仍会接管 deepseek-official 路由，否则 DeepSeek 模型会从选择器消失。' +
-        '如需完全恢复官方原生行，请先把 cordis.patch.yml 里 llm-deepseek 的 disabled 改回 false 再重启。',
+        '提示：这是旧版 Host，且官方 DeepSeek 行当前被禁用；Vision Router 正使用兼容性 keep-alive 路由。' +
+        '如需恢复完全官方的原生行，请在 cordis.patch.yml 中重新启用 llm-deepseek 后重启。',
+      stealthOfficialHostOwnedHint:
+        '检测到官方 DeepSeek provider 被禁用或不可用，但当前 DSH 已由 Host 负责该路由。Vision Router 不会自行重建它。' +
+        '请重新启用 llm-deepseek，再通过「+ 自动识图」包装 /「👁 识图」处理图片任务。',
       numTimeoutMs: '单次识图请求超时（毫秒）',
       numVisionTaskTimeoutMs: '识图任务最长时间（毫秒）',
       numOcrTimeoutMs: 'OCR 最长时间（毫秒）',
@@ -507,16 +508,16 @@ window.__ModuleLoader__.load({
         'Local backends are unaffected and stay first. When off, the existing order is preserved (paid first, free appended last).',
       hintDesktopScreenshot: 'Lets the model capture the desktop on demand for image understanding. Off by default; vision_screenshot is exposed only when enabled. On macOS, saving the enabled setting immediately triggers a screen-recording permission check; if permission was already granted, macOS will not prompt again.',
       hintStealth:
-        'Only affects the official DeepSeek route: takes it over while the model picker looks exactly like stock. Requires the ' +
-        'official llm-deepseek row to be disabled in your profile patch layer (cordis.patch.yml); while the ' +
-        'stock row is present the plugin falls back to the visible auto-vision wrapper entry. Custom routes like opencode ' +
-        'are auto-wrapped by default; use the manual wrapper section below only when you want to restrict their scope. ' +
-        'Restart dsh after changing stealth/profile takeover.',
+        'Only affects the official DeepSeek route. On newer DSH Hosts the official provider stays Host-owned, so Vision Router ' +
+        'uses the “+ Auto Vision” wrapper and never asks you to disable llm-deepseek. Legacy Hosts retain the historical ' +
+        'takeover compatibility when the stock row is absent. Custom routes like opencode are auto-wrapped by default; use ' +
+        'the manual wrapper section below only when you want to restrict their scope.',
       stealthOfficialDeadHint:
-        'Notice: the official DeepSeek row is currently disabled (profile patch layer), so this plugin keeps ' +
-        'serving the deepseek-official route even with stealth mode off — otherwise the DeepSeek models would ' +
-        'vanish from the picker. To restore the fully official route, re-enable the llm-deepseek row in ' +
-        'cordis.patch.yml first, then restart.',
+        'Notice: on this legacy Host the official DeepSeek row is disabled, so Vision Router is using its compatibility ' +
+        'keep-alive route. To restore the fully official route, re-enable llm-deepseek in cordis.patch.yml and restart.',
+      stealthOfficialHostOwnedHint:
+        'The official DeepSeek provider is disabled or unavailable, but this DSH Host owns that provider route. Vision Router ' +
+        'will not recreate it. Re-enable llm-deepseek, then use the “+ Auto Vision” wrapper / Vision control for image tasks.',
       numTimeoutMs: 'Single vision request timeout (ms)',
       numVisionTaskTimeoutMs: 'Vision task maximum time (ms)',
       numOcrTimeoutMs: 'OCR maximum time (ms)',
@@ -3913,7 +3914,11 @@ window.__ModuleLoader__.load({
       const stealthNotice = () => {
         if (testState.status !== 'done') return null
         const state = testState.result && testState.result.stealth
-        if (!state || state.active !== true || state.reason !== 'official-unavailable') return null
+        if (!state) return null
+        if (state.reason === 'host-owned-official-unavailable') {
+          return h('p', { className: 'vr-hint vr-stealth-notice' }, t('stealthOfficialHostOwnedHint'))
+        }
+        if (state.active !== true || state.reason !== 'official-unavailable') return null
         return h('p', { className: 'vr-hint vr-stealth-notice' }, t('stealthOfficialDeadHint'))
       }
 
@@ -4252,40 +4257,257 @@ window.__ModuleLoader__.load({
       )
     }
 
+    const PRESENTED_IMAGE_CACHE_MAX_ENTRIES = 32
+    const PRESENTED_IMAGE_CACHE_MAX_BYTES = 64 * 1024 * 1024
+    const PRESENTED_IMAGE_CACHE_MAX_ACTIVE_LOADS = 3
+    const PRESENTED_IMAGE_CACHE_MAX_PENDING_ENTRIES = 256
+
+    function presentedImageResourceKey(sessionId, attachment) {
+      return `${String(sessionId)}:${String(attachment && attachment.attachmentId)}`
+    }
+
+    function createPresentedImageResourceCache(options = {}) {
+      const maxEntries = Number.isFinite(options.maxEntries)
+        ? Math.max(0, Math.floor(options.maxEntries))
+        : PRESENTED_IMAGE_CACHE_MAX_ENTRIES
+      const maxBytes = Number.isFinite(options.maxBytes)
+        ? Math.max(0, Math.floor(options.maxBytes))
+        : PRESENTED_IMAGE_CACHE_MAX_BYTES
+      const maxActiveLoads = Number.isFinite(options.maxActiveLoads)
+        ? Math.max(1, Math.floor(options.maxActiveLoads))
+        : PRESENTED_IMAGE_CACHE_MAX_ACTIVE_LOADS
+      const maxPendingEntries = Number.isFinite(options.maxPendingEntries)
+        ? Math.max(0, Math.floor(options.maxPendingEntries))
+        : PRESENTED_IMAGE_CACHE_MAX_PENDING_ENTRIES
+      const nativeObjectUrls =
+        typeof URL !== 'undefined' &&
+        typeof URL.createObjectURL === 'function' &&
+        typeof URL.revokeObjectURL === 'function' &&
+        typeof Blob === 'function'
+      const createObjectURL = typeof options.createObjectURL === 'function'
+        ? options.createObjectURL
+        : nativeObjectUrls
+          ? (data, mediaType) => URL.createObjectURL(new Blob([data], { type: mediaType }))
+          : undefined
+      const revokeObjectURL = typeof options.revokeObjectURL === 'function'
+        ? options.revokeObjectURL
+        : nativeObjectUrls
+          ? (url) => URL.revokeObjectURL(url)
+          : undefined
+      const encodeDataURL = typeof options.encodeDataURL === 'function'
+        ? options.encodeDataURL
+        : (data, mediaType) => {
+            let binary = ''
+            const chunk = 0x8000
+            for (let offset = 0; offset < data.length; offset += chunk) {
+              binary += String.fromCharCode(...data.subarray(offset, offset + chunk))
+            }
+            return `data:${mediaType};base64,${btoa(binary)}`
+          }
+      const useObjectUrls = typeof createObjectURL === 'function' && typeof revokeObjectURL === 'function'
+      const entries = new Map()
+      const loadQueue = []
+      let sequence = 0
+      let disposed = false
+      let activeLoads = 0
+      let pendingEntries = 0
+
+      const resourceError = (code, message) => {
+        const error = new Error(message)
+        error.code = code
+        return error
+      }
+      const touch = (entry) => { entry.lastUsed = ++sequence }
+      const dataBytes = (data) => {
+        const value = Number(data && (data.byteLength ?? data.length))
+        return Number.isFinite(value) && value > 0 ? value : 0
+      }
+      const remove = (entry, reason) => {
+        if (!entry || entries.get(entry.key) !== entry) return false
+        entries.delete(entry.key)
+        if (!entry.settled) {
+          pendingEntries = Math.max(0, pendingEntries - 1)
+          entry.cancelled = true
+          entry.cancelReason = reason ?? resourceError(
+            'VISION_PRESENT_LOAD_RELEASED',
+            'vision_present: image resource load released',
+          )
+          if (!entry.started && typeof entry.reject === 'function') entry.reject(entry.cancelReason)
+        }
+        if (entry.revocable && entry.url) {
+          try { revokeObjectURL(entry.url) } catch {}
+          entry.revocable = false
+        }
+        return true
+      }
+      const settledEntries = () => [...entries.values()].filter((entry) => entry.settled)
+      const trim = () => {
+        const settled = settledEntries()
+        let count = settled.length
+        let bytes = settled.reduce((total, entry) => total + entry.weight, 0)
+        const victims = settled.sort((left, right) => {
+          const leftOwned = left.owners.size > 0 ? 1 : 0
+          const rightOwned = right.owners.size > 0 ? 1 : 0
+          return leftOwned - rightOwned || left.lastUsed - right.lastUsed
+        })
+        for (const entry of victims) {
+          if (count <= maxEntries && bytes <= maxBytes) break
+          if (!remove(entry)) continue
+          count -= 1
+          bytes = Math.max(0, bytes - entry.weight)
+        }
+      }
+      const pump = () => {
+        if (disposed) return
+        while (activeLoads < maxActiveLoads && loadQueue.length > 0) {
+          const entry = loadQueue.shift()
+          if (!entry || entries.get(entry.key) !== entry || entry.started || entry.cancelled) continue
+          entry.started = true
+          activeLoads += 1
+          Promise.resolve()
+            .then(() => entry.loader())
+            .then(({ data, mediaType }) => {
+              if (disposed || entry.cancelled || entries.get(entry.key) !== entry) {
+                throw entry.cancelReason ?? resourceError(
+                  'VISION_PRESENT_CACHE_DISPOSED',
+                  'vision_present: image resource cache disposed',
+                )
+              }
+              const rawBytes = dataBytes(data)
+              if (useObjectUrls) {
+                entry.url = createObjectURL(data, mediaType)
+                entry.revocable = true
+                entry.weight = rawBytes
+              } else {
+                entry.url = encodeDataURL(data, mediaType)
+                entry.weight = entry.url.length * 2
+              }
+              entry.settled = true
+              pendingEntries = Math.max(0, pendingEntries - 1)
+              entry.loader = undefined
+              touch(entry)
+              trim()
+              activeLoads = Math.max(0, activeLoads - 1)
+              pump()
+              entry.resolve(entry.url)
+            })
+            .catch((error) => {
+              const retained = entries.get(entry.key) === entry
+              if (retained) remove(entry, error)
+              activeLoads = Math.max(0, activeLoads - 1)
+              pump()
+              entry.reject(error)
+            })
+        }
+      }
+
+      const load = (keyValue, loader, ownerToken) => {
+        if (disposed) {
+          return Promise.reject(resourceError(
+            'VISION_PRESENT_CACHE_DISPOSED',
+            'vision_present: image resource cache disposed',
+          ))
+        }
+        const key = String(keyValue)
+        const cached = entries.get(key)
+        if (cached) {
+          if (ownerToken !== undefined) cached.owners.add(ownerToken)
+          touch(cached)
+          return cached.promise
+        }
+        if (pendingEntries >= maxPendingEntries) {
+          return Promise.reject(resourceError(
+            'VISION_PRESENT_CACHE_BUSY',
+            'vision_present: too many image resources are waiting to load; retry when earlier images finish',
+          ))
+        }
+        let resolvePending
+        let rejectPending
+        const pending = new Promise((resolve, reject) => {
+          resolvePending = resolve
+          rejectPending = reject
+        })
+        const entry = {
+          key,
+          owners: new Set(ownerToken === undefined ? [] : [ownerToken]),
+          promise: pending,
+          resolve: resolvePending,
+          reject: rejectPending,
+          loader,
+          url: undefined,
+          revocable: false,
+          settled: false,
+          started: false,
+          cancelled: false,
+          cancelReason: undefined,
+          weight: 0,
+          lastUsed: 0,
+        }
+        touch(entry)
+        entries.set(key, entry)
+        pendingEntries += 1
+        loadQueue.push(entry)
+        pump()
+        return pending
+      }
+      const release = (keyValue, ownerToken, releaseOptions = {}) => {
+        const key = String(keyValue)
+        const entry = entries.get(key)
+        if (!entry) return false
+        if (ownerToken !== undefined) entry.owners.delete(ownerToken)
+        touch(entry)
+        if (releaseOptions.purge === true && entry.owners.size === 0) {
+          return remove(entry)
+        }
+        trim()
+        return true
+      }
+      const dispose = () => {
+        if (disposed) return
+        disposed = true
+        const reason = resourceError(
+          'VISION_PRESENT_CACHE_DISPOSED',
+          'vision_present: image resource cache disposed',
+        )
+        for (const entry of [...entries.values()]) remove(entry, reason)
+        loadQueue.length = 0
+        entries.clear()
+      }
+      const stats = () => {
+        const settled = settledEntries()
+        const queuedLoads = [...entries.values()].filter((entry) => !entry.settled && !entry.started).length
+        return {
+          entries: entries.size,
+          settledEntries: settled.length,
+          pendingEntries,
+          activeLoads,
+          queuedLoads,
+          residentBytes: settled.reduce((total, entry) => total + entry.weight, 0),
+          ownedEntries: settled.filter((entry) => entry.owners.size > 0).length,
+          disposed,
+        }
+      }
+
+      return { load, release, dispose, stats }
+    }
+
     function apply(ctx) {
       const localScope = ctx.settingsScope.bind({ namespace: 'vision-router' })
-      const presentedImageUrls = new Map()
-      const createdImageUrls = new Set()
-      const loadPresentedImage = (sessionId, attachment) => {
-        const key = `${String(sessionId)}:${String(attachment.attachmentId)}`
-        const cached = presentedImageUrls.get(key)
-        if (cached !== undefined) return cached
-        const pending = (async () => {
+      const presentedImageResources = createPresentedImageResourceCache()
+      const loadPresentedImage = (sessionId, attachment, ownerToken) => {
+        const key = presentedImageResourceKey(sessionId, attachment)
+        return presentedImageResources.load(key, async () => {
           const binding = ctx.sessions.binding(sessionId)
           if (binding === undefined) throw new Error(`vision_present: unknown session ${String(sessionId)}`)
           const result = await binding.session.readAttachment(attachment.attachmentId)
           if (!result.ok) {
             throw new Error(`vision_present: ${result.error.code}: ${result.error.message}`)
           }
-          const ref = result.value.attachment
-          const data = result.value.data
-          if (typeof URL.createObjectURL === 'function') {
-            const url = URL.createObjectURL(new Blob([data], { type: ref.mediaType }))
-            createdImageUrls.add(url)
-            return url
-          }
-          let binary = ''
-          const chunk = 0x8000
-          for (let offset = 0; offset < data.length; offset += chunk) {
-            binary += String.fromCharCode(...data.subarray(offset, offset + chunk))
+          return {
+            data: result.value.data,
+            mediaType: result.value.attachment.mediaType,
           }
-          return `data:${ref.mediaType};base64,${btoa(binary)}`
-        })().catch((error) => {
-          presentedImageUrls.delete(key)
-          throw error
-        })
-        presentedImageUrls.set(key, pending)
-        return pending
+        }, ownerToken)
       }
       // Follow the app language: register our dictionaries and re-read them
       // whenever the user switches the locale in Settings → General.
@@ -4297,6 +4519,27 @@ window.__ModuleLoader__.load({
         const images = content
           .filter((item) => item && item.type === 'image' && item.attachment)
           .map((item) => ({ attachment: item.attachment }))
+        const imageKeys = images.map(({ attachment }) => presentedImageResourceKey(sessionId, attachment))
+        const imageKeySignature = JSON.stringify(imageKeys)
+        const imageOwnerToken = React.useRef({}).current
+        const ownedImageKeys = React.useRef(new Set())
+        React.useEffect(() => {
+          const current = new Set(imageKeys)
+          for (const key of ownedImageKeys.current) {
+            if (current.has(key)) continue
+            presentedImageResources.release(key, imageOwnerToken, { purge: true })
+            ownedImageKeys.current.delete(key)
+          }
+        }, [imageKeySignature])
+        React.useEffect(() => () => {
+          for (const key of ownedImageKeys.current) presentedImageResources.release(key, imageOwnerToken, { purge: true })
+          ownedImageKeys.current.clear()
+        }, [])
+        const loadOwnedPresentedImage = (attachment) => {
+          const key = presentedImageResourceKey(sessionId, attachment)
+          ownedImageKeys.current.add(key)
+          return loadPresentedImage(sessionId, attachment, imageOwnerToken)
+        }
         if (images.length === 0) {
           return React.createElement(
             'div',
@@ -4331,16 +4574,12 @@ window.__ModuleLoader__.load({
             images,
             align: 'start',
             labels,
-            load: (attachment) => loadPresentedImage(sessionId, attachment),
+            load: loadOwnedPresentedImage,
           }),
         )
       }
       ctx.effect(
-        () => () => {
-          for (const url of createdImageUrls) URL.revokeObjectURL(url)
-          createdImageUrls.clear()
-          presentedImageUrls.clear()
-        },
+        () => () => presentedImageResources.dispose(),
         'vision-router: presented image URL cache',
       )
       // Lazily reach the client `connection` service for the model catalog.
@@ -4449,6 +4688,12 @@ window.__ModuleLoader__.load({
     exports.createRemoteSettingsScope = createRemoteSettingsScope
     exports.shouldUseRemoteSettings = shouldUseRemoteSettings
     exports.installSettingsPersistence = installSettingsPersistence
+    exports.PRESENTED_IMAGE_CACHE_MAX_ENTRIES = PRESENTED_IMAGE_CACHE_MAX_ENTRIES
+    exports.PRESENTED_IMAGE_CACHE_MAX_BYTES = PRESENTED_IMAGE_CACHE_MAX_BYTES
+    exports.PRESENTED_IMAGE_CACHE_MAX_ACTIVE_LOADS = PRESENTED_IMAGE_CACHE_MAX_ACTIVE_LOADS
+    exports.PRESENTED_IMAGE_CACHE_MAX_PENDING_ENTRIES = PRESENTED_IMAGE_CACHE_MAX_PENDING_ENTRIES
+    exports.presentedImageResourceKey = presentedImageResourceKey
+    exports.createPresentedImageResourceCache = createPresentedImageResourceCache
     exports.GUIDE_STATE = GUIDE_STATE
     exports.GUIDE_EVENT = GUIDE_EVENT
     exports.guideTransition = guideTransition