dsh-vision-router 2.3.0 → 3.0.0

package/lib/image-resource-governor.js

@@ -1,254 +1,236 @@
-import { currentVisionTurnBudgetSignal } from './turn-budget-context.js'
-
-const MIB = 1024 * 1024
-export const DEFAULT_IMAGE_RESOURCE_MAX_BYPASSES = 2
-
+import { currentVisionTurnBudgetSignal } from './turn-budget-context.js';
+const MIB = 1024 * 1024;
+export const DEFAULT_IMAGE_RESOURCE_MAX_BYPASSES = 2;
 function abortError() {
-  const error = new Error('image resource wait aborted')
-  error.name = 'AbortError'
-  error.code = 'ABORT_ERR'
-  return error
+    const error = new Error('image resource wait aborted');
+    error.name = 'AbortError';
+    error.code = 'ABORT_ERR';
+    return error;
 }
-
 function effectiveSignal(explicit) {
-  const ambient = currentVisionTurnBudgetSignal()
-  if (!explicit) return ambient
-  if (!ambient || ambient === explicit) return explicit
-  return AbortSignal.any([explicit, ambient])
+    const ambient = currentVisionTurnBudgetSignal();
+    if (!explicit)
+        return ambient;
+    if (!ambient || ambient === explicit)
+        return explicit;
+    return AbortSignal.any([explicit, ambient]);
 }
-
-export function estimateDecodedBytes(
-  width,
-  height,
-  { channels = 4, copies = 1, safetyFactor = 1.25 } = {},
-) {
-  const w = Math.max(0, Math.floor(Number(width) || 0))
-  const h = Math.max(0, Math.floor(Number(height) || 0))
-  const c = Math.max(1, Number(channels) || 4)
-  const n = Math.max(1, Number(copies) || 1)
-  const factor = Math.max(1, Number(safetyFactor) || 1)
-  return Math.ceil(w * h * c * n * factor)
+export function estimateDecodedBytes(width, height, { channels = 4, copies = 1, safetyFactor = 1.25, } = {}) {
+    const w = Math.max(0, Math.floor(Number(width) || 0));
+    const h = Math.max(0, Math.floor(Number(height) || 0));
+    const c = Math.max(1, Number(channels) || 4);
+    const n = Math.max(1, Number(copies) || 1);
+    const factor = Math.max(1, Number(safetyFactor) || 1);
+    return Math.ceil(w * h * c * n * factor);
 }
-
 export function estimateImageOperationBytes(operation, width, height) {
-  switch (operation) {
-    case 'metadata':
-      return 1 * MIB
-    case 'preview':
-    case 'annotation':
-      return estimateDecodedBytes(width, height, { copies: 1, safetyFactor: 1.5 })
-    case 'tile':
-    case 'crop':
-      return estimateDecodedBytes(width, height, { copies: 1, safetyFactor: 1.35 })
-    case 'raw':
-      return estimateDecodedBytes(width, height, { copies: 2, safetyFactor: 1.5 })
-    case 'pixel-diff':
-      return estimateDecodedBytes(width, height, { copies: 3, safetyFactor: 1.5 })
-    default:
-      return estimateDecodedBytes(width, height, { copies: 1, safetyFactor: 1.5 })
-  }
+    switch (operation) {
+        case 'metadata':
+            return 1 * MIB;
+        case 'preview':
+        case 'annotation':
+            return estimateDecodedBytes(width, height, { copies: 1, safetyFactor: 1.5 });
+        case 'tile':
+        case 'crop':
+            return estimateDecodedBytes(width, height, { copies: 1, safetyFactor: 1.35 });
+        case 'raw':
+            return estimateDecodedBytes(width, height, { copies: 2, safetyFactor: 1.5 });
+        case 'pixel-diff':
+            return estimateDecodedBytes(width, height, { copies: 3, safetyFactor: 1.5 });
+        default:
+            return estimateDecodedBytes(width, height, { copies: 1, safetyFactor: 1.5 });
+    }
 }
-
 export function scaledDimensions(width, height, maxPixels) {
-  const w = Math.max(0, Math.floor(Number(width) || 0))
-  const h = Math.max(0, Math.floor(Number(height) || 0))
-  const limit = Math.max(1, Math.floor(Number(maxPixels) || 1))
-  if (w <= 0 || h <= 0) return { width: w, height: h, scale: 1 }
-  const pixels = w * h
-  if (pixels <= limit) return { width: w, height: h, scale: 1 }
-  const scale = Math.sqrt(limit / pixels)
-  return {
-    width: Math.max(1, Math.floor(w * scale)),
-    height: Math.max(1, Math.floor(h * scale)),
-    scale,
-  }
+    const w = Math.max(0, Math.floor(Number(width) || 0));
+    const h = Math.max(0, Math.floor(Number(height) || 0));
+    const limit = Math.max(1, Math.floor(Number(maxPixels) || 1));
+    if (w <= 0 || h <= 0)
+        return { width: w, height: h, scale: 1 };
+    const pixels = w * h;
+    if (pixels <= limit)
+        return { width: w, height: h, scale: 1 };
+    const scale = Math.sqrt(limit / pixels);
+    return {
+        width: Math.max(1, Math.floor(w * scale)),
+        height: Math.max(1, Math.floor(h * scale)),
+        scale,
+    };
 }
-
 export function scaleBox(box, fromWidth, fromHeight, toWidth, toHeight) {
-  const sx = fromWidth > 0 ? toWidth / fromWidth : 1
-  const sy = fromHeight > 0 ? toHeight / fromHeight : 1
-  return {
-    x1: Math.max(0, Math.round(box.x1 * sx)),
-    y1: Math.max(0, Math.round(box.y1 * sy)),
-    x2: Math.min(toWidth, Math.max(1, Math.round(box.x2 * sx))),
-    y2: Math.min(toHeight, Math.max(1, Math.round(box.y2 * sy))),
-  }
+    const sx = fromWidth > 0 ? toWidth / fromWidth : 1;
+    const sy = fromHeight > 0 ? toHeight / fromHeight : 1;
+    return {
+        x1: Math.max(0, Math.round(box.x1 * sx)),
+        y1: Math.max(0, Math.round(box.y1 * sy)),
+        x2: Math.min(toWidth, Math.max(1, Math.round(box.x2 * sx))),
+        y2: Math.min(toHeight, Math.max(1, Math.round(box.y2 * sy))),
+    };
 }
-
 /**
  * Cover a long/large image with bounded tiles in reading order. Normal narrow
  * screenshots keep one full-width strip. Ultra-wide inputs split horizontally
  * as well so width * height never exceeds maxTilePixels.
  */
-export function boundedOcrTiles(
-  width,
-  height,
-  { chunkHeight = 1200, overlap = 120, maxTilePixels = 4_000_000 } = {},
-) {
-  const w = Math.max(1, Math.floor(Number(width) || 1))
-  const h = Math.max(1, Math.floor(Number(height) || 1))
-  const requestedHeight = Math.max(1, Math.min(h, Math.floor(Number(chunkHeight) || 1200)))
-  const pixelLimit = Math.max(1, Math.floor(Number(maxTilePixels) || 4_000_000))
-  const tileWidth = Math.min(w, Math.max(1, Math.floor(pixelLimit / requestedHeight)))
-  const tileHeight = Math.min(requestedHeight, Math.max(1, Math.floor(pixelLimit / tileWidth)))
-  const verticalOverlap = Math.min(
-    Math.max(0, Math.floor(Number(overlap) || 0)),
-    Math.max(0, Math.floor(tileHeight / 2)),
-  )
-  const verticalStep = Math.max(1, tileHeight - verticalOverlap)
-  const tiles = []
-  for (let top = 0; top < h; top += verticalStep) {
-    const bottom = Math.min(h, top + tileHeight)
-    for (let left = 0; left < w; left += tileWidth) {
-      const right = Math.min(w, left + tileWidth)
-      tiles.push({ left, right, top, bottom })
+export function boundedOcrTiles(width, height, { chunkHeight = 1200, overlap = 120, maxTilePixels = 4_000_000, } = {}) {
+    const w = Math.max(1, Math.floor(Number(width) || 1));
+    const h = Math.max(1, Math.floor(Number(height) || 1));
+    const requestedHeight = Math.max(1, Math.min(h, Math.floor(Number(chunkHeight) || 1200)));
+    const pixelLimit = Math.max(1, Math.floor(Number(maxTilePixels) || 4_000_000));
+    const tileWidth = Math.min(w, Math.max(1, Math.floor(pixelLimit / requestedHeight)));
+    const tileHeight = Math.min(requestedHeight, Math.max(1, Math.floor(pixelLimit / tileWidth)));
+    const verticalOverlap = Math.min(Math.max(0, Math.floor(Number(overlap) || 0)), Math.max(0, Math.floor(tileHeight / 2)));
+    const verticalStep = Math.max(1, tileHeight - verticalOverlap);
+    const tiles = [];
+    for (let top = 0; top < h; top += verticalStep) {
+        const bottom = Math.min(h, top + tileHeight);
+        for (let left = 0; left < w; left += tileWidth) {
+            const right = Math.min(w, left + tileWidth);
+            tiles.push({ left, right, top, bottom });
+        }
+        if (bottom >= h)
+            break;
     }
-    if (bottom >= h) break
-  }
-  return tiles
+    return tiles;
 }
-
 export class ImageResourceGovernor {
-  constructor({
-    maxBytes = 256 * MIB,
-    maxConcurrent = 2,
-    maxBypasses = DEFAULT_IMAGE_RESOURCE_MAX_BYPASSES,
-  } = {}) {
-    this.maxBytes = Math.max(1, Math.floor(Number(maxBytes) || 256 * MIB))
-    this.maxConcurrent = Math.max(1, Math.floor(Number(maxConcurrent) || 2))
-    this.maxBypasses = Math.max(0, Math.floor(Number(maxBypasses) || 0))
-    this.activeBytes = 0
-    this.activeCount = 0
-    this.activeExclusive = false
-    this.queue = []
-  }
-
-  _normalize(bytes, exclusive) {
-    const requested = Math.max(1, Math.ceil(Number(bytes) || 1))
-    const wantsExclusive = exclusive === true || requested >= this.maxBytes
-    return {
-      requested,
-      charged: Math.min(requested, this.maxBytes),
-      exclusive: wantsExclusive,
+    maxBytes;
+    maxConcurrent;
+    maxBypasses;
+    activeBytes = 0;
+    activeCount = 0;
+    activeExclusive = false;
+    queue = [];
+    constructor({ maxBytes = 256 * MIB, maxConcurrent = 2, maxBypasses = DEFAULT_IMAGE_RESOURCE_MAX_BYPASSES, } = {}) {
+        this.maxBytes = Math.max(1, Math.floor(Number(maxBytes) || 256 * MIB));
+        this.maxConcurrent = Math.max(1, Math.floor(Number(maxConcurrent) || 2));
+        this.maxBypasses = Math.max(0, Math.floor(Number(maxBypasses) || 0));
     }
-  }
-
-  _canRun(request) {
-    if (this.activeExclusive) return false
-    if (request.exclusive) return this.activeCount === 0
-    return (
-      this.activeCount < this.maxConcurrent &&
-      this.activeBytes + request.charged <= this.maxBytes
-    )
-  }
-
-  _grant(item) {
-    if (item.settled) return
-    item.settled = true
-    if (item.signal && item.abortHandler) {
-      item.signal.removeEventListener('abort', item.abortHandler)
+    _normalize(bytes, exclusive) {
+        const requested = Math.max(1, Math.ceil(Number(bytes) || 1));
+        const wantsExclusive = exclusive === true || requested >= this.maxBytes;
+        return {
+            requested,
+            charged: Math.min(requested, this.maxBytes),
+            exclusive: wantsExclusive,
+        };
     }
-    this.activeCount += 1
-    this.activeBytes += item.request.charged
-    if (item.request.exclusive) this.activeExclusive = true
-    let released = false
-    item.resolve(() => {
-      if (released) return
-      released = true
-      this.activeCount = Math.max(0, this.activeCount - 1)
-      this.activeBytes = Math.max(0, this.activeBytes - item.request.charged)
-      if (item.request.exclusive) this.activeExclusive = false
-      this._drain()
-    })
-  }
-
-  /**
-   * Find work that fits the current byte/concurrency window without letting a
-   * large request permanently pin every smaller request behind it. Each blocked
-   * non-exclusive request may be bypassed only a small, fixed number of times;
-   * after that it becomes a fairness barrier until capacity is released.
-   * Exclusive work is always a barrier immediately.
-   */
-  _nextRunnable() {
-    const bypassed = []
-    for (let index = 0; index < this.queue.length; index++) {
-      const item = this.queue[index]
-      if (!item || item.settled) continue
-      if (this._canRun(item.request)) return { index, item, bypassed }
-      if (item.request.exclusive || item.bypassCount >= this.maxBypasses) return undefined
-      bypassed.push(item)
+    _canRun(request) {
+        if (this.activeExclusive)
+            return false;
+        if (request.exclusive)
+            return this.activeCount === 0;
+        return (this.activeCount < this.maxConcurrent &&
+            this.activeBytes + request.charged <= this.maxBytes);
     }
-    return undefined
-  }
-
-  _drain() {
-    while (this.queue.length > 0) {
-      while (this.queue[0]?.settled) this.queue.shift()
-      if (this.queue.length === 0) return
-      const selected = this._nextRunnable()
-      if (!selected) return
-      this.queue.splice(selected.index, 1)
-      for (const item of selected.bypassed) item.bypassCount += 1
-      this._grant(selected.item)
-      if (selected.item.request.exclusive) return
+    _grant(item) {
+        if (item.settled)
+            return;
+        item.settled = true;
+        if (item.signal && item.abortHandler) {
+            item.signal.removeEventListener('abort', item.abortHandler);
+        }
+        this.activeCount += 1;
+        this.activeBytes += item.request.charged;
+        if (item.request.exclusive)
+            this.activeExclusive = true;
+        let released = false;
+        item.resolve(() => {
+            if (released)
+                return;
+            released = true;
+            this.activeCount = Math.max(0, this.activeCount - 1);
+            this.activeBytes = Math.max(0, this.activeBytes - item.request.charged);
+            if (item.request.exclusive)
+                this.activeExclusive = false;
+            this._drain();
+        });
     }
-  }
-
-  acquire(bytes, { signal, exclusive = false } = {}) {
-    // Structured 1+x installs its remaining turn deadline in AsyncLocalStorage.
-    // Even image helpers that historically passed `{}` now inherit that signal
-    // while they wait in the resource queue, so an exhausted turn cannot leave
-    // dead work queued behind another large image operation.
-    const combinedSignal = effectiveSignal(signal)
-    if (combinedSignal?.aborted) return Promise.reject(abortError())
-    const request = this._normalize(bytes, exclusive)
-    return new Promise((resolve, reject) => {
-      const item = {
-        request,
-        signal: combinedSignal,
-        resolve,
-        reject,
-        settled: false,
-        abortHandler: undefined,
-        bypassCount: 0,
-      }
-      item.abortHandler = () => {
-        if (item.settled) return
-        item.settled = true
-        const index = this.queue.indexOf(item)
-        if (index >= 0) this.queue.splice(index, 1)
-        reject(abortError())
-        this._drain()
-      }
-      if (combinedSignal) combinedSignal.addEventListener('abort', item.abortHandler, { once: true })
-      if (this.queue.length === 0 && this._canRun(request)) {
-        this._grant(item)
-      } else {
-        this.queue.push(item)
-        this._drain()
-      }
-    })
-  }
-
-  async withBudget(bytes, options, fn) {
-    const release = await this.acquire(bytes, options)
-    try {
-      return await fn()
-    } finally {
-      release()
+    _nextRunnable() {
+        const bypassed = [];
+        for (let index = 0; index < this.queue.length; index++) {
+            const item = this.queue[index];
+            if (!item || item.settled)
+                continue;
+            if (this._canRun(item.request))
+                return { index, item, bypassed };
+            if (item.request.exclusive || item.bypassCount >= this.maxBypasses)
+                return undefined;
+            bypassed.push(item);
+        }
+        return undefined;
     }
-  }
-
-  stats() {
-    return {
-      maxBytes: this.maxBytes,
-      maxConcurrent: this.maxConcurrent,
-      activeBytes: this.activeBytes,
-      activeCount: this.activeCount,
-      queued: this.queue.filter((item) => !item.settled).length,
-      exclusive: this.activeExclusive,
+    _drain() {
+        while (this.queue.length > 0) {
+            while (this.queue[0]?.settled)
+                this.queue.shift();
+            if (this.queue.length === 0)
+                return;
+            const selected = this._nextRunnable();
+            if (!selected)
+                return;
+            this.queue.splice(selected.index, 1);
+            for (const item of selected.bypassed)
+                item.bypassCount += 1;
+            this._grant(selected.item);
+            if (selected.item.request.exclusive)
+                return;
+        }
+    }
+    acquire(bytes, { signal, exclusive = false } = {}) {
+        const combinedSignal = effectiveSignal(signal);
+        if (combinedSignal?.aborted)
+            return Promise.reject(abortError());
+        const request = this._normalize(bytes, exclusive);
+        return new Promise((resolve, reject) => {
+            const item = {
+                request,
+                signal: combinedSignal,
+                resolve,
+                reject,
+                settled: false,
+                abortHandler: undefined,
+                bypassCount: 0,
+            };
+            item.abortHandler = () => {
+                if (item.settled)
+                    return;
+                item.settled = true;
+                const index = this.queue.indexOf(item);
+                if (index >= 0)
+                    this.queue.splice(index, 1);
+                reject(abortError());
+                this._drain();
+            };
+            if (combinedSignal)
+                combinedSignal.addEventListener('abort', item.abortHandler, { once: true });
+            if (this.queue.length === 0 && this._canRun(request)) {
+                this._grant(item);
+            }
+            else {
+                this.queue.push(item);
+                this._drain();
+            }
+        });
+    }
+    async withBudget(bytes, options, fn) {
+        const release = await this.acquire(bytes, options);
+        try {
+            return await fn();
+        }
+        finally {
+            release();
+        }
+    }
+    stats() {
+        return {
+            maxBytes: this.maxBytes,
+            maxConcurrent: this.maxConcurrent,
+            activeBytes: this.activeBytes,
+            activeCount: this.activeCount,
+            queued: this.queue.filter((item) => !item.settled).length,
+            exclusive: this.activeExclusive,
+        };
     }
-  }
 }
-
-export const defaultImageResourceGovernor = new ImageResourceGovernor()
+export const defaultImageResourceGovernor = new ImageResourceGovernor();

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

@@ -15,6 +15,11 @@ import {
 } from './proxy-routing.js'
 
 const legacyProxyScope = new AsyncLocalStorage()
+// The one process-wide fetch this boundary currently owns. Consumers that must
+// follow the same egress path ask for it here instead of reading `globalThis.fetch`
+// at call time (which the lifecycle invariant forbids and which would re-admit
+// whatever wrapper happens to be installed later).
+let installedScopedFetch
 
 export const LEGACY_GLOBAL_PROXY_REMOVAL_CONDITION =
   'Remove the remaining wrapper when explicit Vision Router proxy overrides no longer need Host-owned adapter interception and the legacy direct whole-turn fallback is retired by product policy.'
@@ -86,6 +91,36 @@ export function legacyGlobalProxyScopeAllows(config = {}, state = currentLegacyG
   return configuredHostOwnedPair(config, state.provider, state.model)
 }
 
+// Probe paths (live model discovery, the settings "test connection" route) do not
+// stream a provider turn, so they have no adapter call to open a scope for them.
+// Without a scope, `scopedFetch` falls through to the original fetch and a
+// configured `proxy` silently does not apply — while real vision turns to the same
+// provider are proxied. Expose the exact pair lookup and a plain-promise scope
+// runner so those probes follow the same egress path as the traffic they describe.
+export function currentLegacyGlobalProxyFetch() {
+  return installedScopedFetch
+}
+
+export function legacyGlobalProxyPairFor(config = {}, provider) {
+  if (!visionProxyOverrideConfigured(config) || typeof provider !== 'string' || provider === '') return undefined
+  return configuredPairs(config).find(
+    (pair) => pair.provider === provider && !routerOwnedProvider(pair.provider, config),
+  )
+}
+
+export function runWithLegacyGlobalProxyScope(provider, model, work) {
+  if (typeof work !== 'function') throw new TypeError('legacy proxy scope requires work')
+  if (!validPair(provider, model)) return work()
+  const state = { provider, model, active: true }
+  return legacyProxyScope.run(state, async () => {
+    try {
+      return await work()
+    } finally {
+      state.active = false
+    }
+  })
+}
+
 // AsyncIterable work is lazy: the adapter normally opens its network request on
 // iterator.next(), not when ctx.llm.stream() returns. Keep the scope active for
 // every iterator operation and retire it as soon as the stream ends/fails.
@@ -229,19 +264,27 @@ export function installLegacyGlobalProxyBoundary(ctx, config = {}, options = {})
   }
 
   const restoreFetch = installFetchWrapper(scopedFetch)
+  installedScopedFetch = scopedFetch
   let disposed = false
+  let disposePromise
   const dispose = () => {
-    if (disposed) return
+    if (disposePromise) return disposePromise
+    if (disposed) return Promise.resolve()
     disposed = true
     active = false
-    void dispatcherPool.dispose()
+    if (installedScopedFetch === scopedFetch) installedScopedFetch = undefined
+    // Process-wide fetch ownership is released synchronously; the returned
+    // Promise owns only DVR's private dispatcher retirement and is awaitable by
+    // the Cordis fiber during HMR/unload.
     restoreFetch()
+    disposePromise = dispatcherPool.dispose()
+    return disposePromise
   }
   if (typeof ctx?.effect === 'function') {
     try {
       ctx.effect(() => dispose, 'vision-router: scoped legacy proxy fetch')
     } catch (error) {
-      dispose()
+      void dispose().catch(() => {})
       throw error
     }
   }

package/lib/live-model-client-prelude.js

@@ -503,12 +503,20 @@ export const LIVE_MODEL_CLIENT_PRELUDE = String.raw`(function(){
       }
     });
     if (contexts) contexts.set(ctx, wrapped);
+    var disposeLifecycle = function() {
+      live.dispose();
+      if (contexts && contexts.get(ctx) === wrapped) contexts.delete(ctx);
+    };
+    var lifecycleOwned = false;
     try {
-      if (typeof ctx.effect === 'function') ctx.effect(function(){ return function(){ live.dispose(); }; }, 'vision-router: live model catalog client');
+      if (typeof ctx.effect === 'function') {
+        ctx.effect(function(){ return disposeLifecycle; }, 'vision-router: live model catalog client');
+        lifecycleOwned = true;
+      }
     } catch (_) {}
-    // Warm the Host cache as soon as the plugin activates. By the time the user
-    // opens Settings, stale-while-revalidate normally has a snapshot ready.
-    void live.refresh(true);
+    if (!lifecycleOwned) disposeLifecycle();
+    // Warm the Host cache only after Cordis owns this client generation.
+    if (lifecycleOwned) void live.refresh(true);
     return wrapped;
   }