sonamu 0.7.53 → 0.8.0

package/dist/api/sonamu.js

@@ -5,9 +5,10 @@ import fs from "node:fs/promises";
 import mime, { lookup as mimeLookup } from "mime-types";
 import os from "os";
 import path from "path";
-import { BASE_FIELD_MAPPINGS, convertFastifyHeadersToStandard, createMockSSEFactory, DB, isDaemonServer, merge } from "../index.js";
+import { BASE_FIELD_MAPPINGS, convertFastifyHeadersToStandard, createMockSSEFactory, DB, isDaemonServer, merge, NotFoundException } from "../index.js";
 import { applyCacheHeaders, CachePresets } from "../cache-control/cache-control.js";
 import { toFastifyCompressOption } from "../compress/compress.js";
+import { SD } from "../dict/sd.js";
 import { Naite } from "../naite/naite.js";
 import { BufferedFile } from "../storage/buffered-file.js";
 import { UploadedFile } from "../storage/uploaded-file.js";
@@ -275,7 +276,6 @@ class SonamuClass {
             const { sonamuUIApiPlugin } = await import("../ui/api.js");
             server.register(sonamuUIApiPlugin);
         }
-        // 로컬/프로덕션 환경 분기
         const webPath = path.join(this.appRootPath, "web");
         const hasWeb = await exists(webPath);
         // 전역 compress 옵션 계산 (route.compress: true일 때 사용)
@@ -293,9 +293,13 @@ class SonamuClass {
             customTypes: pluginCompress.customTypes
         } : undefined;
         if (isLocal()) {
-            // 로컬 개발 환경: Vite Dev Server + 통합 핸들러
-            if (hasWeb) {
-                await this.setupViteDevServer(server, webPath, config, globalCompressOptions);
+            // 로컬 개발 환경: catch-all로 API를 동적 매칭하여 HMR을 지원합니다.
+            // SONAMU_DISABLE_INTEGRATED_WEB=yes로 설정하면 dev_api 모드에서 Vite 통합을 비활성화할 수 있습니다.
+            const disableIntegratedWeb = process.env.SONAMU_DISABLE_INTEGRATED_WEB === "yes";
+            if (hasWeb && !disableIntegratedWeb) {
+                await this.setupDevServerWithVite(server, webPath, config);
+            } else {
+                this.setupDevServer(server, config);
             }
         } else {
             // 프로덕션 환경: 개별 API 라우트 + 정적 파일 서빙
@@ -310,14 +314,70 @@ class SonamuClass {
                     compress: toFastifyCompressOption(api.options.compress, globalCompressOptions)
                 });
             }
-            if (hasWeb) {
-                await this.setupStaticWebServer(server, webPath, config, globalCompressOptions);
+            // 프로덕션에서는 web 소스(appRoot/web) 유무와 무관하게,
+            // api/web-dist 존재 여부를 setupStaticWebServer 내부에서 판단합니다.
+            await this.setupStaticWebServer(server, config, globalCompressOptions);
+        }
+    }
+    /**
+   * dev 모드 공통: catch-all에서 syncer.apis를 동적으로 탐색하여 API 요청을 처리합니다.
+   * server.route()로 개별 등록하면 handler가 고정되어 HMR이 동작하지 않으므로,
+   * 매 요청마다 syncer.apis를 조회하는 이 방식을 사용합니다.
+   *
+   * 요청이 /api(정확히는 this.config.api.route.prefix)로 시작하지 않는 경우라면 null을 반환하며 끝냅니다.
+   */ handleDevApiRequest(request, config) {
+        const url = this.getPathnameFromUrl(request.url);
+        const method = request.method;
+        if (!url.startsWith(this.config.api.route.prefix)) {
+            return null;
+        }
+        // syncer.apis의 path는 :param 형태를 포함할 수 있으므로 세그먼트 단위로 매칭합니다.
+        // 정규식 생성 방식은 path 문자열 내 특수문자(., +, (, [ 등)로 오작동할 수 있어 사용하지 않습니다.
+        const matchedApi = this.syncer.apis.find((api)=>{
+            if (this.syncer.models[api.modelName] === undefined) {
+                return false;
             }
+            const apiMethod = api.options.httpMethod ?? "GET";
+            if (apiMethod !== method) return false;
+            const fullPath = this.config.api.route.prefix + api.path;
+            return this.isPathPatternMatch(fullPath, url);
+        });
+        if (!matchedApi) {
+            throw new NotFoundException(SD("error.api.notFound"));
         }
+        return this.createApiHandler(matchedApi, config);
+    }
+    /**
+   * dev api 모드: Vite 없이 API 동적 라우팅만 제공합니다.
+   * HMR을 위해 catch-all에서 매 요청마다 syncer.apis를 조회합니다.
+   */ setupDevServer(server, config) {
+        server.route({
+            method: [
+                "GET",
+                "HEAD",
+                "POST",
+                "PUT",
+                "DELETE",
+                "PATCH"
+            ],
+            url: `${this.config.api.route.prefix}/*`,
+            handler: async (request, reply)=>{
+                const handler = this.handleDevApiRequest(request, config);
+                if (handler) {
+                    return handler(request, reply);
+                }
+                // 사실 /api로 시작하지 않는 요청은 여기에 들어오지도 않을 거라 이 라인은 도달 불가능입니다만,
+                // 안전빵으로 남겨놓습니다.
+                throw new NotFoundException(SD("error.api.notFound"));
+            }
+        });
     }
     // biome-ignore lint/suspicious/noExplicitAny: ViteDevServer 타입을 동적으로 로드해야 함
     viteServer = null;
-    async setupViteDevServer(server, webPath, config, globalCompressOptions) {
+    /**
+   * dev all 모드: Vite Dev Server를 통합하여 API + SSR + CSR을 모두 제공합니다.
+   * API 동적 매칭은 handleDevApiRequest를 공유합니다.
+   */ async setupDevServerWithVite(server, webPath, config) {
         // @fastify/middie 등록 (Connect-style middleware 지원)
         await server.register((await import("@fastify/middie")).default);
         const vite = await import("vite");
@@ -340,48 +400,35 @@ class SonamuClass {
             // 나머지는 Vite middleware로 전달
             return this.viteServer.middlewares(req, res, next);
         });
-        // API 동적 라우팅 (catch-all 전에 등록)
-        for (const api of this.syncer.apis){
-            if (this.syncer.models[api.modelName] === undefined) {
-                throw new Error(`정의되지 않은 모델에 접근 ${api.modelName}`);
-            }
-            server.route({
-                method: api.options.httpMethod ?? "GET",
-                url: this.config.api.route.prefix + api.path,
-                handler: this.createApiHandler(api, config),
-                compress: toFastifyCompressOption(api.options.compress, globalCompressOptions)
-            });
-        }
-        // SSR 라우트 개별 등록 (compress 옵션이 라우트별로 적용되도록)
-        const { getSSRRoutes, renderSSR } = await import("../ssr/index.js");
-        const ssrRoutes = getSSRRoutes();
-        for (const route of ssrRoutes){
-            server.route({
-                method: [
-                    "GET",
-                    "HEAD"
-                ],
-                url: route.path,
-                compress: toFastifyCompressOption(route.compress ?? true, globalCompressOptions),
-                handler: async (request, reply)=>{
-                    const url = request.url;
-                    console.log(`[SSR] Matched route: ${route.path}`);
-                    const params = this.extractPathParams(route.path, url);
-                    const html = await renderSSR(url, route, params, request, reply, config, this.viteServer);
-                    reply.type("text/html");
-                    return html;
-                }
-            });
-        }
-        // CSR fallback (SSR 라우트에 매칭되지 않는 모든 요청)
+        // catch-all 라우트에서 동적으로 API/SSR 처리
+        // 개발 환경에서는 라우트별 compress 옵션을 포기하고 HMR 이점을 취합니다.
         server.route({
             method: [
                 "GET",
-                "HEAD"
+                "HEAD",
+                "POST",
+                "PUT",
+                "DELETE",
+                "PATCH"
             ],
             url: "/*",
             handler: async (request, reply)=>{
+                // 1. API 요청 처리
+                const result = this.handleDevApiRequest(request, config);
+                if (result) {
+                    return result(request, reply);
+                }
                 const url = request.url;
+                // 2. SSR 라우트 처리
+                const { matchSSRRoute, renderSSR } = await import("../ssr/index.js");
+                const ssrMatch = matchSSRRoute(url);
+                if (ssrMatch) {
+                    console.log(`[SSR] Matched route: ${ssrMatch.route.path}`);
+                    const html = await renderSSR(url, ssrMatch.route, ssrMatch.params, request, reply, config, this.viteServer);
+                    reply.type("text/html");
+                    return html;
+                }
+                // 3. CSR fallback
                 try {
                     const fs = await import("node:fs/promises");
                     let template = await fs.readFile(path.join(this.viteServer.config.root, "index.html"), "utf-8");
@@ -402,12 +449,12 @@ class SonamuClass {
         });
         console.log("✓ Vite dev server integrated");
     }
-    async setupStaticWebServer(server, _webPath, config, globalCompressOptions) {
-        // 경로 명확화: api/public/web, api/dist/ssr
-        const webDistPath = path.join(this.apiRootPath, "public", "web");
-        const ssrPath = path.join(this.apiRootPath, "dist", "ssr");
+    async setupStaticWebServer(server, config, globalCompressOptions) {
+        // 경로 명확화: api/web-dist/client (정적 파일), api/web-dist/server (SSR entry), api/dist/ssr (SSR routes - API 소유)
+        const webDistPath = path.join(this.apiRootPath, "web-dist", "client");
+        const ssrPath = path.join(this.apiRootPath, "web-dist", "server");
         const ssrEntryPath = path.join(ssrPath, "entry-server.generated.js");
-        const ssrRoutesPath = path.join(ssrPath, "routes.js");
+        const ssrRoutesPath = path.join(this.apiRootPath, "dist", "ssr", "routes.js");
         if (!await exists(webDistPath)) {
             console.warn(`⚠ Web dist not found: ${webDistPath}`);
             return;
@@ -434,7 +481,13 @@ class SonamuClass {
         server.get("/assets/:filename", async (request, reply)=>{
             const requestedFile = request.params.filename;
             const assetsDir = path.join(webDistPath, "assets");
-            const assetPath = `/assets/${requestedFile}`;
+            const safeFilePath = this.resolvePathWithinBaseDir(assetsDir, requestedFile);
+            if (safeFilePath === null) {
+                reply.status(403).send();
+                return;
+            }
+            const normalizedRequestedFile = path.relative(assetsDir, safeFilePath).replace(/\\/g, "/");
+            const assetPath = `/assets/${normalizedRequestedFile}`;
             // Cache-Control 헤더 결정
             const getCacheControlForAsset = ()=>{
                 const cacheReq = {
@@ -452,8 +505,8 @@ class SonamuClass {
                 return CachePresets.immutable;
             };
             // index-*.js 또는 index-*.css 요청인 경우
-            if (/^index-[a-f0-9]+\.(js|css)$/.test(requestedFile)) {
-                const ext = requestedFile.split(".").pop();
+            if (/^index-[a-f0-9]+\.(js|css)$/.test(normalizedRequestedFile)) {
+                const ext = normalizedRequestedFile.split(".").pop();
                 const files = await fs.readdir(assetsDir);
                 const currentFile = files.find((f)=>f.startsWith("index-") && f.endsWith(`.${ext}`));
                 if (currentFile) {
@@ -465,17 +518,17 @@ class SonamuClass {
                 }
             }
             // 일반 파일 서빙
-            const filePath = path.join(assetsDir, requestedFile);
+            const filePath = safeFilePath;
             if (await exists(filePath)) {
                 const content = await fs.readFile(filePath);
-                const ext = requestedFile.split(".").pop();
+                const ext = normalizedRequestedFile.split(".").pop();
                 reply.type(ext === "js" ? "application/javascript" : ext === "css" ? "text/css" : "");
-                if (requestedFile.includes("-")) {
+                if (normalizedRequestedFile.includes("-")) {
                     applyCacheHeaders(reply, getCacheControlForAsset());
                 }
                 return reply.send(content);
             }
-            reply.code(404).send("Not found");
+            reply.status(404).send();
         });
         // SSR 라우트 개별 등록 (compress 옵션이 라우트별로 적용되도록)
         if (ssrAvailable) {
@@ -511,9 +564,7 @@ class SonamuClass {
             handler: async (request, reply)=>{
                 // /api, /sonamu-ui는 404 그대로
                 if (request.url.startsWith("/api") || request.url.startsWith("/sonamu-ui")) {
-                    reply.code(404).send({
-                        error: "Not Found"
-                    });
+                    reply.status(404).send();
                     return;
                 }
                 // CSR용 Cache-Control 헤더 설정
@@ -530,10 +581,15 @@ class SonamuClass {
                     }
                 }
                 // 정적 파일이 존재할 경우, 정적 파일을 먼저 서빙해야함
-                const filePath = path.join(webDistPath, request.url);
-                if (await fileExists(filePath)) {
-                    const content = await fs.readFile(filePath);
-                    return reply.type(mimeLookup(filePath) || "application/octet-stream").send(content);
+                const requestPath = this.getPathnameFromUrl(request.url);
+                const safeFilePath = this.resolvePathWithinBaseDir(webDistPath, requestPath);
+                if (safeFilePath === null) {
+                    reply.status(403).send();
+                    return;
+                }
+                if (await fileExists(safeFilePath)) {
+                    const content = await fs.readFile(safeFilePath);
+                    return reply.type(mimeLookup(safeFilePath) || "application/octet-stream").send(content);
                 }
                 // CSR fallback: index.html 서빙
                 const indexPath = path.join(webDistPath, "index.html");
@@ -668,7 +724,7 @@ class SonamuClass {
    * 예: pattern="/admin/companies/:companyId", url="/admin/companies/123" → { companyId: "123" }
    */ extractPathParams(pattern, url) {
         const patternParts = pattern.split("/").filter(Boolean);
-        const urlParts = url.split("?")[0].split("/").filter(Boolean);
+        const urlParts = this.getPathnameFromUrl(url).split("/").filter(Boolean);
         const params = {};
         for(let i = 0; i < patternParts.length; i++){
             if (patternParts[i].startsWith(":")) {
@@ -677,6 +733,44 @@ class SonamuClass {
         }
         return params;
     }
+    isPathPatternMatch(pattern, url) {
+        const patternParts = pattern.split("/").filter(Boolean);
+        const urlParts = this.getPathnameFromUrl(url).split("/").filter(Boolean);
+        if (patternParts.length !== urlParts.length) {
+            return false;
+        }
+        for(let i = 0; i < patternParts.length; i++){
+            const patternPart = patternParts[i];
+            const urlPart = urlParts[i];
+            if (patternPart.startsWith(":")) {
+                continue;
+            }
+            if (patternPart !== urlPart) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getPathnameFromUrl(url) {
+        return url.split("?")[0];
+    }
+    resolvePathWithinBaseDir(baseDir, inputPath) {
+        try {
+            const decoded = decodeURIComponent(inputPath).replace(/\\/g, "/");
+            if (decoded.includes("\0")) {
+                return null;
+            }
+            const relativePath = decoded.replace(/^\/+/, "");
+            const resolvedPath = path.resolve(baseDir, relativePath);
+            const relativeFromBase = path.relative(baseDir, resolvedPath);
+            if (relativeFromBase.startsWith("..") || path.isAbsolute(relativeFromBase)) {
+                return null;
+            }
+            return resolvedPath;
+        } catch  {
+            return null;
+        }
+    }
     /**
    * API 응답에 적용할 Cache-Control 설정을 결정합니다.
    * 우선순위: 개별 지정 > cacheControlHandler
@@ -800,7 +894,7 @@ class SonamuClass {
         });
     }
     /*
-     A function that automatically handles init and destroy when using Sonamu via scripts.    
+     A function that automatically handles init and destroy when using Sonamu via scripts.
   */ async runScript(fn) {
         await this.init(true, false, undefined, false);
         try {
@@ -1023,4 +1117,4 @@ export const Sonamu = new SonamuClass();
     return `uploads/${timestamp}-${random}.${ext}`;
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/api/sonamu.ts"],"sourcesContent":["import { dispose as logtapeDispose } from \"@logtape/logtape\";\nimport assert from \"assert\";\nimport { AsyncLocalStorage } from \"async_hooks\";\nimport type { Auth } from \"better-auth\";\nimport type { FSWatcher } from \"chokidar\";\nimport type { FastifyInstance, FastifyReply, FastifyRequest } from \"fastify\";\nimport fs from \"fs/promises\";\nimport type { IncomingMessage, Server, ServerResponse } from \"http\";\nimport mime, { lookup as mimeLookup } from \"mime-types\";\nimport os from \"os\";\nimport path from \"path\";\nimport type { PoolConfig } from \"pg\";\nimport type { ZodObject } from \"zod\";\nimport {\n  BASE_FIELD_MAPPINGS,\n  convertFastifyHeadersToStandard,\n  createMockSSEFactory,\n  DB,\n  isDaemonServer,\n  merge,\n} from \"..\";\nimport type { CacheConfig, CacheManager } from \"../cache/types\";\nimport { applyCacheHeaders, CachePresets } from \"../cache-control/cache-control\";\nimport type { CacheControlConfig, CacheControlRequest } from \"../cache-control/types\";\nimport { toFastifyCompressOption } from \"../compress/compress\";\nimport type { CompressOptions } from \"../compress/types\";\nimport type { SonamuDBConfig } from \"../database/db\";\nimport type { LocalizedString } from \"../dict/types\";\nimport { Naite } from \"../naite/naite\";\nimport { BufferedFile } from \"../storage/buffered-file\";\nimport type { StorageManager } from \"../storage/storage-manager\";\nimport type { KeyGenerator } from \"../storage/types\";\nimport { UploadedFile } from \"../storage/uploaded-file\";\nimport type { Syncer } from \"../syncer/syncer\";\nimport type { WorkflowManager } from \"../tasks/workflow-manager\";\nimport type { SonamuFastifyConfig } from \"../types/types\";\nimport { exists, fileExists } from \"../utils/fs-utils\";\nimport type { AbsolutePath } from \"../utils/path-utils\";\nimport type { SonamuConfig, SonamuServerOptions, SonamuTaskOptions } from \"./config\";\nimport type { Context } from \"./context\";\nimport type { ExtendedApi } from \"./decorators\";\nimport { getSecrets, type SonamuSecrets } from \"./secret\";\n\nclass SonamuClass {\n  public isInitialized: boolean = false;\n  public forTesting: boolean = false;\n  public asyncLocalStorage: AsyncLocalStorage<{\n    context: Context;\n  }> = new AsyncLocalStorage();\n\n  public getContext(): Context {\n    const store = this.asyncLocalStorage.getStore();\n    if (store?.context) {\n      return store.context as Context;\n    }\n\n    if (process.env.NODE_ENV === \"test\") {\n      // 테스팅 환경에서 컨텍스트가 주입되지 않은 경우 빈 컨텍스트 리턴\n      return {\n        request: null,\n        reply: null,\n        headers: {},\n        createSSE: (schema: ZodObject) => createMockSSEFactory(schema),\n        // biome-ignore lint/suspicious/noExplicitAny: 테스팅 환경에서 컨텍스트가 주입되지 않은 경우 빈 컨텍스트 리턴\n        naiteStore: new Map<string, any>(),\n      } as unknown as Context;\n    } else {\n      throw new Error(\"Sonamu cannot find context\");\n    }\n  }\n\n  private _apiRootPath: AbsolutePath | null = null;\n  set apiRootPath(apiRootPath: AbsolutePath) {\n    this._apiRootPath = apiRootPath;\n  }\n  get apiRootPath(): AbsolutePath {\n    if (this._apiRootPath === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n    return this._apiRootPath;\n  }\n  get appRootPath(): string {\n    return this.apiRootPath.split(path.sep).slice(0, -1).join(path.sep);\n  }\n\n  private _dbConfig: SonamuDBConfig | null = null;\n  set dbConfig(dbConfig: SonamuDBConfig) {\n    this._dbConfig = dbConfig;\n  }\n  get dbConfig(): SonamuDBConfig {\n    if (this._dbConfig === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n    return this._dbConfig;\n  }\n\n  private _syncer: Syncer | null = null;\n  set syncer(syncer: Syncer) {\n    this._syncer = syncer;\n  }\n  get syncer(): Syncer {\n    if (this._syncer === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n    return this._syncer;\n  }\n\n  private _config: SonamuConfig | null = null;\n  set config(config: SonamuConfig) {\n    this._config = config;\n  }\n  get config(): SonamuConfig {\n    if (this._config === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n    return this._config;\n  }\n\n  public readonly secrets: SonamuSecrets = getSecrets();\n\n  private _storage: StorageManager | null = null;\n  /**\n   * StorageManager 인스턴스\n   */\n  get storage(): StorageManager {\n    if (!this._storage) {\n      throw new Error(\"Storage has not been initialized. Check storage config.\");\n    }\n    return this._storage;\n  }\n\n  private _cache: CacheManager | null = null;\n  /**\n   * CacheManager 인스턴스 (BentoCache)\n   */\n  get cache(): CacheManager {\n    if (!this._cache) {\n      throw new Error(\"Cache has not been initialized. Check cache config in sonamu.config.ts.\");\n    }\n    return this._cache;\n  }\n\n  private _workflows: WorkflowManager | null = null;\n  get workflows(): WorkflowManager {\n    if (this._workflows === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n\n    return this._workflows;\n  }\n\n  private _auth: Auth | null = null;\n  get auth(): Auth {\n    if (!this._auth) {\n      throw new Error(\"Auth has not been initialized. Check auth config in sonamu.config.ts.\");\n    }\n    return this._auth;\n  }\n\n  // HMR 처리\n  public watcher: FSWatcher | null = null;\n  private pendingFiles: string[] = [];\n  private hmrStartTime: number = 0;\n\n  public server: FastifyInstance | null = null;\n\n  async initForTesting() {\n    await this.init(true, false, undefined, true);\n  }\n\n  async init(\n    doSilent: boolean = false,\n    enableSync: boolean = true,\n    apiRootPath?: AbsolutePath,\n    forTesting: boolean = false,\n  ) {\n    this.forTesting = forTesting;\n\n    if (this.isInitialized) {\n      return;\n    }\n\n    if (!doSilent) {\n      const chalk = (await import(\"chalk\")).default;\n      console.time(chalk.cyan(`Sonamu.init${forTesting ? \" for testing\" : \"\"}`));\n    }\n\n    // API 루트 패스\n    const { findApiRootPath } = await import(\"../utils/utils\");\n    this.apiRootPath = apiRootPath ?? findApiRootPath();\n\n    // 설정을 로딩하는 것부터 시작\n    const { loadConfig } = await import(\"./config\");\n    this.config = await loadConfig(this.apiRootPath);\n    // sonamu.config.ts 기본값 설정\n    this.config.database.database = this.config.database.database ?? \"pg\";\n    this.config.database.defaultOptions.client = this.config.database.database ?? \"pg\";\n\n    // 로깅 설정\n    const { configureLogTape } = await import(\"../logger/configure\");\n    if (this.config.logging !== false) {\n      await configureLogTape({\n        ...this.config.logging,\n      });\n    }\n\n    // DB 로드\n    const { DB } = await import(\"../database/db\");\n    this.dbConfig = DB.generateDBConfig(this.config.database);\n    if (!doSilent) {\n      const chalk = (await import(\"chalk\")).default;\n      console.log(chalk.green(\"DB Config Loaded!\"));\n    }\n\n    // Entity 로드\n    // 테스트에서도 Entity 정보는 필요합니다.\n    // upsert가 제대로 작동하려면 entity의 unique index 정보가 필요하기 때문입니다.\n    const { EntityManager } = await import(\"../entity/entity-manager\");\n    await EntityManager.autoload(doSilent);\n\n    // Cache 초기화\n    await this.initializeCache(this.config.server.cache, forTesting);\n\n    // 테스팅인 경우 싱크 없이 중단\n    if (forTesting) {\n      this.isInitialized = true;\n      return;\n    }\n\n    // Task 등록\n    await this.initializeWorkflows(this.config.tasks);\n\n    // Syncer\n    const { Syncer } = await import(\"../syncer/syncer\");\n    this.syncer = new Syncer();\n\n    // Autoload: Models / Types / APIs / Workflows / Templates / SSR Routes\n    await this.syncer.autoloadTypes();\n    await this.syncer.autoloadModels();\n    await this.syncer.autoloadApis();\n    await this.syncer.autoloadWorkflows();\n    const { TemplateManager } = await import(\"../template\");\n    await TemplateManager.autoload();\n    await this.syncer.autoloadSSRRoutes();\n\n    const { isLocal, isTest } = await import(\"../utils/controller\");\n    if (isLocal()) {\n      // 로컬에서는 코드 생성을 위해 Biome 셋업이 필요함 (현재 apiRootPath 전달하여 실행)\n      (await import(\"../utils/formatter\")).setupBiome(this.apiRootPath);\n    }\n\n    const { isHotReloadServer } = await import(\"../utils/controller\");\n    if (isLocal() && !isTest() && isHotReloadServer() && enableSync) {\n      await this.syncer.sync();\n      await this.startWatcher();\n    }\n\n    this.isInitialized = true;\n    if (!doSilent) {\n      const chalk = (await import(\"chalk\")).default;\n      console.timeEnd(chalk.cyan(\"Sonamu.init\"));\n    }\n  }\n\n  async createServer(initOptions?: { enableSync?: boolean; doSilent?: boolean }) {\n    if (this.isInitialized === false) {\n      await this.init(initOptions?.doSilent, initOptions?.enableSync);\n    }\n\n    const options = this.config.server;\n    const { default: fastify } = await import(\"fastify\");\n    const { getLogTapeFastifyLogger } = await import(\"@logtape/fastify\");\n    const server = fastify({\n      ...options.fastify,\n      logger:\n        this.config.logging !== false\n          ? getLogTapeFastifyLogger({\n              category: this.config.logging?.fastifyCategory ?? [\"fastify\"],\n            })\n          : undefined,\n    });\n    this.server = server;\n\n    // Storage 설정 → StorageManager 생성\n    if (options.storage) {\n      const { StorageManager } = await import(\"../storage/storage-manager\");\n      this._storage = new StorageManager(options.storage);\n    }\n\n    // 플러그인 등록\n    if (options.plugins) {\n      await this.registerPlugins(server, options.plugins);\n    }\n\n    if (options.auth) {\n      await this.registerBetterAuth(server, options.auth);\n    }\n\n    // API 라우팅 설정\n    await this.withFastify(server, options.apiConfig, {\n      enableSync: initOptions?.enableSync,\n      doSilent: initOptions?.doSilent,\n    });\n\n    // 서버 시작\n    await this.boot(server, options);\n\n    return server;\n  }\n\n  async withFastify(\n    server: FastifyInstance<Server, IncomingMessage, ServerResponse>,\n    config: SonamuFastifyConfig,\n    options?: {\n      enableSync?: boolean;\n      doSilent?: boolean;\n    },\n  ) {\n    if (this.isInitialized === false) {\n      await this.init(options?.doSilent, options?.enableSync);\n    }\n\n    this.server = server;\n\n    // timezone 설정\n    const timezone = this.config.api.timezone;\n    if (timezone) {\n      // 타임존에 맞게 응답 날짜 스트링을 변환해주어야 합니다.\n      // 가령 timezone이 \"Asia/Seoul\" 이면\n      // \"2025-11-21T00:00:00.000Z\" 를 \"2025-11-21T09:00:00+09:00\" 으로 변환해주어야 합니다.\n      const { formatInTimeZone } = await import(\"date-fns-tz\");\n\n      // ISO 8601 날짜 형식 정규식 (예: 2024-01-15T09:30:00.000Z)\n      const ISO_DATE_REGEX = /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d{3})?Z$/;\n\n      // T를 둘러싼 작은따옴표가 없다면 \"2025-11-19176354618900018:56:29+09:00\"와 같은 결과가 나옵니다.\n      // 이는 date-fns 특입니다.\n      // 이렇게 해도 괜찮습니다. \"2025-11-19T18:56:29+09:00\" 모양으로 잘 나옵니다.\n      const DATE_FORMAT = \"yyyy-MM-dd'T'HH:mm:ssXXX\";\n\n      server.setReplySerializer((payload) => {\n        return JSON.stringify(payload, (_key, value) => {\n          if (typeof value === \"string\" && ISO_DATE_REGEX.test(value)) {\n            return formatInTimeZone(\n              new Date(value),\n              timezone as `${string}/${string}`,\n              DATE_FORMAT,\n            );\n          }\n          return value;\n        });\n      });\n      if (!options?.doSilent) {\n        const chalk = (await import(\"chalk\")).default;\n        console.log(chalk.green(`Timezone set to ${timezone}`));\n      }\n    }\n\n    // 전체 라우팅 리스트\n    server.get(\n      `${this.config.api.route.prefix}/routes`,\n      async (_request, _reply): Promise<typeof this.syncer.apis> => {\n        return this.syncer.apis;\n      },\n    );\n\n    // Healthcheck API\n    server.get(\n      `${this.config.api.route.prefix}/healthcheck`,\n      async (_request, _reply): Promise<string> => {\n        return \"ok\";\n      },\n    );\n\n    // Sonamu UI API (로컬 환경에서만)\n    const { isLocal } = await import(\"../utils/controller\");\n    if (isLocal()) {\n      const { sonamuUIApiPlugin } = await import(\"../ui/api\");\n      server.register(sonamuUIApiPlugin);\n    }\n\n    // 로컬/프로덕션 환경 분기\n    const webPath = path.join(this.appRootPath, \"web\");\n    const hasWeb = await exists(webPath);\n\n    // 전역 compress 옵션 계산 (route.compress: true일 때 사용)\n    const pluginCompress = this.config.server.plugins?.compress;\n    const globalCompressOptions: CompressOptions | undefined = pluginCompress\n      ? pluginCompress === true\n        ? { threshold: 1024, encodings: [\"br\", \"gzip\", \"deflate\"] }\n        : {\n            threshold: pluginCompress.threshold,\n            encodings: pluginCompress.encodings,\n            customTypes: pluginCompress.customTypes,\n          }\n      : undefined;\n\n    if (isLocal()) {\n      // 로컬 개발 환경: Vite Dev Server + 통합 핸들러\n      if (hasWeb) {\n        await this.setupViteDevServer(server, webPath, config, globalCompressOptions);\n      }\n    } else {\n      // 프로덕션 환경: 개별 API 라우트 + 정적 파일 서빙\n      for (const api of this.syncer.apis) {\n        if (this.syncer.models[api.modelName] === undefined) {\n          throw new Error(`정의되지 않은 모델에 접근 ${api.modelName}`);\n        }\n\n        server.route({\n          method: api.options.httpMethod ?? \"GET\",\n          url: this.config.api.route.prefix + api.path,\n          handler: this.createApiHandler(api, config),\n          compress: toFastifyCompressOption(api.options.compress, globalCompressOptions),\n        });\n      }\n\n      if (hasWeb) {\n        await this.setupStaticWebServer(server, webPath, config, globalCompressOptions);\n      }\n    }\n  }\n\n  // biome-ignore lint/suspicious/noExplicitAny: ViteDevServer 타입을 동적으로 로드해야 함\n  private viteServer: any = null;\n\n  private async setupViteDevServer(\n    server: FastifyInstance<Server, IncomingMessage, ServerResponse>,\n    webPath: string,\n    config: SonamuFastifyConfig,\n    globalCompressOptions?: CompressOptions,\n  ): Promise<void> {\n    // @fastify/middie 등록 (Connect-style middleware 지원)\n    await server.register((await import(\"@fastify/middie\")).default);\n\n    const vite = await import(\"vite\");\n\n    this.viteServer = await vite.createServer({\n      root: webPath,\n      server: {\n        middlewareMode: true,\n        hmr: {\n          server: server.server,\n        },\n      },\n      appType: \"custom\",\n    });\n\n    // Vite middleware 등록 (Vite 에셋 처리)\n    server.use((req, res, next) => {\n      // API와 Sonamu UI는 Fastify 라우트가 처리하도록 skip\n      if (req.url?.startsWith(this.config.api.route.prefix) || req.url?.startsWith(\"/sonamu-ui\")) {\n        return next();\n      }\n      // 나머지는 Vite middleware로 전달\n      return this.viteServer.middlewares(req, res, next);\n    });\n\n    // API 동적 라우팅 (catch-all 전에 등록)\n    for (const api of this.syncer.apis) {\n      if (this.syncer.models[api.modelName] === undefined) {\n        throw new Error(`정의되지 않은 모델에 접근 ${api.modelName}`);\n      }\n\n      server.route({\n        method: api.options.httpMethod ?? \"GET\",\n        url: this.config.api.route.prefix + api.path,\n        handler: this.createApiHandler(api, config),\n        compress: toFastifyCompressOption(api.options.compress, globalCompressOptions),\n      });\n    }\n\n    // SSR 라우트 개별 등록 (compress 옵션이 라우트별로 적용되도록)\n    const { getSSRRoutes, renderSSR } = await import(\"../ssr\");\n    const ssrRoutes = getSSRRoutes();\n\n    for (const route of ssrRoutes) {\n      server.route({\n        method: [\"GET\", \"HEAD\"],\n        url: route.path,\n        compress: toFastifyCompressOption(route.compress ?? true, globalCompressOptions),\n        handler: async (request, reply) => {\n          const url = request.url;\n          console.log(`[SSR] Matched route: ${route.path}`);\n\n          const params = this.extractPathParams(route.path, url);\n          const html = await renderSSR(url, route, params, request, reply, config, this.viteServer);\n\n          reply.type(\"text/html\");\n          return html;\n        },\n      });\n    }\n\n    // CSR fallback (SSR 라우트에 매칭되지 않는 모든 요청)\n    server.route({\n      method: [\"GET\", \"HEAD\"],\n      url: \"/*\",\n      handler: async (request, reply) => {\n        const url = request.url;\n\n        try {\n          const fs = await import(\"node:fs/promises\");\n          let template = await fs.readFile(\n            path.join(this.viteServer.config.root, \"index.html\"),\n            \"utf-8\",\n          );\n          template = await this.viteServer.transformIndexHtml(url, template);\n\n          reply.type(\"text/html\");\n          return template;\n        } catch (e) {\n          this.viteServer.ssrFixStacktrace(e as Error);\n          console.error(e);\n          reply.status(500);\n          return (e as Error).message;\n        }\n      },\n    });\n\n    // 서버 종료 시 Vite도 종료\n    server.addHook(\"onClose\", async () => {\n      await this.viteServer.close();\n    });\n\n    console.log(\"✓ Vite dev server integrated\");\n  }\n\n  private async setupStaticWebServer(\n    server: FastifyInstance<Server, IncomingMessage, ServerResponse>,\n    _webPath: string,\n    config: SonamuFastifyConfig,\n    globalCompressOptions: CompressOptions | undefined,\n  ): Promise<void> {\n    // 경로 명확화: api/public/web, api/dist/ssr\n    const webDistPath = path.join(this.apiRootPath, \"public\", \"web\");\n    const ssrPath = path.join(this.apiRootPath, \"dist\", \"ssr\");\n    const ssrEntryPath = path.join(ssrPath, \"entry-server.generated.js\");\n    const ssrRoutesPath = path.join(ssrPath, \"routes.js\");\n\n    if (!(await exists(webDistPath))) {\n      console.warn(`⚠ Web dist not found: ${webDistPath}`);\n      return;\n    }\n\n    // SSR entry 존재 여부 확인\n    const ssrAvailable = await exists(ssrEntryPath);\n\n    if (!ssrAvailable) {\n      console.warn(`⚠ SSR entry not found: ${ssrEntryPath}`);\n      console.warn(\"  SSR will be disabled. Only CSR will work.\");\n    }\n\n    // SSR 라우트 로드 (production에서만, 사용자 프로젝트의 ssr/routes.ts)\n    if (ssrAvailable) {\n      if (await exists(ssrRoutesPath)) {\n        // ts-loader라면 \"file://\"로 시작하는 fully-resolved path만 받기에 이를 처리해주는 importMembers를 사용해야 했겠지만,\n        // 여기는 프로덕션 환경에서 loader 없이 돌아가기 때문에 \"진짜 js 파일\"의 \"그냥\" 절대경로를 바로 import해도 됩니다.\n        // 이 내용은 이 함수 내에서 아래에 나올 다른 import 호출에도 동일하게 적용됩니다.\n        await import(ssrRoutesPath);\n        console.log(\"✓ SSR routes loaded\");\n      } else {\n        console.warn(`⚠ SSR routes not found: ${ssrRoutesPath}`);\n      }\n    }\n\n    // 롤링 업데이트 대응: asset hash 불일치 시 현재 버전 직접 서빙\n    server.get(\"/assets/:filename\", async (request, reply) => {\n      const requestedFile = (request.params as { filename: string }).filename;\n      const assetsDir = path.join(webDistPath, \"assets\");\n      const assetPath = `/assets/${requestedFile}`;\n\n      // Cache-Control 헤더 결정\n      const getCacheControlForAsset = (): CacheControlConfig => {\n        const cacheReq: CacheControlRequest = {\n          type: \"assets\",\n          url: request.url,\n          path: assetPath,\n          method: request.method,\n        };\n\n        // 사용자 정의 핸들러 우선\n        if (config.cacheControlHandler) {\n          const result = config.cacheControlHandler(cacheReq);\n          if (result) return result;\n        }\n\n        // 기본값: immutable\n        return CachePresets.immutable;\n      };\n\n      // index-*.js 또는 index-*.css 요청인 경우\n      if (/^index-[a-f0-9]+\\.(js|css)$/.test(requestedFile)) {\n        const ext = requestedFile.split(\".\").pop();\n        const files = await fs.readdir(assetsDir);\n        const currentFile = files.find((f) => f.startsWith(\"index-\") && f.endsWith(`.${ext}`));\n\n        if (currentFile) {\n          const filePath = path.join(assetsDir, currentFile);\n          const content = await fs.readFile(filePath);\n          reply.type(ext === \"js\" ? \"application/javascript\" : \"text/css\");\n          applyCacheHeaders(reply, getCacheControlForAsset());\n          return reply.send(content);\n        }\n      }\n\n      // 일반 파일 서빙\n      const filePath = path.join(assetsDir, requestedFile);\n      if (await exists(filePath)) {\n        const content = await fs.readFile(filePath);\n        const ext = requestedFile.split(\".\").pop();\n        reply.type(ext === \"js\" ? \"application/javascript\" : ext === \"css\" ? \"text/css\" : \"\");\n        if (requestedFile.includes(\"-\")) {\n          applyCacheHeaders(reply, getCacheControlForAsset());\n        }\n        return reply.send(content);\n      }\n\n      reply.code(404).send(\"Not found\");\n    });\n\n    // SSR 라우트 개별 등록 (compress 옵션이 라우트별로 적용되도록)\n    if (ssrAvailable) {\n      const { getSSRRoutes } = await import(\"../ssr\");\n      const { renderSSR } = await import(\"../ssr/renderer\");\n      const ssrRoutes = getSSRRoutes();\n\n      for (const route of ssrRoutes) {\n        server.route({\n          method: [\"GET\", \"HEAD\"],\n          url: route.path,\n          compress: toFastifyCompressOption(route.compress ?? true, globalCompressOptions),\n          handler: async (request, reply) => {\n            const url = request.url;\n            console.log(`[SSR] Matched route: ${route.path}`);\n\n            const params = this.extractPathParams(route.path, url);\n            const html = await renderSSR(url, route, params, request, reply, config);\n\n            reply.type(\"text/html\");\n            return html;\n          },\n        });\n      }\n    }\n\n    // CSR or Static File Fallback (SSR 라우트에 매칭되지 않는 모든 요청)\n    server.route({\n      method: [\"GET\", \"HEAD\"],\n      url: \"*\",\n      handler: async (request, reply) => {\n        // /api, /sonamu-ui는 404 그대로\n        if (request.url.startsWith(\"/api\") || request.url.startsWith(\"/sonamu-ui\")) {\n          reply.code(404).send({ error: \"Not Found\" });\n          return;\n        }\n\n        // CSR용 Cache-Control 헤더 설정\n        if (config.cacheControlHandler) {\n          const csrCacheReq: CacheControlRequest = {\n            type: \"csr\",\n            url: request.url,\n            path: request.url.split(\"?\")[0],\n            method: request.method,\n          };\n          const csrCacheConfig = config.cacheControlHandler(csrCacheReq);\n\n          if (csrCacheConfig) {\n            applyCacheHeaders(reply, csrCacheConfig);\n          }\n        }\n\n        // 정적 파일이 존재할 경우, 정적 파일을 먼저 서빙해야함\n        const filePath = path.join(webDistPath, request.url);\n        if (await fileExists(filePath)) {\n          const content = await fs.readFile(filePath);\n          return reply.type(mimeLookup(filePath) || \"application/octet-stream\").send(content);\n        }\n\n        // CSR fallback: index.html 서빙\n        const indexPath = path.join(webDistPath, \"index.html\");\n        return reply.type(\"text/html\").send(await fs.readFile(indexPath, \"utf-8\"));\n      },\n    });\n\n    console.log(`✓ Static web server configured with ${ssrAvailable ? \"SSR\" : \"CSR only\"} support`);\n  }\n\n  createApiHandler(\n    api: ExtendedApi,\n    config: SonamuFastifyConfig,\n  ): (request: FastifyRequest, reply: FastifyReply) => Promise<unknown> {\n    return async (request: FastifyRequest, reply: FastifyReply): Promise<unknown> => {\n      // Context 생성\n      const context: Context = await this.createContext(config, request, reply);\n\n      return this.asyncLocalStorage.run({ context }, async () => {\n        // guards 처리\n        (api.options.guards ?? []).every((guard) => config.guardHandler(guard, request, api));\n\n        // 파라미터 정보로 zod 스키마 빌드\n        const { getZodObjectFromApi } = await import(\"./code-converters\");\n        const ReqType = getZodObjectFromApi(api, this.syncer.types);\n\n        // request 파싱\n        const which = api.options.httpMethod === \"GET\" ? \"query\" : \"body\";\n        let reqBody: {\n          [key: string]: unknown;\n        };\n        // 파일 업로드 있는 경우 임시 데이터\n        const files: {\n          bufferedFiles: BufferedFile[];\n          uploadedFiles: UploadedFile[];\n        } = {\n          bufferedFiles: [],\n          uploadedFiles: [],\n        };\n\n        try {\n          const body = (request[which] ?? {}) as Record<string, unknown>;\n          if (api.uploadOptions) {\n            const parts = request.parts({\n              limits: api.uploadOptions.limits,\n            });\n\n            // FormData의 field들을 임시로 저장\n            const fields: Record<string, string> = {};\n\n            if (api.uploadOptions.consume === \"buffer\" || !api.uploadOptions.consume) {\n              // Buffer 모드: 메모리에 로드\n              for await (const part of parts) {\n                if (part.type === \"file\") {\n                  // CRITICAL: 파일 스트림을 즉시 consume해야 다음 part로 넘어갈 수 있음\n                  // 이 호출이 없으면 종종 multipart 파싱이 pending 상태로 타임아웃 발생\n                  const buffer = await part.toBuffer();\n                  files.bufferedFiles.push(new BufferedFile(part, buffer));\n                } else if (part.type === \"field\") {\n                  fields[part.fieldname] = String(part.value);\n                }\n              }\n            } else if (api.uploadOptions.consume === \"stream\") {\n              // Stream 모드: 즉시 저장소로 스트리밍\n              const diskName = api.uploadOptions.destination;\n              const disk = this.storage.use(diskName);\n\n              // 우선순위: 데코레이터 > 전역 설정 > 기본값\n              const keyGenerator: KeyGenerator =\n                api.uploadOptions.keyGenerator ??\n                this.config.server.storage?.keyGenerator ??\n                defaultKeyGenerator;\n\n              for await (const part of parts) {\n                if (part.type === \"file\") {\n                  const key = await keyGenerator({\n                    filename: part.filename,\n                    mimetype: part.mimetype,\n                  });\n\n                  await disk.putStream(key, part.file, {\n                    contentType: part.mimetype,\n                  });\n\n                  const url = await disk.getUrl(key);\n                  const signedUrl = await disk.getSignedUrl(key);\n\n                  files.uploadedFiles.push(\n                    new UploadedFile({\n                      filename: part.filename,\n                      mimetype: part.mimetype,\n                      size: part.file.bytesRead,\n                      url,\n                      signedUrl,\n                      key,\n                      diskName,\n                    }),\n                  );\n                } else if (part.type === \"field\") {\n                  fields[part.fieldname] = String(part.value);\n                }\n              }\n            }\n\n            // qs로 중첩 구조 파싱: params[category] → { params: { category: \"test\" } }\n            const qs = await import(\"qs\");\n            const parsed = qs.default.parse(fields);\n            Object.assign(body, parsed);\n          }\n\n          const { fastifyCaster } = await import(\"./caster\");\n          reqBody = fastifyCaster(ReqType).parse(body);\n        } catch (e) {\n          const { ZodError } = await import(\"zod\");\n          if (e instanceof ZodError) {\n            const { humanizeZodError } = await import(\"../utils/zod-error\");\n            const messages = humanizeZodError(e)\n              .map((issue) => issue.message)\n              .join(\" \");\n            const { BadRequestException } = await import(\"../exceptions/so-exceptions\");\n            throw new BadRequestException(messages as LocalizedString, {\n              zodError: e,\n            });\n          } else {\n            throw e;\n          }\n        }\n\n        // Content-Type\n        reply.type(api.options.contentType ?? \"application/json\");\n\n        // Cache-Control 헤더 설정\n        const apiCacheConfig = this.getApiCacheControl(api, request, config);\n        if (apiCacheConfig) {\n          applyCacheHeaders(reply, apiCacheConfig);\n        }\n\n        // 업로드 옵션이 있는 경우 파일 데이터를 Context에 추가\n        if (api.uploadOptions) {\n          const consume = api.uploadOptions.consume ?? \"buffer\";\n          if (consume === \"buffer\") {\n            context.bufferedFiles = files.bufferedFiles;\n          } else if (consume === \"stream\") {\n            context.uploadedFiles = files.uploadedFiles;\n          }\n        }\n\n        // 모델 메소드 args 생성하여 호출\n        const { ApiParamType } = await import(\"../types/types\");\n        const args = api.parameters.map((param) => {\n          // Context 인젝션\n          if (ApiParamType.isContext(param.type)) {\n            return context;\n          } else {\n            return reqBody[param.name];\n          }\n        });\n\n        return this.invokeModelMethod(api, args, reply);\n      });\n    };\n  }\n\n  /**\n   * URL에서 path params를 추출합니다.\n   * 예: pattern=\"/admin/companies/:companyId\", url=\"/admin/companies/123\" → { companyId: \"123\" }\n   */\n  private extractPathParams(pattern: string, url: string): Record<string, string> {\n    const patternParts = pattern.split(\"/\").filter(Boolean);\n    const urlParts = url.split(\"?\")[0].split(\"/\").filter(Boolean);\n    const params: Record<string, string> = {};\n\n    for (let i = 0; i < patternParts.length; i++) {\n      if (patternParts[i].startsWith(\":\")) {\n        params[patternParts[i].slice(1)] = urlParts[i];\n      }\n    }\n    return params;\n  }\n\n  /**\n   * API 응답에 적용할 Cache-Control 설정을 결정합니다.\n   * 우선순위: 개별 지정 > cacheControlHandler\n   */\n  private getApiCacheControl(\n    api: ExtendedApi,\n    request: FastifyRequest,\n    config: SonamuFastifyConfig,\n  ) {\n    // 데코레이터 설정 우선\n    if (api.options.cacheControl) {\n      return api.options.cacheControl;\n    }\n\n    // 전역 핸들러\n    if (config.cacheControlHandler) {\n      const cacheReq: CacheControlRequest = {\n        type: \"api\",\n        url: request.url,\n        path: request.routeOptions?.url ?? request.url.split(\"?\")[0],\n        method: request.method,\n        api,\n      };\n      const result = config.cacheControlHandler(cacheReq);\n      if (result) return result;\n    }\n\n    return null;\n  }\n\n  /**\n   * SSR용 API 호출 (HTTP 오버헤드 없이 직접 호출)\n   * createApiHandler의 로직을 재사용하되, request 파싱 대신 params 직접 사용\n   */\n  async invokeApiForSSR(\n    api: ExtendedApi,\n    // biome-ignore lint/suspicious/noExplicitAny: SSR에서 다양한 타입의 params를 받아야 함\n    params: any[],\n    config: SonamuFastifyConfig,\n    request: FastifyRequest,\n    reply: FastifyReply,\n  ): Promise<unknown> {\n    // Context 생성 (기존 메소드 재사용)\n    const context = await this.createContext(config, request, reply);\n\n    return this.asyncLocalStorage.run({ context }, async () => {\n      // args 생성: Context 파라미터는 주입, 나머지는 params에서 가져오기\n      const { ApiParamType } = await import(\"../types/types\");\n      let paramsIndex = 0;\n      const args = api.parameters.map((param) => {\n        if (ApiParamType.isContext(param.type)) {\n          return context;\n        }\n        return params[paramsIndex++];\n      });\n\n      // 모델 메서드 호출 (기존 메서드 재사용)\n      return this.invokeModelMethod(api, args, reply);\n    });\n  }\n\n  async invokeModelMethod(\n    api: ExtendedApi,\n    args: unknown[],\n    reply: FastifyReply,\n  ): Promise<unknown> {\n    const model = this.syncer.models[api.modelName];\n    // biome-ignore lint/suspicious/noExplicitAny: model은 모델 인스턴스이므로 메서드 호출 가능\n    const result = await (model as any)[api.methodName].apply(model, args);\n    reply.type(api.options.contentType ?? \"application/json\");\n\n    return result;\n  }\n\n  async createContext(\n    config: SonamuFastifyConfig,\n    request: FastifyRequest,\n    reply: FastifyReply,\n  ): Promise<Context> {\n    // createSSEFactory 함수에 미리 request의 socket과 reply를 바인딩.\n    const { createSSEFactory } = await import(\"../stream/sse\");\n    const createSSE = (<T extends ZodObject>(\n      _request: FastifyRequest,\n      _reply: FastifyReply,\n      _events: T,\n    ) => createSSEFactory(_request.socket, _reply, _events)).bind(null, request, reply);\n\n    // locale 감지\n    const locale =\n      this.detectLocale(request.headers[\"accept-language\"], this.config.i18n.supportedLocales) ??\n      this.config.i18n.defaultLocale;\n\n    // auth context 추가\n    const headers = convertFastifyHeadersToStandard(request.headers);\n    const session = (await this._auth?.api.getSession({ headers })) ?? null;\n\n    const context: Context = {\n      ...(await Promise.resolve(\n        config.contextProvider(\n          {\n            request,\n            reply,\n            headers: request.headers,\n            createSSE,\n            naiteStore: Naite.createStore(),\n            locale,\n            // auth\n            user: session?.user ?? null,\n            session: session?.session ?? null,\n          },\n          request,\n          reply,\n        ),\n      )),\n    };\n    return context;\n  }\n\n  /**\n   * Accept-Language 헤더에서 지원하는 locale을 찾습니다.\n   * @example \"ko-KR,ko;q=0.9,en;q=0.8\" → \"ko\"\n   */\n  private detectLocale(\n    acceptLanguage: string | undefined,\n    supported: string[],\n  ): string | undefined {\n    if (!acceptLanguage) return undefined;\n\n    // Accept-Language: ko-KR,ko;q=0.9,en;q=0.8\n    const langs = acceptLanguage.split(\",\").map((lang) => {\n      const [code] = lang.split(\";\");\n      return code.trim().split(\"-\")[0]; // ko-KR → ko\n    });\n\n    return langs.find((lang) => supported.includes(lang));\n  }\n\n  async startWatcher(): Promise<void> {\n    const watchPath = [path.join(this.apiRootPath, \"src\")];\n\n    const chokidar = (await import(\"chokidar\")).default;\n    this.watcher = chokidar.watch(watchPath, {\n      ignored: (path, stats) =>\n        !!stats?.isFile() && !path.endsWith(\".ts\") && !path.endsWith(\".json\"),\n      persistent: true,\n      ignoreInitial: true,\n    });\n\n    this.watcher.on(\"all\", async (event: string, filePath: string) => {\n      const absolutePath = filePath as AbsolutePath;\n      assert(\n        absolutePath.startsWith(this.apiRootPath),\n        \"File path is not within the API root path\",\n      );\n\n      if (event !== \"change\" && event !== \"add\") {\n        return;\n      }\n\n      try {\n        // sonamu.config.ts 변경 시 재시작\n        const isConfigTs = filePath === path.join(this.apiRootPath, \"src\", \"sonamu.config.ts\");\n\n        if (isConfigTs) {\n          const relativePath = filePath.replace(this.apiRootPath, \"api\");\n          const chalk = (await import(\"chalk\")).default;\n          console.log(\n            chalk.bold(`Detected(${event}): ${chalk.blue(relativePath)} - Restarting...`),\n          );\n          process.kill(process.pid, \"SIGUSR2\");\n          return;\n        }\n\n        await this.handleFileChange(event, absolutePath);\n      } catch (e) {\n        console.error(e);\n      }\n    });\n  }\n\n  /*\n     A function that automatically handles init and destroy when using Sonamu via scripts.    \n  */\n  async runScript(fn: () => Promise<void>) {\n    await this.init(true, false, undefined, false);\n    try {\n      await fn();\n    } finally {\n      await this.destroy();\n    }\n  }\n\n  private async registerPlugins(server: FastifyInstance, plugins: SonamuServerOptions[\"plugins\"]) {\n    if (!plugins) {\n      return;\n    }\n\n    // compress 플러그인은 다른 플러그인보다 먼저 등록되어야 합니다.\n    if (plugins.compress) {\n      const compressPlugin = (await import(\"@fastify/compress\")).default;\n      const defaultOptions = {\n        threshold: 1024,\n        encodings: [\"br\", \"gzip\", \"deflate\"] as (\"br\" | \"gzip\" | \"deflate\")[],\n      };\n\n      if (plugins.compress === true) {\n        server.register(compressPlugin, defaultOptions);\n      } else {\n        server.register(compressPlugin, {\n          ...defaultOptions,\n          ...plugins.compress,\n        });\n      }\n    }\n\n    const pluginsModules = {\n      cors: \"@fastify/cors\",\n      formbody: \"@fastify/formbody\",\n      multipart: \"@fastify/multipart\",\n      qs: \"fastify-qs\",\n      sse: \"fastify-sse-v2\",\n      static: \"@fastify/static\",\n    } as const;\n\n    const registerPlugin = async <K extends keyof NonNullable<typeof plugins>>(\n      key: K,\n      pluginName: string,\n    ) => {\n      const option = plugins[key];\n      if (!option) return;\n\n      if (option === true) {\n        server.register((await import(pluginName)).default);\n      } else {\n        server.register((await import(pluginName)).default, option);\n      }\n    };\n\n    for (const [key, pluginName] of Object.entries(pluginsModules)) {\n      await registerPlugin(key as keyof typeof plugins, pluginName);\n    }\n\n    if (plugins.custom) {\n      plugins.custom(server);\n    }\n  }\n\n  /**\n   * better-auth 라우트를 등록합니다.\n   * /api/auth/* 경로로 인증 API가 자동 등록됩니다.\n   */\n  private async registerBetterAuth(\n    server: FastifyInstance,\n    options: NonNullable<SonamuServerOptions[\"auth\"]>,\n  ) {\n    if (!options) return;\n\n    const basePath = options.basePath ?? \"/api/auth\";\n\n    // 사용자 설정과 기본값을 merge\n    const mergedFieldMappings = merge(BASE_FIELD_MAPPINGS, options);\n\n    // better-auth 인스턴스 생성\n    const { betterAuth } = await import(\"better-auth\");\n    const { Pool } = await import(\"pg\");\n\n    this._auth = betterAuth({\n      database: new Pool(DB.getDBConfig(\"w\").connection as PoolConfig),\n      ...mergedFieldMappings,\n    });\n\n    // better-auth 라우트 등록\n    server.route({\n      method: [\"GET\", \"POST\"],\n      url: `${basePath}/*`,\n      handler: async (request, reply) => {\n        const url = new URL(request.url, `http://${request.headers.host}`);\n        const headers = convertFastifyHeadersToStandard(request.headers);\n        const req = new Request(url.toString(), {\n          method: request.method,\n          headers,\n          ...(request.body ? { body: JSON.stringify(request.body) } : {}),\n        });\n\n        const response = await this.auth.handler(req);\n\n        reply.status(response.status);\n        response.headers.forEach((value: string, key: string) => {\n          reply.header(key, value);\n        });\n        return reply.send(response.body ? await response.text() : null);\n      },\n    });\n\n    const chalk = (await import(\"chalk\")).default;\n    console.log(chalk.green(`✓ better-auth registered at ${basePath}/*`));\n  }\n\n  private async initializeCache(config: CacheConfig | undefined, forTesting: boolean) {\n    const { setCacheManagerRef } = await import(\"../cache/decorator\");\n\n    // 테스트 환경에서 메모리 드라이버 자동 사용\n    if (forTesting) {\n      const { createTestCacheManager } = await import(\"../cache/cache-manager\");\n      this._cache = createTestCacheManager();\n      setCacheManagerRef(this._cache);\n      return;\n    }\n\n    // 설정이 없으면 캐시 비활성화\n    if (!config) {\n      setCacheManagerRef(null);\n      return;\n    }\n\n    // 설정에 따라 CacheManager 생성\n    const { createCacheManager } = await import(\"../cache/cache-manager\");\n    this._cache = createCacheManager(config);\n    setCacheManagerRef(this._cache);\n  }\n\n  private async initializeWorkflows(options: SonamuTaskOptions | undefined) {\n    const { WorkflowManager } = await import(\"../tasks/workflow-manager\");\n    // NOTE: @sonamu-kit/tasks 안에선 knex config를 수정하기 때문에 connection이 아닌 config 째로 보냅니다.\n    this._workflows = new WorkflowManager(DB.getDBConfig(\"w\"));\n    if (!options) {\n      return;\n    }\n\n    const enableWorker = options.enableWorker ?? isDaemonServer();\n    const defaultWorkerOptions = {\n      concurrency: os.cpus().length - 1,\n      usePubSub: true,\n      listenDelay: 500,\n    };\n\n    if (enableWorker) {\n      this.workflows.setupWorker({\n        ...defaultWorkerOptions,\n        ...options.workerOptions,\n      });\n    }\n  }\n\n  private async boot(server: FastifyInstance, options: SonamuServerOptions) {\n    const port = options.listen?.port ?? 3000;\n    const host = options.listen?.host ?? \"localhost\";\n\n    server.addHook(\"onClose\", async () => {\n      await options.lifecycle?.onShutdown?.(server);\n      await this.workflows.destroy();\n      await this.destroy();\n    });\n\n    const shutdown = async () => {\n      try {\n        await server.close();\n        process.exit(0);\n      } catch (err) {\n        console.error(\"Error during shutdown:\", err);\n        process.exit(1);\n      }\n    };\n\n    process.on(\"SIGINT\", shutdown);\n    process.on(\"SIGTERM\", shutdown);\n\n    if (options.lifecycle?.onError) {\n      server.setErrorHandler(options.lifecycle?.onError);\n    }\n\n    server\n      .listen({ port, host })\n      .then(async () => {\n        await this.workflows.startWorker();\n        await options.lifecycle?.onStart?.(server);\n      })\n      .catch(async (err) => {\n        const chalk = (await import(\"chalk\")).default;\n        console.error(chalk.red(\"Failed to start server:\", err));\n        await shutdown();\n      });\n  }\n\n  private async handleFileChange(event: string, filePath: AbsolutePath): Promise<void> {\n    // 첫 번째 파일이면 HMR 시작 시간 기록\n    if (this.pendingFiles.length === 0) {\n      this.hmrStartTime = Date.now();\n    }\n    this.pendingFiles.push(filePath);\n\n    const relativePath = path.relative(this.apiRootPath, filePath);\n    const chalk = (await import(\"chalk\")).default;\n    console.log(chalk.bold(`Detected(${event}): ${chalk.blue(relativePath)}`));\n\n    await this.syncer.syncFromWatcher(event, filePath);\n\n    // 처리 완료된 파일을 대기 목록에서 제거\n    this.pendingFiles = this.pendingFiles.slice(1);\n\n    // 모든 파일 처리가 완료되면 최종 메시지 출력\n    if (this.pendingFiles.length === 0) {\n      await this.finishHMR();\n    }\n  }\n\n  private async finishHMR(): Promise<void> {\n    await this.syncer.renewChecksums();\n\n    const endTime = Date.now();\n    const totalTime = endTime - this.hmrStartTime;\n    const [chalk, { centerText }] = await Promise.all([\n      (await import(\"chalk\")).default,\n      import(\"../utils/console-util\"),\n    ]);\n    const msg = `HMR Done! ${chalk.bold.white(`${totalTime}ms`)}`;\n\n    console.log(chalk.black.bgGreen(centerText(msg)));\n  }\n\n  async destroy(): Promise<void> {\n    const { BaseModel } = await import(\"../database/base-model\");\n    // 먼저 처리해야함.\n    await BaseModel.destroy();\n    await Promise.allSettled([\n      this._workflows?.destroy() ?? Promise.resolve(),\n      this._cache?.disconnect() ?? Promise.resolve(),\n      this.watcher?.close() ?? Promise.resolve(),\n      logtapeDispose(),\n    ]);\n  }\n}\n\nexport const Sonamu = new SonamuClass();\n\n/**\n * stream 모드에서 키 생성 함수가 지정되지 않았을 때 사용하는 기본 함수입니다.\n */\nfunction defaultKeyGenerator(file: { filename: string; mimetype: string }): string {\n  const ext = mime.extension(file.mimetype) || \"bin\";\n  const timestamp = Date.now();\n  const random = Math.random().toString(36).slice(2, 8);\n  return `uploads/${timestamp}-${random}.${ext}`;\n}\n"],"names":["dispose","logtapeDispose","assert","AsyncLocalStorage","fs","mime","lookup","mimeLookup","os","path","BASE_FIELD_MAPPINGS","convertFastifyHeadersToStandard","createMockSSEFactory","DB","isDaemonServer","merge","applyCacheHeaders","CachePresets","toFastifyCompressOption","Naite","BufferedFile","UploadedFile","exists","fileExists","getSecrets","SonamuClass","isInitialized","forTesting","asyncLocalStorage","getContext","store","getStore","context","process","env","NODE_ENV","request","reply","headers","createSSE","schema","naiteStore","Map","Error","_apiRootPath","apiRootPath","appRootPath","split","sep","slice","join","_dbConfig","dbConfig","_syncer","syncer","_config","config","secrets","_storage","storage","_cache","cache","_workflows","workflows","_auth","auth","watcher","pendingFiles","hmrStartTime","server","initForTesting","init","undefined","doSilent","enableSync","chalk","default","console","time","cyan","findApiRootPath","loadConfig","database","defaultOptions","client","configureLogTape","logging","generateDBConfig","log","green","EntityManager","autoload","initializeCache","initializeWorkflows","tasks","Syncer","autoloadTypes","autoloadModels","autoloadApis","autoloadWorkflows","TemplateManager","autoloadSSRRoutes","isLocal","isTest","setupBiome","isHotReloadServer","sync","startWatcher","timeEnd","createServer","initOptions","options","fastify","getLogTapeFastifyLogger","logger","category","fastifyCategory","StorageManager","plugins","registerPlugins","registerBetterAuth","withFastify","apiConfig","boot","timezone","api","formatInTimeZone","ISO_DATE_REGEX","DATE_FORMAT","setReplySerializer","payload","JSON","stringify","_key","value","test","Date","get","route","prefix","_request","_reply","apis","sonamuUIApiPlugin","register","webPath","hasWeb","pluginCompress","compress","globalCompressOptions","threshold","encodings","customTypes","setupViteDevServer","models","modelName","method","httpMethod","url","handler","createApiHandler","setupStaticWebServer","viteServer","vite","root","middlewareMode","hmr","appType","use","req","res","next","startsWith","middlewares","getSSRRoutes","renderSSR","ssrRoutes","params","extractPathParams","html","type","template","readFile","transformIndexHtml","e","ssrFixStacktrace","error","status","message","addHook","close","_webPath","webDistPath","ssrPath","ssrEntryPath","ssrRoutesPath","warn","ssrAvailable","requestedFile","filename","assetsDir","assetPath","getCacheControlForAsset","cacheReq","cacheControlHandler","result","immutable","ext","pop","files","readdir","currentFile","find","f","endsWith","filePath","content","send","includes","code","csrCacheReq","csrCacheConfig","indexPath","createContext","run","guards","every","guard","guardHandler","getZodObjectFromApi","ReqType","types","which","reqBody","bufferedFiles","uploadedFiles","body","uploadOptions","parts","limits","fields","consume","part","buffer","toBuffer","push","fieldname","String","diskName","destination","disk","keyGenerator","defaultKeyGenerator","key","mimetype","putStream","file","contentType","getUrl","signedUrl","getSignedUrl","size","bytesRead","qs","parsed","parse","Object","assign","fastifyCaster","ZodError","humanizeZodError","messages","map","issue","BadRequestException","zodError","apiCacheConfig","getApiCacheControl","ApiParamType","args","parameters","param","isContext","name","invokeModelMethod","pattern","patternParts","filter","Boolean","urlParts","i","length","cacheControl","routeOptions","invokeApiForSSR","paramsIndex","model","methodName","apply","createSSEFactory","_events","socket","bind","locale","detectLocale","i18n","supportedLocales","defaultLocale","session","getSession","Promise","resolve","contextProvider","createStore","user","acceptLanguage","supported","langs","lang","trim","watchPath","chokidar","watch","ignored","stats","isFile","persistent","ignoreInitial","on","event","absolutePath","isConfigTs","relativePath","replace","bold","blue","kill","pid","handleFileChange","runScript","fn","destroy","compressPlugin","pluginsModules","cors","formbody","multipart","sse","static","registerPlugin","pluginName","option","entries","custom","basePath","mergedFieldMappings","betterAuth","Pool","getDBConfig","connection","URL","host","Request","toString","response","forEach","header","text","setCacheManagerRef","createTestCacheManager","createCacheManager","WorkflowManager","enableWorker","defaultWorkerOptions","concurrency","cpus","usePubSub","listenDelay","setupWorker","workerOptions","port","listen","lifecycle","onShutdown","shutdown","exit","err","onError","setErrorHandler","then","startWorker","onStart","catch","red","now","relative","syncFromWatcher","finishHMR","renewChecksums","endTime","totalTime","centerText","all","msg","white","black","bgGreen","BaseModel","allSettled","disconnect","Sonamu","extension","timestamp","random","Math"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/api/sonamu.ts"],"sourcesContent":["import { dispose as logtapeDispose } from \"@logtape/logtape\";\nimport assert from \"assert\";\nimport { AsyncLocalStorage } from \"async_hooks\";\nimport type { Auth } from \"better-auth\";\nimport type { FSWatcher } from \"chokidar\";\nimport type { FastifyInstance, FastifyReply, FastifyRequest } from \"fastify\";\nimport fs from \"fs/promises\";\nimport type { IncomingMessage, Server, ServerResponse } from \"http\";\nimport mime, { lookup as mimeLookup } from \"mime-types\";\nimport os from \"os\";\nimport path from \"path\";\nimport type { PoolConfig } from \"pg\";\nimport type { ZodObject } from \"zod\";\nimport {\n  BASE_FIELD_MAPPINGS,\n  convertFastifyHeadersToStandard,\n  createMockSSEFactory,\n  DB,\n  isDaemonServer,\n  merge,\n  NotFoundException,\n} from \"..\";\nimport type { CacheConfig, CacheManager } from \"../cache/types\";\nimport { applyCacheHeaders, CachePresets } from \"../cache-control/cache-control\";\nimport type { CacheControlConfig, CacheControlRequest } from \"../cache-control/types\";\nimport { toFastifyCompressOption } from \"../compress/compress\";\nimport type { CompressOptions } from \"../compress/types\";\nimport type { SonamuDBConfig } from \"../database/db\";\nimport { SD } from \"../dict/sd\";\nimport type { LocalizedString } from \"../dict/types\";\nimport { Naite } from \"../naite/naite\";\nimport { BufferedFile } from \"../storage/buffered-file\";\nimport type { StorageManager } from \"../storage/storage-manager\";\nimport type { KeyGenerator } from \"../storage/types\";\nimport { UploadedFile } from \"../storage/uploaded-file\";\nimport type { Syncer } from \"../syncer/syncer\";\nimport type { WorkflowManager } from \"../tasks/workflow-manager\";\nimport type { SonamuFastifyConfig } from \"../types/types\";\nimport { exists, fileExists } from \"../utils/fs-utils\";\nimport type { AbsolutePath } from \"../utils/path-utils\";\nimport type { SonamuConfig, SonamuServerOptions, SonamuTaskOptions } from \"./config\";\nimport type { Context } from \"./context\";\nimport type { ExtendedApi } from \"./decorators\";\nimport { getSecrets, type SonamuSecrets } from \"./secret\";\n\nclass SonamuClass {\n  public isInitialized: boolean = false;\n  public forTesting: boolean = false;\n  public asyncLocalStorage: AsyncLocalStorage<{\n    context: Context;\n  }> = new AsyncLocalStorage();\n\n  public getContext(): Context {\n    const store = this.asyncLocalStorage.getStore();\n    if (store?.context) {\n      return store.context as Context;\n    }\n\n    if (process.env.NODE_ENV === \"test\") {\n      // 테스팅 환경에서 컨텍스트가 주입되지 않은 경우 빈 컨텍스트 리턴\n      return {\n        request: null,\n        reply: null,\n        headers: {},\n        createSSE: (schema: ZodObject) => createMockSSEFactory(schema),\n        // biome-ignore lint/suspicious/noExplicitAny: 테스팅 환경에서 컨텍스트가 주입되지 않은 경우 빈 컨텍스트 리턴\n        naiteStore: new Map<string, any>(),\n      } as unknown as Context;\n    } else {\n      throw new Error(\"Sonamu cannot find context\");\n    }\n  }\n\n  private _apiRootPath: AbsolutePath | null = null;\n  set apiRootPath(apiRootPath: AbsolutePath) {\n    this._apiRootPath = apiRootPath;\n  }\n  get apiRootPath(): AbsolutePath {\n    if (this._apiRootPath === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n    return this._apiRootPath;\n  }\n  get appRootPath(): string {\n    return this.apiRootPath.split(path.sep).slice(0, -1).join(path.sep);\n  }\n\n  private _dbConfig: SonamuDBConfig | null = null;\n  set dbConfig(dbConfig: SonamuDBConfig) {\n    this._dbConfig = dbConfig;\n  }\n  get dbConfig(): SonamuDBConfig {\n    if (this._dbConfig === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n    return this._dbConfig;\n  }\n\n  private _syncer: Syncer | null = null;\n  set syncer(syncer: Syncer) {\n    this._syncer = syncer;\n  }\n  get syncer(): Syncer {\n    if (this._syncer === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n    return this._syncer;\n  }\n\n  private _config: SonamuConfig | null = null;\n  set config(config: SonamuConfig) {\n    this._config = config;\n  }\n  get config(): SonamuConfig {\n    if (this._config === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n    return this._config;\n  }\n\n  public readonly secrets: SonamuSecrets = getSecrets();\n\n  private _storage: StorageManager | null = null;\n  /**\n   * StorageManager 인스턴스\n   */\n  get storage(): StorageManager {\n    if (!this._storage) {\n      throw new Error(\"Storage has not been initialized. Check storage config.\");\n    }\n    return this._storage;\n  }\n\n  private _cache: CacheManager | null = null;\n  /**\n   * CacheManager 인스턴스 (BentoCache)\n   */\n  get cache(): CacheManager {\n    if (!this._cache) {\n      throw new Error(\"Cache has not been initialized. Check cache config in sonamu.config.ts.\");\n    }\n    return this._cache;\n  }\n\n  private _workflows: WorkflowManager | null = null;\n  get workflows(): WorkflowManager {\n    if (this._workflows === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n\n    return this._workflows;\n  }\n\n  private _auth: Auth | null = null;\n  get auth(): Auth {\n    if (!this._auth) {\n      throw new Error(\"Auth has not been initialized. Check auth config in sonamu.config.ts.\");\n    }\n    return this._auth;\n  }\n\n  // HMR 처리\n  public watcher: FSWatcher | null = null;\n  private pendingFiles: string[] = [];\n  private hmrStartTime: number = 0;\n\n  public server: FastifyInstance | null = null;\n\n  async initForTesting() {\n    await this.init(true, false, undefined, true);\n  }\n\n  async init(\n    doSilent: boolean = false,\n    enableSync: boolean = true,\n    apiRootPath?: AbsolutePath,\n    forTesting: boolean = false,\n  ) {\n    this.forTesting = forTesting;\n\n    if (this.isInitialized) {\n      return;\n    }\n\n    if (!doSilent) {\n      const chalk = (await import(\"chalk\")).default;\n      console.time(chalk.cyan(`Sonamu.init${forTesting ? \" for testing\" : \"\"}`));\n    }\n\n    // API 루트 패스\n    const { findApiRootPath } = await import(\"../utils/utils\");\n    this.apiRootPath = apiRootPath ?? findApiRootPath();\n\n    // 설정을 로딩하는 것부터 시작\n    const { loadConfig } = await import(\"./config\");\n    this.config = await loadConfig(this.apiRootPath);\n    // sonamu.config.ts 기본값 설정\n    this.config.database.database = this.config.database.database ?? \"pg\";\n    this.config.database.defaultOptions.client = this.config.database.database ?? \"pg\";\n\n    // 로깅 설정\n    const { configureLogTape } = await import(\"../logger/configure\");\n    if (this.config.logging !== false) {\n      await configureLogTape({\n        ...this.config.logging,\n      });\n    }\n\n    // DB 로드\n    const { DB } = await import(\"../database/db\");\n    this.dbConfig = DB.generateDBConfig(this.config.database);\n    if (!doSilent) {\n      const chalk = (await import(\"chalk\")).default;\n      console.log(chalk.green(\"DB Config Loaded!\"));\n    }\n\n    // Entity 로드\n    // 테스트에서도 Entity 정보는 필요합니다.\n    // upsert가 제대로 작동하려면 entity의 unique index 정보가 필요하기 때문입니다.\n    const { EntityManager } = await import(\"../entity/entity-manager\");\n    await EntityManager.autoload(doSilent);\n\n    // Cache 초기화\n    await this.initializeCache(this.config.server.cache, forTesting);\n\n    // 테스팅인 경우 싱크 없이 중단\n    if (forTesting) {\n      this.isInitialized = true;\n      return;\n    }\n\n    // Task 등록\n    await this.initializeWorkflows(this.config.tasks);\n\n    // Syncer\n    const { Syncer } = await import(\"../syncer/syncer\");\n    this.syncer = new Syncer();\n\n    // Autoload: Models / Types / APIs / Workflows / Templates / SSR Routes\n    await this.syncer.autoloadTypes();\n    await this.syncer.autoloadModels();\n    await this.syncer.autoloadApis();\n    await this.syncer.autoloadWorkflows();\n    const { TemplateManager } = await import(\"../template\");\n    await TemplateManager.autoload();\n    await this.syncer.autoloadSSRRoutes();\n\n    const { isLocal, isTest } = await import(\"../utils/controller\");\n    if (isLocal()) {\n      // 로컬에서는 코드 생성을 위해 Biome 셋업이 필요함 (현재 apiRootPath 전달하여 실행)\n      (await import(\"../utils/formatter\")).setupBiome(this.apiRootPath);\n    }\n\n    const { isHotReloadServer } = await import(\"../utils/controller\");\n    if (isLocal() && !isTest() && isHotReloadServer() && enableSync) {\n      await this.syncer.sync();\n      await this.startWatcher();\n    }\n\n    this.isInitialized = true;\n    if (!doSilent) {\n      const chalk = (await import(\"chalk\")).default;\n      console.timeEnd(chalk.cyan(\"Sonamu.init\"));\n    }\n  }\n\n  async createServer(initOptions?: { enableSync?: boolean; doSilent?: boolean }) {\n    if (this.isInitialized === false) {\n      await this.init(initOptions?.doSilent, initOptions?.enableSync);\n    }\n\n    const options = this.config.server;\n    const { default: fastify } = await import(\"fastify\");\n    const { getLogTapeFastifyLogger } = await import(\"@logtape/fastify\");\n    const server = fastify({\n      ...options.fastify,\n      logger:\n        this.config.logging !== false\n          ? getLogTapeFastifyLogger({\n              category: this.config.logging?.fastifyCategory ?? [\"fastify\"],\n            })\n          : undefined,\n    });\n    this.server = server;\n\n    // Storage 설정 → StorageManager 생성\n    if (options.storage) {\n      const { StorageManager } = await import(\"../storage/storage-manager\");\n      this._storage = new StorageManager(options.storage);\n    }\n\n    // 플러그인 등록\n    if (options.plugins) {\n      await this.registerPlugins(server, options.plugins);\n    }\n\n    if (options.auth) {\n      await this.registerBetterAuth(server, options.auth);\n    }\n\n    // API 라우팅 설정\n    await this.withFastify(server, options.apiConfig, {\n      enableSync: initOptions?.enableSync,\n      doSilent: initOptions?.doSilent,\n    });\n\n    // 서버 시작\n    await this.boot(server, options);\n\n    return server;\n  }\n\n  async withFastify(\n    server: FastifyInstance<Server, IncomingMessage, ServerResponse>,\n    config: SonamuFastifyConfig,\n    options?: {\n      enableSync?: boolean;\n      doSilent?: boolean;\n    },\n  ) {\n    if (this.isInitialized === false) {\n      await this.init(options?.doSilent, options?.enableSync);\n    }\n\n    this.server = server;\n\n    // timezone 설정\n    const timezone = this.config.api.timezone;\n    if (timezone) {\n      // 타임존에 맞게 응답 날짜 스트링을 변환해주어야 합니다.\n      // 가령 timezone이 \"Asia/Seoul\" 이면\n      // \"2025-11-21T00:00:00.000Z\" 를 \"2025-11-21T09:00:00+09:00\" 으로 변환해주어야 합니다.\n      const { formatInTimeZone } = await import(\"date-fns-tz\");\n\n      // ISO 8601 날짜 형식 정규식 (예: 2024-01-15T09:30:00.000Z)\n      const ISO_DATE_REGEX = /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d{3})?Z$/;\n\n      // T를 둘러싼 작은따옴표가 없다면 \"2025-11-19176354618900018:56:29+09:00\"와 같은 결과가 나옵니다.\n      // 이는 date-fns 특입니다.\n      // 이렇게 해도 괜찮습니다. \"2025-11-19T18:56:29+09:00\" 모양으로 잘 나옵니다.\n      const DATE_FORMAT = \"yyyy-MM-dd'T'HH:mm:ssXXX\";\n\n      server.setReplySerializer((payload) => {\n        return JSON.stringify(payload, (_key, value) => {\n          if (typeof value === \"string\" && ISO_DATE_REGEX.test(value)) {\n            return formatInTimeZone(\n              new Date(value),\n              timezone as `${string}/${string}`,\n              DATE_FORMAT,\n            );\n          }\n          return value;\n        });\n      });\n      if (!options?.doSilent) {\n        const chalk = (await import(\"chalk\")).default;\n        console.log(chalk.green(`Timezone set to ${timezone}`));\n      }\n    }\n\n    // 전체 라우팅 리스트\n    server.get(\n      `${this.config.api.route.prefix}/routes`,\n      async (_request, _reply): Promise<typeof this.syncer.apis> => {\n        return this.syncer.apis;\n      },\n    );\n\n    // Healthcheck API\n    server.get(\n      `${this.config.api.route.prefix}/healthcheck`,\n      async (_request, _reply): Promise<string> => {\n        return \"ok\";\n      },\n    );\n\n    // Sonamu UI API (로컬 환경에서만)\n    const { isLocal } = await import(\"../utils/controller\");\n    if (isLocal()) {\n      const { sonamuUIApiPlugin } = await import(\"../ui/api\");\n      server.register(sonamuUIApiPlugin);\n    }\n\n    const webPath = path.join(this.appRootPath, \"web\");\n    const hasWeb = await exists(webPath);\n\n    // 전역 compress 옵션 계산 (route.compress: true일 때 사용)\n    const pluginCompress = this.config.server.plugins?.compress;\n    const globalCompressOptions: CompressOptions | undefined = pluginCompress\n      ? pluginCompress === true\n        ? { threshold: 1024, encodings: [\"br\", \"gzip\", \"deflate\"] }\n        : {\n            threshold: pluginCompress.threshold,\n            encodings: pluginCompress.encodings,\n            customTypes: pluginCompress.customTypes,\n          }\n      : undefined;\n\n    if (isLocal()) {\n      // 로컬 개발 환경: catch-all로 API를 동적 매칭하여 HMR을 지원합니다.\n      // SONAMU_DISABLE_INTEGRATED_WEB=yes로 설정하면 dev_api 모드에서 Vite 통합을 비활성화할 수 있습니다.\n      const disableIntegratedWeb = process.env.SONAMU_DISABLE_INTEGRATED_WEB === \"yes\";\n      if (hasWeb && !disableIntegratedWeb) {\n        await this.setupDevServerWithVite(server, webPath, config);\n      } else {\n        this.setupDevServer(server, config);\n      }\n    } else {\n      // 프로덕션 환경: 개별 API 라우트 + 정적 파일 서빙\n      for (const api of this.syncer.apis) {\n        if (this.syncer.models[api.modelName] === undefined) {\n          throw new Error(`정의되지 않은 모델에 접근 ${api.modelName}`);\n        }\n\n        server.route({\n          method: api.options.httpMethod ?? \"GET\",\n          url: this.config.api.route.prefix + api.path,\n          handler: this.createApiHandler(api, config),\n          compress: toFastifyCompressOption(api.options.compress, globalCompressOptions),\n        });\n      }\n\n      // 프로덕션에서는 web 소스(appRoot/web) 유무와 무관하게,\n      // api/web-dist 존재 여부를 setupStaticWebServer 내부에서 판단합니다.\n      await this.setupStaticWebServer(server, config, globalCompressOptions);\n    }\n  }\n\n  /**\n   * dev 모드 공통: catch-all에서 syncer.apis를 동적으로 탐색하여 API 요청을 처리합니다.\n   * server.route()로 개별 등록하면 handler가 고정되어 HMR이 동작하지 않으므로,\n   * 매 요청마다 syncer.apis를 조회하는 이 방식을 사용합니다.\n   *\n   * 요청이 /api(정확히는 this.config.api.route.prefix)로 시작하지 않는 경우라면 null을 반환하며 끝냅니다.\n   */\n  private handleDevApiRequest(\n    request: FastifyRequest,\n    config: SonamuFastifyConfig,\n  ): ((request: FastifyRequest, reply: FastifyReply) => Promise<unknown>) | null {\n    const url = this.getPathnameFromUrl(request.url);\n    const method = request.method;\n\n    if (!url.startsWith(this.config.api.route.prefix)) {\n      return null;\n    }\n\n    // syncer.apis의 path는 :param 형태를 포함할 수 있으므로 세그먼트 단위로 매칭합니다.\n    // 정규식 생성 방식은 path 문자열 내 특수문자(., +, (, [ 등)로 오작동할 수 있어 사용하지 않습니다.\n    const matchedApi = this.syncer.apis.find((api) => {\n      if (this.syncer.models[api.modelName] === undefined) {\n        return false;\n      }\n      const apiMethod = api.options.httpMethod ?? \"GET\";\n      if (apiMethod !== method) return false;\n\n      const fullPath = this.config.api.route.prefix + api.path;\n      return this.isPathPatternMatch(fullPath, url);\n    });\n\n    if (!matchedApi) {\n      throw new NotFoundException(SD(\"error.api.notFound\"));\n    }\n\n    return this.createApiHandler(matchedApi, config);\n  }\n\n  /**\n   * dev api 모드: Vite 없이 API 동적 라우팅만 제공합니다.\n   * HMR을 위해 catch-all에서 매 요청마다 syncer.apis를 조회합니다.\n   */\n  private setupDevServer(\n    server: FastifyInstance<Server, IncomingMessage, ServerResponse>,\n    config: SonamuFastifyConfig,\n  ): void {\n    server.route({\n      method: [\"GET\", \"HEAD\", \"POST\", \"PUT\", \"DELETE\", \"PATCH\"],\n      url: `${this.config.api.route.prefix}/*`,\n      handler: async (request, reply) => {\n        const handler = this.handleDevApiRequest(request, config);\n        if (handler) {\n          return handler(request, reply);\n        }\n        // 사실 /api로 시작하지 않는 요청은 여기에 들어오지도 않을 거라 이 라인은 도달 불가능입니다만,\n        // 안전빵으로 남겨놓습니다.\n        throw new NotFoundException(SD(\"error.api.notFound\"));\n      },\n    });\n  }\n\n  // biome-ignore lint/suspicious/noExplicitAny: ViteDevServer 타입을 동적으로 로드해야 함\n  private viteServer: any = null;\n\n  /**\n   * dev all 모드: Vite Dev Server를 통합하여 API + SSR + CSR을 모두 제공합니다.\n   * API 동적 매칭은 handleDevApiRequest를 공유합니다.\n   */\n  private async setupDevServerWithVite(\n    server: FastifyInstance<Server, IncomingMessage, ServerResponse>,\n    webPath: string,\n    config: SonamuFastifyConfig,\n  ): Promise<void> {\n    // @fastify/middie 등록 (Connect-style middleware 지원)\n    await server.register((await import(\"@fastify/middie\")).default);\n\n    const vite = await import(\"vite\");\n\n    this.viteServer = await vite.createServer({\n      root: webPath,\n      server: {\n        middlewareMode: true,\n        hmr: {\n          server: server.server,\n        },\n      },\n      appType: \"custom\",\n    });\n\n    // Vite middleware 등록 (Vite 에셋 처리)\n    server.use((req, res, next) => {\n      // API와 Sonamu UI는 Fastify 라우트가 처리하도록 skip\n      if (req.url?.startsWith(this.config.api.route.prefix) || req.url?.startsWith(\"/sonamu-ui\")) {\n        return next();\n      }\n      // 나머지는 Vite middleware로 전달\n      return this.viteServer.middlewares(req, res, next);\n    });\n\n    // catch-all 라우트에서 동적으로 API/SSR 처리\n    // 개발 환경에서는 라우트별 compress 옵션을 포기하고 HMR 이점을 취합니다.\n    server.route({\n      method: [\"GET\", \"HEAD\", \"POST\", \"PUT\", \"DELETE\", \"PATCH\"],\n      url: \"/*\",\n      handler: async (request, reply) => {\n        // 1. API 요청 처리\n        const result = this.handleDevApiRequest(request, config);\n        if (result) {\n          return result(request, reply);\n        }\n\n        const url = request.url;\n\n        // 2. SSR 라우트 처리\n        const { matchSSRRoute, renderSSR } = await import(\"../ssr\");\n        const ssrMatch = matchSSRRoute(url);\n        if (ssrMatch) {\n          console.log(`[SSR] Matched route: ${ssrMatch.route.path}`);\n          const html = await renderSSR(\n            url,\n            ssrMatch.route,\n            ssrMatch.params,\n            request,\n            reply,\n            config,\n            this.viteServer,\n          );\n          reply.type(\"text/html\");\n          return html;\n        }\n\n        // 3. CSR fallback\n        try {\n          const fs = await import(\"node:fs/promises\");\n          let template = await fs.readFile(\n            path.join(this.viteServer.config.root, \"index.html\"),\n            \"utf-8\",\n          );\n          template = await this.viteServer.transformIndexHtml(url, template);\n\n          reply.type(\"text/html\");\n          return template;\n        } catch (e) {\n          this.viteServer.ssrFixStacktrace(e as Error);\n          console.error(e);\n          reply.status(500);\n          return (e as Error).message;\n        }\n      },\n    });\n\n    // 서버 종료 시 Vite도 종료\n    server.addHook(\"onClose\", async () => {\n      await this.viteServer.close();\n    });\n\n    console.log(\"✓ Vite dev server integrated\");\n  }\n\n  private async setupStaticWebServer(\n    server: FastifyInstance<Server, IncomingMessage, ServerResponse>,\n    config: SonamuFastifyConfig,\n    globalCompressOptions: CompressOptions | undefined,\n  ): Promise<void> {\n    // 경로 명확화: api/web-dist/client (정적 파일), api/web-dist/server (SSR entry), api/dist/ssr (SSR routes - API 소유)\n    const webDistPath = path.join(this.apiRootPath, \"web-dist\", \"client\");\n    const ssrPath = path.join(this.apiRootPath, \"web-dist\", \"server\");\n    const ssrEntryPath = path.join(ssrPath, \"entry-server.generated.js\");\n    const ssrRoutesPath = path.join(this.apiRootPath, \"dist\", \"ssr\", \"routes.js\");\n\n    if (!(await exists(webDistPath))) {\n      console.warn(`⚠ Web dist not found: ${webDistPath}`);\n      return;\n    }\n\n    // SSR entry 존재 여부 확인\n    const ssrAvailable = await exists(ssrEntryPath);\n\n    if (!ssrAvailable) {\n      console.warn(`⚠ SSR entry not found: ${ssrEntryPath}`);\n      console.warn(\"  SSR will be disabled. Only CSR will work.\");\n    }\n\n    // SSR 라우트 로드 (production에서만, 사용자 프로젝트의 ssr/routes.ts)\n    if (ssrAvailable) {\n      if (await exists(ssrRoutesPath)) {\n        // ts-loader라면 \"file://\"로 시작하는 fully-resolved path만 받기에 이를 처리해주는 importMembers를 사용해야 했겠지만,\n        // 여기는 프로덕션 환경에서 loader 없이 돌아가기 때문에 \"진짜 js 파일\"의 \"그냥\" 절대경로를 바로 import해도 됩니다.\n        // 이 내용은 이 함수 내에서 아래에 나올 다른 import 호출에도 동일하게 적용됩니다.\n        await import(ssrRoutesPath);\n        console.log(\"✓ SSR routes loaded\");\n      } else {\n        console.warn(`⚠ SSR routes not found: ${ssrRoutesPath}`);\n      }\n    }\n\n    // 롤링 업데이트 대응: asset hash 불일치 시 현재 버전 직접 서빙\n    server.get(\"/assets/:filename\", async (request, reply) => {\n      const requestedFile = (request.params as { filename: string }).filename;\n      const assetsDir = path.join(webDistPath, \"assets\");\n      const safeFilePath = this.resolvePathWithinBaseDir(assetsDir, requestedFile);\n      if (safeFilePath === null) {\n        reply.status(403).send();\n        return;\n      }\n      const normalizedRequestedFile = path.relative(assetsDir, safeFilePath).replace(/\\\\/g, \"/\");\n\n      const assetPath = `/assets/${normalizedRequestedFile}`;\n\n      // Cache-Control 헤더 결정\n      const getCacheControlForAsset = (): CacheControlConfig => {\n        const cacheReq: CacheControlRequest = {\n          type: \"assets\",\n          url: request.url,\n          path: assetPath,\n          method: request.method,\n        };\n\n        // 사용자 정의 핸들러 우선\n        if (config.cacheControlHandler) {\n          const result = config.cacheControlHandler(cacheReq);\n          if (result) return result;\n        }\n\n        // 기본값: immutable\n        return CachePresets.immutable;\n      };\n\n      // index-*.js 또는 index-*.css 요청인 경우\n      if (/^index-[a-f0-9]+\\.(js|css)$/.test(normalizedRequestedFile)) {\n        const ext = normalizedRequestedFile.split(\".\").pop();\n        const files = await fs.readdir(assetsDir);\n        const currentFile = files.find((f) => f.startsWith(\"index-\") && f.endsWith(`.${ext}`));\n\n        if (currentFile) {\n          const filePath = path.join(assetsDir, currentFile);\n          const content = await fs.readFile(filePath);\n          reply.type(ext === \"js\" ? \"application/javascript\" : \"text/css\");\n          applyCacheHeaders(reply, getCacheControlForAsset());\n          return reply.send(content);\n        }\n      }\n\n      // 일반 파일 서빙\n      const filePath = safeFilePath;\n      if (await exists(filePath)) {\n        const content = await fs.readFile(filePath);\n        const ext = normalizedRequestedFile.split(\".\").pop();\n        reply.type(ext === \"js\" ? \"application/javascript\" : ext === \"css\" ? \"text/css\" : \"\");\n        if (normalizedRequestedFile.includes(\"-\")) {\n          applyCacheHeaders(reply, getCacheControlForAsset());\n        }\n        return reply.send(content);\n      }\n\n      reply.status(404).send();\n    });\n\n    // SSR 라우트 개별 등록 (compress 옵션이 라우트별로 적용되도록)\n    if (ssrAvailable) {\n      const { getSSRRoutes } = await import(\"../ssr\");\n      const { renderSSR } = await import(\"../ssr/renderer\");\n      const ssrRoutes = getSSRRoutes();\n\n      for (const route of ssrRoutes) {\n        server.route({\n          method: [\"GET\", \"HEAD\"],\n          url: route.path,\n          compress: toFastifyCompressOption(route.compress ?? true, globalCompressOptions),\n          handler: async (request, reply) => {\n            const url = request.url;\n            console.log(`[SSR] Matched route: ${route.path}`);\n\n            const params = this.extractPathParams(route.path, url);\n            const html = await renderSSR(url, route, params, request, reply, config);\n\n            reply.type(\"text/html\");\n            return html;\n          },\n        });\n      }\n    }\n\n    // CSR or Static File Fallback (SSR 라우트에 매칭되지 않는 모든 요청)\n    server.route({\n      method: [\"GET\", \"HEAD\"],\n      url: \"*\",\n      handler: async (request, reply) => {\n        // /api, /sonamu-ui는 404 그대로\n        if (request.url.startsWith(\"/api\") || request.url.startsWith(\"/sonamu-ui\")) {\n          reply.status(404).send();\n          return;\n        }\n\n        // CSR용 Cache-Control 헤더 설정\n        if (config.cacheControlHandler) {\n          const csrCacheReq: CacheControlRequest = {\n            type: \"csr\",\n            url: request.url,\n            path: request.url.split(\"?\")[0],\n            method: request.method,\n          };\n          const csrCacheConfig = config.cacheControlHandler(csrCacheReq);\n\n          if (csrCacheConfig) {\n            applyCacheHeaders(reply, csrCacheConfig);\n          }\n        }\n\n        // 정적 파일이 존재할 경우, 정적 파일을 먼저 서빙해야함\n        const requestPath = this.getPathnameFromUrl(request.url);\n        const safeFilePath = this.resolvePathWithinBaseDir(webDistPath, requestPath);\n        if (safeFilePath === null) {\n          reply.status(403).send();\n          return;\n        }\n        if (await fileExists(safeFilePath)) {\n          const content = await fs.readFile(safeFilePath);\n          return reply.type(mimeLookup(safeFilePath) || \"application/octet-stream\").send(content);\n        }\n\n        // CSR fallback: index.html 서빙\n        const indexPath = path.join(webDistPath, \"index.html\");\n        return reply.type(\"text/html\").send(await fs.readFile(indexPath, \"utf-8\"));\n      },\n    });\n\n    console.log(`✓ Static web server configured with ${ssrAvailable ? \"SSR\" : \"CSR only\"} support`);\n  }\n\n  createApiHandler(\n    api: ExtendedApi,\n    config: SonamuFastifyConfig,\n  ): (request: FastifyRequest, reply: FastifyReply) => Promise<unknown> {\n    return async (request: FastifyRequest, reply: FastifyReply): Promise<unknown> => {\n      // Context 생성\n      const context: Context = await this.createContext(config, request, reply);\n\n      return this.asyncLocalStorage.run({ context }, async () => {\n        // guards 처리\n        (api.options.guards ?? []).every((guard) => config.guardHandler(guard, request, api));\n\n        // 파라미터 정보로 zod 스키마 빌드\n        const { getZodObjectFromApi } = await import(\"./code-converters\");\n        const ReqType = getZodObjectFromApi(api, this.syncer.types);\n\n        // request 파싱\n        const which = api.options.httpMethod === \"GET\" ? \"query\" : \"body\";\n        let reqBody: {\n          [key: string]: unknown;\n        };\n        // 파일 업로드 있는 경우 임시 데이터\n        const files: {\n          bufferedFiles: BufferedFile[];\n          uploadedFiles: UploadedFile[];\n        } = {\n          bufferedFiles: [],\n          uploadedFiles: [],\n        };\n\n        try {\n          const body = (request[which] ?? {}) as Record<string, unknown>;\n          if (api.uploadOptions) {\n            const parts = request.parts({\n              limits: api.uploadOptions.limits,\n            });\n\n            // FormData의 field들을 임시로 저장\n            const fields: Record<string, string> = {};\n\n            if (api.uploadOptions.consume === \"buffer\" || !api.uploadOptions.consume) {\n              // Buffer 모드: 메모리에 로드\n              for await (const part of parts) {\n                if (part.type === \"file\") {\n                  // CRITICAL: 파일 스트림을 즉시 consume해야 다음 part로 넘어갈 수 있음\n                  // 이 호출이 없으면 종종 multipart 파싱이 pending 상태로 타임아웃 발생\n                  const buffer = await part.toBuffer();\n                  files.bufferedFiles.push(new BufferedFile(part, buffer));\n                } else if (part.type === \"field\") {\n                  fields[part.fieldname] = String(part.value);\n                }\n              }\n            } else if (api.uploadOptions.consume === \"stream\") {\n              // Stream 모드: 즉시 저장소로 스트리밍\n              const diskName = api.uploadOptions.destination;\n              const disk = this.storage.use(diskName);\n\n              // 우선순위: 데코레이터 > 전역 설정 > 기본값\n              const keyGenerator: KeyGenerator =\n                api.uploadOptions.keyGenerator ??\n                this.config.server.storage?.keyGenerator ??\n                defaultKeyGenerator;\n\n              for await (const part of parts) {\n                if (part.type === \"file\") {\n                  const key = await keyGenerator({\n                    filename: part.filename,\n                    mimetype: part.mimetype,\n                  });\n\n                  await disk.putStream(key, part.file, {\n                    contentType: part.mimetype,\n                  });\n\n                  const url = await disk.getUrl(key);\n                  const signedUrl = await disk.getSignedUrl(key);\n\n                  files.uploadedFiles.push(\n                    new UploadedFile({\n                      filename: part.filename,\n                      mimetype: part.mimetype,\n                      size: part.file.bytesRead,\n                      url,\n                      signedUrl,\n                      key,\n                      diskName,\n                    }),\n                  );\n                } else if (part.type === \"field\") {\n                  fields[part.fieldname] = String(part.value);\n                }\n              }\n            }\n\n            // qs로 중첩 구조 파싱: params[category] → { params: { category: \"test\" } }\n            const qs = await import(\"qs\");\n            const parsed = qs.default.parse(fields);\n            Object.assign(body, parsed);\n          }\n\n          const { fastifyCaster } = await import(\"./caster\");\n          reqBody = fastifyCaster(ReqType).parse(body);\n        } catch (e) {\n          const { ZodError } = await import(\"zod\");\n          if (e instanceof ZodError) {\n            const { humanizeZodError } = await import(\"../utils/zod-error\");\n            const messages = humanizeZodError(e)\n              .map((issue) => issue.message)\n              .join(\" \");\n            const { BadRequestException } = await import(\"../exceptions/so-exceptions\");\n            throw new BadRequestException(messages as LocalizedString, {\n              zodError: e,\n            });\n          } else {\n            throw e;\n          }\n        }\n\n        // Content-Type\n        reply.type(api.options.contentType ?? \"application/json\");\n\n        // Cache-Control 헤더 설정\n        const apiCacheConfig = this.getApiCacheControl(api, request, config);\n        if (apiCacheConfig) {\n          applyCacheHeaders(reply, apiCacheConfig);\n        }\n\n        // 업로드 옵션이 있는 경우 파일 데이터를 Context에 추가\n        if (api.uploadOptions) {\n          const consume = api.uploadOptions.consume ?? \"buffer\";\n          if (consume === \"buffer\") {\n            context.bufferedFiles = files.bufferedFiles;\n          } else if (consume === \"stream\") {\n            context.uploadedFiles = files.uploadedFiles;\n          }\n        }\n\n        // 모델 메소드 args 생성하여 호출\n        const { ApiParamType } = await import(\"../types/types\");\n        const args = api.parameters.map((param) => {\n          // Context 인젝션\n          if (ApiParamType.isContext(param.type)) {\n            return context;\n          } else {\n            return reqBody[param.name];\n          }\n        });\n\n        return this.invokeModelMethod(api, args, reply);\n      });\n    };\n  }\n\n  /**\n   * URL에서 path params를 추출합니다.\n   * 예: pattern=\"/admin/companies/:companyId\", url=\"/admin/companies/123\" → { companyId: \"123\" }\n   */\n  private extractPathParams(pattern: string, url: string): Record<string, string> {\n    const patternParts = pattern.split(\"/\").filter(Boolean);\n    const urlParts = this.getPathnameFromUrl(url).split(\"/\").filter(Boolean);\n    const params: Record<string, string> = {};\n\n    for (let i = 0; i < patternParts.length; i++) {\n      if (patternParts[i].startsWith(\":\")) {\n        params[patternParts[i].slice(1)] = urlParts[i];\n      }\n    }\n    return params;\n  }\n\n  private isPathPatternMatch(pattern: string, url: string): boolean {\n    const patternParts = pattern.split(\"/\").filter(Boolean);\n    const urlParts = this.getPathnameFromUrl(url).split(\"/\").filter(Boolean);\n\n    if (patternParts.length !== urlParts.length) {\n      return false;\n    }\n\n    for (let i = 0; i < patternParts.length; i++) {\n      const patternPart = patternParts[i];\n      const urlPart = urlParts[i];\n      if (patternPart.startsWith(\":\")) {\n        continue;\n      }\n      if (patternPart !== urlPart) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  private getPathnameFromUrl(url: string): string {\n    return url.split(\"?\")[0];\n  }\n\n  private resolvePathWithinBaseDir(baseDir: string, inputPath: string): string | null {\n    try {\n      const decoded = decodeURIComponent(inputPath).replace(/\\\\/g, \"/\");\n      if (decoded.includes(\"\\0\")) {\n        return null;\n      }\n      const relativePath = decoded.replace(/^\\/+/, \"\");\n      const resolvedPath = path.resolve(baseDir, relativePath);\n      const relativeFromBase = path.relative(baseDir, resolvedPath);\n      if (relativeFromBase.startsWith(\"..\") || path.isAbsolute(relativeFromBase)) {\n        return null;\n      }\n      return resolvedPath;\n    } catch {\n      return null;\n    }\n  }\n\n  /**\n   * API 응답에 적용할 Cache-Control 설정을 결정합니다.\n   * 우선순위: 개별 지정 > cacheControlHandler\n   */\n  private getApiCacheControl(\n    api: ExtendedApi,\n    request: FastifyRequest,\n    config: SonamuFastifyConfig,\n  ) {\n    // 데코레이터 설정 우선\n    if (api.options.cacheControl) {\n      return api.options.cacheControl;\n    }\n\n    // 전역 핸들러\n    if (config.cacheControlHandler) {\n      const cacheReq: CacheControlRequest = {\n        type: \"api\",\n        url: request.url,\n        path: request.routeOptions?.url ?? request.url.split(\"?\")[0],\n        method: request.method,\n        api,\n      };\n      const result = config.cacheControlHandler(cacheReq);\n      if (result) return result;\n    }\n\n    return null;\n  }\n\n  /**\n   * SSR용 API 호출 (HTTP 오버헤드 없이 직접 호출)\n   * createApiHandler의 로직을 재사용하되, request 파싱 대신 params 직접 사용\n   */\n  async invokeApiForSSR(\n    api: ExtendedApi,\n    // biome-ignore lint/suspicious/noExplicitAny: SSR에서 다양한 타입의 params를 받아야 함\n    params: any[],\n    config: SonamuFastifyConfig,\n    request: FastifyRequest,\n    reply: FastifyReply,\n  ): Promise<unknown> {\n    // Context 생성 (기존 메소드 재사용)\n    const context = await this.createContext(config, request, reply);\n\n    return this.asyncLocalStorage.run({ context }, async () => {\n      // args 생성: Context 파라미터는 주입, 나머지는 params에서 가져오기\n      const { ApiParamType } = await import(\"../types/types\");\n      let paramsIndex = 0;\n      const args = api.parameters.map((param) => {\n        if (ApiParamType.isContext(param.type)) {\n          return context;\n        }\n        return params[paramsIndex++];\n      });\n\n      // 모델 메서드 호출 (기존 메서드 재사용)\n      return this.invokeModelMethod(api, args, reply);\n    });\n  }\n\n  async invokeModelMethod(\n    api: ExtendedApi,\n    args: unknown[],\n    reply: FastifyReply,\n  ): Promise<unknown> {\n    const model = this.syncer.models[api.modelName];\n    // biome-ignore lint/suspicious/noExplicitAny: model은 모델 인스턴스이므로 메서드 호출 가능\n    const result = await (model as any)[api.methodName].apply(model, args);\n    reply.type(api.options.contentType ?? \"application/json\");\n\n    return result;\n  }\n\n  async createContext(\n    config: SonamuFastifyConfig,\n    request: FastifyRequest,\n    reply: FastifyReply,\n  ): Promise<Context> {\n    // createSSEFactory 함수에 미리 request의 socket과 reply를 바인딩.\n    const { createSSEFactory } = await import(\"../stream/sse\");\n    const createSSE = (<T extends ZodObject>(\n      _request: FastifyRequest,\n      _reply: FastifyReply,\n      _events: T,\n    ) => createSSEFactory(_request.socket, _reply, _events)).bind(null, request, reply);\n\n    // locale 감지\n    const locale =\n      this.detectLocale(request.headers[\"accept-language\"], this.config.i18n.supportedLocales) ??\n      this.config.i18n.defaultLocale;\n\n    // auth context 추가\n    const headers = convertFastifyHeadersToStandard(request.headers);\n    const session = (await this._auth?.api.getSession({ headers })) ?? null;\n\n    const context: Context = {\n      ...(await Promise.resolve(\n        config.contextProvider(\n          {\n            request,\n            reply,\n            headers: request.headers,\n            createSSE,\n            naiteStore: Naite.createStore(),\n            locale,\n            // auth\n            user: session?.user ?? null,\n            session: session?.session ?? null,\n          },\n          request,\n          reply,\n        ),\n      )),\n    };\n    return context;\n  }\n\n  /**\n   * Accept-Language 헤더에서 지원하는 locale을 찾습니다.\n   * @example \"ko-KR,ko;q=0.9,en;q=0.8\" → \"ko\"\n   */\n  private detectLocale(\n    acceptLanguage: string | undefined,\n    supported: string[],\n  ): string | undefined {\n    if (!acceptLanguage) return undefined;\n\n    // Accept-Language: ko-KR,ko;q=0.9,en;q=0.8\n    const langs = acceptLanguage.split(\",\").map((lang) => {\n      const [code] = lang.split(\";\");\n      return code.trim().split(\"-\")[0]; // ko-KR → ko\n    });\n\n    return langs.find((lang) => supported.includes(lang));\n  }\n\n  async startWatcher(): Promise<void> {\n    const watchPath = [path.join(this.apiRootPath, \"src\")];\n\n    const chokidar = (await import(\"chokidar\")).default;\n    this.watcher = chokidar.watch(watchPath, {\n      ignored: (path, stats) =>\n        !!stats?.isFile() && !path.endsWith(\".ts\") && !path.endsWith(\".json\"),\n      persistent: true,\n      ignoreInitial: true,\n    });\n\n    this.watcher.on(\"all\", async (event: string, filePath: string) => {\n      const absolutePath = filePath as AbsolutePath;\n      assert(\n        absolutePath.startsWith(this.apiRootPath),\n        \"File path is not within the API root path\",\n      );\n\n      if (event !== \"change\" && event !== \"add\") {\n        return;\n      }\n\n      try {\n        // sonamu.config.ts 변경 시 재시작\n        const isConfigTs = filePath === path.join(this.apiRootPath, \"src\", \"sonamu.config.ts\");\n\n        if (isConfigTs) {\n          const relativePath = filePath.replace(this.apiRootPath, \"api\");\n          const chalk = (await import(\"chalk\")).default;\n          console.log(\n            chalk.bold(`Detected(${event}): ${chalk.blue(relativePath)} - Restarting...`),\n          );\n          process.kill(process.pid, \"SIGUSR2\");\n          return;\n        }\n\n        await this.handleFileChange(event, absolutePath);\n      } catch (e) {\n        console.error(e);\n      }\n    });\n  }\n\n  /*\n     A function that automatically handles init and destroy when using Sonamu via scripts.\n  */\n  async runScript(fn: () => Promise<void>) {\n    await this.init(true, false, undefined, false);\n    try {\n      await fn();\n    } finally {\n      await this.destroy();\n    }\n  }\n\n  private async registerPlugins(server: FastifyInstance, plugins: SonamuServerOptions[\"plugins\"]) {\n    if (!plugins) {\n      return;\n    }\n\n    // compress 플러그인은 다른 플러그인보다 먼저 등록되어야 합니다.\n    if (plugins.compress) {\n      const compressPlugin = (await import(\"@fastify/compress\")).default;\n      const defaultOptions = {\n        threshold: 1024,\n        encodings: [\"br\", \"gzip\", \"deflate\"] as (\"br\" | \"gzip\" | \"deflate\")[],\n      };\n\n      if (plugins.compress === true) {\n        server.register(compressPlugin, defaultOptions);\n      } else {\n        server.register(compressPlugin, {\n          ...defaultOptions,\n          ...plugins.compress,\n        });\n      }\n    }\n\n    const pluginsModules = {\n      cors: \"@fastify/cors\",\n      formbody: \"@fastify/formbody\",\n      multipart: \"@fastify/multipart\",\n      qs: \"fastify-qs\",\n      sse: \"fastify-sse-v2\",\n      static: \"@fastify/static\",\n    } as const;\n\n    const registerPlugin = async <K extends keyof NonNullable<typeof plugins>>(\n      key: K,\n      pluginName: string,\n    ) => {\n      const option = plugins[key];\n      if (!option) return;\n\n      if (option === true) {\n        server.register((await import(pluginName)).default);\n      } else {\n        server.register((await import(pluginName)).default, option);\n      }\n    };\n\n    for (const [key, pluginName] of Object.entries(pluginsModules)) {\n      await registerPlugin(key as keyof typeof plugins, pluginName);\n    }\n\n    if (plugins.custom) {\n      plugins.custom(server);\n    }\n  }\n\n  /**\n   * better-auth 라우트를 등록합니다.\n   * /api/auth/* 경로로 인증 API가 자동 등록됩니다.\n   */\n  private async registerBetterAuth(\n    server: FastifyInstance,\n    options: NonNullable<SonamuServerOptions[\"auth\"]>,\n  ) {\n    if (!options) return;\n\n    const basePath = options.basePath ?? \"/api/auth\";\n\n    // 사용자 설정과 기본값을 merge\n    const mergedFieldMappings = merge(BASE_FIELD_MAPPINGS, options);\n\n    // better-auth 인스턴스 생성\n    const { betterAuth } = await import(\"better-auth\");\n    const { Pool } = await import(\"pg\");\n\n    this._auth = betterAuth({\n      database: new Pool(DB.getDBConfig(\"w\").connection as PoolConfig),\n      ...mergedFieldMappings,\n    });\n\n    // better-auth 라우트 등록\n    server.route({\n      method: [\"GET\", \"POST\"],\n      url: `${basePath}/*`,\n      handler: async (request, reply) => {\n        const url = new URL(request.url, `http://${request.headers.host}`);\n        const headers = convertFastifyHeadersToStandard(request.headers);\n        const req = new Request(url.toString(), {\n          method: request.method,\n          headers,\n          ...(request.body ? { body: JSON.stringify(request.body) } : {}),\n        });\n\n        const response = await this.auth.handler(req);\n\n        reply.status(response.status);\n        response.headers.forEach((value: string, key: string) => {\n          reply.header(key, value);\n        });\n        return reply.send(response.body ? await response.text() : null);\n      },\n    });\n\n    const chalk = (await import(\"chalk\")).default;\n    console.log(chalk.green(`✓ better-auth registered at ${basePath}/*`));\n  }\n\n  private async initializeCache(config: CacheConfig | undefined, forTesting: boolean) {\n    const { setCacheManagerRef } = await import(\"../cache/decorator\");\n\n    // 테스트 환경에서 메모리 드라이버 자동 사용\n    if (forTesting) {\n      const { createTestCacheManager } = await import(\"../cache/cache-manager\");\n      this._cache = createTestCacheManager();\n      setCacheManagerRef(this._cache);\n      return;\n    }\n\n    // 설정이 없으면 캐시 비활성화\n    if (!config) {\n      setCacheManagerRef(null);\n      return;\n    }\n\n    // 설정에 따라 CacheManager 생성\n    const { createCacheManager } = await import(\"../cache/cache-manager\");\n    this._cache = createCacheManager(config);\n    setCacheManagerRef(this._cache);\n  }\n\n  private async initializeWorkflows(options: SonamuTaskOptions | undefined) {\n    const { WorkflowManager } = await import(\"../tasks/workflow-manager\");\n    // NOTE: @sonamu-kit/tasks 안에선 knex config를 수정하기 때문에 connection이 아닌 config 째로 보냅니다.\n    this._workflows = new WorkflowManager(DB.getDBConfig(\"w\"));\n    if (!options) {\n      return;\n    }\n\n    const enableWorker = options.enableWorker ?? isDaemonServer();\n    const defaultWorkerOptions = {\n      concurrency: os.cpus().length - 1,\n      usePubSub: true,\n      listenDelay: 500,\n    };\n\n    if (enableWorker) {\n      this.workflows.setupWorker({\n        ...defaultWorkerOptions,\n        ...options.workerOptions,\n      });\n    }\n  }\n\n  private async boot(server: FastifyInstance, options: SonamuServerOptions) {\n    const port = options.listen?.port ?? 3000;\n    const host = options.listen?.host ?? \"localhost\";\n\n    server.addHook(\"onClose\", async () => {\n      await options.lifecycle?.onShutdown?.(server);\n      await this.workflows.destroy();\n      await this.destroy();\n    });\n\n    const shutdown = async () => {\n      try {\n        await server.close();\n        process.exit(0);\n      } catch (err) {\n        console.error(\"Error during shutdown:\", err);\n        process.exit(1);\n      }\n    };\n\n    process.on(\"SIGINT\", shutdown);\n    process.on(\"SIGTERM\", shutdown);\n\n    if (options.lifecycle?.onError) {\n      server.setErrorHandler(options.lifecycle?.onError);\n    }\n\n    server\n      .listen({ port, host })\n      .then(async () => {\n        await this.workflows.startWorker();\n        await options.lifecycle?.onStart?.(server);\n      })\n      .catch(async (err) => {\n        const chalk = (await import(\"chalk\")).default;\n        console.error(chalk.red(\"Failed to start server:\", err));\n        await shutdown();\n      });\n  }\n\n  private async handleFileChange(event: string, filePath: AbsolutePath): Promise<void> {\n    // 첫 번째 파일이면 HMR 시작 시간 기록\n    if (this.pendingFiles.length === 0) {\n      this.hmrStartTime = Date.now();\n    }\n    this.pendingFiles.push(filePath);\n\n    const relativePath = path.relative(this.apiRootPath, filePath);\n    const chalk = (await import(\"chalk\")).default;\n    console.log(chalk.bold(`Detected(${event}): ${chalk.blue(relativePath)}`));\n\n    await this.syncer.syncFromWatcher(event, filePath);\n\n    // 처리 완료된 파일을 대기 목록에서 제거\n    this.pendingFiles = this.pendingFiles.slice(1);\n\n    // 모든 파일 처리가 완료되면 최종 메시지 출력\n    if (this.pendingFiles.length === 0) {\n      await this.finishHMR();\n    }\n  }\n\n  private async finishHMR(): Promise<void> {\n    await this.syncer.renewChecksums();\n\n    const endTime = Date.now();\n    const totalTime = endTime - this.hmrStartTime;\n    const [chalk, { centerText }] = await Promise.all([\n      (await import(\"chalk\")).default,\n      import(\"../utils/console-util\"),\n    ]);\n    const msg = `HMR Done! ${chalk.bold.white(`${totalTime}ms`)}`;\n\n    console.log(chalk.black.bgGreen(centerText(msg)));\n  }\n\n  async destroy(): Promise<void> {\n    const { BaseModel } = await import(\"../database/base-model\");\n    // 먼저 처리해야함.\n    await BaseModel.destroy();\n    await Promise.allSettled([\n      this._workflows?.destroy() ?? Promise.resolve(),\n      this._cache?.disconnect() ?? Promise.resolve(),\n      this.watcher?.close() ?? Promise.resolve(),\n      logtapeDispose(),\n    ]);\n  }\n}\n\nexport const Sonamu = new SonamuClass();\n\n/**\n * stream 모드에서 키 생성 함수가 지정되지 않았을 때 사용하는 기본 함수입니다.\n */\nfunction defaultKeyGenerator(file: { filename: string; mimetype: string }): string {\n  const ext = mime.extension(file.mimetype) || \"bin\";\n  const timestamp = Date.now();\n  const random = Math.random().toString(36).slice(2, 8);\n  return `uploads/${timestamp}-${random}.${ext}`;\n}\n"],"names":["dispose","logtapeDispose","assert","AsyncLocalStorage","fs","mime","lookup","mimeLookup","os","path","BASE_FIELD_MAPPINGS","convertFastifyHeadersToStandard","createMockSSEFactory","DB","isDaemonServer","merge","NotFoundException","applyCacheHeaders","CachePresets","toFastifyCompressOption","SD","Naite","BufferedFile","UploadedFile","exists","fileExists","getSecrets","SonamuClass","isInitialized","forTesting","asyncLocalStorage","getContext","store","getStore","context","process","env","NODE_ENV","request","reply","headers","createSSE","schema","naiteStore","Map","Error","_apiRootPath","apiRootPath","appRootPath","split","sep","slice","join","_dbConfig","dbConfig","_syncer","syncer","_config","config","secrets","_storage","storage","_cache","cache","_workflows","workflows","_auth","auth","watcher","pendingFiles","hmrStartTime","server","initForTesting","init","undefined","doSilent","enableSync","chalk","default","console","time","cyan","findApiRootPath","loadConfig","database","defaultOptions","client","configureLogTape","logging","generateDBConfig","log","green","EntityManager","autoload","initializeCache","initializeWorkflows","tasks","Syncer","autoloadTypes","autoloadModels","autoloadApis","autoloadWorkflows","TemplateManager","autoloadSSRRoutes","isLocal","isTest","setupBiome","isHotReloadServer","sync","startWatcher","timeEnd","createServer","initOptions","options","fastify","getLogTapeFastifyLogger","logger","category","fastifyCategory","StorageManager","plugins","registerPlugins","registerBetterAuth","withFastify","apiConfig","boot","timezone","api","formatInTimeZone","ISO_DATE_REGEX","DATE_FORMAT","setReplySerializer","payload","JSON","stringify","_key","value","test","Date","get","route","prefix","_request","_reply","apis","sonamuUIApiPlugin","register","webPath","hasWeb","pluginCompress","compress","globalCompressOptions","threshold","encodings","customTypes","disableIntegratedWeb","SONAMU_DISABLE_INTEGRATED_WEB","setupDevServerWithVite","setupDevServer","models","modelName","method","httpMethod","url","handler","createApiHandler","setupStaticWebServer","handleDevApiRequest","getPathnameFromUrl","startsWith","matchedApi","find","apiMethod","fullPath","isPathPatternMatch","viteServer","vite","root","middlewareMode","hmr","appType","use","req","res","next","middlewares","result","matchSSRRoute","renderSSR","ssrMatch","html","params","type","template","readFile","transformIndexHtml","e","ssrFixStacktrace","error","status","message","addHook","close","webDistPath","ssrPath","ssrEntryPath","ssrRoutesPath","warn","ssrAvailable","requestedFile","filename","assetsDir","safeFilePath","resolvePathWithinBaseDir","send","normalizedRequestedFile","relative","replace","assetPath","getCacheControlForAsset","cacheReq","cacheControlHandler","immutable","ext","pop","files","readdir","currentFile","f","endsWith","filePath","content","includes","getSSRRoutes","ssrRoutes","extractPathParams","csrCacheReq","csrCacheConfig","requestPath","indexPath","createContext","run","guards","every","guard","guardHandler","getZodObjectFromApi","ReqType","types","which","reqBody","bufferedFiles","uploadedFiles","body","uploadOptions","parts","limits","fields","consume","part","buffer","toBuffer","push","fieldname","String","diskName","destination","disk","keyGenerator","defaultKeyGenerator","key","mimetype","putStream","file","contentType","getUrl","signedUrl","getSignedUrl","size","bytesRead","qs","parsed","parse","Object","assign","fastifyCaster","ZodError","humanizeZodError","messages","map","issue","BadRequestException","zodError","apiCacheConfig","getApiCacheControl","ApiParamType","args","parameters","param","isContext","name","invokeModelMethod","pattern","patternParts","filter","Boolean","urlParts","i","length","patternPart","urlPart","baseDir","inputPath","decoded","decodeURIComponent","relativePath","resolvedPath","resolve","relativeFromBase","isAbsolute","cacheControl","routeOptions","invokeApiForSSR","paramsIndex","model","methodName","apply","createSSEFactory","_events","socket","bind","locale","detectLocale","i18n","supportedLocales","defaultLocale","session","getSession","Promise","contextProvider","createStore","user","acceptLanguage","supported","langs","lang","code","trim","watchPath","chokidar","watch","ignored","stats","isFile","persistent","ignoreInitial","on","event","absolutePath","isConfigTs","bold","blue","kill","pid","handleFileChange","runScript","fn","destroy","compressPlugin","pluginsModules","cors","formbody","multipart","sse","static","registerPlugin","pluginName","option","entries","custom","basePath","mergedFieldMappings","betterAuth","Pool","getDBConfig","connection","URL","host","Request","toString","response","forEach","header","text","setCacheManagerRef","createTestCacheManager","createCacheManager","WorkflowManager","enableWorker","defaultWorkerOptions","concurrency","cpus","usePubSub","listenDelay","setupWorker","workerOptions","port","listen","lifecycle","onShutdown","shutdown","exit","err","onError","setErrorHandler","then","startWorker","onStart","catch","red","now","syncFromWatcher","finishHMR","renewChecksums","endTime","totalTime","centerText","all","msg","white","black","bgGreen","BaseModel","allSettled","disconnect","Sonamu","extension","timestamp","random","Math"],"mappings":"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"}