From 191f1e6dc59a430562e63ac8c10bbd59c4a657c0 Mon Sep 17 00:00:00 2001
From: Waleed Latif <walif6@gmail.com>
Date: Thu, 6 Aug 2026 14:01:48 -0700
Subject: [PATCH 1/4] fix(files): render audio and video stored as
 application/octet-stream

The file viewer built the blob backing <audio>/<video> from the record's stored
content type with a truthiness fallback, so a stored application/octet-stream
was passed straight through and the element could not determine the format.
Downloading the same file worked because the download path derives its content
type from the filename.

- Add resolveEffectiveMimeType, which resolves a generic stored type against the
  filename, and use it for the media blob, the type column, and the type filter
  (an octet-stream video was also invisible to the Audio/Video/Image filters)
- Map .webm to video/webm rather than audio/webm: a <video> element plays an
  audio-only stream, an <audio> element drops the picture
- Preview .bmp, .avif and .ico, which upload accepts but the viewer sent to the
  download-only path; serve them with their real content type so nosniff does
  not block them. .tiff and .heic stay unsupported - no browser renders them
- Open .jsonl in the text editor, and fill the extension-to-mime gaps for
  .mmd, .diff, .patch and .fish
---
 apps/sim/app/api/files/utils.ts               |  6 +++
 .../file-viewer/file-category.test.ts         | 23 ++++++++++
 .../components/file-viewer/file-category.ts   | 30 +++++++++++-
 .../components/file-viewer/file-viewer.tsx    | 32 +++++++++++--
 .../workspace/[workspaceId]/files/files.tsx   | 16 +++++--
 apps/sim/lib/uploads/utils/file-utils.test.ts | 46 +++++++++++++++++++
 apps/sim/lib/uploads/utils/file-utils.ts      | 44 +++++++++++++++++-
 7 files changed, 185 insertions(+), 12 deletions(-)

diff --git a/apps/sim/app/api/files/utils.ts b/apps/sim/app/api/files/utils.ts
index a5f97e4b431..9c958cd62e4 100644
--- a/apps/sim/app/api/files/utils.ts
+++ b/apps/sim/app/api/files/utils.ts
@@ -60,6 +60,9 @@ export const contentTypeMap: Record<string, string> = {
   gif: 'image/gif',
   svg: 'image/svg+xml',
   webp: 'image/webp',
+  avif: 'image/avif',
+  bmp: 'image/bmp',
+  ico: 'image/x-icon',
   zip: 'application/zip',
   googleFolder: 'application/vnd.google-apps.folder',
 }
@@ -159,6 +162,9 @@ const SAFE_INLINE_TYPES = new Set([
   'image/gif',
   'image/svg+xml',
   'image/webp',
+  'image/avif',
+  'image/bmp',
+  'image/x-icon',
   'application/pdf',
   'text/plain',
   'text/csv',
diff --git a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-category.test.ts b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-category.test.ts
index 5cfd8498edc..ff90fec30dc 100644
--- a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-category.test.ts
+++ b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-category.test.ts
@@ -222,6 +222,29 @@ describe('resolveFileCategory — MIME priority', () => {
   })
 })
 
+describe('resolveFileCategory — formats accepted on upload must be previewable', () => {
+  it.each([
+    ['image.bmp', 'image/bmp'],
+    ['image.avif', 'image/avif'],
+    ['favicon.ico', 'image/x-icon'],
+  ])('%s previews as an image', (filename, mimeType) => {
+    expect(resolveFileCategory(mimeType, filename)).toBe('image-previewable')
+    expect(resolveFileCategory('application/octet-stream', filename)).toBe('image-previewable')
+  })
+
+  it.each(['image.tiff', 'photo.heic'])(
+    '%s stays unsupported — no browser renders it in an <img>',
+    (filename) => {
+      expect(resolveFileCategory(null, filename)).toBe('unsupported')
+    }
+  )
+
+  it('.jsonl opens in the text editor', () => {
+    expect(resolveFileCategory('application/jsonl', 'events.jsonl')).toBe('text-editable')
+    expect(resolveFileCategory('application/octet-stream', 'events.jsonl')).toBe('text-editable')
+  })
+})
+
 describe('resolveFileCategory — extension case', () => {
   it('recognises uppercase extension via extension lookup (getFileExtension lowercases)', () => {
     expect(resolveFileCategory(null, 'README.MD')).toBe('text-editable')
diff --git a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-category.ts b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-category.ts
index f405f181609..6aa2fde82c7 100644
--- a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-category.ts
+++ b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-category.ts
@@ -5,6 +5,7 @@ const TEXT_EDITABLE_MIME_TYPES = new Set([
   'text/markdown',
   'text/plain',
   'application/json',
+  'application/jsonl',
   'application/x-yaml',
   'text/csv',
   'text/html',
@@ -26,6 +27,7 @@ const TEXT_EDITABLE_EXTENSIONS = new Set([
   'md',
   'txt',
   'json',
+  'jsonl',
   'yaml',
   'yml',
   'csv',
@@ -43,8 +45,32 @@ const IFRAME_PREVIEWABLE_MIME_TYPES = new Set([
 ])
 const IFRAME_PREVIEWABLE_EXTENSIONS = new Set(['pdf'])
 
-const IMAGE_PREVIEWABLE_MIME_TYPES = new Set(['image/png', 'image/jpeg', 'image/gif', 'image/webp'])
-const IMAGE_PREVIEWABLE_EXTENSIONS = new Set(['png', 'jpg', 'jpeg', 'gif', 'webp'])
+/**
+ * Image formats every supported browser decodes natively. `.tif`/`.tiff` and
+ * `.heic`/`.heif` are accepted uploads but deliberately absent — no browser renders
+ * them in an `<img>`, so they stay on the download-only path rather than showing a
+ * broken image.
+ */
+const IMAGE_PREVIEWABLE_MIME_TYPES = new Set([
+  'image/png',
+  'image/jpeg',
+  'image/gif',
+  'image/webp',
+  'image/avif',
+  'image/bmp',
+  'image/x-icon',
+  'image/vnd.microsoft.icon',
+])
+const IMAGE_PREVIEWABLE_EXTENSIONS = new Set([
+  'png',
+  'jpg',
+  'jpeg',
+  'gif',
+  'webp',
+  'avif',
+  'bmp',
+  'ico',
+])
 
 const AUDIO_PREVIEWABLE_MIME_TYPES = new Set([
   'audio/mpeg',
diff --git a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-viewer.tsx b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-viewer.tsx
index ce72038ac74..8a44d9e304c 100644
--- a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-viewer.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-viewer.tsx
@@ -4,7 +4,7 @@ import { memo, useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { Music } from '@sim/emcn/icons'
 import dynamic from 'next/dynamic'
 import type { WorkspaceFileRecord } from '@/lib/uploads/contexts/workspace'
-import { getFileExtension } from '@/lib/uploads/utils/file-utils'
+import { getFileExtension, resolveEffectiveMimeType } from '@/lib/uploads/utils/file-utils'
 import {
   useWorkspaceFileBinary,
   useWorkspaceFileContent,
@@ -363,6 +363,28 @@ function useBlobUrl(workspaceId: string, fileId: string, fileKey: string) {
 
 const MEDIA_FALLBACK_MIME = { audio: 'audio/mpeg', video: 'video/mp4' } as const
 
+/**
+ * The `type` for the blob backing an `<audio>`/`<video>` element. That type is the only
+ * format signal the element gets, so it has to be resolved against the filename rather
+ * than read off the record: storage legitimately holds `application/octet-stream` (the
+ * browser reports it for plenty of media formats, and the presigned PUT handshake
+ * requires persisting it verbatim), and an element handed that type cannot determine the
+ * format and renders nothing — which is why the same file downloads perfectly.
+ *
+ * Anything that does not resolve to a playable media type falls back to the kind's
+ * default rather than being passed through, so a stale or mismatched stored type can
+ * never leave the element with a type it cannot play.
+ */
+function resolveMediaBlobType(
+  storedType: string | null,
+  filename: string,
+  kind: 'audio' | 'video'
+): string {
+  const resolved = resolveEffectiveMimeType(storedType, filename)
+  if (resolved?.startsWith('audio/') || resolved?.startsWith('video/')) return resolved
+  return MEDIA_FALLBACK_MIME[kind]
+}
+
 /**
  * Shared blob-backed preview for audio and video files — the fetch, blob-URL
  * lifecycle, and error/loading handling are identical; only the rendered
@@ -385,12 +407,12 @@ const MediaPreview = memo(function MediaPreview({
     replaceBlobUrl,
   } = useBlobUrl(workspaceId, file.id, file.key)
 
+  const mediaType = resolveMediaBlobType(file.type, file.name, kind)
+
   useEffect(() => {
     if (!fileData) return
-    replaceBlobUrl(
-      URL.createObjectURL(new Blob([fileData], { type: file.type || MEDIA_FALLBACK_MIME[kind] }))
-    )
-  }, [file.type, fileData, kind, replaceBlobUrl])
+    replaceBlobUrl(URL.createObjectURL(new Blob([fileData], { type: mediaType })))
+  }, [fileData, mediaType, replaceBlobUrl])
 
   const error = blobUrl !== null ? null : resolvePreviewError(fetchError, null)
   if (error) return <PreviewError label={kind} error={error} />
diff --git a/apps/sim/app/workspace/[workspaceId]/files/files.tsx b/apps/sim/app/workspace/[workspaceId]/files/files.tsx
index 6733fcd84e7..28cf98e1611 100644
--- a/apps/sim/app/workspace/[workspaceId]/files/files.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/files/files.tsx
@@ -36,6 +36,7 @@ import {
   getMimeTypeFromExtension,
   isAudioFileType,
   isVideoFileType,
+  resolveEffectiveMimeType,
 } from '@/lib/uploads/utils/file-utils'
 import {
   isSupportedExtension,
@@ -195,7 +196,11 @@ const parseRowId = (rowId: string): { kind: 'file' | 'folder'; id: string } => {
 const hasExternalFiles = (dataTransfer: DataTransfer): boolean =>
   dataTransfer.types.includes('Files')
 
-function formatFileType(mimeType: string | null, filename: string): string {
+function formatFileType(storedType: string | null, filename: string): string {
+  // A stored `application/octet-stream` labels nothing and matches no filter, so the
+  // effective type is resolved from the filename first — see resolveEffectiveMimeType.
+  const mimeType = resolveEffectiveMimeType(storedType, filename)
+
   if (mimeType && MIME_TYPE_LABELS[mimeType]) {
     return MIME_TYPE_LABELS[mimeType]
   }
@@ -493,10 +498,13 @@ export function Files() {
     if (typeFilter.length > 0) {
       result = result.filter((f) => {
         const ext = getFileExtension(f.name)
+        // Matching on the raw stored type would hide every file the browser uploaded as
+        // `application/octet-stream` from the audio/video/image filters.
+        const type = resolveEffectiveMimeType(f.type, f.name) ?? ''
         if (typeFilter.includes('document') && isSupportedExtension(ext)) return true
-        if (typeFilter.includes('audio') && isAudioFileType(f.type)) return true
-        if (typeFilter.includes('video') && isVideoFileType(f.type)) return true
-        if (typeFilter.includes('image') && f.type?.startsWith('image/')) return true
+        if (typeFilter.includes('audio') && isAudioFileType(type)) return true
+        if (typeFilter.includes('video') && isVideoFileType(type)) return true
+        if (typeFilter.includes('image') && type.startsWith('image/')) return true
         return false
       })
     }
diff --git a/apps/sim/lib/uploads/utils/file-utils.test.ts b/apps/sim/lib/uploads/utils/file-utils.test.ts
index c771d7e29fe..f91c749ba5a 100644
--- a/apps/sim/lib/uploads/utils/file-utils.test.ts
+++ b/apps/sim/lib/uploads/utils/file-utils.test.ts
@@ -11,6 +11,7 @@ import {
   isMarkdownFile,
   isNetworkError,
   processSingleFileToUserFile,
+  resolveEffectiveMimeType,
   resolveTrustedFileContext,
 } from '@/lib/uploads/utils/file-utils'
 
@@ -193,3 +194,48 @@ describe('processSingleFileToUserFile', () => {
     expect(result.key).toBe('workspace/ws-1/doc.pdf')
   })
 })
+
+describe('resolveEffectiveMimeType', () => {
+  it('keeps a specific stored type', () => {
+    expect(resolveEffectiveMimeType('video/quicktime', 'clip.mp4')).toBe('video/quicktime')
+    expect(resolveEffectiveMimeType('text/markdown', 'notes.md')).toBe('text/markdown')
+  })
+
+  it.each([
+    ['clip.mp4', 'video/mp4'],
+    ['clip.mov', 'video/quicktime'],
+    ['clip.mkv', 'video/x-matroska'],
+    ['song.mp3', 'audio/mpeg'],
+    ['song.flac', 'audio/flac'],
+    ['icon.ico', 'image/x-icon'],
+    ['shot.avif', 'image/avif'],
+  ])('resolves a stored application/octet-stream for %s from the extension', (name, expected) => {
+    expect(resolveEffectiveMimeType('application/octet-stream', name)).toBe(expected)
+  })
+
+  it('resolves binary/octet-stream and blank stored types too', () => {
+    expect(resolveEffectiveMimeType('binary/octet-stream', 'clip.mp4')).toBe('video/mp4')
+    expect(resolveEffectiveMimeType('  ', 'clip.mp4')).toBe('video/mp4')
+    expect(resolveEffectiveMimeType(null, 'clip.mp4')).toBe('video/mp4')
+    expect(resolveEffectiveMimeType(undefined, 'clip.mp4')).toBe('video/mp4')
+  })
+
+  it('resolves .webm to the video type so the picture is not dropped', () => {
+    expect(resolveEffectiveMimeType('application/octet-stream', 'clip.webm')).toBe('video/webm')
+  })
+
+  it('keeps an explicit audio/webm from the browser', () => {
+    expect(resolveEffectiveMimeType('audio/webm', 'recording.webm')).toBe('audio/webm')
+  })
+
+  it('returns the generic type when the extension identifies nothing either', () => {
+    expect(resolveEffectiveMimeType('application/octet-stream', 'firmware.bin')).toBe(
+      'application/octet-stream'
+    )
+  })
+
+  it('returns null when there is neither a stored type nor a known extension', () => {
+    expect(resolveEffectiveMimeType(null, 'firmware.bin')).toBeNull()
+    expect(resolveEffectiveMimeType('', 'noextension')).toBeNull()
+  })
+})
diff --git a/apps/sim/lib/uploads/utils/file-utils.ts b/apps/sim/lib/uploads/utils/file-utils.ts
index 9e331c10854..f0989ec2076 100644
--- a/apps/sim/lib/uploads/utils/file-utils.ts
+++ b/apps/sim/lib/uploads/utils/file-utils.ts
@@ -312,6 +312,7 @@ const EXTENSION_TO_MIME: Record<string, string> = {
   xls: 'application/vnd.ms-excel',
   ppt: 'application/vnd.ms-powerpoint',
   md: 'text/markdown',
+  jsonl: 'application/jsonl',
   yaml: 'application/x-yaml',
   yml: 'application/x-yaml',
   rtf: 'application/rtf',
@@ -362,12 +363,15 @@ const EXTENSION_TO_MIME: Record<string, string> = {
   graphql: 'text/x-graphql',
   gql: 'text/x-graphql',
   proto: 'text/x-protobuf',
+  mmd: 'text/x-mermaid',
+  diff: 'text/x-diff',
+  patch: 'text/x-diff',
+  fish: 'text/x-shellscript',
 
   // Audio
   mp3: 'audio/mpeg',
   m4a: 'audio/mp4',
   wav: 'audio/wav',
-  webm: 'audio/webm',
   ogg: 'audio/ogg',
   flac: 'audio/flac',
   aac: 'audio/aac',
@@ -378,8 +382,20 @@ const EXTENSION_TO_MIME: Record<string, string> = {
   mov: 'video/quicktime',
   avi: 'video/x-msvideo',
   mkv: 'video/x-matroska',
+  // `.webm` is both an audio and a video container; the video type is the safe
+  // resolution because a `<video>` element plays an audio-only stream, while an
+  // `<audio>` element handed a video stream drops the picture.
+  webm: 'video/webm',
 }
 
+/**
+ * MIME types that carry no format information. Storage keeps whatever the browser
+ * reported at upload time, and the direct-PUT path preserves it verbatim (see
+ * {@link getFileContentType}), so a stored type may be one of these even when the
+ * filename identifies the format precisely.
+ */
+const GENERIC_MIME_TYPES = new Set(['application/octet-stream', 'binary/octet-stream'])
+
 /**
  * Get MIME type from file extension (fallback if not provided)
  */
@@ -416,6 +432,32 @@ export function getFileContentType(file: File): string {
   return resolveFileType(file, { preserveOctetStream: true })
 }
 
+/**
+ * The MIME type to render a *stored* file as, resolving the generic types that storage
+ * legitimately holds against the filename.
+ *
+ * A stored `application/octet-stream` is not an error — browsers report it for plenty of
+ * real formats, and the presigned PUT handshake requires persisting it verbatim. Any
+ * consumer that feeds a stored type to a `Blob`, a media element, or a type filter must
+ * go through this rather than trusting `file.type` directly: a truthiness check
+ * (`file.type || fallback`) passes `application/octet-stream` straight through, and a
+ * media element handed that blob cannot determine the format and renders nothing.
+ *
+ * Returns `null` only when neither the stored type nor the extension identifies the file.
+ */
+export function resolveEffectiveMimeType(
+  storedType: string | null | undefined,
+  filename: string
+): string | null {
+  const stored = storedType?.trim()
+  if (stored && !GENERIC_MIME_TYPES.has(stored)) return stored
+
+  const fromExtension = getMimeTypeFromExtension(getFileExtension(filename))
+  if (!GENERIC_MIME_TYPES.has(fromExtension)) return fromExtension
+
+  return stored || null
+}
+
 /**
  * Whether `error` is a DOM `AbortError` (XHR `abort()`, fetch `signal.aborted`,
  * etc). Used in upload retry loops so aborts short-circuit instead of retrying.

From 942cc085aac81a514c0ae92eca176401d844efed Mon Sep 17 00:00:00 2001
From: Waleed Latif <walif6@gmail.com>
Date: Thu, 6 Aug 2026 14:30:10 -0700
Subject: [PATCH 2/4] fix(files): settle the audio/video container ambiguity at
 the call site

Follow-up to the review pass on this branch.

- Revert the global .webm -> video/webm remap. EXTENSION_TO_MIME is shared with
  non-viewer callers, and a .webm with an empty stored type would have started
  taking the STT route's video branch (stt/route.ts:211 -> extractAudioFromVideo),
  which 500s where no ffmpeg binary is on PATH. The ambiguity is now settled in
  resolveMediaMimeType, which knows which element the caller is rendering
- Resolve the public share route's Content-Type from the filename via
  getContentType, matching the workspace serve route, instead of echoing the
  client-declared stored type into a public unauthenticated response. Add the
  audio/video entries contentTypeMap was missing so a shared media file keeps a
  real Content-Type (disposition is unchanged - none are inline-safe)
- Make resolveEffectiveMimeType total (string, not string | null); the null
  contract only bought one label edge case and cost a ?? at every call site,
  one of which was dead
- Drop .jsonl from the text-editable set. The editor loads the whole file and
  only CSV has a byte cap, so a large .jsonl would trade a download-only
  fallback for a crashed tab. Needs the size guard generalized first
- Trim two comments that restated their code
---
 .../api/files/public/[token]/content/route.ts |  13 ++-
 apps/sim/app/api/files/utils.ts               |  12 ++
 .../file-viewer/file-category.test.ts         |   5 -
 .../components/file-viewer/file-category.ts   |   2 -
 .../components/file-viewer/file-viewer.tsx    |  28 +----
 .../workspace/[workspaceId]/files/files.tsx   |  16 ++-
 apps/sim/lib/uploads/utils/file-utils.test.ts |  38 ++++--
 apps/sim/lib/uploads/utils/file-utils.ts      | 109 +++++++++---------
 8 files changed, 116 insertions(+), 107 deletions(-)

diff --git a/apps/sim/app/api/files/public/[token]/content/route.ts b/apps/sim/app/api/files/public/[token]/content/route.ts
index 87282d86f4d..bd877ef5508 100644
--- a/apps/sim/app/api/files/public/[token]/content/route.ts
+++ b/apps/sim/app/api/files/public/[token]/content/route.ts
@@ -11,7 +11,12 @@ import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import { enforcePublicFileRateLimit } from '@/lib/public-shares/rate-limit'
 import { resolveActiveShareByToken } from '@/lib/public-shares/share-manager'
 import { downloadFile } from '@/lib/uploads/core/storage-service'
-import { createErrorResponse, createFileResponse, FileNotFoundError } from '@/app/api/files/utils'
+import {
+  createErrorResponse,
+  createFileResponse,
+  FileNotFoundError,
+  getContentType,
+} from '@/app/api/files/utils'
 
 export const dynamic = 'force-dynamic'
 
@@ -73,7 +78,11 @@ export const GET = withRouteHandler(
       }
 
       const buffer = servable.kind === 'artifact' ? servable.buffer : raw
-      const contentType = servable.kind === 'artifact' ? servable.contentType : file.contentType
+      // This response is `nosniff`, so a stored `application/octet-stream` refuses to render
+      // even though the bytes are fine. Resolving from the filename also keeps this route on
+      // the same inline allowlist as the workspace serve route.
+      const contentType =
+        servable.kind === 'artifact' ? servable.contentType : getContentType(file.originalName)
 
       logger.info('Public shared file served', { token, key: file.key, size: buffer.length })
 
diff --git a/apps/sim/app/api/files/utils.ts b/apps/sim/app/api/files/utils.ts
index 9c958cd62e4..33b9a7740ba 100644
--- a/apps/sim/app/api/files/utils.ts
+++ b/apps/sim/app/api/files/utils.ts
@@ -63,6 +63,18 @@ export const contentTypeMap: Record<string, string> = {
   avif: 'image/avif',
   bmp: 'image/bmp',
   ico: 'image/x-icon',
+  mp3: 'audio/mpeg',
+  m4a: 'audio/mp4',
+  wav: 'audio/wav',
+  ogg: 'audio/ogg',
+  flac: 'audio/flac',
+  aac: 'audio/aac',
+  opus: 'audio/opus',
+  mp4: 'video/mp4',
+  mov: 'video/quicktime',
+  avi: 'video/x-msvideo',
+  mkv: 'video/x-matroska',
+  webm: 'video/webm',
   zip: 'application/zip',
   googleFolder: 'application/vnd.google-apps.folder',
 }
diff --git a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-category.test.ts b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-category.test.ts
index ff90fec30dc..cd3ff2b3b6a 100644
--- a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-category.test.ts
+++ b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-category.test.ts
@@ -238,11 +238,6 @@ describe('resolveFileCategory — formats accepted on upload must be previewable
       expect(resolveFileCategory(null, filename)).toBe('unsupported')
     }
   )
-
-  it('.jsonl opens in the text editor', () => {
-    expect(resolveFileCategory('application/jsonl', 'events.jsonl')).toBe('text-editable')
-    expect(resolveFileCategory('application/octet-stream', 'events.jsonl')).toBe('text-editable')
-  })
 })
 
 describe('resolveFileCategory — extension case', () => {
diff --git a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-category.ts b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-category.ts
index 6aa2fde82c7..22fa9703ec9 100644
--- a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-category.ts
+++ b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-category.ts
@@ -5,7 +5,6 @@ const TEXT_EDITABLE_MIME_TYPES = new Set([
   'text/markdown',
   'text/plain',
   'application/json',
-  'application/jsonl',
   'application/x-yaml',
   'text/csv',
   'text/html',
@@ -27,7 +26,6 @@ const TEXT_EDITABLE_EXTENSIONS = new Set([
   'md',
   'txt',
   'json',
-  'jsonl',
   'yaml',
   'yml',
   'csv',
diff --git a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-viewer.tsx b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-viewer.tsx
index 8a44d9e304c..9b0b6af14dd 100644
--- a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-viewer.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-viewer.tsx
@@ -4,7 +4,7 @@ import { memo, useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { Music } from '@sim/emcn/icons'
 import dynamic from 'next/dynamic'
 import type { WorkspaceFileRecord } from '@/lib/uploads/contexts/workspace'
-import { getFileExtension, resolveEffectiveMimeType } from '@/lib/uploads/utils/file-utils'
+import { getFileExtension, resolveMediaMimeType } from '@/lib/uploads/utils/file-utils'
 import {
   useWorkspaceFileBinary,
   useWorkspaceFileContent,
@@ -361,30 +361,6 @@ function useBlobUrl(workspaceId: string, fileId: string, fileKey: string) {
   return { fileData, isLoading, error, blobUrl, replaceBlobUrl }
 }
 
-const MEDIA_FALLBACK_MIME = { audio: 'audio/mpeg', video: 'video/mp4' } as const
-
-/**
- * The `type` for the blob backing an `<audio>`/`<video>` element. That type is the only
- * format signal the element gets, so it has to be resolved against the filename rather
- * than read off the record: storage legitimately holds `application/octet-stream` (the
- * browser reports it for plenty of media formats, and the presigned PUT handshake
- * requires persisting it verbatim), and an element handed that type cannot determine the
- * format and renders nothing — which is why the same file downloads perfectly.
- *
- * Anything that does not resolve to a playable media type falls back to the kind's
- * default rather than being passed through, so a stale or mismatched stored type can
- * never leave the element with a type it cannot play.
- */
-function resolveMediaBlobType(
-  storedType: string | null,
-  filename: string,
-  kind: 'audio' | 'video'
-): string {
-  const resolved = resolveEffectiveMimeType(storedType, filename)
-  if (resolved?.startsWith('audio/') || resolved?.startsWith('video/')) return resolved
-  return MEDIA_FALLBACK_MIME[kind]
-}
-
 /**
  * Shared blob-backed preview for audio and video files — the fetch, blob-URL
  * lifecycle, and error/loading handling are identical; only the rendered
@@ -407,7 +383,7 @@ const MediaPreview = memo(function MediaPreview({
     replaceBlobUrl,
   } = useBlobUrl(workspaceId, file.id, file.key)
 
-  const mediaType = resolveMediaBlobType(file.type, file.name, kind)
+  const mediaType = resolveMediaMimeType(file.type, file.name, kind)
 
   useEffect(() => {
     if (!fileData) return
diff --git a/apps/sim/app/workspace/[workspaceId]/files/files.tsx b/apps/sim/app/workspace/[workspaceId]/files/files.tsx
index 28cf98e1611..92dca7e8221 100644
--- a/apps/sim/app/workspace/[workspaceId]/files/files.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/files/files.tsx
@@ -197,22 +197,20 @@ const hasExternalFiles = (dataTransfer: DataTransfer): boolean =>
   dataTransfer.types.includes('Files')
 
 function formatFileType(storedType: string | null, filename: string): string {
-  // A stored `application/octet-stream` labels nothing and matches no filter, so the
-  // effective type is resolved from the filename first — see resolveEffectiveMimeType.
   const mimeType = resolveEffectiveMimeType(storedType, filename)
 
-  if (mimeType && MIME_TYPE_LABELS[mimeType]) {
+  if (MIME_TYPE_LABELS[mimeType]) {
     return MIME_TYPE_LABELS[mimeType]
   }
 
-  if (mimeType?.startsWith('audio/')) return 'Audio'
-  if (mimeType?.startsWith('video/')) return 'Video'
-  if (mimeType?.startsWith('image/')) return 'Image'
+  if (mimeType.startsWith('audio/')) return 'Audio'
+  if (mimeType.startsWith('video/')) return 'Video'
+  if (mimeType.startsWith('image/')) return 'Image'
 
   const ext = getFileExtension(filename)
   if (ext) return ext.toUpperCase()
 
-  return mimeType ?? 'File'
+  return storedType ?? 'File'
 }
 
 export function Files() {
@@ -498,9 +496,9 @@ export function Files() {
     if (typeFilter.length > 0) {
       result = result.filter((f) => {
         const ext = getFileExtension(f.name)
-        // Matching on the raw stored type would hide every file the browser uploaded as
+        // Matching the raw stored type would hide every file the browser uploaded as
         // `application/octet-stream` from the audio/video/image filters.
-        const type = resolveEffectiveMimeType(f.type, f.name) ?? ''
+        const type = resolveEffectiveMimeType(f.type, f.name)
         if (typeFilter.includes('document') && isSupportedExtension(ext)) return true
         if (typeFilter.includes('audio') && isAudioFileType(type)) return true
         if (typeFilter.includes('video') && isVideoFileType(type)) return true
diff --git a/apps/sim/lib/uploads/utils/file-utils.test.ts b/apps/sim/lib/uploads/utils/file-utils.test.ts
index f91c749ba5a..fa11644c509 100644
--- a/apps/sim/lib/uploads/utils/file-utils.test.ts
+++ b/apps/sim/lib/uploads/utils/file-utils.test.ts
@@ -12,6 +12,7 @@ import {
   isNetworkError,
   processSingleFileToUserFile,
   resolveEffectiveMimeType,
+  resolveMediaMimeType,
   resolveTrustedFileContext,
 } from '@/lib/uploads/utils/file-utils'
 
@@ -220,22 +221,37 @@ describe('resolveEffectiveMimeType', () => {
     expect(resolveEffectiveMimeType(undefined, 'clip.mp4')).toBe('video/mp4')
   })
 
-  it('resolves .webm to the video type so the picture is not dropped', () => {
-    expect(resolveEffectiveMimeType('application/octet-stream', 'clip.webm')).toBe('video/webm')
+  it('stays generic when the extension identifies nothing either', () => {
+    expect(resolveEffectiveMimeType('application/octet-stream', 'firmware.bin')).toBe(
+      'application/octet-stream'
+    )
+    expect(resolveEffectiveMimeType(null, 'firmware.bin')).toBe('application/octet-stream')
+    expect(resolveEffectiveMimeType('', 'noextension')).toBe('application/octet-stream')
+  })
+})
+
+describe('resolveMediaMimeType', () => {
+  it('resolves a generic stored type from the extension', () => {
+    expect(resolveMediaMimeType('application/octet-stream', 'clip.mp4', 'video')).toBe('video/mp4')
+    expect(resolveMediaMimeType('application/octet-stream', 'song.flac', 'audio')).toBe(
+      'audio/flac'
+    )
   })
 
-  it('keeps an explicit audio/webm from the browser', () => {
-    expect(resolveEffectiveMimeType('audio/webm', 'recording.webm')).toBe('audio/webm')
+  it('retags a dual audio/video container to the kind being rendered', () => {
+    expect(resolveMediaMimeType(null, 'clip.webm', 'video')).toBe('video/webm')
+    expect(resolveMediaMimeType('audio/webm', 'clip.webm', 'video')).toBe('video/webm')
+    expect(resolveMediaMimeType(null, 'recording.webm', 'audio')).toBe('audio/webm')
+    expect(resolveMediaMimeType('video/webm', 'recording.webm', 'audio')).toBe('audio/webm')
   })
 
-  it('returns the generic type when the extension identifies nothing either', () => {
-    expect(resolveEffectiveMimeType('application/octet-stream', 'firmware.bin')).toBe(
-      'application/octet-stream'
-    )
+  it('keeps a specific type that already names the right kind', () => {
+    expect(resolveMediaMimeType('video/quicktime', 'clip.mov', 'video')).toBe('video/quicktime')
+    expect(resolveMediaMimeType('audio/opus', 'voice.opus', 'audio')).toBe('audio/opus')
   })
 
-  it('returns null when there is neither a stored type nor a known extension', () => {
-    expect(resolveEffectiveMimeType(null, 'firmware.bin')).toBeNull()
-    expect(resolveEffectiveMimeType('', 'noextension')).toBeNull()
+  it('falls back to the kind default when nothing names a media format', () => {
+    expect(resolveMediaMimeType('application/zip', 'weird.bin', 'audio')).toBe('audio/mpeg')
+    expect(resolveMediaMimeType(null, 'weird.bin', 'video')).toBe('video/mp4')
   })
 })
diff --git a/apps/sim/lib/uploads/utils/file-utils.ts b/apps/sim/lib/uploads/utils/file-utils.ts
index f0989ec2076..f3b5f75a107 100644
--- a/apps/sim/lib/uploads/utils/file-utils.ts
+++ b/apps/sim/lib/uploads/utils/file-utils.ts
@@ -312,7 +312,6 @@ const EXTENSION_TO_MIME: Record<string, string> = {
   xls: 'application/vnd.ms-excel',
   ppt: 'application/vnd.ms-powerpoint',
   md: 'text/markdown',
-  jsonl: 'application/jsonl',
   yaml: 'application/x-yaml',
   yml: 'application/x-yaml',
   rtf: 'application/rtf',
@@ -363,15 +362,12 @@ const EXTENSION_TO_MIME: Record<string, string> = {
   graphql: 'text/x-graphql',
   gql: 'text/x-graphql',
   proto: 'text/x-protobuf',
-  mmd: 'text/x-mermaid',
-  diff: 'text/x-diff',
-  patch: 'text/x-diff',
-  fish: 'text/x-shellscript',
 
   // Audio
   mp3: 'audio/mpeg',
   m4a: 'audio/mp4',
   wav: 'audio/wav',
+  webm: 'audio/webm',
   ogg: 'audio/ogg',
   flac: 'audio/flac',
   aac: 'audio/aac',
@@ -382,32 +378,71 @@ const EXTENSION_TO_MIME: Record<string, string> = {
   mov: 'video/quicktime',
   avi: 'video/x-msvideo',
   mkv: 'video/x-matroska',
-  // `.webm` is both an audio and a video container; the video type is the safe
-  // resolution because a `<video>` element plays an audio-only stream, while an
-  // `<audio>` element handed a video stream drops the picture.
-  webm: 'video/webm',
 }
 
-/**
- * MIME types that carry no format information. Storage keeps whatever the browser
- * reported at upload time, and the direct-PUT path preserves it verbatim (see
- * {@link getFileContentType}), so a stored type may be one of these even when the
- * filename identifies the format precisely.
- */
-const GENERIC_MIME_TYPES = new Set(['application/octet-stream', 'binary/octet-stream'])
+const GENERIC_MIME_TYPE = 'application/octet-stream'
+
+/** Every MIME type that identifies no format, including the legacy `binary/` spelling. */
+const GENERIC_MIME_TYPES = new Set([GENERIC_MIME_TYPE, 'binary/octet-stream'])
 
 /**
  * Get MIME type from file extension (fallback if not provided)
  */
 export function getMimeTypeFromExtension(extension: string): string {
-  return EXTENSION_TO_MIME[extension.toLowerCase()] || 'application/octet-stream'
+  return EXTENSION_TO_MIME[extension.toLowerCase()] || GENERIC_MIME_TYPE
+}
+
+/**
+ * The MIME type that best identifies `filename`, preferring `declaredType` — by a browser
+ * at upload time or by storage at read time — and falling back to the extension when what
+ * was declared identifies no format.
+ *
+ * A declared `application/octet-stream` is not an error: browsers report it for plenty of
+ * real formats, and the presigned PUT handshake requires persisting it verbatim (see
+ * {@link getFileContentType}). A stored type therefore has to be resolved here before it
+ * can drive rendering — a truthiness check (`file.type || fallback`) passes the generic
+ * type straight through, and a `Blob` or media element handed that renders nothing.
+ */
+export function resolveEffectiveMimeType(
+  declaredType: string | null | undefined,
+  filename: string
+): string {
+  const declared = declaredType?.trim()
+  if (declared && !GENERIC_MIME_TYPES.has(declared)) return declared
+  return getMimeTypeFromExtension(getFileExtension(filename))
+}
+
+const MEDIA_FALLBACK_MIME = { audio: 'audio/mpeg', video: 'video/mp4' } as const
+
+/**
+ * The MIME type to hand an `<audio>`/`<video>` element, given which of the two the caller
+ * is rendering.
+ *
+ * Beyond {@link resolveEffectiveMimeType} this settles an ambiguity a filename alone cannot:
+ * `.webm` and `.ogg` are both audio and video containers, so a resolved `audio/webm` would
+ * make a `<video>` element drop the picture. The caller has already chosen the element, so
+ * the container subtype is kept and retagged to that kind — the choice belongs here, where
+ * the kind is known, and not in the extension table, which several non-viewer callers share.
+ *
+ * A type naming no media format falls back to the kind's default: passed through, it would
+ * leave the element unable to determine the format, rendering nothing.
+ */
+export function resolveMediaMimeType(
+  declaredType: string | null | undefined,
+  filename: string,
+  kind: 'audio' | 'video'
+): string {
+  const resolved = resolveEffectiveMimeType(declaredType, filename)
+  const [type, subtype] = resolved.split('/')
+  if (type === kind) return resolved
+  if (type === 'audio' || type === 'video') return `${kind}/${subtype}`
+  return MEDIA_FALLBACK_MIME[kind]
 }
 
 /**
  * Resolve a reliable MIME type from a file, falling back to the extension map
- * when the browser reports an empty type. By default treats
- * `application/octet-stream` as "unknown" and falls back to the extension —
- * pass `{ preserveOctetStream: true }` for direct PUT uploads where the
+ * when the browser reports an empty or generic type. Pass
+ * `{ preserveOctetStream: true }` for direct PUT uploads where the
  * browser-supplied content-type must match the presigned handshake exactly.
  */
 export function resolveFileType(
@@ -415,12 +450,8 @@ export function resolveFileType(
   options?: { preserveOctetStream?: boolean }
 ): string {
   const browserType = file.type?.trim()
-  if (browserType) {
-    if (options?.preserveOctetStream || browserType !== 'application/octet-stream') {
-      return browserType
-    }
-  }
-  return getMimeTypeFromExtension(getFileExtension(file.name))
+  if (browserType && options?.preserveOctetStream) return browserType
+  return resolveEffectiveMimeType(browserType, file.name)
 }
 
 /**
@@ -432,32 +463,6 @@ export function getFileContentType(file: File): string {
   return resolveFileType(file, { preserveOctetStream: true })
 }
 
-/**
- * The MIME type to render a *stored* file as, resolving the generic types that storage
- * legitimately holds against the filename.
- *
- * A stored `application/octet-stream` is not an error — browsers report it for plenty of
- * real formats, and the presigned PUT handshake requires persisting it verbatim. Any
- * consumer that feeds a stored type to a `Blob`, a media element, or a type filter must
- * go through this rather than trusting `file.type` directly: a truthiness check
- * (`file.type || fallback`) passes `application/octet-stream` straight through, and a
- * media element handed that blob cannot determine the format and renders nothing.
- *
- * Returns `null` only when neither the stored type nor the extension identifies the file.
- */
-export function resolveEffectiveMimeType(
-  storedType: string | null | undefined,
-  filename: string
-): string | null {
-  const stored = storedType?.trim()
-  if (stored && !GENERIC_MIME_TYPES.has(stored)) return stored
-
-  const fromExtension = getMimeTypeFromExtension(getFileExtension(filename))
-  if (!GENERIC_MIME_TYPES.has(fromExtension)) return fromExtension
-
-  return stored || null
-}
-
 /**
  * Whether `error` is a DOM `AbortError` (XHR `abort()`, fetch `signal.aborted`,
  * etc). Used in upload retry loops so aborts short-circuit instead of retrying.

From c43ca27768d667ab1c52b52fc4d1a3bd22e7b382 Mon Sep 17 00:00:00 2001
From: Waleed Latif <walif6@gmail.com>
Date: Thu, 6 Aug 2026 14:37:32 -0700
Subject: [PATCH 3/4] fix(files): resolve dual audio/video containers to the
 kind the app presents

The viewer routes .webm to the video player, but the Type column and the
audio/video filters resolved it through EXTENSION_TO_MIME and read audio/webm,
so one file showed as Audio and opened in a <video>.

resolveEffectiveMimeType now consults a DUAL_CONTAINER_MIME map first. It stays
out of EXTENSION_TO_MIME because the speech-to-text and ElevenLabs routes read
that table directly, where a video/* label pushes a .webm into ffmpeg audio
extraction it does not need.
---
 apps/sim/lib/uploads/utils/file-utils.test.ts | 14 ++++++++++++++
 apps/sim/lib/uploads/utils/file-utils.ts      | 17 ++++++++++++++++-
 2 files changed, 30 insertions(+), 1 deletion(-)

diff --git a/apps/sim/lib/uploads/utils/file-utils.test.ts b/apps/sim/lib/uploads/utils/file-utils.test.ts
index fa11644c509..0b52451d44b 100644
--- a/apps/sim/lib/uploads/utils/file-utils.test.ts
+++ b/apps/sim/lib/uploads/utils/file-utils.test.ts
@@ -5,6 +5,7 @@ import { createLogger } from '@sim/logger'
 import { describe, expect, it } from 'vitest'
 import {
   extractStorageKey,
+  getMimeTypeFromExtension,
   inferContextFromKey,
   isAbortError,
   isInternalFileUrl,
@@ -221,6 +222,19 @@ describe('resolveEffectiveMimeType', () => {
     expect(resolveEffectiveMimeType(undefined, 'clip.mp4')).toBe('video/mp4')
   })
 
+  it('resolves a dual audio/video container to video, matching how the app presents it', () => {
+    expect(resolveEffectiveMimeType('application/octet-stream', 'clip.webm')).toBe('video/webm')
+    expect(resolveEffectiveMimeType(null, 'clip.webm')).toBe('video/webm')
+  })
+
+  it('still keeps an explicit audio/webm declared by the browser', () => {
+    expect(resolveEffectiveMimeType('audio/webm', 'recording.webm')).toBe('audio/webm')
+  })
+
+  it('leaves the upload-time extension table alone for dual containers', () => {
+    expect(getMimeTypeFromExtension('webm')).toBe('audio/webm')
+  })
+
   it('stays generic when the extension identifies nothing either', () => {
     expect(resolveEffectiveMimeType('application/octet-stream', 'firmware.bin')).toBe(
       'application/octet-stream'
diff --git a/apps/sim/lib/uploads/utils/file-utils.ts b/apps/sim/lib/uploads/utils/file-utils.ts
index f3b5f75a107..68d03a22c64 100644
--- a/apps/sim/lib/uploads/utils/file-utils.ts
+++ b/apps/sim/lib/uploads/utils/file-utils.ts
@@ -382,6 +382,19 @@ const EXTENSION_TO_MIME: Record<string, string> = {
 
 const GENERIC_MIME_TYPE = 'application/octet-stream'
 
+/**
+ * Containers that hold either audio or video, mapped to the kind this app presents them as.
+ * A filename cannot say which a `.webm` is, and the viewer already routes it to the video
+ * player, so everything user-facing has to agree — otherwise one file reads "Audio" in the
+ * Type column and opens in a `<video>`.
+ *
+ * Deliberately not folded into {@link EXTENSION_TO_MIME}: the speech-to-text and ElevenLabs
+ * routes read that table directly to label an upload, and a `video/*` label there sends a
+ * `.webm` down an ffmpeg extraction path it does not need. Callers that know which element
+ * they are rendering retag from here — see {@link resolveMediaMimeType}.
+ */
+const DUAL_CONTAINER_MIME: Record<string, string> = { webm: 'video/webm' }
+
 /** Every MIME type that identifies no format, including the legacy `binary/` spelling. */
 const GENERIC_MIME_TYPES = new Set([GENERIC_MIME_TYPE, 'binary/octet-stream'])
 
@@ -409,7 +422,9 @@ export function resolveEffectiveMimeType(
 ): string {
   const declared = declaredType?.trim()
   if (declared && !GENERIC_MIME_TYPES.has(declared)) return declared
-  return getMimeTypeFromExtension(getFileExtension(filename))
+
+  const extension = getFileExtension(filename)
+  return DUAL_CONTAINER_MIME[extension] ?? getMimeTypeFromExtension(extension)
 }
 
 const MEDIA_FALLBACK_MIME = { audio: 'audio/mpeg', video: 'video/mp4' } as const

From 0a6214737121767a0b78b0872d01002af6f4e537 Mon Sep 17 00:00:00 2001
From: Waleed Latif <walif6@gmail.com>
Date: Thu, 6 Aug 2026 14:47:09 -0700
Subject: [PATCH 4/4] fix(files): keep the dual-container video default out of
 the persisted type

resolveFileType writes user_file.content_type, and it delegated to
resolveEffectiveMimeType, so DUAL_CONTAINER_MIME could persist video/webm. The
speech-to-text route reads that back as file.type, which sends the upload into
the ffmpeg extraction path the previous commit set out to avoid.

resolveFileType now resolves through EXTENSION_TO_MIME alone; the video default
stays on the presentation path. Both share an identifiesFormat predicate.
---
 apps/sim/lib/uploads/utils/file-utils.test.ts | 11 +++++++++++
 apps/sim/lib/uploads/utils/file-utils.ts      | 18 ++++++++++++++++--
 2 files changed, 27 insertions(+), 2 deletions(-)

diff --git a/apps/sim/lib/uploads/utils/file-utils.test.ts b/apps/sim/lib/uploads/utils/file-utils.test.ts
index 0b52451d44b..79032282bcf 100644
--- a/apps/sim/lib/uploads/utils/file-utils.test.ts
+++ b/apps/sim/lib/uploads/utils/file-utils.test.ts
@@ -13,6 +13,7 @@ import {
   isNetworkError,
   processSingleFileToUserFile,
   resolveEffectiveMimeType,
+  resolveFileType,
   resolveMediaMimeType,
   resolveTrustedFileContext,
 } from '@/lib/uploads/utils/file-utils'
@@ -235,6 +236,16 @@ describe('resolveEffectiveMimeType', () => {
     expect(getMimeTypeFromExtension('webm')).toBe('audio/webm')
   })
 
+  it('never lets the video default reach the type that gets persisted', () => {
+    // resolveFileType writes user_file.content_type, which the speech-to-text route reads
+    // back as file.type — a video/* value there sends the upload into ffmpeg extraction.
+    expect(resolveFileType({ type: '', name: 'clip.webm' })).toBe('audio/webm')
+    expect(resolveFileType({ type: 'application/octet-stream', name: 'clip.webm' })).toBe(
+      'audio/webm'
+    )
+    expect(resolveFileType({ type: 'audio/webm', name: 'clip.webm' })).toBe('audio/webm')
+  })
+
   it('stays generic when the extension identifies nothing either', () => {
     expect(resolveEffectiveMimeType('application/octet-stream', 'firmware.bin')).toBe(
       'application/octet-stream'
diff --git a/apps/sim/lib/uploads/utils/file-utils.ts b/apps/sim/lib/uploads/utils/file-utils.ts
index 68d03a22c64..da2c51c0f91 100644
--- a/apps/sim/lib/uploads/utils/file-utils.ts
+++ b/apps/sim/lib/uploads/utils/file-utils.ts
@@ -398,6 +398,11 @@ const DUAL_CONTAINER_MIME: Record<string, string> = { webm: 'video/webm' }
 /** Every MIME type that identifies no format, including the legacy `binary/` spelling. */
 const GENERIC_MIME_TYPES = new Set([GENERIC_MIME_TYPE, 'binary/octet-stream'])
 
+/** Whether a declared MIME type names an actual format, rather than "some bytes". */
+function identifiesFormat(declared: string | undefined): declared is string {
+  return declared !== undefined && declared !== '' && !GENERIC_MIME_TYPES.has(declared)
+}
+
 /**
  * Get MIME type from file extension (fallback if not provided)
  */
@@ -421,7 +426,7 @@ export function resolveEffectiveMimeType(
   filename: string
 ): string {
   const declared = declaredType?.trim()
-  if (declared && !GENERIC_MIME_TYPES.has(declared)) return declared
+  if (identifiesFormat(declared)) return declared
 
   const extension = getFileExtension(filename)
   return DUAL_CONTAINER_MIME[extension] ?? getMimeTypeFromExtension(extension)
@@ -459,6 +464,14 @@ export function resolveMediaMimeType(
  * when the browser reports an empty or generic type. Pass
  * `{ preserveOctetStream: true }` for direct PUT uploads where the
  * browser-supplied content-type must match the presigned handshake exactly.
+ *
+ * This is the type that gets *persisted*, so it resolves through
+ * {@link EXTENSION_TO_MIME} alone and deliberately skips {@link DUAL_CONTAINER_MIME}.
+ * Storing `video/webm` here would put a `video/*` type on the record that the
+ * speech-to-text route reads as `file.type`, sending the upload down the ffmpeg
+ * extraction path — the same failure keeping the dual-container default out of the
+ * extension table avoids. Presentation resolves separately, in
+ * {@link resolveEffectiveMimeType}.
  */
 export function resolveFileType(
   file: { type: string; name: string },
@@ -466,7 +479,8 @@ export function resolveFileType(
 ): string {
   const browserType = file.type?.trim()
   if (browserType && options?.preserveOctetStream) return browserType
-  return resolveEffectiveMimeType(browserType, file.name)
+  if (identifiesFormat(browserType)) return browserType
+  return getMimeTypeFromExtension(getFileExtension(file.name))
 }
 
 /**