sonamu 0.8.26 → 0.9.0

package/dist/api/sonamu.js

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