diff --git a/apps/stage-tamagotchi/src/renderer/components/WithScreenCapture.vue b/apps/stage-tamagotchi/src/renderer/components/WithScreenCapture.vue
index a053ec131..e96d2373a 100644
--- a/apps/stage-tamagotchi/src/renderer/components/WithScreenCapture.vue
+++ b/apps/stage-tamagotchi/src/renderer/components/WithScreenCapture.vue
@@ -12,6 +12,10 @@ const props = defineProps<{
   sourcesOptions: SourcesOptions
 }>()
 
+const emit = defineEmits<{
+  permissionGranted: []
+}>()
+
 const sourcesOptions = toRef(props, 'sourcesOptions')
 
 const hasPermissions = ref(false)
@@ -57,6 +61,12 @@ watch(focused, async (isFocused) => {
     await checkPermissions()
   }
 })
+
+watch(hasPermissions, (nextHasPermissions, previousHasPermissions) => {
+  if (nextHasPermissions && !previousHasPermissions) {
+    emit('permissionGranted')
+  }
+})
 </script>
 
 <template>
diff --git a/apps/stage-tamagotchi/src/renderer/composables/use-vision-screen-capture.ts b/apps/stage-tamagotchi/src/renderer/composables/use-vision-screen-capture.ts
index 3df35bdec..571fa272c 100644
--- a/apps/stage-tamagotchi/src/renderer/composables/use-vision-screen-capture.ts
+++ b/apps/stage-tamagotchi/src/renderer/composables/use-vision-screen-capture.ts
@@ -3,35 +3,46 @@ import type { SourcesOptions } from 'electron'
 import type { MaybeRefOrGetter } from 'vue'
 
 import { useElectronScreenCapture } from '@proj-airi/electron-screen-capture/vue'
-import { computed, ref, toRaw, toValue } from 'vue'
+import { computed, ref, shallowRef, watch } from 'vue'
+
+import { createObjectUrlFromBytes } from '../utils/create-object-url-from-bytes'
 
 interface ScreenCaptureSource extends SerializableDesktopCapturerSource {
   appIconURL?: string
   thumbnailURL?: string
 }
 
-function toLocalArrayBuffer(bytes: Uint8Array) {
-  if (typeof SharedArrayBuffer !== 'undefined' && bytes.buffer instanceof SharedArrayBuffer) {
-    return bytes.slice().buffer
-  }
-  return bytes.buffer as ArrayBuffer
-}
-
-function toObjectUrl(bytes: Uint8Array, mime: string) {
-  return URL.createObjectURL(new Blob([toLocalArrayBuffer(bytes)], { type: mime }))
-}
-
+/**
+ * Manages Electron-backed screen-capture sources and the active preview stream for vision workflows.
+ *
+ * Use when:
+ * - A renderer page needs to browse screen/window sources before capturing frames
+ * - The page should keep a single active `MediaStream` in sync with the selected source
+ *
+ * Expects:
+ * - The Electron screen-capture preload APIs to be available on `window.electron.ipcRenderer`
+ * - Callers to invoke `cleanup()` when the owning component unmounts
+ *
+ * Returns:
+ * - Reactive source lists, active stream state, and helpers for refetching, starting, stopping, and capturing frames
+ */
 export function useVisionScreenCapture(sourcesOptions: MaybeRefOrGetter<SourcesOptions>) {
   const sources = ref<ScreenCaptureSource[]>([])
   const isRefetching = ref(false)
   const hasFetchedOnce = ref(false)
   const activeSourceId = ref('')
-  const activeStream = ref<MediaStream | null>(null)
+  const activeStream = shallowRef<MediaStream | null>(null)
+  const activeStreamSourceId = ref('')
+
+  watch(activeSourceId, (nextId) => {
+    if (activeStreamSourceId.value && activeStreamSourceId.value !== nextId) {
+      clearActiveStream()
+    }
+  })
 
   const {
     getSources,
-    setSource,
-    resetSource,
+    selectWithSource,
   } = useElectronScreenCapture(window.electron.ipcRenderer, sourcesOptions)
 
   const activeSource = computed(() => sources.value.find(source => source.id === activeSourceId.value) || null)
@@ -47,18 +58,31 @@ export function useVisionScreenCapture(sourcesOptions: MaybeRefOrGetter<SourcesO
     const stream = activeStream.value
     if (!stream) {
       activeStream.value = null
+      activeStreamSourceId.value = ''
       return
     }
 
     stream.getTracks().forEach(track => track.stop())
     activeStream.value = null
+    activeStreamSourceId.value = ''
   }
 
-  function attachStreamLifecycle(stream: MediaStream) {
+  function revokeSourceObjectUrls(entries: ScreenCaptureSource[]) {
+    entries.forEach((source) => {
+      if (source.appIconURL)
+        URL.revokeObjectURL(source.appIconURL)
+      if (source.thumbnailURL)
+        URL.revokeObjectURL(source.thumbnailURL)
+    })
+  }
+
+  function attachStreamLifecycle(stream: MediaStream, sourceId: string) {
     stream.getTracks().forEach((track) => {
       track.addEventListener('ended', () => {
-        if (activeStream.value === stream)
+        if (activeStream.value === stream && activeStreamSourceId.value === sourceId) {
           activeStream.value = null
+          activeStreamSourceId.value = ''
+        }
       }, { once: true })
     })
   }
@@ -75,22 +99,17 @@ export function useVisionScreenCapture(sourcesOptions: MaybeRefOrGetter<SourcesO
           return a.name.localeCompare(b.name)
         })
 
-      sources.value.forEach((oldSource) => {
-        if (oldSource.appIconURL)
-          URL.revokeObjectURL(oldSource.appIconURL)
-        if (oldSource.thumbnailURL)
-          URL.revokeObjectURL(oldSource.thumbnailURL)
-      })
+      revokeSourceObjectUrls(sources.value)
 
       sources.value = nextSources.map(source => ({
         ...source,
-        appIconURL: source.appIcon && source.appIcon.length > 0 ? toObjectUrl(source.appIcon, 'image/png') : undefined,
-        thumbnailURL: source.thumbnail && source.thumbnail.length > 0 ? toObjectUrl(source.thumbnail, 'image/jpeg') : undefined,
+        appIconURL: source.appIcon && source.appIcon.length > 0 ? createObjectUrlFromBytes(source.appIcon, 'image/png') : undefined,
+        thumbnailURL: source.thumbnail && source.thumbnail.length > 0 ? createObjectUrlFromBytes(source.thumbnail, 'image/jpeg') : undefined,
       }))
 
       const hasActiveSource = sources.value.some(source => source.id === activeSourceId.value)
-      if (!hasActiveSource)
-        activeSourceId.value = sources.value[0]?.id || ''
+      const nextActiveSourceId = hasActiveSource ? activeSourceId.value : sources.value[0]?.id || ''
+      activeSourceId.value = nextActiveSourceId
     }
     finally {
       isRefetching.value = false
@@ -99,32 +118,29 @@ export function useVisionScreenCapture(sourcesOptions: MaybeRefOrGetter<SourcesO
   }
 
   async function startStream() {
-    if (!activeSourceId.value)
+    const sourceId = activeSourceId.value
+    if (!sourceId)
       throw new Error('No active source selected')
 
-    if (isActiveStream(activeStream.value))
+    if (isActiveStream(activeStream.value) && activeStreamSourceId.value === sourceId)
       return activeStream.value!
 
     clearActiveStream()
 
-    const handle = await setSource({
-      options: toRaw(toValue(sourcesOptions)),
-      sourceId: activeSourceId.value,
-    })
+    const stream = await selectWithSource(
+      () => sourceId,
+      async () => await navigator.mediaDevices.getDisplayMedia({ video: true, audio: false }),
+    )
+    if (!isActiveStream(stream)) {
+      stream.getTracks().forEach(track => track.stop())
+      throw new Error('Selected source did not provide a live video track')
+    }
 
-    try {
-      const stream = await navigator.mediaDevices.getDisplayMedia({ video: true, audio: false })
-      activeStream.value = stream
-      attachStreamLifecycle(stream)
-      return stream
-    }
-    catch (error) {
-      activeStream.value = null
-      throw error
-    }
-    finally {
-      await resetSource(handle)
-    }
+    activeStream.value = stream
+    activeStreamSourceId.value = sourceId
+    attachStreamLifecycle(stream, sourceId)
+
+    return stream
   }
 
   function stopStream() {
@@ -133,12 +149,7 @@ export function useVisionScreenCapture(sourcesOptions: MaybeRefOrGetter<SourcesO
 
   function cleanup() {
     stopStream()
-    sources.value.forEach((oldSource) => {
-      if (oldSource.appIconURL)
-        URL.revokeObjectURL(oldSource.appIconURL)
-      if (oldSource.thumbnailURL)
-        URL.revokeObjectURL(oldSource.thumbnailURL)
-    })
+    revokeSourceObjectUrls(sources.value)
   }
 
   function captureFrame(video: HTMLVideoElement, quality = 0.82, maxWidth = 1280, maxHeight = 720) {
@@ -148,6 +159,9 @@ export function useVisionScreenCapture(sourcesOptions: MaybeRefOrGetter<SourcesO
     const canvas = document.createElement('canvas')
     const sourceWidth = video.videoWidth
     const sourceHeight = video.videoHeight
+    if (sourceWidth <= 0 || sourceHeight <= 0)
+      return null
+
     const scale = Math.min(maxWidth / sourceWidth, maxHeight / sourceHeight, 1)
     canvas.width = Math.round(sourceWidth * scale)
     canvas.height = Math.round(sourceHeight * scale)
diff --git a/apps/stage-tamagotchi/src/renderer/pages/devtools/screen-capture.vue b/apps/stage-tamagotchi/src/renderer/pages/devtools/screen-capture.vue
index 57fad5c44..eda555174 100644
--- a/apps/stage-tamagotchi/src/renderer/pages/devtools/screen-capture.vue
+++ b/apps/stage-tamagotchi/src/renderer/pages/devtools/screen-capture.vue
@@ -9,6 +9,8 @@ import { useI18n } from 'vue-i18n'
 
 import WithScreenCapture from '../../components/WithScreenCapture.vue'
 
+import { createObjectUrlFromBytes } from '../../utils/create-object-url-from-bytes'
+
 interface ScreenCaptureSource extends SerializableDesktopCapturerSource {
   appIconURL?: string
   thumbnailURL?: string
@@ -74,17 +76,6 @@ function getShareLabel(source: ScreenCaptureSource) {
   return 'Share Window'
 }
 
-function toLocalArrayBuffer(bytes: Uint8Array) {
-  if (typeof SharedArrayBuffer !== 'undefined' && bytes.buffer instanceof SharedArrayBuffer) {
-    return bytes.slice().buffer
-  }
-  return bytes.buffer as ArrayBuffer
-}
-
-function toObjectUrl(bytes: Uint8Array, mime: string) {
-  return URL.createObjectURL(new Blob([toLocalArrayBuffer(bytes)], { type: mime }))
-}
-
 async function startCapture(source: SerializableDesktopCapturerSource) {
   try {
     await selectWithSource(
@@ -139,8 +130,8 @@ async function refetchSources() {
       // NOTICE(@sumimakito): Not only thumbnail is empty, the appIcon could be empty as well with nothing returned.
       // REVIEW(@sumimakito): This has nothing to do with our side, probably related to a Electron bug, you can
       // read more here https://github.com/electron/electron/issues/44504
-      appIconURL: source.appIcon && source.appIcon.length > 0 ? toObjectUrl(source.appIcon, 'image/png') : undefined,
-      thumbnailURL: source.thumbnail && source.thumbnail.length > 0 ? toObjectUrl(source.thumbnail, 'image/jpeg') : undefined,
+      appIconURL: source.appIcon && source.appIcon.length > 0 ? createObjectUrlFromBytes(source.appIcon, 'image/png') : undefined,
+      thumbnailURL: source.thumbnail && source.thumbnail.length > 0 ? createObjectUrlFromBytes(source.thumbnail, 'image/jpeg') : undefined,
     }))
   }
   catch (err) {
@@ -153,7 +144,7 @@ async function refetchSources() {
 }
 
 onMounted(async () => {
-  refetchSources()
+  await refetchSources()
 })
 
 onBeforeUnmount(() => {
diff --git a/apps/stage-tamagotchi/src/renderer/pages/devtools/vision.vue b/apps/stage-tamagotchi/src/renderer/pages/devtools/vision.vue
index e66137c6f..149557038 100644
--- a/apps/stage-tamagotchi/src/renderer/pages/devtools/vision.vue
+++ b/apps/stage-tamagotchi/src/renderer/pages/devtools/vision.vue
@@ -14,7 +14,7 @@ import WithScreenCapture from '../../components/WithScreenCapture.vue'
 
 import { useVisionScreenCapture } from '../../composables/use-vision-screen-capture'
 
-type SourceCategory = 'applications' | 'displays' | 'devices'
+type SourceCategory = 'applications' | 'displays'
 
 const visionStore = useVisionStore()
 const visionProcessingStore = useVisionProcessingStore()
@@ -68,7 +68,6 @@ const {
 const categoryOptions = [
   { label: 'Applications', value: 'applications', icon: 'i-solar:window-frame-line-duotone' },
   { label: 'Displays', value: 'displays', icon: 'i-solar:screencast-2-line-duotone' },
-  { label: 'Devices', value: 'devices', icon: 'i-solar:smartphone-2-line-duotone' },
 ]
 
 const workloadOptions = VISION_WORKLOADS.map(workload => ({
@@ -78,27 +77,21 @@ const workloadOptions = VISION_WORKLOADS.map(workload => ({
 
 const isDisplaySource = (source: { id: string }) => source.id.startsWith('screen:')
 const isWindowSource = (source: { id: string }) => source.id.startsWith('window:')
-const isDeviceSource = (source: { id: string }) => source.id.startsWith('device:')
 
 const filteredSources = computed(() => {
   if (sourceCategory.value === 'applications')
     return sources.value.filter(isWindowSource)
-  if (sourceCategory.value === 'displays')
-    return sources.value.filter(isDisplaySource)
-  return sources.value.filter(isDeviceSource)
+  return sources.value.filter(isDisplaySource)
 })
 
 const sourceCounts = computed(() => ({
   applications: sources.value.filter(isWindowSource).length,
   displays: sources.value.filter(isDisplaySource).length,
-  devices: sources.value.filter(isDeviceSource).length,
 }))
 
 function getShareLabel(source: { id: string }) {
   if (isDisplaySource(source))
     return 'Share Screen'
-  if (isDeviceSource(source))
-    return 'Share Device'
   return 'Share Window'
 }
 
@@ -154,7 +147,13 @@ async function ensureVideoStream() {
       resolve()
       return
     }
-    video.onloadedmetadata = () => resolve()
+
+    const handleLoadedMetadata = () => {
+      video.removeEventListener('loadedmetadata', handleLoadedMetadata)
+      resolve()
+    }
+
+    video.addEventListener('loadedmetadata', handleLoadedMetadata)
   })
 }
 
@@ -164,7 +163,7 @@ async function handleVisionTick() {
 
   try {
     if (!hasLiveVideoStream(activeStream.value)) {
-      activeStream.value = null
+      stopStream()
       await ensureVideoStream()
     }
 
@@ -253,6 +252,10 @@ async function shareSource(sourceId: string) {
   }
 }
 
+function handlePermissionGranted() {
+  void refetchSources()
+}
+
 onBeforeUnmount(() => {
   visionProcessingStore.stopTicker()
   stopStream()
@@ -261,16 +264,15 @@ onBeforeUnmount(() => {
 </script>
 
 <template>
-  <WithScreenCapture :sources-options="sourcesOptions">
+  <WithScreenCapture
+    :sources-options="sourcesOptions"
+    @permission-granted="handlePermissionGranted()"
+  >
     <template #default="{ hasPermissions, requestPermission }">
       <div
         v-if="hasPermissions"
         :class="['flex', 'flex-col', 'gap-6']"
       >
-        <div v-if="!hasFetchedOnce && !isRefetching" :class="['hidden']">
-          {{ refetchSources() }}
-        </div>
-
         <div :class="['flex', 'items-center', 'justify-between', 'rounded-xl', 'bg-neutral-100', 'p-4', 'dark:bg-[rgba(0,0,0,0.3)]']">
           <div :class="['flex', 'flex-col', 'gap-1']">
             <div :class="['text-sm', 'uppercase', 'tracking-wide', 'text-neutral-400']">
@@ -549,7 +551,7 @@ onBeforeUnmount(() => {
             <div :class="['rounded-xl', 'bg-neutral-100', 'p-4', 'dark:bg-[rgba(0,0,0,0.3)]']">
               <div :class="['flex', 'items-center', 'justify-between', 'text-xs', 'uppercase', 'tracking-wide', 'text-neutral-400']">
                 <span>Snapshot</span>
-                <span>{{ captureCount }} captures · {{ contextUpdateCount }} context updates</span>
+                <span>{{ captureCount }} captures, {{ contextUpdateCount }} context updates</span>
               </div>
               <div
                 v-if="screenshotDataUrl"
diff --git a/apps/stage-tamagotchi/src/renderer/utils/create-object-url-from-bytes.ts b/apps/stage-tamagotchi/src/renderer/utils/create-object-url-from-bytes.ts
new file mode 100644
index 000000000..73ade6592
--- /dev/null
+++ b/apps/stage-tamagotchi/src/renderer/utils/create-object-url-from-bytes.ts
@@ -0,0 +1,17 @@
+/**
+ * Creates a blob URL from a byte view without leaking unrelated backing-buffer bytes.
+ *
+ * Use when:
+ * - Electron screen-capture APIs return `Uint8Array` thumbnails or app icons
+ * - The byte view may point at a sliced `ArrayBuffer` or `SharedArrayBuffer`
+ *
+ * Expects:
+ * - `bytes` to contain only the payload that should be exposed through the blob URL
+ *
+ * Returns:
+ * - A `blob:` URL that the caller must revoke when it is no longer needed
+ */
+export function createObjectUrlFromBytes(bytes: Uint8Array, mime: string): string {
+  const ownedBytes = Uint8Array.from(bytes)
+  return URL.createObjectURL(new Blob([ownedBytes], { type: mime }))
+}
diff --git a/nix/assets-hash.txt b/nix/assets-hash.txt
index 14f1af7bd..185ca65de 100644
--- a/nix/assets-hash.txt
+++ b/nix/assets-hash.txt
@@ -1 +1 @@
-sha256-+ruQJso6gF5n4vdu9xTMiYoTP6q3xRrCVsGrEEggQqc=
+sha256-xa45blGXsW12Fh2ivSPrB8mR7+ui9WJ6ki0Zj73GMa8=
diff --git a/packages/stage-ui/src/stores/modules/vision/orchestrator.test.ts b/packages/stage-ui/src/stores/modules/vision/orchestrator.test.ts
index dd46c4526..87fb4a5d2 100644
--- a/packages/stage-ui/src/stores/modules/vision/orchestrator.test.ts
+++ b/packages/stage-ui/src/stores/modules/vision/orchestrator.test.ts
@@ -93,4 +93,16 @@ describe('vision orchestrator', () => {
       contextId: 'vision:screen:understand',
     })
   })
+
+  it('records inference failures on the store before rethrowing', async () => {
+    const store = useVisionOrchestratorStore()
+    runVisionInference.mockRejectedValueOnce(new Error('Vision inference failed'))
+
+    await expect(store.processCapture({
+      imageDataUrl: 'data:image/jpeg;base64,broken',
+      workloadId: 'screen:interpret',
+    })).rejects.toThrow('Vision inference failed')
+
+    expect(store.lastError).toBe('Vision inference failed')
+  })
 })
diff --git a/packages/stage-ui/src/stores/modules/vision/orchestrator.ts b/packages/stage-ui/src/stores/modules/vision/orchestrator.ts
index 174b4ffe0..64fcc380d 100644
--- a/packages/stage-ui/src/stores/modules/vision/orchestrator.ts
+++ b/packages/stage-ui/src/stores/modules/vision/orchestrator.ts
@@ -2,6 +2,7 @@ import type { CommonContentPart } from '@xsai/shared-chat'
 
 import type { VisionWorkloadId } from '../../../composables/vision/use-vision-workloads'
 
+import { errorMessageFrom } from '@moeru/std'
 import { ContextUpdateStrategy } from '@proj-airi/server-sdk'
 import { defineStore, storeToRefs } from 'pinia'
 import { ref } from 'vue'
@@ -11,11 +12,19 @@ import { getVisionWorkload } from '../../../composables/vision/use-vision-worklo
 import { useModsServerChannelStore } from '../../mods/api/channel-server'
 import { useVisionStore } from './store'
 
+/**
+ * Payload describing one captured frame routed through the vision orchestrator.
+ */
 export interface VisionCapturePayload {
+  /** JPEG or PNG data URL captured from the selected source. */
   imageDataUrl: string
+  /** Vision workload that describes how the frame should be interpreted. */
   workloadId: VisionWorkloadId
+  /** Optional source identifier used to keep context updates stable per source. */
   sourceId?: string
+  /** Timestamp recorded when the frame was captured. */
   capturedAt?: number
+  /** When `true`, publish the inference result into the character context channel. */
   publishContext?: boolean
 }
 
@@ -25,6 +34,19 @@ function getVisionContextId(payload: Pick<VisionCapturePayload, 'workloadId' | '
     : `vision:${payload.workloadId}`
 }
 
+/**
+ * Coordinates screen-capture inference and optional context publishing for vision workflows.
+ *
+ * Use when:
+ * - A renderer page captures frames and needs multimodal inference results
+ * - Successful results may also need to become context updates for downstream modules
+ *
+ * Expects:
+ * - The vision settings store to already contain an active provider and model
+ *
+ * Returns:
+ * - A Pinia store that tracks the latest result, last error, and capture-processing actions
+ */
 export const useVisionOrchestratorStore = defineStore('vision-orchestrator', () => {
   const visionStore = useVisionStore()
   const { activeProvider, activeModel } = storeToRefs(visionStore)
@@ -37,55 +59,64 @@ export const useVisionOrchestratorStore = defineStore('vision-orchestrator', ()
   const lastWorkloadId = ref<VisionWorkloadId>('screen:interpret')
 
   async function processCapture(payload: VisionCapturePayload) {
-    if (!activeProvider.value || !activeModel.value)
-      throw new Error('Vision model is not configured')
+    if (!activeProvider.value || !activeModel.value) {
+      const configurationError = new Error('Vision model is not configured')
+      recordError(configurationError)
+      throw configurationError
+    }
 
     lastWorkloadId.value = payload.workloadId
 
-    const text = await runVisionInference({
-      imageDataUrl: payload.imageDataUrl,
-      workloadId: payload.workloadId,
-    })
-
-    lastResultText.value = text
-    lastResultAt.value = Date.now()
-    lastError.value = null
-
-    if (payload.publishContext) {
-      const workload = getVisionWorkload(payload.workloadId)
-      const content: CommonContentPart[] = [
-        { type: 'text', text },
-        {
-          type: 'image_url',
-          image_url: {
-            url: payload.imageDataUrl,
-          },
-        },
-      ]
-
-      modsServerChannelStore.sendContextUpdate({
-        strategy: ContextUpdateStrategy.ReplaceSelf,
-        contextId: getVisionContextId(payload),
-        text,
-        content,
-        metadata: {
-          module: 'vision',
-          workload: workload.id,
-          workloadLabel: workload.label,
-          sourceId: payload.sourceId,
-          capturedAt: payload.capturedAt,
-          provider: activeProvider.value,
-          model: activeModel.value,
-        },
+    try {
+      const text = await runVisionInference({
+        imageDataUrl: payload.imageDataUrl,
+        workloadId: payload.workloadId,
       })
-      return { contextUpdates: 1, text }
-    }
 
-    return { contextUpdates: 0, text }
+      lastResultText.value = text
+      lastResultAt.value = Date.now()
+      lastError.value = null
+
+      if (payload.publishContext) {
+        const workload = getVisionWorkload(payload.workloadId)
+        const content: CommonContentPart[] = [
+          { type: 'text', text },
+          {
+            type: 'image_url',
+            image_url: {
+              url: payload.imageDataUrl,
+            },
+          },
+        ]
+
+        modsServerChannelStore.sendContextUpdate({
+          strategy: ContextUpdateStrategy.ReplaceSelf,
+          contextId: getVisionContextId(payload),
+          text,
+          content,
+          metadata: {
+            module: 'vision',
+            workload: workload.id,
+            workloadLabel: workload.label,
+            sourceId: payload.sourceId,
+            capturedAt: payload.capturedAt,
+            provider: activeProvider.value,
+            model: activeModel.value,
+          },
+        })
+        return { contextUpdates: 1, text }
+      }
+
+      return { contextUpdates: 0, text }
+    }
+    catch (error) {
+      recordError(error)
+      throw error
+    }
   }
 
   function recordError(error: unknown) {
-    lastError.value = error instanceof Error ? error.message : String(error)
+    lastError.value = errorMessageFrom(error) ?? 'Unknown error'
   }
 
   return {
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 74d51ff21..c2c13388e 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -6243,6 +6243,7 @@ packages:
   '@hono/node-ws@1.3.0':
     resolution: {integrity: sha512-ju25YbbvLuXdqBCmLZLqnNYu1nbHIQjoyUqA8ApZOeL1k4skuiTcw5SW77/5SUYo2Xi2NVBJoVlfQurnKEp03Q==}
     engines: {node: '>=18.14.1'}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
     peerDependencies:
       '@hono/node-server': ^1.19.2
       hono: ^4.6.0