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.

Author: waleedlatif1

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'

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,14 +464,23 @@ 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 },
   options?: { preserveOctetStream?: boolean }
 ): 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))
 }
 
 /**