@gencow/core 0.1.24 → 0.1.25

package/src/__tests__/image-optimization.test.ts

@@ -12,8 +12,8 @@
  */
 
 import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { createStorage, storageRoutes } from "../storage";
-import type { StorageImageTierConfig } from "../storage";
+import { createStorage, storageRoutes } from "../storage.js";
+import type { StorageImageTierConfig } from "../storage.js";
 import * as fs from "fs/promises";
 import * as path from "path";
 import * as os from "os";
@@ -21,632 +21,628 @@ import * as os from "os";
 // ─── 테스트 헬퍼 ────────────────────────────────────────
 
 /** 간단한 Hono context mock */
-function mockContext(
-    id: string,
-    query: Record<string, string> = {},
-    headers: Record<string, string> = {},
-) {
-    let responseData: unknown = null;
-    let responseStatus: number = 200;
-    let responseHeaders: Record<string, string> = {};
-
-    return {
-        c: {
-            req: {
-                param: (key: string) => (key === "id" ? id : ""),
-                query: (key: string) => query[key],
-                header: (name: string) => headers[name.toLowerCase()],
-            },
-            json: (data: unknown, status?: number) => {
-                responseData = data;
-                responseStatus = status ?? 200;
-                return new Response(JSON.stringify(data), {
-                    status: responseStatus,
-                    headers: { "Content-Type": "application/json" },
-                });
-            },
-            body: (data: unknown, status: number, hdrs: Record<string, string>) => {
-                responseStatus = status;
-                responseHeaders = hdrs;
-                return new Response(data as BodyInit, { status, headers: hdrs });
-            },
-        },
-        getResponseData: () => responseData,
-        getResponseStatus: () => responseStatus,
-        getResponseHeaders: () => responseHeaders,
-    };
+function mockContext(id: string, query: Record<string, string> = {}, headers: Record<string, string> = {}) {
+  let responseData: unknown = null;
+  let responseStatus: number = 200;
+  let responseHeaders: Record<string, string> = {};
+
+  return {
+    c: {
+      req: {
+        param: (key: string) => (key === "id" ? id : ""),
+        query: (key: string) => query[key],
+        header: (name: string) => headers[name.toLowerCase()],
+      },
+      json: (data: unknown, status?: number) => {
+        responseData = data;
+        responseStatus = status ?? 200;
+        return new Response(JSON.stringify(data), {
+          status: responseStatus,
+          headers: { "Content-Type": "application/json" },
+        });
+      },
+      body: (data: unknown, status: number, hdrs: Record<string, string>) => {
+        responseStatus = status;
+        responseHeaders = hdrs;
+        return new Response(data as BodyInit, { status, headers: hdrs });
+      },
+    },
+    getResponseData: () => responseData,
+    getResponseStatus: () => responseStatus,
+    getResponseHeaders: () => responseHeaders,
+  };
 }
 
 // ─── 테스트 시작 ────────────────────────────────────────
 
 describe("Image Optimization — storageRoutes", () => {
-    let tmpDir: string;
-
-    beforeEach(async () => {
-        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "gencow-img-test-"));
-    });
-
-    afterEach(async () => {
-        await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "gencow-img-test-"));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+  });
+
+  // ─── 기본 동작 (파라미터 없음) ──────────────────────
+
+  describe("기본 동작 — 파라미터 없음", () => {
+    it("이미지 파일에 파라미터 없이 요청 → 원본 서빙", async () => {
+      const storage = createStorage(tmpDir);
+      // 1x1 PNG (유효한 이미지)
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+
+      const handler = storageRoutes(storage, undefined, tmpDir);
+      const { c } = mockContext(id, {}, {});
+      const response = await handler(c as any);
+
+      expect(response.status).toBe(200);
+      expect(response.headers.get("content-type")).toBe("image/png");
     });
 
-    // ─── 기본 동작 (파라미터 없음) ──────────────────────
-
-    describe("기본 동작 — 파라미터 없음", () => {
-        it("이미지 파일에 파라미터 없이 요청 → 원본 서빙", async () => {
-            const storage = createStorage(tmpDir);
-            // 1x1 PNG (유효한 이미지)
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
-
-            const handler = storageRoutes(storage, undefined, tmpDir);
-            const { c } = mockContext(id, {}, {});
-            const response = await handler(c as any);
+    it("비이미지 파일은 항상 원본 서빙", async () => {
+      const storage = createStorage(tmpDir);
+      const id = await storage.storeBuffer(Buffer.from("hello"), "test.txt", "text/plain");
 
-            expect(response.status).toBe(200);
-            expect(response.headers.get("content-type")).toBe("image/png");
-        });
-
-        it("비이미지 파일은 항상 원본 서빙", async () => {
-            const storage = createStorage(tmpDir);
-            const id = await storage.storeBuffer(Buffer.from("hello"), "test.txt", "text/plain");
-
-            const handler = storageRoutes(storage, undefined, tmpDir);
-            const { c } = mockContext(id, { w: "300" }, {}); // 파라미터 있어도 변환 안 됨
-
-            const response = await handler(c as any);
-            expect(response.status).toBe(200);
-            expect(response.headers.get("content-type")).toBe("text/plain");
-        });
+      const handler = storageRoutes(storage, undefined, tmpDir);
+      const { c } = mockContext(id, { w: "300" }, {}); // 파라미터 있어도 변환 안 됨
 
-        it("존재하지 않는 storageId → 404", async () => {
-            const storage = createStorage(tmpDir);
-            const handler = storageRoutes(storage, undefined, tmpDir);
-            const { c } = mockContext("nonexistent-id");
-
-            const response = await handler(c as any);
-            expect(response.status).toBe(404);
-        });
+      const response = await handler(c as any);
+      expect(response.status).toBe(200);
+      expect(response.headers.get("content-type")).toBe("text/plain");
     });
 
-    // ─── 파라미터 검증 (parseTransformParams 간접 검증) ─
-
-    describe("파라미터 검증", () => {
-        it("유효한 w 파라미터 → 변환 시도 (sharp 미설치 시 원본 반환)", async () => {
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
-
-            const handler = storageRoutes(storage, undefined, tmpDir);
-            const { c } = mockContext(id, { w: "300" }, {});
-            const response = await handler(c as any);
-            // sharp 미설치 → graceful degradation → 원본 서빙
-            expect(response.status).toBe(200);
-        });
-
-        it("무효한 w 파라미터 (> 4096) → 원본 서빙 (파라미터 무시)", async () => {
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
-
-            const handler = storageRoutes(storage, undefined, tmpDir);
-            const { c } = mockContext(id, { w: "9999" }, {});
-            const response = await handler(c as any);
-            expect(response.status).toBe(200);
-            // 무효 파라미터 → parseTransformParams returns null → 원본 서빙
-            expect(response.headers.get("content-type")).toBe("image/png");
-        });
-
-        it("무효한 w 파라미터 (음수) → 원본 서빙", async () => {
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
-
-            const handler = storageRoutes(storage, undefined, tmpDir);
-            const { c } = mockContext(id, { w: "-1" }, {});
-            const response = await handler(c as any);
-            expect(response.status).toBe(200);
-            expect(response.headers.get("content-type")).toBe("image/png");
-        });
-
-        it("무효한 포맷 → 원본 서빙", async () => {
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
-
-            const handler = storageRoutes(storage, undefined, tmpDir);
-            const { c } = mockContext(id, { f: "bmp" }, {}); // bmp는 허용 포맷 아님
-            const response = await handler(c as any);
-            expect(response.status).toBe(200);
-            expect(response.headers.get("content-type")).toBe("image/png");
-        });
+    it("존재하지 않는 storageId → 404", async () => {
+      const storage = createStorage(tmpDir);
+      const handler = storageRoutes(storage, undefined, tmpDir);
+      const { c } = mockContext("nonexistent-id");
 
-        it("무효한 품질 (0) → 원본 서빙", async () => {
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
-
-            const handler = storageRoutes(storage, undefined, tmpDir);
-            const { c } = mockContext(id, { q: "0" }, {});
-            const response = await handler(c as any);
-            expect(response.status).toBe(200);
-        });
+      const response = await handler(c as any);
+      expect(response.status).toBe(404);
+    });
+  });
+
+  // ─── 파라미터 검증 (parseTransformParams 간접 검증) ─
+
+  describe("파라미터 검증", () => {
+    it("유효한 w 파라미터 → 변환 시도 (sharp 미설치 시 원본 반환)", async () => {
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+
+      const handler = storageRoutes(storage, undefined, tmpDir);
+      const { c } = mockContext(id, { w: "300" }, {});
+      const response = await handler(c as any);
+      // sharp 미설치 → graceful degradation → 원본 서빙
+      expect(response.status).toBe(200);
+    });
 
-        it("무효한 품질 (101) → 원본 서빙", async () => {
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
-
-            const handler = storageRoutes(storage, undefined, tmpDir);
-            const { c } = mockContext(id, { q: "101" }, {});
-            const response = await handler(c as any);
-            expect(response.status).toBe(200);
-        });
+    it("무효한 w 파라미터 (> 4096) → 원본 서빙 (파라미터 무시)", async () => {
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+
+      const handler = storageRoutes(storage, undefined, tmpDir);
+      const { c } = mockContext(id, { w: "9999" }, {});
+      const response = await handler(c as any);
+      expect(response.status).toBe(200);
+      // 무효 파라미터 → parseTransformParams returns null → 원본 서빙
+      expect(response.headers.get("content-type")).toBe("image/png");
+    });
 
-        it("무효한 fit 모드 → 원본 서빙", async () => {
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
-
-            const handler = storageRoutes(storage, undefined, tmpDir);
-            const { c } = mockContext(id, { fit: "stretch" }, {});
-            const response = await handler(c as any);
-            expect(response.status).toBe(200);
-        });
+    it("무효한 w 파라미터 (음수) → 원본 서빙", async () => {
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+
+      const handler = storageRoutes(storage, undefined, tmpDir);
+      const { c } = mockContext(id, { w: "-1" }, {});
+      const response = await handler(c as any);
+      expect(response.status).toBe(200);
+      expect(response.headers.get("content-type")).toBe("image/png");
     });
 
-    // ─── Auto WebP 분기 ──────────────────────────────────
+    it("무효한 포맷 → 원본 서빙", async () => {
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+
+      const handler = storageRoutes(storage, undefined, tmpDir);
+      const { c } = mockContext(id, { f: "bmp" }, {}); // bmp는 허용 포맷 아님
+      const response = await handler(c as any);
+      expect(response.status).toBe(200);
+      expect(response.headers.get("content-type")).toBe("image/png");
+    });
 
-    describe("Auto WebP", () => {
-        it("Accept: image/webp + PNG 원본 → Auto WebP 시도", async () => {
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+    it("무효한 품질 (0) → 원본 서빙", async () => {
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+
+      const handler = storageRoutes(storage, undefined, tmpDir);
+      const { c } = mockContext(id, { q: "0" }, {});
+      const response = await handler(c as any);
+      expect(response.status).toBe(200);
+    });
 
-            const handler = storageRoutes(storage, undefined, tmpDir);
-            const { c } = mockContext(id, {}, { accept: "text/html,image/webp,*/*" });
-            const response = await handler(c as any);
-            // sharp 미설치 시 원본 서빙 (graceful degradation)
-            expect(response.status).toBe(200);
-        });
+    it("무효한 품질 (101) → 원본 서빙", async () => {
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+
+      const handler = storageRoutes(storage, undefined, tmpDir);
+      const { c } = mockContext(id, { q: "101" }, {});
+      const response = await handler(c as any);
+      expect(response.status).toBe(200);
+    });
 
-        it("Accept 헤더에 webp 없음 → Auto WebP 안 함 (원본 서빙)", async () => {
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
-
-            const handler = storageRoutes(storage, undefined, tmpDir);
-            const { c } = mockContext(id, {}, { accept: "text/html,*/*" });
-            const response = await handler(c as any);
-            expect(response.status).toBe(200);
-            expect(response.headers.get("content-type")).toBe("image/png");
-        });
+    it("무효한 fit 모드 → 원본 서빙", async () => {
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+
+      const handler = storageRoutes(storage, undefined, tmpDir);
+      const { c } = mockContext(id, { fit: "stretch" }, {});
+      const response = await handler(c as any);
+      expect(response.status).toBe(200);
+    });
+  });
+
+  // ─── Auto WebP 분기 ──────────────────────────────────
+
+  describe("Auto WebP", () => {
+    it("Accept: image/webp + PNG 원본 → Auto WebP 시도", async () => {
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+
+      const handler = storageRoutes(storage, undefined, tmpDir);
+      const { c } = mockContext(id, {}, { accept: "text/html,image/webp,*/*" });
+      const response = await handler(c as any);
+      // sharp 미설치 시 원본 서빙 (graceful degradation)
+      expect(response.status).toBe(200);
+    });
 
-        it("WebP 원본에는 Auto WebP 적용 안 함", async () => {
-            const storage = createStorage(tmpDir);
-            // 가짜 webp 데이터 — RIFF 헤더
-            const webpBuffer = Buffer.alloc(16);
-            webpBuffer.write("RIFF", 0);
-            webpBuffer.writeUInt32LE(8, 4);
-            webpBuffer.write("WEBP", 8);
-            const id = await storage.storeBuffer(webpBuffer, "test.webp", "image/webp");
-
-            const handler = storageRoutes(storage, undefined, tmpDir);
-            const { c } = mockContext(id, {}, { accept: "image/webp" });
-            const response = await handler(c as any);
-            expect(response.status).toBe(200);
-            expect(response.headers.get("content-type")).toBe("image/webp");
-        });
+    it("Accept 헤더에 webp 없음 → Auto WebP 안 함 (원본 서빙)", async () => {
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+
+      const handler = storageRoutes(storage, undefined, tmpDir);
+      const { c } = mockContext(id, {}, { accept: "text/html,*/*" });
+      const response = await handler(c as any);
+      expect(response.status).toBe(200);
+      expect(response.headers.get("content-type")).toBe("image/png");
+    });
 
-        it("autoWebp=false 설정 → Auto WebP 비활성", async () => {
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
-
-            const tierConfig: StorageImageTierConfig = { autoWebp: false };
-            const handler = storageRoutes(storage, undefined, tmpDir, tierConfig);
-            const { c } = mockContext(id, {}, { accept: "image/webp" });
-            const response = await handler(c as any);
-            expect(response.status).toBe(200);
-            expect(response.headers.get("content-type")).toBe("image/png");
-        });
+    it("WebP 원본에는 Auto WebP 적용 안 함", async () => {
+      const storage = createStorage(tmpDir);
+      // 가짜 webp 데이터 — RIFF 헤더
+      const webpBuffer = Buffer.alloc(16);
+      webpBuffer.write("RIFF", 0);
+      webpBuffer.writeUInt32LE(8, 4);
+      webpBuffer.write("WEBP", 8);
+      const id = await storage.storeBuffer(webpBuffer, "test.webp", "image/webp");
+
+      const handler = storageRoutes(storage, undefined, tmpDir);
+      const { c } = mockContext(id, {}, { accept: "image/webp" });
+      const response = await handler(c as any);
+      expect(response.status).toBe(200);
+      expect(response.headers.get("content-type")).toBe("image/webp");
     });
 
-    // ─── Tier 기반 403 응답 ─────────────────────────────
-
-    describe("Tier 기반 접근 제어", () => {
-        it("resize=false + w 파라미터 → 403 PLAN_LIMIT", async () => {
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
-
-            const tierConfig: StorageImageTierConfig = {
-                autoWebp: true,
-                resize: false,
-                formats: ["webp"],
-                qualityControl: false,
-            };
-            const handler = storageRoutes(storage, undefined, tmpDir, tierConfig);
-            const { c } = mockContext(id, { w: "300" }, {});
-            const response = await handler(c as any);
-
-            expect(response.status).toBe(403);
-            const body = await response.json();
-            expect(body.code).toBe("PLAN_LIMIT");
-            expect(body.upgrade).toBeTruthy();
-        });
+    it("autoWebp=false 설정 → Auto WebP 비활성", async () => {
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+
+      const tierConfig: StorageImageTierConfig = { autoWebp: false };
+      const handler = storageRoutes(storage, undefined, tmpDir, tierConfig);
+      const { c } = mockContext(id, {}, { accept: "image/webp" });
+      const response = await handler(c as any);
+      expect(response.status).toBe(200);
+      expect(response.headers.get("content-type")).toBe("image/png");
+    });
+  });
+
+  // ─── Tier 기반 403 응답 ─────────────────────────────
+
+  describe("Tier 기반 접근 제어", () => {
+    it("resize=false + w 파라미터 → 403 PLAN_LIMIT", async () => {
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+
+      const tierConfig: StorageImageTierConfig = {
+        autoWebp: true,
+        resize: false,
+        formats: ["webp"],
+        qualityControl: false,
+      };
+      const handler = storageRoutes(storage, undefined, tmpDir, tierConfig);
+      const { c } = mockContext(id, { w: "300" }, {});
+      const response = await handler(c as any);
+
+      expect(response.status).toBe(403);
+      const body = await response.json();
+      expect(body.code).toBe("PLAN_LIMIT");
+      expect(body.upgrade).toBeTruthy();
+    });
 
-        it("허용되지 않은 포맷 → 403 PLAN_LIMIT", async () => {
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
-
-            const tierConfig: StorageImageTierConfig = {
-                resize: true,
-                formats: ["webp"], // avif 불허
-                qualityControl: true,
-            };
-            const handler = storageRoutes(storage, undefined, tmpDir, tierConfig);
-            const { c } = mockContext(id, { f: "avif" }, {});
-            const response = await handler(c as any);
-
-            expect(response.status).toBe(403);
-            const body = await response.json();
-            expect(body.code).toBe("PLAN_LIMIT");
-            expect(body.allowed.formats).toEqual(["webp"]);
-        });
+    it("허용되지 않은 포맷 → 403 PLAN_LIMIT", async () => {
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+
+      const tierConfig: StorageImageTierConfig = {
+        resize: true,
+        formats: ["webp"], // avif 불허
+        qualityControl: true,
+      };
+      const handler = storageRoutes(storage, undefined, tmpDir, tierConfig);
+      const { c } = mockContext(id, { f: "avif" }, {});
+      const response = await handler(c as any);
+
+      expect(response.status).toBe(403);
+      const body = await response.json();
+      expect(body.code).toBe("PLAN_LIMIT");
+      expect(body.allowed.formats).toEqual(["webp"]);
+    });
 
-        it("qualityControl=false + q 파라미터 → 403", async () => {
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
-
-            const tierConfig: StorageImageTierConfig = {
-                resize: true,
-                formats: ["webp", "avif", "jpeg", "png"],
-                qualityControl: false,
-            };
-            const handler = storageRoutes(storage, undefined, tmpDir, tierConfig);
-            const { c } = mockContext(id, { q: "50" }, {});
-            const response = await handler(c as any);
-
-            expect(response.status).toBe(403);
-        });
+    it("qualityControl=false + q 파라미터 → 403", async () => {
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+
+      const tierConfig: StorageImageTierConfig = {
+        resize: true,
+        formats: ["webp", "avif", "jpeg", "png"],
+        qualityControl: false,
+      };
+      const handler = storageRoutes(storage, undefined, tmpDir, tierConfig);
+      const { c } = mockContext(id, { q: "50" }, {});
+      const response = await handler(c as any);
+
+      expect(response.status).toBe(403);
+    });
 
-        it("모든 기능 허용 → 403 없음 (sharp 미설치 시 원본 반환)", async () => {
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+    it("모든 기능 허용 → 403 없음 (sharp 미설치 시 원본 반환)", async () => {
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
 
-            // tierConfig 미전달 → 모든 기능 활성화
-            const handler = storageRoutes(storage, undefined, tmpDir);
-            const { c } = mockContext(id, { w: "300", f: "webp", q: "80" }, {});
-            const response = await handler(c as any);
+      // tierConfig 미전달 → 모든 기능 활성화
+      const handler = storageRoutes(storage, undefined, tmpDir);
+      const { c } = mockContext(id, { w: "300", f: "webp", q: "80" }, {});
+      const response = await handler(c as any);
 
-            expect(response.status).toBe(200); // 403이 아님
-        });
+      expect(response.status).toBe(200); // 403이 아님
+    });
+  });
+
+  // ─── 캐시 관리 ─────────────────────────────────────
+
+  describe("캐시 관리", () => {
+    it("delete 시 캐시 디렉토리도 정리된다", async () => {
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+
+      // 가짜 캐시 파일 생성
+      const cacheDir = path.join(tmpDir, ".cache");
+      await fs.mkdir(cacheDir, { recursive: true });
+      await fs.writeFile(path.join(cacheDir, `${id}_auto_webp.webp`), "fake cache");
+      await fs.writeFile(path.join(cacheDir, `${id}_w300_fwebp_q80.webp`), "fake cache 2");
+      // 다른 UUID의 캐시는 남아야 함
+      await fs.writeFile(path.join(cacheDir, "other-uuid_auto_webp.webp"), "other");
+
+      // 삭제
+      await storage.delete(id);
+
+      // 해당 UUID 캐시 삭제됨
+      const entries = await fs.readdir(cacheDir);
+      expect(entries).not.toContain(`${id}_auto_webp.webp`);
+      expect(entries).not.toContain(`${id}_w300_fwebp_q80.webp`);
+      // 다른 UUID 캐시는 남아 있음
+      expect(entries).toContain("other-uuid_auto_webp.webp");
     });
 
-    // ─── 캐시 관리 ─────────────────────────────────────
-
-    describe("캐시 관리", () => {
-        it("delete 시 캐시 디렉토리도 정리된다", async () => {
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
-
-            // 가짜 캐시 파일 생성
-            const cacheDir = path.join(tmpDir, ".cache");
-            await fs.mkdir(cacheDir, { recursive: true });
-            await fs.writeFile(path.join(cacheDir, `${id}_auto_webp.webp`), "fake cache");
-            await fs.writeFile(path.join(cacheDir, `${id}_w300_fwebp_q80.webp`), "fake cache 2");
-            // 다른 UUID의 캐시는 남아야 함
-            await fs.writeFile(path.join(cacheDir, "other-uuid_auto_webp.webp"), "other");
-
-            // 삭제
-            await storage.delete(id);
-
-            // 해당 UUID 캐시 삭제됨
-            const entries = await fs.readdir(cacheDir);
-            expect(entries).not.toContain(`${id}_auto_webp.webp`);
-            expect(entries).not.toContain(`${id}_w300_fwebp_q80.webp`);
-            // 다른 UUID 캐시는 남아 있음
-            expect(entries).toContain("other-uuid_auto_webp.webp");
-        });
-
-        it("캐시 디렉토리 미존재 시 delete 에러 없음", async () => {
-            const storage = createStorage(tmpDir);
-            const id = await storage.storeBuffer(Buffer.from("test"), "test.png", "image/png");
+    it("캐시 디렉토리 미존재 시 delete 에러 없음", async () => {
+      const storage = createStorage(tmpDir);
+      const id = await storage.storeBuffer(Buffer.from("test"), "test.png", "image/png");
 
-            // .cache 디렉토리가 없어도 에러 없이 정상 삭제
-            await expect(storage.delete(id)).resolves.toBeUndefined();
-        });
+      // .cache 디렉토리가 없어도 에러 없이 정상 삭제
+      await expect(storage.delete(id)).resolves.toBeUndefined();
     });
+  });
 
-    // ─── 하위호환성 ────────────────────────────────────
+  // ─── 하위호환성 ────────────────────────────────────
 
-    describe("하위호환성", () => {
-        it("tierConfig 없이 storageRoutes 호출 → 에러 없음", () => {
-            const storage = createStorage(tmpDir);
-            // 기존 3인자 호출
-            const handler = storageRoutes(storage, undefined, tmpDir);
-            expect(typeof handler).toBe("function");
-        });
+  describe("하위호환성", () => {
+    it("tierConfig 없이 storageRoutes 호출 → 에러 없음", () => {
+      const storage = createStorage(tmpDir);
+      // 기존 3인자 호출
+      const handler = storageRoutes(storage, undefined, tmpDir);
+      expect(typeof handler).toBe("function");
+    });
 
-        it("Cache-Control: immutable 헤더 유지", async () => {
-            const storage = createStorage(tmpDir);
-            const id = await storage.storeBuffer(Buffer.from("test"), "test.txt", "text/plain");
+    it("Cache-Control: immutable 헤더 유지", async () => {
+      const storage = createStorage(tmpDir);
+      const id = await storage.storeBuffer(Buffer.from("test"), "test.txt", "text/plain");
 
-            const handler = storageRoutes(storage, undefined, tmpDir);
-            const { c } = mockContext(id);
-            const response = await handler(c as any);
+      const handler = storageRoutes(storage, undefined, tmpDir);
+      const { c } = mockContext(id);
+      const response = await handler(c as any);
 
-            expect(response.headers.get("cache-control")).toContain("immutable");
-        });
+      expect(response.headers.get("cache-control")).toContain("immutable");
     });
+  });
 
-    // ─── 앱별 이미지 오버라이드 ─────────────────────────
+  // ─── 앱별 이미지 오버라이드 ─────────────────────────
 
-    describe("앱별 이미지 오버라이드", () => {
-        afterEach(() => {
-            delete process.env.__GENCOW_IMAGE_APP_CONFIG;
-        });
+  describe("앱별 이미지 오버라이드", () => {
+    afterEach(() => {
+      delete process.env.__GENCOW_IMAGE_APP_CONFIG;
+    });
 
-        it("autoQuality를 tierConfig로 전달하면 기본값(75) 대신 사용", () => {
-            const storage = createStorage(tmpDir);
-            const tierConfig: StorageImageTierConfig = { autoQuality: 85 };
-            const handler = storageRoutes(storage, undefined, tmpDir, tierConfig);
-            expect(typeof handler).toBe("function");
-        });
+    it("autoQuality를 tierConfig로 전달하면 기본값(75) 대신 사용", () => {
+      const storage = createStorage(tmpDir);
+      const tierConfig: StorageImageTierConfig = { autoQuality: 85 };
+      const handler = storageRoutes(storage, undefined, tmpDir, tierConfig);
+      expect(typeof handler).toBe("function");
+    });
 
-        it("__GENCOW_IMAGE_APP_CONFIG 환경변수가 있으면 파싱하여 config에 병합", async () => {
-            process.env.__GENCOW_IMAGE_APP_CONFIG = JSON.stringify({ autoMaxWidth: 1280, autoQuality: 60 });
-
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
-
-            // Tier: autoMaxWidth=1920 → 앱 설정 1280이 더 작으므로 1280 적용
-            const tierConfig: StorageImageTierConfig = { autoMaxWidth: 1920 };
-            const handler = storageRoutes(storage, undefined, tmpDir, tierConfig);
-            const { c } = mockContext(id, {}, { accept: "image/webp" });
-            const response = await handler(c as any);
-            expect(response.status).toBe(200); // 정상 처리 (sharp 미설치 시 원본)
-        });
+    it("__GENCOW_IMAGE_APP_CONFIG 환경변수가 있으면 파싱하여 config에 병합", async () => {
+      process.env.__GENCOW_IMAGE_APP_CONFIG = JSON.stringify({ autoMaxWidth: 1280, autoQuality: 60 });
+
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+
+      // Tier: autoMaxWidth=1920 → 앱 설정 1280이 더 작으므로 1280 적용
+      const tierConfig: StorageImageTierConfig = { autoMaxWidth: 1920 };
+      const handler = storageRoutes(storage, undefined, tmpDir, tierConfig);
+      const { c } = mockContext(id, {}, { accept: "image/webp" });
+      const response = await handler(c as any);
+      expect(response.status).toBe(200); // 정상 처리 (sharp 미설치 시 원본)
+    });
 
-        it("앱 maxWidth > Tier maxWidth → Tier ceiling 적용", async () => {
-            // 앱이 3840을 원하지만 Tier(Hobby)가 1920이면 1920 적용
-            process.env.__GENCOW_IMAGE_APP_CONFIG = JSON.stringify({ autoMaxWidth: 3840 });
-
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
-
-            const tierConfig: StorageImageTierConfig = { autoMaxWidth: 1920 };
-            const handler = storageRoutes(storage, undefined, tmpDir, tierConfig);
-            const { c } = mockContext(id, {}, { accept: "image/webp" });
-            const response = await handler(c as any);
-            expect(response.status).toBe(200);
-        });
+    it("앱 maxWidth > Tier maxWidth → Tier ceiling 적용", async () => {
+      // 앱이 3840을 원하지만 Tier(Hobby)가 1920이면 1920 적용
+      process.env.__GENCOW_IMAGE_APP_CONFIG = JSON.stringify({ autoMaxWidth: 3840 });
+
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+
+      const tierConfig: StorageImageTierConfig = { autoMaxWidth: 1920 };
+      const handler = storageRoutes(storage, undefined, tmpDir, tierConfig);
+      const { c } = mockContext(id, {}, { accept: "image/webp" });
+      const response = await handler(c as any);
+      expect(response.status).toBe(200);
+    });
 
-        it("앱 설정 없음 → 기본값 유지", async () => {
-            // __GENCOW_IMAGE_APP_CONFIG가 없을 때 기본 동작
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
-
-            const handler = storageRoutes(storage, undefined, tmpDir);
-            const { c } = mockContext(id, {}, { accept: "image/webp" });
-            const response = await handler(c as any);
-            expect(response.status).toBe(200);
-        });
+    it("앱 설정 없음 → 기본값 유지", async () => {
+      // __GENCOW_IMAGE_APP_CONFIG가 없을 때 기본 동작
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+
+      const handler = storageRoutes(storage, undefined, tmpDir);
+      const { c } = mockContext(id, {}, { accept: "image/webp" });
+      const response = await handler(c as any);
+      expect(response.status).toBe(200);
+    });
 
-        it("무효한 JSON → 파싱 무시 (에러 없음)", async () => {
-            process.env.__GENCOW_IMAGE_APP_CONFIG = "not-valid-json";
+    it("무효한 JSON → 파싱 무시 (에러 없음)", async () => {
+      process.env.__GENCOW_IMAGE_APP_CONFIG = "not-valid-json";
 
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
 
-            const handler = storageRoutes(storage, undefined, tmpDir);
-            const { c } = mockContext(id, {}, { accept: "image/webp" });
-            const response = await handler(c as any);
-            expect(response.status).toBe(200); // 에러 없이 기본값 사용
-        });
+      const handler = storageRoutes(storage, undefined, tmpDir);
+      const { c } = mockContext(id, {}, { accept: "image/webp" });
+      const response = await handler(c as any);
+      expect(response.status).toBe(200); // 에러 없이 기본값 사용
+    });
 
-        it("autoQuality 범위 초과 (101) → 무시", async () => {
-            process.env.__GENCOW_IMAGE_APP_CONFIG = JSON.stringify({ autoQuality: 101 });
+    it("autoQuality 범위 초과 (101) → 무시", async () => {
+      process.env.__GENCOW_IMAGE_APP_CONFIG = JSON.stringify({ autoQuality: 101 });
 
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
 
-            const handler = storageRoutes(storage, undefined, tmpDir);
-            const { c } = mockContext(id, {}, { accept: "image/webp" });
-            const response = await handler(c as any);
-            expect(response.status).toBe(200);
-        });
+      const handler = storageRoutes(storage, undefined, tmpDir);
+      const { c } = mockContext(id, {}, { accept: "image/webp" });
+      const response = await handler(c as any);
+      expect(response.status).toBe(200);
+    });
 
-        it(".image-config.json 변경 → 동일 handler에서 새 config 반영 (파일 기반 hot-reload)", async () => {
-            // 1. .image-config.json에 mw320 설정
-            const fs = await import("fs");
-            const configPath = `${tmpDir}/.image-config.json`;
-            fs.writeFileSync(configPath, JSON.stringify({ autoMaxWidth: 320 }));
-
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
-
-            const handler = storageRoutes(storage, undefined, tmpDir, { autoMaxWidth: 1920 });
-            const { c: c1 } = mockContext(id, {}, { accept: "image/webp" });
-            const response1 = await handler(c1 as any);
-            expect(response1.status).toBe(200);
-
-            // 2. 파일을 mw1920으로 변경 (앱 재시작 없이)
-            fs.writeFileSync(configPath, JSON.stringify({ autoMaxWidth: 1920 }));
-
-            // 3. 동일 handler로 다시 요청 → 새 config 반영되어야 함
-            const { c: c2 } = mockContext(id, {}, { accept: "image/webp" });
-            const response2 = await handler(c2 as any);
-            expect(response2.status).toBe(200);
-            // 두 요청 모두 성공 — config 파일이 매 요청마다 읽히므로 재시작 불필요
-        });
+    it(".image-config.json 변경 → 동일 handler에서 새 config 반영 (파일 기반 hot-reload)", async () => {
+      // 1. .image-config.json에 mw320 설정
+      const fs = await import("fs");
+      const configPath = `${tmpDir}/.image-config.json`;
+      fs.writeFileSync(configPath, JSON.stringify({ autoMaxWidth: 320 }));
+
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+
+      const handler = storageRoutes(storage, undefined, tmpDir, { autoMaxWidth: 1920 });
+      const { c: c1 } = mockContext(id, {}, { accept: "image/webp" });
+      const response1 = await handler(c1 as any);
+      expect(response1.status).toBe(200);
+
+      // 2. 파일을 mw1920으로 변경 (앱 재시작 없이)
+      fs.writeFileSync(configPath, JSON.stringify({ autoMaxWidth: 1920 }));
+
+      // 3. 동일 handler로 다시 요청 → 새 config 반영되어야 함
+      const { c: c2 } = mockContext(id, {}, { accept: "image/webp" });
+      const response2 = await handler(c2 as any);
+      expect(response2.status).toBe(200);
+      // 두 요청 모두 성공 — config 파일이 매 요청마다 읽히므로 재시작 불필요
+    });
 
-        it("config 파일 삭제 → 기본값으로 복원 (파일 기반 hot-reload)", async () => {
-            // 1. 커스텀 config 파일 생성
-            const fs = await import("fs");
-            const configPath = `${tmpDir}/.image-config.json`;
-            fs.writeFileSync(configPath, JSON.stringify({ autoMaxWidth: 320, autoQuality: 50 }));
-
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
-
-            const handler = storageRoutes(storage, undefined, tmpDir);
-            const { c: c1 } = mockContext(id, {}, { accept: "image/webp" });
-            await handler(c1 as any);
-
-            // 2. config 파일 삭제 (리셋)
-            fs.unlinkSync(configPath);
-
-            // 3. 동일 handler → 기본값 사용
-            const { c: c2 } = mockContext(id, {}, { accept: "image/webp" });
-            const response2 = await handler(c2 as any);
-            expect(response2.status).toBe(200);
-        });
+    it("config 파일 삭제 → 기본값으로 복원 (파일 기반 hot-reload)", async () => {
+      // 1. 커스텀 config 파일 생성
+      const fs = await import("fs");
+      const configPath = `${tmpDir}/.image-config.json`;
+      fs.writeFileSync(configPath, JSON.stringify({ autoMaxWidth: 320, autoQuality: 50 }));
+
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+
+      const handler = storageRoutes(storage, undefined, tmpDir);
+      const { c: c1 } = mockContext(id, {}, { accept: "image/webp" });
+      await handler(c1 as any);
+
+      // 2. config 파일 삭제 (리셋)
+      fs.unlinkSync(configPath);
+
+      // 3. 동일 handler → 기본값 사용
+      const { c: c2 } = mockContext(id, {}, { accept: "image/webp" });
+      const response2 = await handler(c2 as any);
+      expect(response2.status).toBe(200);
+    });
 
-        it("config 파일 파싱 — autoWebp=false → WebP 변환 미적용", async () => {
-            const fs = await import("fs");
-            const configPath = `${tmpDir}/.image-config.json`;
-            // autoWebp=false로 설정
-            fs.writeFileSync(configPath, JSON.stringify({ autoWebp: false }));
-
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
-
-            const handler = storageRoutes(storage, undefined, tmpDir, { autoWebp: true });
-            const { c } = mockContext(id, {}, { accept: "image/webp" });
-            const response = await handler(c as any);
-            expect(response.status).toBe(200);
-            // autoWebp=false → Content-Type이 원본(image/png)으로 유지되어야 함
-            // sharp 미설치 시 원본 서빙이므로 항상 image/png
-            const ct = response.headers.get("content-type");
-            expect(ct).toBe("image/png");
-        });
+    it("config 파일 파싱 — autoWebp=false → WebP 변환 미적용", async () => {
+      const fs = await import("fs");
+      const configPath = `${tmpDir}/.image-config.json`;
+      // autoWebp=false로 설정
+      fs.writeFileSync(configPath, JSON.stringify({ autoWebp: false }));
+
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+
+      const handler = storageRoutes(storage, undefined, tmpDir, { autoWebp: true });
+      const { c } = mockContext(id, {}, { accept: "image/webp" });
+      const response = await handler(c as any);
+      expect(response.status).toBe(200);
+      // autoWebp=false → Content-Type이 원본(image/png)으로 유지되어야 함
+      // sharp 미설치 시 원본 서빙이므로 항상 image/png
+      const ct = response.headers.get("content-type");
+      expect(ct).toBe("image/png");
+    });
 
-        it("config 파일 파싱 — Tier ceiling 초과 값은 clamp", async () => {
-            const fs = await import("fs");
-            const configPath = `${tmpDir}/.image-config.json`;
-            // autoMaxWidth=5000 (Tier ceiling 1920 초과)
-            fs.writeFileSync(configPath, JSON.stringify({ autoMaxWidth: 5000 }));
-
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
-
-            // Tier ceiling = 1920
-            const handler = storageRoutes(storage, undefined, tmpDir, { autoMaxWidth: 1920 });
-            const { c } = mockContext(id, {}, { accept: "image/webp" });
-            const response = await handler(c as any);
-            expect(response.status).toBe(200);
-            // config의 5000이 Tier ceiling 1920으로 clamp되어야 함
-            // sharp 미설치 → 원본 서빙이지만, 파싱 자체가 에러 없이 동작하는지 확인
-        });
+    it("config 파일 파싱 — Tier ceiling 초과 값은 clamp", async () => {
+      const fs = await import("fs");
+      const configPath = `${tmpDir}/.image-config.json`;
+      // autoMaxWidth=5000 (Tier ceiling 1920 초과)
+      fs.writeFileSync(configPath, JSON.stringify({ autoMaxWidth: 5000 }));
+
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+
+      // Tier ceiling = 1920
+      const handler = storageRoutes(storage, undefined, tmpDir, { autoMaxWidth: 1920 });
+      const { c } = mockContext(id, {}, { accept: "image/webp" });
+      const response = await handler(c as any);
+      expect(response.status).toBe(200);
+      // config의 5000이 Tier ceiling 1920으로 clamp되어야 함
+      // sharp 미설치 → 원본 서빙이지만, 파싱 자체가 에러 없이 동작하는지 확인
+    });
 
-        it("config 파일 파싱 — 잘못된 JSON → 기본값 fallback (에러 없음)", async () => {
-            const fs = await import("fs");
-            const configPath = `${tmpDir}/.image-config.json`;
-            // 잘못된 JSON
-            fs.writeFileSync(configPath, "{ invalid json !!!");
-
-            const storage = createStorage(tmpDir);
-            const pngBuffer = Buffer.from(
-                "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-                "base64"
-            );
-            const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
-
-            const handler = storageRoutes(storage, undefined, tmpDir, { autoMaxWidth: 1920 });
-            const { c } = mockContext(id, {}, { accept: "image/webp" });
-            // 잘못된 JSON이 에러 없이 기본값으로 fallback
-            const response = await handler(c as any);
-            expect(response.status).toBe(200);
-        });
+    it("config 파일 파싱 — 잘못된 JSON → 기본값 fallback (에러 없음)", async () => {
+      const fs = await import("fs");
+      const configPath = `${tmpDir}/.image-config.json`;
+      // 잘못된 JSON
+      fs.writeFileSync(configPath, "{ invalid json !!!");
+
+      const storage = createStorage(tmpDir);
+      const pngBuffer = Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+        "base64",
+      );
+      const id = await storage.storeBuffer(pngBuffer, "test.png", "image/png");
+
+      const handler = storageRoutes(storage, undefined, tmpDir, { autoMaxWidth: 1920 });
+      const { c } = mockContext(id, {}, { accept: "image/webp" });
+      // 잘못된 JSON이 에러 없이 기본값으로 fallback
+      const response = await handler(c as any);
+      expect(response.status).toBe(200);
     });
+  });
 });