@vellumai/assistant 0.4.16 → 0.4.18

package/src/__tests__/attachments-store.test.ts

@@ -1,36 +1,36 @@
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { afterAll, beforeEach, describe, expect, mock,test } from 'bun:test';
+const testDir = mkdtempSync(join(tmpdir(), "attach-store-test-"));
 
-const testDir = mkdtempSync(join(tmpdir(), 'attach-store-test-'));
-
-mock.module('../util/platform.js', () => ({
+mock.module("../util/platform.js", () => ({
   getDataDir: () => testDir,
-  isMacOS: () => process.platform === 'darwin',
-  isLinux: () => process.platform === 'linux',
-  isWindows: () => process.platform === 'win32',
-  getSocketPath: () => join(testDir, 'test.sock'),
-  getPidPath: () => join(testDir, 'test.pid'),
-  getDbPath: () => join(testDir, 'test.db'),
-  getLogPath: () => join(testDir, 'test.log'),
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getSocketPath: () => join(testDir, "test.sock"),
+  getPidPath: () => join(testDir, "test.pid"),
+  getDbPath: () => join(testDir, "test.db"),
+  getLogPath: () => join(testDir, "test.log"),
   ensureDataDir: () => {},
   getRootDir: () => testDir,
 }));
 
-mock.module('../util/logger.js', () => ({
-  getLogger: () => new Proxy({} as Record<string, unknown>, {
-    get: () => () => {},
-  }),
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
 }));
 
-mock.module('../config/loader.js', () => ({
+mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     ui: {},
-    
-    model: 'test',
-    provider: 'test',
+
+    model: "test",
+    provider: "test",
     apiKeys: {},
     memory: { enabled: false },
     rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
@@ -49,115 +49,136 @@ import {
   MAX_UPLOAD_BYTES,
   uploadAttachment,
   validateAttachmentUpload,
-} from '../memory/attachments-store.js';
-import { addMessage,createConversation } from '../memory/conversation-store.js';
-import { getDb, initializeDb, resetDb } from '../memory/db.js';
+} from "../memory/attachments-store.js";
+import {
+  addMessage,
+  createConversation,
+} from "../memory/conversation-store.js";
+import { getDb, initializeDb, resetDb } from "../memory/db.js";
 
 initializeDb();
 
 afterAll(() => {
   resetDb();
-  try { rmSync(testDir, { recursive: true }); } catch { /* best effort */ }
+  try {
+    rmSync(testDir, { recursive: true });
+  } catch {
+    /* best effort */
+  }
 });
 
 function resetTables() {
   const db = getDb();
-  db.run('DELETE FROM message_attachments');
-  db.run('DELETE FROM attachments');
-  db.run('DELETE FROM messages');
-  db.run('DELETE FROM conversations');
+  db.run("DELETE FROM message_attachments");
+  db.run("DELETE FROM attachments");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
 }
 
 // ---------------------------------------------------------------------------
 // uploadAttachment
 // ---------------------------------------------------------------------------
 
-describe('uploadAttachment', () => {
+describe("uploadAttachment", () => {
   beforeEach(resetTables);
 
-  test('stores attachment and returns metadata', () => {
-    const stored = uploadAttachment('chart.png', 'image/png', 'iVBORw0K');
+  test("stores attachment and returns metadata", () => {
+    const stored = uploadAttachment("chart.png", "image/png", "iVBORw0K");
 
     expect(stored.id).toBeDefined();
-    expect(stored.originalFilename).toBe('chart.png');
-    expect(stored.mimeType).toBe('image/png');
-    expect(stored.kind).toBe('image');
+    expect(stored.originalFilename).toBe("chart.png");
+    expect(stored.mimeType).toBe("image/png");
+    expect(stored.kind).toBe("image");
     expect(stored.sizeBytes).toBeGreaterThan(0);
     expect(stored.createdAt).toBeGreaterThan(0);
   });
 
-  test('classifies image MIME as image kind', () => {
-    const stored = uploadAttachment('pic.jpg', 'image/jpeg', 'AAAA');
-    expect(stored.kind).toBe('image');
+  test("classifies image MIME as image kind", () => {
+    const stored = uploadAttachment("pic.jpg", "image/jpeg", "AAAA");
+    expect(stored.kind).toBe("image");
   });
 
-  test('classifies non-image MIME as document kind', () => {
-    const stored = uploadAttachment('doc.pdf', 'application/pdf', 'JVBER');
-    expect(stored.kind).toBe('document');
+  test("classifies non-image MIME as document kind", () => {
+    const stored = uploadAttachment("doc.pdf", "application/pdf", "JVBER");
+    expect(stored.kind).toBe("document");
   });
 
-  test('generates unique IDs for each upload', () => {
-    const a = uploadAttachment('a.txt', 'text/plain', 'AA==');
-    const b = uploadAttachment('b.txt', 'text/plain', 'QQ==');
+  test("generates unique IDs for each upload", () => {
+    const a = uploadAttachment("a.txt", "text/plain", "AA==");
+    const b = uploadAttachment("b.txt", "text/plain", "QQ==");
     expect(a.id).not.toBe(b.id);
   });
 
-  test('computes sizeBytes from base64 correctly', () => {
+  test("computes sizeBytes from base64 correctly", () => {
     // "hello" = "aGVsbG8=" (8 chars, 1 pad → 5 bytes)
-    const stored = uploadAttachment('hello.txt', 'text/plain', 'aGVsbG8=');
+    const stored = uploadAttachment("hello.txt", "text/plain", "aGVsbG8=");
     expect(stored.sizeBytes).toBe(5);
   });
 
-  test('deduplicates by content hash', () => {
-    const first = uploadAttachment('photo.png', 'image/png', 'iVBORw0KGgoAAAANSUh');
-    const second = uploadAttachment('photo.png', 'image/png', 'iVBORw0KGgoAAAANSUh');
+  test("deduplicates by content hash", () => {
+    const first = uploadAttachment(
+      "photo.png",
+      "image/png",
+      "iVBORw0KGgoAAAANSUh",
+    );
+    const second = uploadAttachment(
+      "photo.png",
+      "image/png",
+      "iVBORw0KGgoAAAANSUh",
+    );
     expect(second.id).toBe(first.id);
   });
 
-  test('deduplicates even when filenames differ', () => {
-    const first = uploadAttachment('original.png', 'image/png', 'DUPECONTENT123');
-    const second = uploadAttachment('renamed.png', 'image/png', 'DUPECONTENT123');
+  test("deduplicates even when filenames differ", () => {
+    const first = uploadAttachment(
+      "original.png",
+      "image/png",
+      "DUPECONTENT123",
+    );
+    const second = uploadAttachment(
+      "renamed.png",
+      "image/png",
+      "DUPECONTENT123",
+    );
     expect(second.id).toBe(first.id);
   });
 
-  test('does not deduplicate different content', () => {
-    const first = uploadAttachment('a.txt', 'text/plain', 'CONTENTA');
-    const second = uploadAttachment('b.txt', 'text/plain', 'CONTENTB');
+  test("does not deduplicate different content", () => {
+    const first = uploadAttachment("a.txt", "text/plain", "CONTENTA");
+    const second = uploadAttachment("b.txt", "text/plain", "CONTENTB");
     expect(second.id).not.toBe(first.id);
   });
 
-  test('rejects payloads exceeding MAX_UPLOAD_BYTES', () => {
+  test("rejects payloads exceeding MAX_UPLOAD_BYTES", () => {
     // Build a base64 string that decodes to just over the limit.
     // 4 base64 chars → 3 bytes, so we need ceil((MAX_UPLOAD_BYTES+1)/3)*4 chars.
     const oversizedLength = Math.ceil((MAX_UPLOAD_BYTES + 1) / 3) * 4;
-    const oversizedData = 'A'.repeat(oversizedLength);
+    const oversizedData = "A".repeat(oversizedLength);
 
     expect(() =>
-      uploadAttachment('huge.bin', 'application/octet-stream', oversizedData),
+      uploadAttachment("huge.bin", "application/octet-stream", oversizedData),
     ).toThrow(AttachmentUploadError);
   });
 
-  test('rejects invalid base64 data', () => {
+  test("rejects invalid base64 data", () => {
     expect(() =>
-      uploadAttachment('bad.txt', 'text/plain', '!!!not-base64!!!'),
+      uploadAttachment("bad.txt", "text/plain", "!!!not-base64!!!"),
     ).toThrow(AttachmentUploadError);
   });
 
-  test('accepts base64 with non-standard padding/length', () => {
+  test("accepts base64 with non-standard padding/length", () => {
     // Lenient on length — only character set is validated
-    expect(() =>
-      uploadAttachment('ok.txt', 'text/plain', 'AAA'),
-    ).not.toThrow();
+    expect(() => uploadAttachment("ok.txt", "text/plain", "AAA")).not.toThrow();
   });
 
-  test('accepts payload exactly at MAX_UPLOAD_BYTES', () => {
+  test("accepts payload exactly at MAX_UPLOAD_BYTES", () => {
     // MAX_UPLOAD_BYTES (20 MB) is divisible by 3, so (MAX/3)*4 base64 chars
     // decodes to exactly MAX bytes with no padding.
     const exactLength = (MAX_UPLOAD_BYTES / 3) * 4;
-    const exactData = 'A'.repeat(exactLength);
+    const exactData = "A".repeat(exactLength);
 
     expect(() =>
-      uploadAttachment('exact.bin', 'application/octet-stream', exactData),
+      uploadAttachment("exact.bin", "application/octet-stream", exactData),
     ).not.toThrow();
   });
 });
@@ -166,24 +187,24 @@ describe('uploadAttachment', () => {
 // isValidBase64
 // ---------------------------------------------------------------------------
 
-describe('isValidBase64', () => {
-  test('accepts valid base64 strings', () => {
-    expect(isValidBase64('aGVsbG8=')).toBe(true);     // "hello"
-    expect(isValidBase64('dGVzdA==')).toBe(true);      // "test"
-    expect(isValidBase64('AAAA')).toBe(true);          // no padding
-    expect(isValidBase64('')).toBe(true);              // empty
+describe("isValidBase64", () => {
+  test("accepts valid base64 strings", () => {
+    expect(isValidBase64("aGVsbG8=")).toBe(true); // "hello"
+    expect(isValidBase64("dGVzdA==")).toBe(true); // "test"
+    expect(isValidBase64("AAAA")).toBe(true); // no padding
+    expect(isValidBase64("")).toBe(true); // empty
   });
 
-  test('accepts strings with non-standard length (lenient)', () => {
-    expect(isValidBase64('AAA')).toBe(true);           // 3 chars, OK
-    expect(isValidBase64('AAAAA')).toBe(true);         // 5 chars, OK
+  test("accepts strings with non-standard length (lenient)", () => {
+    expect(isValidBase64("AAA")).toBe(true); // 3 chars, OK
+    expect(isValidBase64("AAAAA")).toBe(true); // 5 chars, OK
   });
 
-  test('rejects strings with invalid characters', () => {
-    expect(isValidBase64('!!!!')).toBe(false);
-    expect(isValidBase64('abc@')).toBe(false);
-    expect(isValidBase64('hello world')).toBe(false);  // space
-    expect(isValidBase64('data_here')).toBe(false);    // underscore
+  test("rejects strings with invalid characters", () => {
+    expect(isValidBase64("!!!!")).toBe(false);
+    expect(isValidBase64("abc@")).toBe(false);
+    expect(isValidBase64("hello world")).toBe(false); // space
+    expect(isValidBase64("data_here")).toBe(false); // underscore
   });
 });
 
@@ -191,31 +212,31 @@ describe('isValidBase64', () => {
 // deleteAttachment
 // ---------------------------------------------------------------------------
 
-describe('deleteAttachment', () => {
+describe("deleteAttachment", () => {
   beforeEach(resetTables);
 
-  test('deletes existing attachment and returns deleted', () => {
-    const stored = uploadAttachment('file.txt', 'text/plain', 'dGVzdA==');
+  test("deletes existing attachment and returns deleted", () => {
+    const stored = uploadAttachment("file.txt", "text/plain", "dGVzdA==");
     const result = deleteAttachment(stored.id);
-    expect(result).toBe('deleted');
+    expect(result).toBe("deleted");
 
     const fetched = getAttachmentById(stored.id);
     expect(fetched).toBeNull();
   });
 
-  test('returns not_found for nonexistent attachment', () => {
-    const result = deleteAttachment('nonexistent-id');
-    expect(result).toBe('not_found');
+  test("returns not_found for nonexistent attachment", () => {
+    const result = deleteAttachment("nonexistent-id");
+    expect(result).toBe("not_found");
   });
 
-  test('returns still_referenced when messages reference the attachment', async () => {
+  test("returns still_referenced when messages reference the attachment", async () => {
     const conv = createConversation();
-    const msg1 = await addMessage(conv.id, 'user', 'First upload');
-    const msg2 = await addMessage(conv.id, 'user', 'Duplicate upload');
+    const msg1 = await addMessage(conv.id, "user", "First upload");
+    const msg2 = await addMessage(conv.id, "user", "Duplicate upload");
 
     // Dedup: both uploads return the same attachment row
-    const first = uploadAttachment('photo.png', 'image/png', 'SHAREDCONTENT1');
-    const second = uploadAttachment('photo.png', 'image/png', 'SHAREDCONTENT1');
+    const first = uploadAttachment("photo.png", "image/png", "SHAREDCONTENT1");
+    const second = uploadAttachment("photo.png", "image/png", "SHAREDCONTENT1");
     expect(second.id).toBe(first.id);
 
     linkAttachmentToMessage(msg1.id, first.id, 0);
@@ -223,7 +244,7 @@ describe('deleteAttachment', () => {
 
     // Delete should return still_referenced and NOT remove the attachment row
     const result = deleteAttachment(first.id);
-    expect(result).toBe('still_referenced');
+    expect(result).toBe("still_referenced");
 
     // Attachment row still exists because messages reference it
     const fetched = getAttachmentById(first.id);
@@ -236,11 +257,11 @@ describe('deleteAttachment', () => {
     expect(linked2).toHaveLength(1);
   });
 
-  test('deletes attachment when no messages reference it', () => {
-    const stored = uploadAttachment('lonely.txt', 'text/plain', 'UNREFERENCED');
+  test("deletes attachment when no messages reference it", () => {
+    const stored = uploadAttachment("lonely.txt", "text/plain", "UNREFERENCED");
     // No linkAttachmentToMessage call — zero references
     const result = deleteAttachment(stored.id);
-    expect(result).toBe('deleted');
+    expect(result).toBe("deleted");
 
     const fetched = getAttachmentById(stored.id);
     expect(fetched).toBeNull();
@@ -251,27 +272,27 @@ describe('deleteAttachment', () => {
 // getAttachmentsByIds
 // ---------------------------------------------------------------------------
 
-describe('getAttachmentsByIds', () => {
+describe("getAttachmentsByIds", () => {
   beforeEach(resetTables);
 
-  test('returns matching attachments with data', () => {
-    const a = uploadAttachment('a.txt', 'text/plain', 'AAAA');
-    const b = uploadAttachment('b.txt', 'text/plain', 'BBBB');
+  test("returns matching attachments with data", () => {
+    const a = uploadAttachment("a.txt", "text/plain", "AAAA");
+    const b = uploadAttachment("b.txt", "text/plain", "BBBB");
 
     const results = getAttachmentsByIds([a.id, b.id]);
     expect(results).toHaveLength(2);
-    expect(results[0].dataBase64).toBe('AAAA');
-    expect(results[1].dataBase64).toBe('BBBB');
+    expect(results[0].dataBase64).toBe("AAAA");
+    expect(results[1].dataBase64).toBe("BBBB");
   });
 
-  test('returns empty array for empty IDs list', () => {
+  test("returns empty array for empty IDs list", () => {
     const results = getAttachmentsByIds([]);
     expect(results).toHaveLength(0);
   });
 
-  test('skips IDs that do not exist', () => {
-    const a = uploadAttachment('a.txt', 'text/plain', 'AAAA');
-    const results = getAttachmentsByIds([a.id, 'nonexistent']);
+  test("skips IDs that do not exist", () => {
+    const a = uploadAttachment("a.txt", "text/plain", "AAAA");
+    const results = getAttachmentsByIds([a.id, "nonexistent"]);
     expect(results).toHaveLength(1);
   });
 });
@@ -280,21 +301,21 @@ describe('getAttachmentsByIds', () => {
 // getAttachmentById
 // ---------------------------------------------------------------------------
 
-describe('getAttachmentById', () => {
+describe("getAttachmentById", () => {
   beforeEach(resetTables);
 
-  test('returns attachment with data when found', () => {
-    const stored = uploadAttachment('report.pdf', 'application/pdf', 'JVBER');
+  test("returns attachment with data when found", () => {
+    const stored = uploadAttachment("report.pdf", "application/pdf", "JVBER");
     const result = getAttachmentById(stored.id);
 
     expect(result).not.toBeNull();
     expect(result!.id).toBe(stored.id);
-    expect(result!.originalFilename).toBe('report.pdf');
-    expect(result!.dataBase64).toBe('JVBER');
+    expect(result!.originalFilename).toBe("report.pdf");
+    expect(result!.dataBase64).toBe("JVBER");
   });
 
-  test('returns null for nonexistent ID', () => {
-    const result = getAttachmentById('no-such-id');
+  test("returns null for nonexistent ID", () => {
+    const result = getAttachmentById("no-such-id");
     expect(result).toBeNull();
   });
 });
@@ -303,28 +324,28 @@ describe('getAttachmentById', () => {
 // linkAttachmentToMessage + getAttachmentsForMessage
 // ---------------------------------------------------------------------------
 
-describe('linkAttachmentToMessage + getAttachmentsForMessage', () => {
+describe("linkAttachmentToMessage + getAttachmentsForMessage", () => {
   beforeEach(resetTables);
 
-  test('links attachment and retrieves it by message', async () => {
+  test("links attachment and retrieves it by message", async () => {
     const conv = createConversation();
-    const msg = await addMessage(conv.id, 'assistant', 'Here is a chart');
-    const stored = uploadAttachment('chart.png', 'image/png', 'iVBORw0K');
+    const msg = await addMessage(conv.id, "assistant", "Here is a chart");
+    const stored = uploadAttachment("chart.png", "image/png", "iVBORw0K");
 
     linkAttachmentToMessage(msg.id, stored.id, 0);
 
     const linked = getAttachmentsForMessage(msg.id);
     expect(linked).toHaveLength(1);
     expect(linked[0].id).toBe(stored.id);
-    expect(linked[0].originalFilename).toBe('chart.png');
-    expect(linked[0].dataBase64).toBe('iVBORw0K');
+    expect(linked[0].originalFilename).toBe("chart.png");
+    expect(linked[0].dataBase64).toBe("iVBORw0K");
   });
 
-  test('returns attachments in position order', async () => {
+  test("returns attachments in position order", async () => {
     const conv = createConversation();
-    const msg = await addMessage(conv.id, 'assistant', 'Multiple files');
-    const a = uploadAttachment('first.txt', 'text/plain', 'AAAA');
-    const b = uploadAttachment('second.txt', 'text/plain', 'BBBB');
+    const msg = await addMessage(conv.id, "assistant", "Multiple files");
+    const a = uploadAttachment("first.txt", "text/plain", "AAAA");
+    const b = uploadAttachment("second.txt", "text/plain", "BBBB");
 
     // Link in reverse order
     linkAttachmentToMessage(msg.id, b.id, 1);
@@ -332,13 +353,13 @@ describe('linkAttachmentToMessage + getAttachmentsForMessage', () => {
 
     const linked = getAttachmentsForMessage(msg.id);
     expect(linked).toHaveLength(2);
-    expect(linked[0].originalFilename).toBe('first.txt');
-    expect(linked[1].originalFilename).toBe('second.txt');
+    expect(linked[0].originalFilename).toBe("first.txt");
+    expect(linked[1].originalFilename).toBe("second.txt");
   });
 
-  test('returns empty for message with no attachments', async () => {
+  test("returns empty for message with no attachments", async () => {
     const conv = createConversation();
-    const msg = await addMessage(conv.id, 'assistant', 'No attachments');
+    const msg = await addMessage(conv.id, "assistant", "No attachments");
 
     const linked = getAttachmentsForMessage(msg.id);
     expect(linked).toHaveLength(0);
@@ -349,20 +370,20 @@ describe('linkAttachmentToMessage + getAttachmentsForMessage', () => {
 // deleteOrphanAttachments
 // ---------------------------------------------------------------------------
 
-describe('deleteOrphanAttachments', () => {
+describe("deleteOrphanAttachments", () => {
   beforeEach(resetTables);
 
-  test('removes candidate attachments with no message links', () => {
-    const stored = uploadAttachment('orphan.txt', 'text/plain', 'ZGF0YQ==');
+  test("removes candidate attachments with no message links", () => {
+    const stored = uploadAttachment("orphan.txt", "text/plain", "ZGF0YQ==");
 
     const removed = deleteOrphanAttachments([stored.id]);
     expect(removed).toBe(1);
   });
 
-  test('preserves attachments that are still linked', async () => {
+  test("preserves attachments that are still linked", async () => {
     const conv = createConversation();
-    const msg = await addMessage(conv.id, 'assistant', 'With attachment');
-    const stored = uploadAttachment('linked.txt', 'text/plain', 'ZGF0YQ==');
+    const msg = await addMessage(conv.id, "assistant", "With attachment");
+    const stored = uploadAttachment("linked.txt", "text/plain", "ZGF0YQ==");
     linkAttachmentToMessage(msg.id, stored.id, 0);
 
     const removed = deleteOrphanAttachments([stored.id]);
@@ -372,11 +393,11 @@ describe('deleteOrphanAttachments', () => {
     expect(fetched).not.toBeNull();
   });
 
-  test('removes only orphans when mixed candidates provided', async () => {
+  test("removes only orphans when mixed candidates provided", async () => {
     const conv = createConversation();
-    const msg = await addMessage(conv.id, 'assistant', 'Mixed');
-    const linked = uploadAttachment('linked.txt', 'text/plain', 'AAAA');
-    const orphan = uploadAttachment('orphan.txt', 'text/plain', 'BBBB');
+    const msg = await addMessage(conv.id, "assistant", "Mixed");
+    const linked = uploadAttachment("linked.txt", "text/plain", "AAAA");
+    const orphan = uploadAttachment("orphan.txt", "text/plain", "BBBB");
     linkAttachmentToMessage(msg.id, linked.id, 0);
 
     const removed = deleteOrphanAttachments([linked.id, orphan.id]);
@@ -386,14 +407,14 @@ describe('deleteOrphanAttachments', () => {
     expect(remaining).not.toBeNull();
   });
 
-  test('returns 0 when no candidates provided', () => {
+  test("returns 0 when no candidates provided", () => {
     const removed = deleteOrphanAttachments([]);
     expect(removed).toBe(0);
   });
 
-  test('does not delete attachments outside the candidate set', () => {
-    const unrelated = uploadAttachment('unrelated.txt', 'text/plain', 'AAAA');
-    const candidate = uploadAttachment('candidate.txt', 'text/plain', 'BBBB');
+  test("does not delete attachments outside the candidate set", () => {
+    const unrelated = uploadAttachment("unrelated.txt", "text/plain", "AAAA");
+    const candidate = uploadAttachment("candidate.txt", "text/plain", "BBBB");
 
     const removed = deleteOrphanAttachments([candidate.id]);
     expect(removed).toBe(1);
@@ -408,71 +429,107 @@ describe('deleteOrphanAttachments', () => {
 // validateAttachmentUpload
 // ---------------------------------------------------------------------------
 
-describe('validateAttachmentUpload', () => {
-  test('accepts common image MIME types', () => {
-    expect(validateAttachmentUpload('photo.png', 'image/png').ok).toBe(true);
-    expect(validateAttachmentUpload('pic.jpg', 'image/jpeg').ok).toBe(true);
-    expect(validateAttachmentUpload('anim.gif', 'image/gif').ok).toBe(true);
-    expect(validateAttachmentUpload('sticker.webp', 'image/webp').ok).toBe(true);
+describe("validateAttachmentUpload", () => {
+  test("accepts common image MIME types", () => {
+    expect(validateAttachmentUpload("photo.png", "image/png").ok).toBe(true);
+    expect(validateAttachmentUpload("pic.jpg", "image/jpeg").ok).toBe(true);
+    expect(validateAttachmentUpload("anim.gif", "image/gif").ok).toBe(true);
+    expect(validateAttachmentUpload("sticker.webp", "image/webp").ok).toBe(
+      true,
+    );
   });
 
-  test('accepts document MIME types', () => {
-    expect(validateAttachmentUpload('doc.pdf', 'application/pdf').ok).toBe(true);
-    expect(validateAttachmentUpload('notes.txt', 'text/plain').ok).toBe(true);
-    expect(validateAttachmentUpload('data.csv', 'text/csv').ok).toBe(true);
-    expect(validateAttachmentUpload('config.json', 'application/json').ok).toBe(true);
+  test("accepts document MIME types", () => {
+    expect(validateAttachmentUpload("doc.pdf", "application/pdf").ok).toBe(
+      true,
+    );
+    expect(validateAttachmentUpload("notes.txt", "text/plain").ok).toBe(true);
+    expect(validateAttachmentUpload("data.csv", "text/csv").ok).toBe(true);
+    expect(validateAttachmentUpload("config.json", "application/json").ok).toBe(
+      true,
+    );
   });
 
-  test('accepts audio and video MIME types', () => {
-    expect(validateAttachmentUpload('voice.ogg', 'audio/ogg').ok).toBe(true);
-    expect(validateAttachmentUpload('song.mp3', 'audio/mpeg').ok).toBe(true);
-    expect(validateAttachmentUpload('clip.mp4', 'video/mp4').ok).toBe(true);
+  test("accepts audio and video MIME types", () => {
+    expect(validateAttachmentUpload("voice.ogg", "audio/ogg").ok).toBe(true);
+    expect(validateAttachmentUpload("song.mp3", "audio/mpeg").ok).toBe(true);
+    expect(validateAttachmentUpload("clip.mp4", "video/mp4").ok).toBe(true);
   });
 
-  test('accepts application/octet-stream fallback', () => {
-    expect(validateAttachmentUpload('data.bin', 'application/octet-stream').ok).toBe(true);
+  test("accepts application/octet-stream fallback", () => {
+    expect(
+      validateAttachmentUpload("data.bin", "application/octet-stream").ok,
+    ).toBe(true);
   });
 
-  test('rejects dangerous file extensions', () => {
-    const exeResult = validateAttachmentUpload('malware.exe', 'application/octet-stream');
+  test("rejects dangerous file extensions", () => {
+    const exeResult = validateAttachmentUpload(
+      "malware.exe",
+      "application/octet-stream",
+    );
     expect(exeResult.ok).toBe(false);
-    if (!exeResult.ok) expect(exeResult.error).toContain('.exe');
+    if (!exeResult.ok) expect(exeResult.error).toContain(".exe");
 
-    const shResult = validateAttachmentUpload('script.sh', 'text/plain');
+    const shResult = validateAttachmentUpload("script.sh", "text/plain");
     expect(shResult.ok).toBe(false);
-    if (!shResult.ok) expect(shResult.error).toContain('.sh');
+    if (!shResult.ok) expect(shResult.error).toContain(".sh");
 
-    const isoResult = validateAttachmentUpload('disk.iso', 'application/octet-stream');
+    const isoResult = validateAttachmentUpload(
+      "disk.iso",
+      "application/octet-stream",
+    );
     expect(isoResult.ok).toBe(false);
-    if (!isoResult.ok) expect(isoResult.error).toContain('.iso');
+    if (!isoResult.ok) expect(isoResult.error).toContain(".iso");
   });
 
-  test('rejects dangerous extensions regardless of claimed MIME type', () => {
+  test("rejects dangerous extensions regardless of claimed MIME type", () => {
     // .exe disguised as image/png
-    const result = validateAttachmentUpload('payload.exe', 'image/png');
+    const result = validateAttachmentUpload("payload.exe", "image/png");
     expect(result.ok).toBe(false);
   });
 
-  test('extension check is case-insensitive', () => {
-    expect(validateAttachmentUpload('PROGRAM.EXE', 'application/octet-stream').ok).toBe(false);
-    expect(validateAttachmentUpload('script.SH', 'text/plain').ok).toBe(false);
+  test("extension check is case-insensitive", () => {
+    expect(
+      validateAttachmentUpload("PROGRAM.EXE", "application/octet-stream").ok,
+    ).toBe(false);
+    expect(validateAttachmentUpload("script.SH", "text/plain").ok).toBe(false);
   });
 
-  test('rejects unsupported MIME types', () => {
-    const result = validateAttachmentUpload('file.unknown', 'application/x-msdownload');
+  test("rejects unsupported MIME types", () => {
+    const result = validateAttachmentUpload(
+      "file.unknown",
+      "application/x-msdownload",
+    );
     expect(result.ok).toBe(false);
-    if (!result.ok) expect(result.error).toContain('Unsupported MIME type');
+    if (!result.ok) expect(result.error).toContain("Unsupported MIME type");
   });
 
-  test('handles filenames without extensions', () => {
+  test("handles filenames without extensions", () => {
     // No extension — only MIME check applies
-    expect(validateAttachmentUpload('Makefile', 'text/plain').ok).toBe(true);
-    expect(validateAttachmentUpload('Makefile', 'application/x-evil').ok).toBe(false);
-  });
-
-  test('rejects all dangerous extension variants', () => {
-    for (const ext of ['bat', 'cmd', 'com', 'msi', 'dmg', 'app', 'scr', 'pif', 'vbs', 'ps1', 'jar']) {
-      const result = validateAttachmentUpload(`file.${ext}`, 'application/octet-stream');
+    expect(validateAttachmentUpload("Makefile", "text/plain").ok).toBe(true);
+    expect(validateAttachmentUpload("Makefile", "application/x-evil").ok).toBe(
+      false,
+    );
+  });
+
+  test("rejects all dangerous extension variants", () => {
+    for (const ext of [
+      "bat",
+      "cmd",
+      "com",
+      "msi",
+      "dmg",
+      "app",
+      "scr",
+      "pif",
+      "vbs",
+      "ps1",
+      "jar",
+    ]) {
+      const result = validateAttachmentUpload(
+        `file.${ext}`,
+        "application/octet-stream",
+      );
       expect(result.ok).toBe(false);
     }
   });