LCOV - code coverage report
Current view: top level - src/extensions/core/load3d/components - modelThumbnail.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 8.7 % 103 9
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { TimeoutError } from 'es-toolkit'
       2              : 
       3              : import { load3dHost } from '@/extensions/core/load3d/load3dHost'
       4              : import {
       5              :   isAssetPreviewSupported,
       6              :   persistThumbnail
       7              : } from '@/platform/assets/utils/assetPreviewUtil'
       8              : import { reportError } from '@comfyorg/telemetry/reportError'
       9              : import { redactTelemetryError } from '@comfyorg/telemetry/redactTelemetryUrls'
      10              : import type { SharedRendererHandle } from '@comfyorg/viewport3d/three/sharedWebGLRenderer'
      11              : 
      12            1 : let queue: Promise<unknown> = Promise.resolve()
      13            1 : const MODEL_LOAD_TIMEOUT_MS = 15_000
      14            1 : const BACKGROUND_SETTLE_GRACE_MS = 15_000
      15            1 : const MAX_QUEUED_RENDERS = 32
      16            1 : const RENDER_CANCELLED = new Error('Model thumbnail render cancelled')
      17            1 : const RENDER_FAILED = new Error('Model thumbnail load did not complete')
      18            1 : let queuedRenderCount = 0
      19            1 : let abandonedOperationCount = 0
      20            1 : let rendererKeepAlive: SharedRendererHandle | null = null
      21              : 
      22              : /**
      23              :  * Outcome of an offscreen thumbnail render. `cancelled` is separated from
      24              :  * `failed` so a caller that walked away is not reported as a fault.
      25              :  */
      26              : export type ModelThumbnailResult =
      27              :   | { status: 'rendered'; dataUrl: string }
      28              :   | { status: 'cancelled' }
      29              :   | { status: 'busy' }
      30              :   | { status: 'timedOut' }
      31              :   | { status: 'failed' }
      32              : 
      33              : /**
      34              :  * Render a model to a thumbnail data URL offscreen, without opening the
      35              :  * viewer. Each render starts after the previous one returns an outcome, and
      36              :  * the result is persisted through the asset API so other surfaces pick it up.
      37              :  *
      38              :  * A render that outlives its deadline, or whose `callerSignal` aborts, is
      39              :  * given up on: its viewer is torn down and the queue moves on. Underlying
      40              :  * parse work may continue briefly, so its renderer lease remains held until
      41              :  * that work settles or a bounded grace period expires. An unsettled operation
      42              :  * continues to occupy admission capacity after the grace period.
      43              :  */
      44            0 : export function generateModelThumbnail(
      45              :   modelUrl: string,
      46              :   assetName: string,
      47              :   callerSignal?: AbortSignal
      48              : ): Promise<ModelThumbnailResult> {
      49            0 :   if (callerSignal?.aborted) {
      50            0 :     return Promise.resolve({ status: 'cancelled' })
      51              :   }
      52            0 :   if (queuedRenderCount + abandonedOperationCount >= MAX_QUEUED_RENDERS) {
      53            0 :     return Promise.resolve({ status: 'busy' })
      54              :   }
      55              : 
      56            0 :   queuedRenderCount++
      57            0 :   const started = queue.then((): ThumbnailTask | ModelThumbnailResult => {
      58            0 :     if (callerSignal?.aborted) return { status: 'cancelled' }
      59            0 :     return renderThumbnailWithTimeout(modelUrl, assetName, callerSignal)
      60              :   })
      61            0 :   const run = started.then((task) =>
      62              :     'result' in task ? task.result : Promise.resolve(task)
      63              :   )
      64            0 :   queue = run.catch(() => null)
      65            0 :   void started.then(async (task) => {
      66            0 :     if ('completed' in task) {
      67              :       const completion = await task.completed
      68            0 :       if (completion === 'graceExpired') {
      69            0 :         abandonedOperationCount++
      70            0 :         function releaseAdmission(): void {
      71            0 :           abandonedOperationCount--
      72              :         }
      73            0 :         void task.operation.then(releaseAdmission, releaseAdmission)
      74              :       }
      75              :     }
      76            0 :     queuedRenderCount--
      77            0 :     if (queuedRenderCount === 0) {
      78            0 :       rendererKeepAlive?.release()
      79            0 :       rendererKeepAlive = null
      80              :     }
      81              :   })
      82            0 :   return run
      83              : }
      84              : 
      85              : type ThumbnailTask = {
      86              :   result: Promise<ModelThumbnailResult>
      87              :   operation: Promise<string>
      88              :   completed: Promise<BackgroundCompletion>
      89              : }
      90              : 
      91              : type BackgroundCompletion = 'settled' | 'graceExpired'
      92              : 
      93            0 : function renderThumbnailWithTimeout(
      94              :   modelUrl: string,
      95              :   assetName: string,
      96              :   callerSignal?: AbortSignal
      97              : ): ThumbnailTask {
      98            0 :   const task = renderThumbnailJob(modelUrl, assetName, callerSignal)
      99            0 :   return {
     100              :     completed: task.completed,
     101              :     operation: task.operation,
     102              :     result: task.result.then(
     103              :       (dataUrl): ModelThumbnailResult => ({ status: 'rendered', dataUrl }),
     104              :       (error: unknown): ModelThumbnailResult => {
     105            0 :         if (error === RENDER_CANCELLED) return { status: 'cancelled' }
     106            0 :         if (error instanceof TimeoutError) return { status: 'timedOut' }
     107            0 :         reportError(redactTelemetryError(error), {
     108              :           errorType: 'agent_model_thumbnail_generation_failure',
     109              :           surface: 'agent'
     110              :         })
     111            0 :         return { status: 'failed' }
     112              :       }
     113              :     )
     114              :   }
     115              : }
     116              : 
     117            0 : function renderThumbnailJob(
     118              :   modelUrl: string,
     119              :   assetName: string,
     120              :   callerSignal?: AbortSignal
     121              : ): {
     122              :   result: Promise<string>
     123              :   operation: Promise<string>
     124              :   completed: Promise<BackgroundCompletion>
     125              : } {
     126            0 :   const deadline = new AbortController()
     127            0 :   const operation = (async () => {
     128            0 :     const { acquireSharedRenderer } =
     129              :       await import('@comfyorg/viewport3d/three/sharedWebGLRenderer')
     130            0 :     deadline.signal.throwIfAborted()
     131            0 :     rendererKeepAlive ??= acquireSharedRenderer()
     132            0 :     return renderThumbnailInner(modelUrl, assetName, deadline.signal)
     133              :   })()
     134            0 :   const result = new Promise<string>((resolve, reject) => {
     135            0 :     let settled = false
     136            0 :     function finish(): boolean {
     137            0 :       if (settled) return false
     138            0 :       settled = true
     139            0 :       clearTimeout(timer)
     140            0 :       callerSignal?.removeEventListener('abort', onCallerAbort)
     141            0 :       deadline.abort()
     142            0 :       return true
     143              :     }
     144            0 :     function settleResolved(dataUrl: string): void {
     145            0 :       if (finish()) resolve(dataUrl)
     146              :     }
     147            0 :     function settleRejected(error: unknown): void {
     148            0 :       if (finish()) reject(error)
     149              :     }
     150            0 :     function onCallerAbort(): void {
     151            0 :       settleRejected(RENDER_CANCELLED)
     152              :     }
     153            0 :     function onTimeout(): void {
     154            0 :       settleRejected(new TimeoutError())
     155              :     }
     156            0 :     const timer = setTimeout(onTimeout, MODEL_LOAD_TIMEOUT_MS)
     157            0 :     callerSignal?.addEventListener('abort', onCallerAbort, { once: true })
     158              : 
     159            0 :     void operation.then(settleResolved, settleRejected)
     160              :   })
     161            0 :   return {
     162              :     result,
     163              :     operation,
     164              :     completed: boundedCompletion(operation, result)
     165              :   }
     166              : }
     167              : 
     168            0 : function boundedCompletion(
     169              :   operation: Promise<string>,
     170              :   result: Promise<string>
     171              : ): Promise<BackgroundCompletion> {
     172            0 :   return new Promise((resolve) => {
     173            0 :     let timer: ReturnType<typeof setTimeout> | undefined
     174            0 :     let completed = false
     175            0 :     function finish(completion: BackgroundCompletion): void {
     176            0 :       if (completed) return
     177            0 :       completed = true
     178            0 :       if (timer) clearTimeout(timer)
     179            0 :       resolve(completion)
     180              :     }
     181            0 :     function startGracePeriod(): void {
     182            0 :       if (completed || timer) return
     183            0 :       timer = setTimeout(
     184              :         () => finish('graceExpired'),
     185              :         BACKGROUND_SETTLE_GRACE_MS
     186              :       )
     187              :     }
     188            0 :     void operation.then(
     189              :       () => finish('settled'),
     190              :       () => finish('settled')
     191              :     )
     192            0 :     void result.then(startGracePeriod, startGracePeriod)
     193              :   })
     194              : }
     195              : 
     196            0 : async function renderThumbnailInner(
     197              :   modelUrl: string,
     198              :   assetName: string,
     199              :   signal: AbortSignal
     200              : ): Promise<string> {
     201            0 :   const { createLoad3d } =
     202              :     await import('@comfyorg/viewport3d/load3d/createLoad3d')
     203            0 :   signal.throwIfAborted()
     204              : 
     205            0 :   const load3d = createLoad3d(document.createElement('div'), load3dHost, {
     206              :     width: 256,
     207              :     height: 256,
     208              :     isViewerMode: true
     209              :   })
     210            0 :   let removed = false
     211            0 :   const remove = () => {
     212            0 :     if (!removed) {
     213            0 :       removed = true
     214            0 :       load3d.remove()
     215              :     }
     216              :   }
     217            0 :   signal.addEventListener('abort', remove, { once: true })
     218              : 
     219            0 :   try {
     220            0 :     const outcome = await load3d.loadModel(modelUrl, undefined, {
     221              :       silent: true,
     222              :       signal
     223              :     })
     224            0 :     if (outcome === 'cancelled') throw RENDER_CANCELLED
     225            0 :     if (outcome !== 'loaded') throw RENDER_FAILED
     226            0 :     signal.throwIfAborted()
     227            0 :     const dataUrl = await load3d.captureThumbnail(256, 256)
     228            0 :     signal.throwIfAborted()
     229            0 :     if (isAssetPreviewSupported()) {
     230            0 :       void fetch(dataUrl)
     231              :         .then((response) => response.blob())
     232              :         .then((blob) => persistThumbnail(assetName, blob))
     233              :         .catch(() => {})
     234              :     }
     235            0 :     return dataUrl
     236              :   } finally {
     237            0 :     signal.removeEventListener('abort', remove)
     238            0 :     remove()
     239              :   }
     240              : }
        

Generated by: LCOV version 2.0-1