fix: route text preview_output outside media parsing pipeline

Text preview_output items (mediaType: 'text') carry a content field
instead of filename and are structurally incompatible with ResultItem.
Exclude them from synthetic effectiveOutputs and construct their
ResultItemImpl directly in calculateFlatOutputs, bypassing
parseNodeOutput and isResultItem entirely.

Also tighten isResultItem to require filename as a string, correctly
rejecting arbitrary non-media objects from custom node outputs.

src/lib/litegraph/src/canvas/LinkConnector.integration.test.ts

@@ -1,5 +1,4 @@
 // oxlint-disable no-empty-pattern
-// TODO: Fix these tests after migration
 import { afterEach, describe, expect, vi } from 'vitest'
 
 import type {

src/lib/litegraph/src/canvas/LinkConnectorSubgraphInputValidation.test.ts

@@ -1,4 +1,3 @@
-// TODO: Fix these tests after migration
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import {

src/lib/litegraph/src/measure.test.ts

@@ -1,4 +1,3 @@
-// TODO: Fix these tests after migration
 import { test as baseTest } from 'vitest'
 
 import type { Point, Rect } from '@/lib/litegraph/src/interfaces'

src/scripts/pnginfo.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest'
+
+import { getWebpMetadata } from './pnginfo'
+
+function buildExifPayload(workflowJson: string): Uint8Array {
+  const fullStr = `workflow:${workflowJson}\0`
+  const strBytes = new TextEncoder().encode(fullStr)
+
+  const headerSize = 22
+  const buf = new Uint8Array(headerSize + strBytes.length)
+  const dv = new DataView(buf.buffer)
+
+  buf.set([0x49, 0x49], 0)
+  dv.setUint16(2, 0x002a, true)
+  dv.setUint32(4, 8, true)
+  dv.setUint16(8, 1, true)
+  dv.setUint16(10, 0, true)
+  dv.setUint16(12, 2, true)
+  dv.setUint32(14, strBytes.length, true)
+  dv.setUint32(18, 22, true)
+  buf.set(strBytes, 22)
+
+  return buf
+}
+
+function buildWebp(precedingChunkLength: number, workflowJson: string): File {
+  const exifPayload = buildExifPayload(workflowJson)
+  const precedingPadded = precedingChunkLength + (precedingChunkLength % 2)
+  const totalSize = 12 + (8 + precedingPadded) + (8 + exifPayload.length)
+
+  const buffer = new Uint8Array(totalSize)
+  const dv = new DataView(buffer.buffer)
+
+  buffer.set([0x52, 0x49, 0x46, 0x46], 0)
+  dv.setUint32(4, totalSize - 8, true)
+  buffer.set([0x57, 0x45, 0x42, 0x50], 8)
+
+  buffer.set([0x56, 0x50, 0x38, 0x20], 12)
+  dv.setUint32(16, precedingChunkLength, true)
+
+  const exifStart = 20 + precedingPadded
+  buffer.set([0x45, 0x58, 0x49, 0x46], exifStart)
+  dv.setUint32(exifStart + 4, exifPayload.length, true)
+  buffer.set(exifPayload, exifStart + 8)
+
+  return new File([buffer], 'test.webp', { type: 'image/webp' })
+}
+
+describe('getWebpMetadata', () => {
+  it('finds workflow when a preceding chunk has odd length (RIFF padding)', async () => {
+    const workflow = '{"nodes":[]}'
+    const file = buildWebp(3, workflow)
+
+    const metadata = await getWebpMetadata(file)
+
+    expect(metadata.workflow).toBe(workflow)
+  })
+
+  it('finds workflow when preceding chunk has even length (no padding)', async () => {
+    const workflow = '{"nodes":[1]}'
+    const file = buildWebp(4, workflow)
+
+    const metadata = await getWebpMetadata(file)
+
+    expect(metadata.workflow).toBe(workflow)
+  })
+})

src/stores/queueStore.test.ts

@@ -189,7 +189,7 @@ describe('TaskItemImpl', () => {
     })
   })
 
-  it.skip('should parse text outputs', () => {
+  it('should parse text outputs', () => {
     const job: JobListItem = {
       ...createHistoryJob(0, 'text-job'),
       preview_output: {

src/stores/queueStore.ts

@@ -256,26 +256,23 @@ export class TaskItemImpl {
     flatOutputs?: ReadonlyArray<ResultItemImpl>
   ) {
     this.job = job
-    // If no outputs provided but job has preview_output, create synthetic outputs
-    // using the real nodeId and mediaType from the backend response
+    const preview = job.preview_output
     const effectiveOutputs =
       outputs ??
-      (job.preview_output
-        ? {
-            [job.preview_output.nodeId]: {
-              [job.preview_output.mediaType]: [job.preview_output]
-            }
-          }
+      (preview && preview.mediaType !== 'text'
+        ? { [preview.nodeId]: { [preview.mediaType]: [preview] } }
         : {})
     this.outputs = effectiveOutputs
     this.flatOutputs = flatOutputs ?? this.calculateFlatOutputs()
   }
 
   calculateFlatOutputs(): ReadonlyArray<ResultItemImpl> {
-    if (!this.outputs) {
-      return []
+    const mediaOutputs = parseTaskOutput(this.outputs)
+    const preview = this.job.preview_output
+    if (preview?.mediaType === 'text') {
+      return [new ResultItemImpl(preview as ResultItemInit), ...mediaOutputs]
     }
-    return parseTaskOutput(this.outputs)
+    return mediaOutputs
   }
 
   /** All outputs that support preview (images, videos, audio, 3D, text) */

src/stores/resultItemParsing.ts

@@ -2,14 +2,8 @@ import type { NodeExecutionOutput, ResultItem } from '@/schemas/apiSchema'
 import { resultItemType } from '@/schemas/apiSchema'
 import { ResultItemImpl } from '@/stores/queueStore'
 
-const METADATA_KEYS = new Set(['animated', 'text'])
+const METADATA_KEYS = new Set(['animated'])
 
-/**
- * Validates that an unknown value is a well-formed ResultItem.
- *
- * Requires `filename` (string) since ResultItemImpl needs it for a valid URL.
- * `subfolder` is optional here — ResultItemImpl constructor falls back to ''.
- */
 function isResultItem(item: unknown): item is ResultItem {
   if (!item || typeof item !== 'object' || Array.isArray(item)) return false
 

src/utils/errorReportUtil.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vitest'
+
+import type { ISerialisedGraph } from '@/lib/litegraph/src/litegraph'
+import type { SystemStats } from '@/schemas/apiSchema'
+
+import type { ErrorReportData } from './errorReportUtil'
+import { generateErrorReport } from './errorReportUtil'
+
+const baseSystemStats: SystemStats = {
+  system: {
+    os: 'linux',
+    comfyui_version: '1.0.0',
+    python_version: '3.11',
+    pytorch_version: '2.0',
+    embedded_python: false,
+    argv: ['main.py'],
+    ram_total: 0,
+    ram_free: 0
+  },
+  devices: []
+}
+
+const baseWorkflow = { nodes: [], links: [] } as unknown as ISerialisedGraph
+
+function buildError(serverLogs: unknown): ErrorReportData {
+  return {
+    exceptionType: 'RuntimeError',
+    exceptionMessage: 'boom',
+    systemStats: baseSystemStats,
+    serverLogs: serverLogs as string,
+    workflow: baseWorkflow
+  }
+}
+
+describe('generateErrorReport', () => {
+  it('embeds string serverLogs verbatim', () => {
+    const report = generateErrorReport(buildError('line one\nline two'))
+
+    expect(report).toContain('line one\nline two')
+    expect(report).not.toContain('[object Object]')
+  })
+
+  it('stringifies object serverLogs instead of rendering [object Object]', () => {
+    const report = generateErrorReport(
+      buildError({ entries: [{ msg: 'hello' }] })
+    )
+
+    expect(report).not.toContain('[object Object]')
+    expect(report).toContain('"entries"')
+    expect(report).toContain('"msg": "hello"')
+  })
+})