fix(conversation): read a .ts file sent as a transport stream as text

mediaKindOf let any video/* media type win over the extension. Servers
and desktop browsers report a TypeScript file as an MPEG transport
stream (video/mp2t, or video/vnd.dlna.mpeg-tts on Windows), since both
use .ts, so index.ts read as video and previewed as a broken player.

Those two types now defer to the extension, and stay video when the
name has no known extension.

Author: pratikbuilds

src/lib/media-kind.test.ts

@@ -17,6 +17,14 @@ describe("mediaKindOf", () => {
     expect(mediaKindOf("clip.pdf", "video/webm")).toBe("video");
   });
 
+  test("a transport stream media type defers to the extension", () => {
+    expect(mediaKindOf("index.ts", "video/mp2t")).toBe("text");
+    expect(mediaKindOf("index.ts", "Video/MP2T; x=1")).toBe("text");
+    expect(mediaKindOf("index.ts", "video/vnd.dlna.mpeg-tts")).toBe("text");
+    expect(mediaKindOf("capture", "video/mp2t")).toBe("video");
+    expect(mediaKindOf("capture.m2ts", "video/mp2t")).toBe("video");
+  });
+
   test("ignores media type parameters and case", () => {
     expect(mediaKindOf("a", "Text/Plain; charset=utf-8")).toBe("text");
   });

src/lib/media-kind.ts

@@ -74,15 +74,27 @@ const TEXT_MEDIA_TYPES: ReadonlySet<string> = new Set([
   "application/yaml",
 ]);
 
+/**
+ * MPEG transport stream types. They share `.ts` with TypeScript, and servers
+ * and desktop browsers report them for a TypeScript file, so the name decides.
+ */
+const TRANSPORT_STREAM_TYPES: ReadonlySet<string> = new Set([
+  "video/mp2t",
+  "video/vnd.dlna.mpeg-tts",
+]);
+
 function table(
   kind: MediaKind,
   extensions: readonly string[],
 ): readonly (readonly [string, MediaKind])[] {
   return extensions.map((extension) => [extension, kind] as const);
 }
 
-function kindOfMediaType(mediaType: string): MediaKind | null {
-  const essence = mediaType.split(";")[0]?.trim().toLowerCase() ?? "";
+function essenceOf(mediaType: string): string {
+  return mediaType.split(";")[0]?.trim().toLowerCase() ?? "";
+}
+
+function kindOfMediaType(essence: string): MediaKind | null {
   if (essence.startsWith("image/")) return "image";
   if (essence.startsWith("video/")) return "video";
   if (essence.startsWith("audio/")) return "audio";
@@ -103,9 +115,13 @@ function kindOfName(name: string): MediaKind | null {
 /**
  * A file's kind from its name and media type. A media type that names a kind
  * wins; a blank or generic one (`application/octet-stream`) defers to the
- * name's extension, matched case-insensitively. Anything unrecognised is
- * `other`.
+ * name's extension, matched case-insensitively. An MPEG transport stream
+ * type (`video/mp2t`) also defers to the extension, since a TypeScript file
+ * shares `.ts` and often arrives with it, and is `video` when the extension
+ * says nothing. Anything unrecognised is `other`.
  */
 export function mediaKindOf(name: string, mediaType: string): MediaKind {
-  return kindOfMediaType(mediaType) ?? kindOfName(name) ?? "other";
+  const essence = essenceOf(mediaType);
+  if (TRANSPORT_STREAM_TYPES.has(essence)) return kindOfName(name) ?? "video";
+  return kindOfMediaType(essence) ?? kindOfName(name) ?? "other";
 }