dsh-vision-router 2.0.0 → 2.1.0

package/lib/abort-signal-compat.js

@@ -0,0 +1,191 @@
+function timeoutReason(root) {
+  try {
+    const DomException = root?.DOMException
+    if (typeof DomException === 'function') {
+      return new DomException('The operation was aborted due to timeout', 'TimeoutError')
+    }
+  } catch {
+    // Fall through to an ordinary Error in runtimes without DOMException.
+  }
+  const error = new Error('The operation was aborted due to timeout')
+  error.name = 'TimeoutError'
+  return error
+}
+
+function defineStatic(target, name, value) {
+  try {
+    Object.defineProperty(target, name, {
+      value,
+      writable: true,
+      configurable: true,
+    })
+  } catch {
+    try { target[name] = value } catch {}
+  }
+  return typeof target?.[name] === 'function'
+}
+
+function isAbortSignalLike(value) {
+  return Boolean(
+    value &&
+    typeof value === 'object' &&
+    typeof value.aborted === 'boolean' &&
+    typeof value.addEventListener === 'function',
+  )
+}
+
+function signalList(signals) {
+  if (signals === undefined || signals === null || typeof signals[Symbol.iterator] !== 'function') {
+    throw new TypeError('AbortSignal.any: signals must be an iterable of AbortSignal values')
+  }
+  const list = Array.from(signals)
+  for (const signal of list) {
+    if (!isAbortSignalLike(signal)) {
+      throw new TypeError('AbortSignal.any: every input must be an AbortSignal')
+    }
+  }
+  return list
+}
+
+function timeoutDelay(delay) {
+  if (typeof delay !== 'number') {
+    throw new TypeError('AbortSignal.timeout: delay must be a number')
+  }
+  if (!Number.isInteger(delay) || delay < 0 || delay > 0xffff_ffff) {
+    throw new RangeError('AbortSignal.timeout: delay must be an integer between 0 and 4294967295')
+  }
+  return delay
+}
+
+function removeAbortListeners(listeners) {
+  for (const [signal, listener] of listeners) {
+    try { signal.removeEventListener?.('abort', listener) } catch {}
+  }
+  listeners.length = 0
+}
+
+function strongAbortRelay(controller, source, cleanup) {
+  return () => {
+    cleanup()
+    if (!controller.signal.aborted) controller.abort(source.reason)
+  }
+}
+
+function weakAbortRelay(outputRef, controllerBySignal, source, cleanup, finalizer, token) {
+  return () => {
+    const output = outputRef.deref()
+    cleanup()
+    try { finalizer.unregister(token) } catch {}
+    if (!output || output.aborted) return
+    const controller = controllerBySignal.get(output)
+    if (controller && !output.aborted) controller.abort(source.reason)
+  }
+}
+
+function weakAnySupport(root) {
+  const WeakRefCtor = root?.WeakRef
+  const FinalizationRegistryCtor = root?.FinalizationRegistry
+  const WeakMapCtor = root?.WeakMap
+  if (
+    typeof WeakRefCtor !== 'function' ||
+    typeof FinalizationRegistryCtor !== 'function' ||
+    typeof WeakMapCtor !== 'function'
+  ) return undefined
+  const controllerBySignal = new WeakMapCtor()
+  const finalizer = new FinalizationRegistryCtor((cleanup) => {
+    try { cleanup?.() } catch {}
+  })
+  return { WeakRefCtor, controllerBySignal, finalizer }
+}
+
+/**
+ * DSH normally runs on Node versions that already provide AbortSignal.any()
+ * and AbortSignal.timeout(). A few supported host/browser bridges, however,
+ * can surface an AbortSignal constructor without those static helpers. The
+ * plugin has several cancellation boundaries that legitimately combine more
+ * than one signal, so install small standards-shaped fallbacks once at the
+ * public package boundary rather than sprinkling version checks everywhere.
+ *
+ * This is intentionally a process-global, missing-only compatibility seam:
+ * native functions are never replaced, and ESM module evaluation installs the
+ * fallback once for all Vision Router contexts in the process. That avoids a
+ * teardown race where unloading one profile could remove helpers still used by
+ * another live profile. When WeakRef/FinalizationRegistry are available, the
+ * `any()` fallback also removes source listeners after an unused composite is
+ * collected instead of pinning long-lived Host lifecycle signals forever.
+ */
+export function installAbortSignalCompat(root = globalThis) {
+  const Signal = root?.AbortSignal
+  const Controller = root?.AbortController
+  const state = {
+    any: typeof Signal?.any === 'function',
+    timeout: typeof Signal?.timeout === 'function',
+  }
+  if (typeof Signal !== 'function' || typeof Controller !== 'function') return state
+
+  if (!state.any) {
+    const weakSupport = weakAnySupport(root)
+    const any = function any(signals) {
+      const list = signalList(signals)
+      const controller = new Controller()
+      const output = controller.signal
+      for (const signal of list) {
+        if (!signal.aborted) continue
+        controller.abort(signal.reason)
+        return output
+      }
+
+      const listeners = []
+      const cleanup = () => removeAbortListeners(listeners)
+      let outputRef
+      let finalizerToken
+      if (weakSupport) {
+        weakSupport.controllerBySignal.set(output, controller)
+        outputRef = new weakSupport.WeakRefCtor(output)
+        finalizerToken = {}
+      }
+
+      try {
+        for (const signal of list) {
+          const listener = outputRef
+            ? weakAbortRelay(
+                outputRef,
+                weakSupport.controllerBySignal,
+                signal,
+                cleanup,
+                weakSupport.finalizer,
+                finalizerToken,
+              )
+            : strongAbortRelay(controller, signal, cleanup)
+          listeners.push([signal, listener])
+          signal.addEventListener('abort', listener, { once: true })
+        }
+        if (outputRef) weakSupport.finalizer.register(output, cleanup, finalizerToken)
+      } catch (error) {
+        cleanup()
+        if (finalizerToken) {
+          try { weakSupport.finalizer.unregister(finalizerToken) } catch {}
+        }
+        throw error
+      }
+      return output
+    }
+    state.any = defineStatic(Signal, 'any', any)
+  }
+
+  if (!state.timeout) {
+    const timeout = function timeout(delay) {
+      const parsed = timeoutDelay(delay)
+      const controller = new Controller()
+      const schedule = typeof root?.setTimeout === 'function' ? root.setTimeout.bind(root) : setTimeout
+      const timer = schedule(() => controller.abort(timeoutReason(root)), parsed)
+      try { timer?.unref?.() } catch {}
+      return controller.signal
+    }
+    state.timeout = defineStatic(Signal, 'timeout', timeout)
+  }
+
+  return state
+}
+
+export const abortSignalCompat = installAbortSignalCompat()

package/lib/adapter-update-coalescer.js

@@ -1,24 +1,24 @@
 const wrappedContexts = new WeakMap()
 const wrappedLlmServices = new WeakMap()
 const preparedAdapterCompat = new WeakMap()
+const fullAdapterContractCompat = new WeakMap()
 
 export const DEFAULT_ADAPTER_RECONCILE_MAX_PASSES = 32
 
-/**
- * DSH 0.1.1 dispatches every model call through adapter.prepareCall(). Older
- * Vision Router adapters are intentionally duck-typed objects and therefore do
- * not inherit LlmAdapter's default implementation. Normalize only adapters
- * registered through Vision Router's wrapped context so host/foreign adapters
- * keep their native identity and behavior.
- */
-export function ensureAdapterPrepareCall(adapter) {
-  if (!adapter || (typeof adapter !== 'object' && typeof adapter !== 'function')) return adapter
-  if (typeof adapter.prepareCall === 'function') return adapter
+function isAdapter(value) {
+  return value !== null && (typeof value === 'object' || typeof value === 'function')
+}
 
-  const cached = preparedAdapterCompat.get(adapter)
-  if (cached) return cached
+function hasFunction(adapter, property) {
+  try {
+    return typeof Reflect.get(adapter, property, adapter) === 'function'
+  } catch {
+    return false
+  }
+}
 
-  const prepareCall = async (provider, model, signal) => {
+function createPrepareCallFallback(adapter) {
+  return async (provider, model, signal) => {
     const fallbackModel = { provider, id: model, name: model }
     const resolved =
       typeof adapter.resolveModel === 'function'
@@ -31,44 +31,127 @@ export function ensureAdapterPrepareCall(adapter) {
       },
     }
   }
+}
 
-  // Preserve the exact adapter object whenever possible. Some runtime paths
-  // retain registration.adapter and compare/reuse it later, so mutation is less
-  // surprising than substituting a wrapper. Frozen/sealed adapters fall back to
-  // a proxy that exposes only the missing contract method.
-  try {
-    Object.defineProperty(adapter, 'prepareCall', {
+function noImageRequestPricing() {
+  return undefined
+}
+
+/**
+ * Normalize Vision Router-owned duck-typed adapters to the Host adapter
+ * contracts that have base-class defaults in newer DSH releases.
+ *
+ * DSH 0.1.1 started dispatching through adapter.prepareCall(). DSH 0.1.2 adds
+ * adapter.imageRequestPricing() and the token meter resolves it synchronously
+ * on every measurement. Vision Router intentionally registers plain adapter
+ * objects, so neither inherited default exists unless we materialize it here.
+ *
+ * Request-image pricing is deliberately NOT delegated to some other adapter.
+ * Wrapper/twin/chain routes can rewrite, replace, or aggregate image input, so
+ * only that exact route can truthfully declare its projection. `undefined` is
+ * LlmAdapter's default and keeps the Host's provider-neutral heuristic. An
+ * adapter that explicitly implements imageRequestPricing remains authoritative.
+ *
+ * The compatibility method is installed non-enumerably on extensible adapters
+ * to preserve registration identity. Frozen/sealed adapters fall back to one
+ * proxy that supplies all missing methods while binding existing methods back
+ * to the original object (important for class/private-field adapters).
+ */
+export function ensureAdapterContracts(adapter, options = {}) {
+  if (!isAdapter(adapter)) return adapter
+
+  const includeImageRequestPricing = options.imageRequestPricing === true
+  const needsPrepareCall = !hasFunction(adapter, 'prepareCall')
+  const needsImageRequestPricing =
+    includeImageRequestPricing && !hasFunction(adapter, 'imageRequestPricing')
+  if (!needsPrepareCall && !needsImageRequestPricing) return adapter
+
+  const cache = includeImageRequestPricing ? fullAdapterContractCompat : preparedAdapterCompat
+  const cached = cache.get(adapter)
+  if (cached) return cached
+
+  const prepareCall = needsPrepareCall ? createPrepareCallFallback(adapter) : undefined
+  const imageRequestPricing = needsImageRequestPricing ? noImageRequestPricing : undefined
+  const descriptors = {}
+  if (prepareCall !== undefined) {
+    descriptors.prepareCall = {
       configurable: true,
       writable: true,
       value: prepareCall,
-    })
-    preparedAdapterCompat.set(adapter, adapter)
+    }
+  }
+  if (imageRequestPricing !== undefined) {
+    descriptors.imageRequestPricing = {
+      configurable: true,
+      writable: true,
+      value: imageRequestPricing,
+    }
+  }
+
+  // Preserve the exact adapter object whenever possible. Some runtime paths
+  // retain registration.adapter and compare/reuse it later, so mutation is less
+  // surprising than substituting a wrapper.
+  try {
+    Object.defineProperties(adapter, descriptors)
+    cache.set(adapter, adapter)
     return adapter
   } catch {
+    const boundFunctions = new Map()
     const wrapped = new Proxy(adapter, {
       get(target, property) {
-        if (property === 'prepareCall') return prepareCall
+        if (property === 'prepareCall' && prepareCall !== undefined) return prepareCall
+        if (property === 'imageRequestPricing' && imageRequestPricing !== undefined) {
+          return imageRequestPricing
+        }
         const value = Reflect.get(target, property, target)
-        return typeof value === 'function' ? value.bind(target) : value
+        if (typeof value !== 'function') return value
+        let bound = boundFunctions.get(value)
+        if (bound === undefined) {
+          bound = value.bind(target)
+          boundFunctions.set(value, bound)
+        }
+        return bound
       },
     })
-    preparedAdapterCompat.set(adapter, wrapped)
+    cache.set(adapter, wrapped)
     return wrapped
   }
 }
 
+/** Preserve the public helper used by the DSH 0.1.1 compatibility tests. */
+export function ensureAdapterPrepareCall(adapter) {
+  return ensureAdapterContracts(adapter)
+}
+
+function llmSupportsImageRequestPricing(llm) {
+  try {
+    return typeof Reflect.get(llm, 'imageRequestPricing', llm) === 'function'
+  } catch {
+    return false
+  }
+}
+
 function wrapLlmService(llm) {
-  if (!llm || (typeof llm !== 'object' && typeof llm !== 'function')) return llm
+  if (!isAdapter(llm)) return llm
   const cached = wrappedLlmServices.get(llm)
   if (cached) return cached
 
+  // Capability detection, not a version check: rc.6/rc.7/rc.8 keep the exact
+  // historical adapter shape, while Hosts exposing the new route-pricing seam
+  // receive the base-class-compatible default on our duck-typed adapters.
+  const includeImageRequestPricing = llmSupportsImageRequestPricing(llm)
   const wrapped = new Proxy(llm, {
     get(target, property) {
       if (property === 'registerAdapter') {
         const registerAdapter = Reflect.get(target, property, target)
         if (typeof registerAdapter !== 'function') return registerAdapter
         return (providers, adapter, ...rest) =>
-          registerAdapter.call(target, providers, ensureAdapterPrepareCall(adapter), ...rest)
+          registerAdapter.call(
+            target,
+            providers,
+            ensureAdapterContracts(adapter, { imageRequestPricing: includeImageRequestPricing }),
+            ...rest,
+          )
       }
       const value = Reflect.get(target, property, target)
       return typeof value === 'function' ? value.bind(target) : value
@@ -154,9 +237,10 @@ export function createCoalescingRunner(run, options = {}) {
  * this wrapped context are coalesced; host and other plugin listeners keep
  * their native event semantics.
  *
- * The same boundary also normalizes Vision Router-owned adapter registrations
- * to the DSH 0.1.1 prepareCall contract. This stays scoped to the wrapped
- * context instead of monkey-patching the Host LLM service process-wide.
+ * The same deepest registration boundary also normalizes Vision Router-owned
+ * adapter contracts: prepareCall for DSH 0.1.1+, and imageRequestPricing when
+ * the Host exposes the DSH 0.1.2 route-pricing seam. This stays scoped to the
+ * wrapped context instead of monkey-patching the Host LLM service process-wide.
  */
 export function contextWithCoalescedAdapterUpdates(ctx) {
   if (!ctx || (typeof ctx !== 'object' && typeof ctx !== 'function')) return ctx

package/lib/adversarial-hardening.js

@@ -478,24 +478,39 @@ export function installAdversarialHardening(ctx, config = {}, core) {
           return effect.call(target, () => {
             const originalFetch = globalThis.fetch
             const disposer = factory()
-            const installedFetch = globalThis.fetch
+            let installedFetch = globalThis.fetch
             let active = true
             // Later plugins may capture this function. Making it an inert
             // delegator on unload removes Vision Router from the chain even if
             // another plugin still sits above it, and prevents it resurfacing
             // when that later plugin restores the fetch value it captured.
-            const guardedFetch = (...args) => active
-              ? installedFetch(...args)
-              : originalFetch(...args)
+            const guardedFetch = (...args) => {
+              const fetchImpl = active && typeof installedFetch === 'function'
+                ? installedFetch
+                : originalFetch
+              return fetchImpl(...args)
+            }
             globalThis.fetch = guardedFetch
             return () => {
+              if (!active) return
               active = false
-              if (globalThis.fetch === guardedFetch) {
-                globalThis.fetch = originalFetch
-                // The core disposer is safe only while our guard is still the
-                // active process-level fetch. Never let its unconditional
-                // assignment clobber a later plugin's patch.
+              // Drop the raw Vision Router fetch closure as soon as ownership
+              // ends. This releases its cached ProxyAgent/undici closure even
+              // when a later plugin still retains guardedFetch.
+              installedFetch = undefined
+              const currentFetch = globalThis.fetch
+              try {
+                // Always run the underlying effect disposer. It may own more
+                // than the process-level pointer; skipping it merely because a
+                // later plugin wrapped fetch leaks that lifecycle forever.
                 if (typeof disposer === 'function') disposer()
+              } finally {
+                // The core disposer currently restores originalFetch
+                // unconditionally. Preserve any later plugin that was above us,
+                // while an outermost Vision Router cleanup returns to the host.
+                globalThis.fetch = currentFetch === guardedFetch
+                  ? originalFetch
+                  : currentFetch
               }
             }
           }, label)

package/lib/artifact-boundary.js

@@ -1,184 +1,25 @@
-import { randomUUID } from 'node:crypto'
-import { lstat, mkdir, realpath, rename, unlink, writeFile } from 'node:fs/promises'
-import path from 'node:path'
-import {
-  currentVisionTurnBudget,
-  currentVisionTurnBudgetSignal,
-} from './turn-budget-context.js'
-import {
-  isManagedArtifactRunName,
-  scheduleArtifactRetention,
-} from './artifact-retention.js'
+import { createVisionArtifactStore } from './vision-artifact-store.js'
 
-export const DEFAULT_ARTIFACTS_DIR = '.dsh-vision-router/artifacts'
-
-function isPathInside(root, candidate) {
-  const relative = path.relative(root, candidate)
-  return relative === '' || (relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative))
-}
-
-function isMissing(error) {
-  return error && (error.code === 'ENOENT' || error.code === 'ENOTDIR')
-}
-
-function artifactAbortError() {
-  const error = new Error('vision-router: artifact publication aborted')
-  error.name = 'AbortError'
-  error.code = 'ABORT_ERR'
-  return error
-}
-
-function throwIfVisionAborted() {
-  if (currentVisionTurnBudgetSignal()?.aborted) throw artifactAbortError()
-}
-
-function currentArtifactRunId() {
-  const value = currentVisionTurnBudget()?.artifactRunId
-  return isManagedArtifactRunName(value) ? value : undefined
-}
-
-export function normalizeArtifactsDir(value) {
-  if (typeof value !== 'string' || value.trim() === '') return DEFAULT_ARTIFACTS_DIR
-  const raw = value.trim()
-  if (path.isAbsolute(raw) || path.win32.isAbsolute(raw)) return DEFAULT_ARTIFACTS_DIR
-  const parts = raw.split(/[\\/]+/)
-  if (parts.some((part) => part === '..')) return DEFAULT_ARTIFACTS_DIR
-  const normalized = path.normalize(raw)
-  if (normalized === '' || normalized === '.' || normalized === path.sep) return DEFAULT_ARTIFACTS_DIR
-  return normalized
-}
-
-function normalizeRelativeArtifactPath(value) {
-  if (typeof value !== 'string' || value.trim() === '') {
-    throw new Error('vision-router: artifact path must be a non-empty relative path')
-  }
-  const raw = value.trim()
-  if (path.isAbsolute(raw) || path.win32.isAbsolute(raw)) {
-    throw new Error('vision-router: artifact path must stay inside the artifacts directory')
-  }
-  const parts = raw.split(/[\\/]+/)
-  if (parts.some((part) => part === '..')) {
-    throw new Error('vision-router: artifact path must stay inside the artifacts directory')
-  }
-  const normalized = path.normalize(raw)
-  if (normalized === '' || normalized === '.' || normalized === path.sep) {
-    throw new Error('vision-router: artifact path must name a file')
-  }
-  return normalized
-}
-
-async function realpathNearestExisting(candidate, realpathImpl) {
-  let current = candidate
-  while (true) {
-    try {
-      return await realpathImpl(current)
-    } catch (error) {
-      if (!isMissing(error)) throw error
-      const parent = path.dirname(current)
-      if (parent === current) throw error
-      current = parent
-    }
-  }
-}
-
-async function safeLstat(target, lstatImpl) {
-  try {
-    return await lstatImpl(target)
-  } catch (error) {
-    if (isMissing(error)) return undefined
-    throw error
-  }
-}
+export {
+  DEFAULT_ARTIFACTS_DIR,
+  normalizeArtifactsDir,
+} from './artifact-io.js'
 
 /**
- * Resolve an artifact target without treating lexical workspace containment as
- * authority. Existing ancestors are canonicalized before mkdir runs, then the
- * completed parent and artifact root are canonicalized again.
+ * Compatibility boundary retained for existing production callers during P2.
+ * Resolution authority now flows through VisionArtifactStore while the public
+ * function signature and return value remain unchanged.
  */
-export async function resolveArtifactTarget(workspace, artifactsDir, relativePath, deps = {}) {
-  const realpathImpl = deps.realpath ?? realpath
-  const mkdirImpl = deps.mkdir ?? mkdir
-  const lstatImpl = deps.lstat ?? lstat
-
-  throwIfVisionAborted()
-  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(runId, requestedTarget))
-    : requestedTarget
-  const lexicalBase = path.resolve(workspaceReal, relativeBase)
-  if (!isPathInside(workspaceReal, lexicalBase)) {
-    throw new Error('vision-router: artifactsDir must stay inside the session workspace')
-  }
-  const lexicalTarget = path.resolve(lexicalBase, relativeTarget)
-  if (!isPathInside(lexicalBase, lexicalTarget)) {
-    throw new Error('vision-router: artifact target must stay inside the artifacts directory')
-  }
-
-  const lexicalParent = path.dirname(lexicalTarget)
-  const existingAncestorReal = await realpathNearestExisting(lexicalParent, realpathImpl)
-  throwIfVisionAborted()
-  if (!isPathInside(workspaceReal, existingAncestorReal)) {
-    throw new Error('vision-router: artifact parent escapes the session workspace through a symlink')
-  }
-
-  await mkdirImpl(lexicalParent, { recursive: true })
-  throwIfVisionAborted()
-  const parentReal = await realpathImpl(lexicalParent)
-  const artifactsBaseReal = await realpathImpl(lexicalBase)
-  throwIfVisionAborted()
-  if (!isPathInside(workspaceReal, parentReal) || !isPathInside(workspaceReal, artifactsBaseReal)) {
-    throw new Error('vision-router: artifact parent escapes the session workspace through a symlink')
-  }
-
-  const target = path.join(parentReal, path.basename(lexicalTarget))
-  const existing = await safeLstat(target, lstatImpl)
-  throwIfVisionAborted()
-  if (existing?.isDirectory?.()) {
-    throw new Error('vision-router: artifact target is a directory')
-  }
-  return { target, parentReal, artifactsBaseReal, existing, runId }
+export function resolveArtifactTarget(workspace, artifactsDir, relativePath, deps = {}) {
+  return createVisionArtifactStore({ workspace, artifactsDir, deps }).resolve(relativePath)
 }
 
 /**
- * Publish artifact bytes without ever opening the final target for writing.
- * A temp file is written in the canonical parent and renamed over the target;
- * an existing symlink is unlinked as a directory entry rather than followed.
+ * Compatibility writer retained while callers migrate to VisionArtifactStore.
+ * The store delegates to the exact hardened IO primitive that previously lived
+ * here, so path layout, atomic publication, cancellation and retention semantics
+ * remain unchanged.
  */
-export async function writeArtifactFile(workspace, artifactsDir, relativePath, data, deps = {}) {
-  const writeFileImpl = deps.writeFile ?? writeFile
-  const renameImpl = deps.rename ?? rename
-  const unlinkImpl = deps.unlink ?? unlink
-  const resolved = await resolveArtifactTarget(workspace, artifactsDir, relativePath, deps)
-  const temp = path.join(
-    resolved.parentReal,
-    `.dsh-vision-router-${process.pid}-${randomUUID()}.tmp`,
-  )
-  let published = false
-  try {
-    throwIfVisionAborted()
-    await writeFileImpl(temp, data, { mode: 0o600 })
-    throwIfVisionAborted()
-    if (resolved.existing !== undefined) {
-      try {
-        await unlinkImpl(resolved.target)
-      } catch (error) {
-        if (!isMissing(error)) throw error
-      }
-      throwIfVisionAborted()
-    }
-    await renameImpl(temp, resolved.target)
-    published = true
-    if (resolved.runId) {
-      scheduleArtifactRetention(resolved.artifactsBaseReal, { protectRunId: resolved.runId })
-    }
-    return resolved.target
-  } finally {
-    if (!published) {
-      try { await unlinkImpl(temp) } catch { /* best effort */ }
-    }
-  }
+export function writeArtifactFile(workspace, artifactsDir, relativePath, data, deps = {}) {
+  return createVisionArtifactStore({ workspace, artifactsDir, deps }).publish(relativePath, data)
 }