dsh-vision-router 2.2.8 → 3.0.0

package/lib/core-primitives.js

@@ -1,94 +1,51 @@
-import z from '@deepseek-ai/schemastery'
-import { mkdir, writeFile, readFile, unlink } from 'node:fs/promises'
+
+
 import path from 'node:path'
-import { tmpdir } from 'node:os'
-import { DeepSeekAdapter, resolveAdapterOptions } from '@deepseek-ai/dsh-llm-deepseek'
-import { getOrCreateAnonymousUserId } from '@deepseek-ai/dsh-anonymous-user-id'
+
 import { existsSync } from 'node:fs'
 import { execFile } from 'node:child_process'
 import { Worker } from 'node:worker_threads'
 import { createRequire } from 'node:module'
 import { pathToFileURL } from 'node:url'
 import { promisify } from 'node:util'
-import { appendPromptToImageOnlyMessage, fetchWithOpenAICompatibility } from './http-compat.js'
+import { fetchWithOpenAICompatibility } from './http-compat.js'
 import {
   directSessionAffinityHeaders,
-  isOfficialOpenCodeGoUrl,
-  openCodeSessionAffinityHeaderForUrl,
   rawSessionIdentity,
-  sessionIdentityOf,
 } from './session-affinity.js'
-import { runWithVisionSessionAffinity, streamWithVisionSessionAffinity } from './session-affinity-runtime.js'
+import { runWithVisionSessionAffinity } from './session-affinity-runtime.js'
 import {
-  routingCorrectionFor,
-  toAnthropicMessages,
   callAnthropicCompatible,
   anthropicMediaType,
 } from './catalog-corrections.js'
-import { createCachedUpdateChecker } from './update-check.js'
-import { probeLocalBackends } from './local-connection-probe.js'
-import { detectDshSelfUpdatePlan, runDshPluginUpdate } from './self-update.js'
+
 import {
-  classifyVisionFailure,
-  createDeadline,
   combineSignals,
-  createVisionCircuitBreaker,
-  createVisionTurnMemory,
-  buildVisionFailure,
-  ensureSentencePunctuation,
-  resultCodeForKinds,
   qwenKeyEndpointHint,
   kindForHttpStatus,
-  VISION_FAILURE_KINDS,
-  VISION_RESULT_CODES,
 } from './vision-resilience.js'
-import { currentVisionExecutionOrder } from './vision-execution-order.js'
-import { applyVisionExecutionOrder } from './vision-execution-order-apply.js'
-import { createHash, randomBytes } from 'node:crypto'
-import {
-  normalizeStructuredBootstrapResult,
-  structuredBootstrapMemory,
-  structuredBootstrapQuestion,
-} from './structured-bootstrap.js'
-import { planMixedBranches, renderMixedGuidance } from './mixed-router.js'
-import { renderDepthGuidance } from './depth-guidance.js'
-import { assertNoRepetitionLoop } from './repetition-guard.js'
-import { compareRgbaStreams } from './pixel-diff-stream.js'
+
+import { createHash } from 'node:crypto'
+
 import {
-  boundedOcrTiles,
   defaultImageResourceGovernor,
   estimateImageOperationBytes,
   scaleBox,
   scaledDimensions,
 } from './image-resource-governor.js'
-import { createSessionVisionIndex } from './session-vision-index.js'
-import { createSessionVisionStateStore } from './session-vision-state.js'
+
 import {
   ERROR_RESPONSE_MAX_BYTES,
-  METADATA_RESPONSE_MAX_BYTES,
   MODEL_RESPONSE_MAX_BYTES,
   readResponseJsonBounded,
   readResponseTextBounded,
 } from './http-body-limit.js'
-import { writeArtifactFile } from './artifact-boundary.js'
+
 import { stripTrailingSlashes } from './string-normalization.js'
 import { isOffloadedImageBlock, offloadedImagePlaceholder } from './image-offload-compat.js'
 import { proxyHostMatchesAny } from './proxy-routing.js'
-import { parseVersionComparator } from './version-range.js'
-import { captureWindowsDesktop } from './windows-desktop-capture.js'
-import {
-  sharpPromise,
-  sharpWarningHook,
-  registerSharpWarningHook,
-  warnSharp,
-  parseVersionParts,
-  compareVersionParts,
-  versionSatisfies,
-  sharpPeerRangeCache,
-  sharpPeerRange,
-  loadSharp,
-} from './sharp-runtime.js'
 
+import { loadSharp } from './sharp-runtime.js'
 export const IMAGE_EXTENSIONS = {
   png: 'image/png',
   jpg: 'image/jpeg',
@@ -109,7 +66,6 @@ export function mediaTypeOf(path) {
  */
 export { depthLimitFor } from './depth-guidance.js'
 
-
 /**
  * Detect the image format from magic bytes instead of the file extension.
  * Attachments are stored as content-addressed files WITHOUT an extension,
@@ -655,77 +611,7 @@ export function extractJson(text) {
   return undefined
 }
 
-function cacheWeight(value) {
-  if (Buffer.isBuffer(value) || value instanceof Uint8Array) return value.byteLength
-  if (typeof value === 'string') return Buffer.byteLength(value, 'utf8')
-  try {
-    const encoded = JSON.stringify(value)
-    return Buffer.byteLength(encoded === undefined ? String(value) : encoded, 'utf8')
-  } catch {
-    return Buffer.byteLength(String(value), 'utf8')
-  }
-}
-
-/** LRU+TTL cache bounded by BOTH entry count and retained bytes. */
-export function createCache(maxEntries, ttlMs, options = {}) {
-  const entries = new Map()
-  const entryLimit = Math.max(0, Math.floor(Number(maxEntries) || 0))
-  const maxBytes = Number.isFinite(Number(options.maxBytes)) && Number(options.maxBytes) >= 0
-    ? Math.floor(Number(options.maxBytes))
-    : 8 * 1024 * 1024
-  const maxEntryBytes = Number.isFinite(Number(options.maxEntryBytes)) && Number(options.maxEntryBytes) >= 0
-    ? Math.floor(Number(options.maxEntryBytes))
-    : Math.min(maxBytes, 1024 * 1024)
-  let retainedBytes = 0
-
-  const remove = (key) => {
-    const entry = entries.get(key)
-    if (!entry) return
-    retainedBytes = Math.max(0, retainedBytes - entry.weight)
-    entries.delete(key)
-  }
-  const evict = () => {
-    while (entries.size > entryLimit || retainedBytes > maxBytes) {
-      const oldest = entries.keys().next().value
-      if (oldest === undefined) break
-      remove(oldest)
-    }
-  }
-
-  return {
-    get(key) {
-      const entry = entries.get(key)
-      if (!entry) return undefined
-      if (entry.expiresAt <= Date.now()) {
-        remove(key)
-        return undefined
-      }
-      entries.delete(key)
-      entries.set(key, entry)
-      return entry.value
-    },
-    set(key, value) {
-      const normalizedKey = String(key)
-      const weight = Buffer.byteLength(normalizedKey, 'utf8') + cacheWeight(value)
-      remove(normalizedKey)
-      if (entryLimit === 0 || maxBytes === 0 || weight > maxEntryBytes || weight > maxBytes) return false
-      entries.set(normalizedKey, {
-        value,
-        weight,
-        expiresAt: ttlMs <= 0 ? Infinity : Date.now() + ttlMs,
-      })
-      retainedBytes += weight
-      evict()
-      return entries.has(normalizedKey)
-    },
-    get size() {
-      return entries.size
-    },
-    get bytes() {
-      return retainedBytes
-    },
-  }
-}
+export { cacheWeight, createCache } from './core-cache.js'
 
 /** True when the harness llm service has a registered adapter for the provider route. */
 export function adapterAvailable(llm, provider) {
@@ -1268,29 +1154,52 @@ export function bitmapOfGray(raw, width, height, threshold = 128) {
   return out
 }
 
+function visionAbortReason(signal, fallback = 'vision operation aborted') {
+  if (signal?.reason instanceof Error) return signal.reason
+  const error = new Error(fallback)
+  error.name = 'AbortError'
+  error.code = 'ABORT_ERR'
+  return error
+}
+
+function throwIfVisionAborted(signal, fallback) {
+  if (signal?.aborted) throw visionAbortReason(signal, fallback)
+}
+
+function isVisionAbort(error, signal) {
+  return signal?.aborted === true || error?.name === 'AbortError' || error?.code === 'ABORT_ERR'
+}
+
 /** Vectorize an image buffer into an SVG string via potrace posterization. */
-export function posterizeSvg(bytes, steps = 4, fillStrategy = 'dominant', timeoutMs = 60000) {
+export function posterizeSvg(bytes, steps = 4, fillStrategy = 'dominant', timeoutMs = 60000, options = {}) {
   // potrace is CPU-bound and runs its computation in long synchronous
   // chunks: on the main thread it blocks the whole dsh process (other
   // sessions time out) and a setTimeout-based timeout can NEVER fire while
   // the loop is blocked. Run it in a worker thread instead — the main loop
   // stays responsive, and a timeout hard-terminates the worker.
+  const signal = options?.signal
   return new Promise((resolve, reject) => {
     let settled = false
     let worker
+    let timer
+    let abortListener
     const finish = (error, svg) => {
       if (settled) return
       settled = true
-      clearTimeout(timer)
+      if (timer !== undefined) clearTimeout(timer)
+      if (signal && abortListener) signal.removeEventListener?.('abort', abortListener)
       void worker?.terminate()
       if (error) reject(error)
       else resolve(svg)
     }
-    const timer = setTimeout(() => {
-      if (settled) return
-      settled = true
-      void worker?.terminate()
-      reject(
+    abortListener = () => finish(visionAbortReason(signal, 'potrace aborted'))
+    if (signal?.aborted) {
+      finish(visionAbortReason(signal, 'potrace aborted'))
+      return
+    }
+    signal?.addEventListener?.('abort', abortListener, { once: true })
+    timer = setTimeout(() => {
+      finish(
         new Error(
           'potrace timed out — the image is too large or too complex; crop it to the target region first',
         ),
@@ -1347,23 +1256,30 @@ export function posterizeSvg(bytes, steps = 4, fillStrategy = 'dominant', timeou
  * @param palette - [{ hex, count, share }] from quantizeColors, ordered by
  *   share descending.
  */
-export function posterizeSvgColor(data, info, palette, timeoutMs = 60000) {
+export function posterizeSvgColor(data, info, palette, timeoutMs = 60000, options = {}) {
+  const signal = options?.signal
   return new Promise((resolve, reject) => {
     let settled = false
     let worker
+    let timer
+    let abortListener
     const finish = (error, svg) => {
       if (settled) return
       settled = true
-      clearTimeout(timer)
+      if (timer !== undefined) clearTimeout(timer)
+      if (signal && abortListener) signal.removeEventListener?.('abort', abortListener)
       void worker?.terminate()
       if (error) reject(error)
       else resolve(svg)
     }
-    const timer = setTimeout(() => {
-      if (settled) return
-      settled = true
-      void worker?.terminate()
-      reject(
+    abortListener = () => finish(visionAbortReason(signal, 'color trace aborted'))
+    if (signal?.aborted) {
+      finish(visionAbortReason(signal, 'color trace aborted'))
+      return
+    }
+    signal?.addEventListener?.('abort', abortListener, { once: true })
+    timer = setTimeout(() => {
+      finish(
         new Error(
           'color trace timed out — the image is too large or too complex; crop it to the target region first',
         ),
@@ -1473,13 +1389,21 @@ export function resolveVisionOcrEngine(requestedEngine, configuredEngine = 'auto
 }
 
 /** OCR image bytes with a local tesseract binary (chi_sim+eng) when available. */
-export async function ocrWithTesseract(bytes, timeoutMs = 60000) {
-  const exec = promisify(execFile)
+export async function ocrWithTesseract(bytes, timeoutMs = 60000, options = {}) {
+  const exec = typeof options.exec === 'function' ? options.exec : promisify(execFile)
+  const signal = options.signal
+  throwIfVisionAborted(signal, 'tesseract OCR aborted')
   const { stdout } = await exec(
     'tesseract',
     ['stdin', 'stdout', '-l', 'chi_sim+eng', '--psm', '6'],
-    { timeout: Math.min(timeoutMs, 60000), maxBuffer: 32 * 1024 * 1024, input: bytes },
+    {
+      timeout: Math.min(timeoutMs, 60000),
+      maxBuffer: 32 * 1024 * 1024,
+      input: bytes,
+      ...(signal === undefined ? {} : { signal }),
+    },
   )
+  throwIfVisionAborted(signal, 'tesseract OCR aborted')
   return String(stdout ?? '')
 }
 
@@ -1543,6 +1467,7 @@ export function selectTesseractOcrCandidate(candidates) {
 
 export async function ocrWithTesseractAdaptive(bytes, timeoutMs = 12000, options = {}) {
   const exec = typeof options.exec === 'function' ? options.exec : promisify(execFile)
+  const signal = options.signal
   const requestedBudget = Number(timeoutMs)
   const budgetMs = Number.isFinite(requestedBudget) && requestedBudget > 0
     ? Math.min(60000, requestedBudget)
@@ -1551,20 +1476,25 @@ export async function ocrWithTesseractAdaptive(bytes, timeoutMs = 12000, options
   const attemptedPsms = []
   const remaining = () => Math.max(1, budgetMs - (Date.now() - started))
   const run = async (psm) => {
+    throwIfVisionAborted(signal, 'adaptive tesseract OCR aborted')
     attemptedPsms.push(psm)
     const common = ['stdin', 'stdout', '-l', 'chi_sim+eng', '--psm', String(psm)]
     const execOptions = () => ({
       timeout: remaining(),
       maxBuffer: 32 * 1024 * 1024,
       input: bytes,
+      ...(signal === undefined ? {} : { signal }),
     })
     const { stdout: plain } = await exec('tesseract', common, execOptions())
+    throwIfVisionAborted(signal, 'adaptive tesseract OCR aborted')
     const text = String(plain ?? '').trim()
     if (text === '') return assessTesseractOcr('', '', psm)
     try {
       const { stdout: tsv } = await exec('tesseract', [...common, 'tsv'], execOptions())
+      throwIfVisionAborted(signal, 'adaptive tesseract OCR aborted')
       return assessTesseractOcr(text, String(tsv ?? ''), psm)
-    } catch {
+    } catch (error) {
+      if (isVisionAbort(error, signal)) throw error
       return { psm, text, words: 0, quality: 0, riskyTokens: [], uncertain: true }
     }
   }
@@ -1577,7 +1507,8 @@ export async function ocrWithTesseractAdaptive(bytes, timeoutMs = 12000, options
     if (Date.now() - started >= budgetMs) break
     try {
       candidates.push(await run(psm))
-    } catch {
+    } catch (error) {
+      if (isVisionAbort(error, signal)) throw error
       // Keep the first successful local OCR result when an optional review pass fails.
     }
   }
@@ -2096,6 +2027,7 @@ export async function callLocalBackend(provider, messages, options = {}) {
         maxTokens,
         signal: options.signal,
         allowKeyless: true,
+        providerTransport: options.providerTransport,
         system: system.join('\n').trim(),
         ...(rawSessionIdentity(options.sessionId) === undefined
           ? {}
@@ -2109,6 +2041,7 @@ export async function callLocalBackend(provider, messages, options = {}) {
   }
   return callOpenAICompatible(provider, messages, {
     maxTokens,
+    providerTransport: options.providerTransport,
     signal: options.signal,
     ...(rawSessionIdentity(options.sessionId) === undefined
       ? {}
@@ -2291,7 +2224,7 @@ export async function callOpenAICompatible(provider, messages, options = {}) {
         body: JSON.stringify(body),
         ...(options.signal === undefined ? {} : { signal: options.signal }),
       },
-      { active: true, providerName: provider.name },
+      { active: true, providerName: provider.name, providerTransport: options.providerTransport },
     )
   const response = await request()
   if (!response.ok) {
@@ -2332,77 +2265,8 @@ export async function callOpenAICompatible(provider, messages, options = {}) {
   return text
 }
 
-/**
- * Minimal harness-chunk assembler (no dsh imports required). Feeds the raw
- * `llm/stream` chunk protocol and produces the final text of text blocks.
- * Terminal failures throw; a `max-tokens` finish returns the partial text.
- */
-export function createChunkAssembler() {
-  const parts = new Map()
-  const order = []
-  let finishKind
-  let failure
-
-  const push = (chunk) => {
-    if (!chunk || typeof chunk.type !== 'string') return
-    switch (chunk.type) {
-      case 'block-start': {
-        if (!parts.has(chunk.index)) {
-          order.push(chunk.index)
-          parts.set(chunk.index, { type: chunk.blockType, text: '' })
-        }
-        break
-      }
-      case 'text-delta': {
-        const part = parts.get(chunk.index)
-        if (part) part.text += chunk.text ?? ''
-        break
-      }
-      case 'reasoning-delta':
-      case 'tool-call-delta':
-      case 'usage':
-        break
-      case 'block-end': {
-        const part = parts.get(chunk.index)
-        if (part && chunk.block && typeof chunk.block.text === 'string') {
-          part.text = chunk.block.text
-        }
-        break
-      }
-      case 'finish': {
-        const reason = chunk.reason
-        if (reason && (reason.kind === 'error' || reason.kind === 'aborted')) {
-          failure = reason.failure
-        }
-        finishKind = reason && reason.kind ? reason.kind : 'stop'
-        break
-      }
-      case 'error':
-      case 'aborted':
-        failure = chunk.failure
-        break
-      default:
-        break
-    }
-  }
-
-  const finish = () => {
-    if (failure) {
-      throw new Error(failure && failure.message ? failure.message : String(failure))
-    }
-    if (finishKind !== undefined && finishKind !== 'stop' && finishKind !== 'max-tokens') {
-      throw new Error(`vision call finished with "${finishKind}"`)
-    }
-    return order
-      .map((index) => parts.get(index))
-      .filter((part) => part && part.type === 'text')
-      .map((part) => part.text)
-      .join('')
-      .trim()
-  }
-
-  return { push, finish }
-}
+import { createChunkAssembler } from './vision-chunk-assembler.js'
+export { createChunkAssembler }
 
 async function visionAnswer(llm, options) {
   return runWithVisionSessionAffinity(options?.sessionId, async () => {
@@ -2414,61 +2278,6 @@ async function visionAnswer(llm, options) {
   })
 }
 
-/** Environment shim for `resolveAdapterOptions`: `{ get: (name) => ({ value }) }`. */
-export function launchEnvironmentLike(env) {
-  const map = env ?? {}
-  return {
-    get(name) {
-      return Object.prototype.hasOwnProperty.call(map, name) ? { value: map[name] } : undefined
-    },
-  }
-}
-
-/**
- * Legacy-only DeepSeek reconstruction for Host contracts that do not own the
- * official provider lifecycle. Modern Hosts keep `deepseek-official` Host-owned
- * because request-local attachment/file/image-access seams cannot be cloned
- * safely here. Remove this helper when the legacy takeover window is retired.
- */
-export function createNativeDeepSeekAdapter(ctx) {
-  const env = launchEnvironmentLike(
-    typeof process !== 'undefined' && process.env ? process.env : {},
-  )
-  const options = () => {
-    let raw
-    try {
-      const settings = ctx.get('settings')
-      raw = settings && settings.get ? settings.get('llm-deepseek') : undefined
-    } catch {
-      raw = undefined
-    }
-    return resolveAdapterOptions(raw ?? {}, env)
-  }
-  const resolveApiKey = async (connection) => {
-    const ref = connection.apiKeyEnv
-    const credentials = ctx.get('credentials')
-    if (credentials !== undefined) {
-      try {
-        const hit = await credentials.resolve(ref)
-        if (hit && typeof hit.value === 'string' && hit.value.length > 0) return hit.value
-      } catch {
-        /* fall through to the environment */
-      }
-    }
-    const ambient = env.get(ref)
-    if (ambient !== undefined && typeof ambient.value === 'string' && ambient.value.length > 0) {
-      return ambient.value
-    }
-    throw new Error(`vision-router: no API key for the native DeepSeek route (${ref})`)
-  }
-  let userId
-  const resolveUserId = () => {
-    if (userId === undefined) userId = getOrCreateAnonymousUserId()
-    return userId
-  }
-  return new DeepSeekAdapter({ options, resolveApiKey, resolveUserId })
-}
-
 /**
  * dsh-vision 并入：本地识别提示模板。
  * `plain` = 平铺描述；`structured` = 结构化识别（【初步判断】/【细节】/
@@ -2595,7 +2404,11 @@ export async function buildInstantLocalMap(ctx, messages, provider, options = {}
                 const text = await callLocalBackend(
                   currentProvider,
                   [{ role: 'user', content }],
-                  { maxTokens: currentProvider.maxTokens ?? 2048, signal },
+                  {
+                    maxTokens: currentProvider.maxTokens ?? 2048,
+                    signal,
+                    providerTransport: options.providerTransport,
+                  },
                 )
                 return { id, ok: true, text, elapsedMs: Date.now() - startedAt }
               } catch (error) {
@@ -2673,7 +2486,7 @@ export async function buildInstantLocalMap(ctx, messages, provider, options = {}
  * 标记；provider/style/timeout 也可以是 getter，让设置页保存后下一次 stream
  * 立即读取新值，无需重启或重建 adapter。
  */
-export function createWrapperStreamBody(ctx, { imageMemory, delegateProvider, preserveImageInput, instantLocal, instantLocalStyle, instantLocalTimeoutMs, instantLocalMaxPixels }) {
+export function createWrapperStreamBody(ctx, { imageMemory, delegateProvider, preserveImageInput, instantLocal, instantLocalStyle, instantLocalTimeoutMs, instantLocalMaxPixels, providerTransport }) {
   // issue #103: the reasoning level is a per-session picker choice (the chat
   // page's bottom-right selector), but the host can drop reasoningEffort from
   // the later steps of a multi-step turn once the twin metadata lacks a
@@ -2709,6 +2522,7 @@ export function createWrapperStreamBody(ctx, { imageMemory, delegateProvider, pr
               memory: imageMemory,
               timeoutMs: liveValue(instantLocalTimeoutMs),
               downscaleMaxPixels: liveValue(instantLocalMaxPixels),
+              providerTransport,
             })
           : undefined
       // Rewrite image blocks ANYWHERE in the model input — including inside
@@ -2801,7 +2615,7 @@ export function createWrapperStreamBody(ctx, { imageMemory, delegateProvider, pr
  * route). Any other route name (e.g. the `deepseek-vision` alias) advertises
  * no models, so it stays functional but invisible in the picker.
  */
-export function createStealthAdapter(ctx, { native, imageMemory, pairs, chainRoute, delegateProvider, instantLocal, instantLocalStyle, instantLocalTimeoutMs, instantLocalMaxPixels }) {
+export function createStealthAdapter(ctx, { native, imageMemory, pairs, chainRoute, delegateProvider, instantLocal, instantLocalStyle, instantLocalTimeoutMs, instantLocalMaxPixels, providerTransport }) {
   return {
     providerInfo(provider) {
       return { id: provider, name: 'DeepSeek' }
@@ -2822,7 +2636,7 @@ export function createStealthAdapter(ctx, { native, imageMemory, pairs, chainRou
       const base = await native.resolveModel(provider, model, signal)
       return { ...base, provider, inputModalities: ['text', 'image'] }
     },
-    ...createWrapperStreamBody(ctx, { imageMemory, delegateProvider, instantLocal, instantLocalStyle, instantLocalTimeoutMs, instantLocalMaxPixels }),
+    ...createWrapperStreamBody(ctx, { imageMemory, delegateProvider, instantLocal, instantLocalStyle, instantLocalTimeoutMs, instantLocalMaxPixels, providerTransport }),
   }
 }
 
@@ -3019,7 +2833,6 @@ export {
   FAILURE_ADVICE,
   PERSISTED_GUARD_STOP_SURFACE_ID,
   imageMarker,
-  cacheWeight,
   visionAnswer,
   NON_GENERATIVE_VISION_MODEL_HINTS,
   VISION_MODEL_NAME_HINTS,

package/lib/core-vision-surface-domain.js

@@ -0,0 +1,63 @@
+import { resolveSessionSurfacePolicy, } from './session-surface-policy-domain.js';
+export const CORE_VISION_SURFACE_KEYS = [
+    'tool',
+    'rewriteImages',
+    'instantDescribe',
+    'autoActivateOnImage',
+    'structuredVisionBootstrap',
+];
+function objectRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function own(object, key) {
+    return Object.prototype.hasOwnProperty.call(object, key);
+}
+function coreFlags(values) {
+    return {
+        toolAvailable: values.tool !== false,
+        rewriteEnabled: values.rewriteImages !== false,
+        instantDescribe: values.instantDescribe === true,
+        autoActivateOnImage: values.autoActivateOnImage !== false,
+        structuredBootstrap: values.structuredVisionBootstrap === true,
+    };
+}
+/**
+ * Explicit Core-facing projection of SessionSurfacePolicy.
+ *
+ * Only the five historical Core switches cross this boundary. Unrelated plugin
+ * Settings cannot masquerade as a Core config/Settings object.
+ */
+export function projectCoreVisionSurface(config = {}, sessionPolicy) {
+    const value = objectRecord(config) ?? {};
+    const policyRecord = objectRecord(sessionPolicy);
+    const policy = policyRecord !== undefined
+        ? policyRecord
+        : resolveSessionSurfacePolicy({ config: value });
+    const overrides = objectRecord(policy.legacyConfigOverrides) ?? {};
+    const projected = {};
+    for (const key of CORE_VISION_SURFACE_KEYS) {
+        projected[key] = own(overrides, key)
+            ? overrides[key]
+            : value[key];
+    }
+    const values = Object.freeze(projected);
+    return Object.freeze({
+        ownership: typeof policy.ownership === 'string'
+            ? policy.ownership
+            : undefined,
+        preserveRawImages: policy.preserveRawImages === true,
+        rewriteCurrentImages: policy.rewriteCurrentImages === true,
+        ...coreFlags(values),
+        values,
+    });
+}
+export function resolveCoreVisionSurface({ visionPolicy, config = {}, schemaBootstrapping = false, } = {}) {
+    const value = objectRecord(config) ?? {};
+    return projectCoreVisionSurface(value, resolveSessionSurfacePolicy({
+        visionPolicy,
+        config: value,
+        schemaBootstrapping,
+    }));
+}