sonamu 0.10.12 → 0.10.13

package/dist/api/sonamu.js

@@ -1,4 +1,5 @@
 import { __esmMin } from "../_virtual/_rolldown/runtime.js";
+import { init_runtime_value, isBigIntValue, isFunctionValue, isNumberValue, isObjectValue, isStringValue, isSymbolValue } from "../utils/runtime-value.js";
 import { getSonamuEnvironment, init_env, readAllEnvironmentSnapshots } from "../env.js";
 import { DB, init_db } from "../database/db.js";
 import { BASE_FIELD_MAPPINGS, init_better_auth_entities } from "../auth/better-auth-entities.js";
@@ -8,6 +9,7 @@ import { CachePresets, applyCacheHeaders, init_cache_control } from "../cache-co
 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 { init_runtime_type, runtimeTypeOf } from "../runtime-type.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";
@@ -15,6 +17,8 @@ import { WebSocketRuntime, init_ws } from "../stream/ws.js";
 import { centerText, init_console_util } from "../utils/console-util.js";
 import { init_controller, isDaemonServer } from "../utils/controller.js";
 import { exists, fileExists, init_fs_utils } from "../utils/fs-utils.js";
+import { init_config, normalizeZodCompilerPolicy } from "./config.js";
+import { assertHttpValidatorRegistry, createHttpValidator, getHttpValidatorRouteKey, init_http_validator } from "./http-validator.js";
 import { getSecrets, init_secret } from "./secret.js";
 import { createWebSocketReplyStub, init_websocket_helpers, resolveIntegratedViteHmrOptions, resolveWebSocketCloseDescriptor, resolveWebSocketPluginOptions } from "./websocket-helpers.js";
 import { AsyncLocalStorage } from "async_hooks";
@@ -23,14 +27,40 @@ import path from "path";
 import chalk from "chalk";
 import fs from "fs/promises";
 import os from "os";
+import "@fastify/websocket";
 import mime, { lookup } from "mime-types";
 //#region src/api/sonamu.ts
+function toApiArgument(value) {
+	if (value === null) return null;
+	if (value === void 0) return void 0;
+	if (value === true) return true;
+	if (value === false) return false;
+	if (isStringValue(value)) return value;
+	if (isNumberValue(value)) return value;
+	if (isBigIntValue(value)) return value;
+	if (isSymbolValue(value)) return value;
+	if (isFunctionValue(value)) return value;
+	if (isObjectValue(value)) return value;
+	throw new Error("지원하지 않는 API 인수 타입입니다.");
+}
+function toApiArgumentMap(value) {
+	return new Map(Object.entries(value).map(([key, item]) => [key, toApiArgument(item)]));
+}
+function createUnavailableSSE(_events) {
+	throw new Error("createSSE is not available in websocket context. Define websocketContextProvider if your context setup depends on SSE helpers.");
+}
+function printDimSummary(message) {
+	console.log(chalk.dim(`✓ ${message}`));
+}
+function printGreenSummary(message) {
+	console.log(chalk.green(`✓ ${message}`));
+}
 function getWebSocketTelemetryContext(ws) {
 	if (!isTelemetryContextProvider(ws)) return {};
 	return ws.getTelemetryContext();
 }
 function isTelemetryContextProvider(ws) {
-	return "getTelemetryContext" in ws && typeof ws.getTelemetryContext === "function";
+	return "getTelemetryContext" in ws && isFunctionValue(ws.getTelemetryContext);
 }
 /**
 * stream 모드에서 키 생성 함수가 지정되지 않았을 때 사용하는 기본 함수입니다.
@@ -48,7 +78,7 @@ function isLocalHost(host) {
 function runGuards({ guards, config, request, api }) {
 	for (const guard of guards ?? []) config.guardHandler(guard, request, api);
 }
-var SonamuClass, Sonamu, LOCAL_HOSTS;
+var defaultSonamuHttpValidatorDependencies, SonamuClass, Sonamu, LOCAL_HOSTS;
 var init_sonamu = __esmMin((() => {
 	init_better_auth_entities();
 	init_better_auth_request();
@@ -58,6 +88,7 @@ var init_sonamu = __esmMin((() => {
 	init_sd();
 	init_env();
 	init_so_exceptions();
+	init_runtime_type();
 	init_buffered_file();
 	init_uploaded_file();
 	init_sse();
@@ -65,13 +96,25 @@ var init_sonamu = __esmMin((() => {
 	init_console_util();
 	init_controller();
 	init_fs_utils();
+	init_runtime_value();
 	init_utils();
+	init_config();
+	init_http_validator();
 	init_secret();
 	init_websocket_helpers();
+	defaultSonamuHttpValidatorDependencies = {
+		createValidator: createHttpValidator,
+		assertRegistry: assertHttpValidatorRegistry
+	};
 	SonamuClass = class {
 		isInitialized = false;
 		forTesting = false;
 		asyncLocalStorage = new AsyncLocalStorage();
+		httpValidators = /* @__PURE__ */ new WeakMap();
+		pendingHttpValidators = /* @__PURE__ */ new WeakMap();
+		aotHttpValidatorRegistry;
+		preparedApis = [];
+		preparedModels = {};
 		getContext() {
 			const store = this.asyncLocalStorage.getStore();
 			if (store?.context) return store.context;
@@ -88,83 +131,107 @@ var init_sonamu = __esmMin((() => {
 			};
 			else throw new Error("Sonamu cannot find context");
 		}
-		_apiRootPath = null;
+		apiRootPathValue = null;
 		set apiRootPath(apiRootPath) {
-			this._apiRootPath = apiRootPath;
+			this.apiRootPathValue = apiRootPath;
 		}
 		get apiRootPath() {
-			if (this._apiRootPath === null) throw new Error("Sonamu has not been initialized");
-			return this._apiRootPath;
+			if (this.apiRootPathValue === null) throw new Error("Sonamu has not been initialized");
+			return this.apiRootPathValue;
 		}
 		get appRootPath() {
 			return this.apiRootPath.split(path.sep).slice(0, -1).join(path.sep);
 		}
-		_dbConfig = null;
+		dbConfigValue = null;
 		set dbConfig(dbConfig) {
-			this._dbConfig = dbConfig;
+			this.dbConfigValue = dbConfig;
 		}
 		get dbConfig() {
-			if (this._dbConfig === null) throw new Error("Sonamu has not been initialized");
-			return this._dbConfig;
+			if (this.dbConfigValue === null) throw new Error("Sonamu has not been initialized");
+			return this.dbConfigValue;
 		}
-		_syncer = null;
+		syncerValue = null;
 		set syncer(syncer) {
-			this._syncer = syncer;
+			this.syncerValue = syncer;
 		}
 		get syncer() {
-			if (this._syncer === null) throw new Error("Sonamu has not been initialized");
-			return this._syncer;
+			if (this.syncerValue === null) throw new Error("Sonamu has not been initialized");
+			return this.syncerValue;
 		}
-		_config = null;
+		configValue = null;
 		set config(config) {
-			this._config = config;
+			this.configValue = config;
 		}
 		get config() {
-			if (this._config === null) throw new Error("Sonamu has not been initialized");
-			return this._config;
+			if (this.configValue === null) throw new Error("Sonamu has not been initialized");
+			return this.configValue;
 		}
 		secrets = getSecrets();
-		_storage = null;
+		storageValue = null;
 		/**
 		* StorageManager 인스턴스
 		*/
 		get storage() {
-			if (!this._storage) throw new Error("Storage has not been initialized. Check storage config.");
-			return this._storage;
+			if (!this.storageValue) throw new Error("Storage has not been initialized. Check storage config.");
+			return this.storageValue;
 		}
-		_cache = null;
+		cacheValue = 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;
+			if (!this.cacheValue) throw new Error("Cache has not been initialized. Check cache config in sonamu.config.ts.");
+			return this.cacheValue;
 		}
-		_workflows = null;
+		workflowsValue = null;
 		get workflows() {
-			if (this._workflows === null) throw new Error("Sonamu has not been initialized");
-			return this._workflows;
+			if (this.workflowsValue === null) throw new Error("Sonamu has not been initialized");
+			return this.workflowsValue;
 		}
-		_auth = null;
+		authValue = null;
 		get auth() {
-			if (!this._auth) throw new Error("Auth has not been initialized. Check auth config in sonamu.config.ts.");
-			return this._auth;
+			if (!this.authValue) throw new Error("Auth has not been initialized. Check auth config in sonamu.config.ts.");
+			return this.authValue;
 		}
-		_devVitestManager = null;
+		devVitestManagerValue = null;
 		get devVitestManager() {
-			return this._devVitestManager;
+			return this.devVitestManagerValue;
 		}
 		set devVitestManager(manager) {
-			this._devVitestManager = manager;
+			this.devVitestManagerValue = manager;
 		}
-		_websocketRuntime = null;
+		websocketRuntimeValue = null;
 		websocketPluginServers = /* @__PURE__ */ new WeakSet();
 		get websocketRuntime() {
-			if (!this._websocketRuntime) throw new Error("WebSocket runtime has not been initialized.");
-			return this._websocketRuntime;
+			if (!this.websocketRuntimeValue) throw new Error("WebSocket runtime has not been initialized.");
+			return this.websocketRuntimeValue;
 		}
 		set websocketRuntime(runtime) {
-			this._websocketRuntime = runtime;
+			this.websocketRuntimeValue = runtime;
+		}
+		captureTestingSnapshot() {
+			return {
+				apiRootPath: this.apiRootPathValue,
+				config: this.configValue,
+				syncer: this.syncerValue,
+				httpValidators: this.httpValidators,
+				pendingHttpValidators: this.pendingHttpValidators,
+				aotHttpValidatorRegistry: this.aotHttpValidatorRegistry,
+				preparedApis: this.preparedApis,
+				preparedModels: this.preparedModels,
+				websocketRuntime: this.websocketRuntimeValue
+			};
+		}
+		restoreTestingSnapshot(snapshot) {
+			this.apiRootPathValue = snapshot.apiRootPath;
+			this.configValue = snapshot.config;
+			this.syncerValue = snapshot.syncer;
+			this.httpValidators = snapshot.httpValidators;
+			this.pendingHttpValidators = snapshot.pendingHttpValidators;
+			this.aotHttpValidatorRegistry = snapshot.aotHttpValidatorRegistry;
+			this.preparedApis = snapshot.preparedApis;
+			this.preparedModels = snapshot.preparedModels;
+			this.websocketRuntimeValue = snapshot.websocketRuntime;
 		}
 		watcher = null;
 		server = null;
@@ -188,11 +255,11 @@ var init_sonamu = __esmMin((() => {
 			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 } = await import("../database/db.js");
+			const { DB: RuntimeDB } = await import("../database/db.js");
 			const { isLocal: isLocalEnvironment } = await import("../utils/controller.js");
 			const environmentSnapshots = isLocalEnvironment() ? readAllEnvironmentSnapshots(this.apiRootPath, baseEnvBeforeConfigLoad) : void 0;
-			this.dbConfig = DB.generateDBConfig(this.config.database, this.config.projectName, environmentSnapshots);
-			DB.setConfig(this.dbConfig);
+			this.dbConfig = RuntimeDB.generateDBConfig(this.config.database, this.config.projectName, environmentSnapshots);
+			RuntimeDB.setConfig(this.dbConfig);
 			const { EntityManager } = await import("../entity/entity-manager.js");
 			await EntityManager.autoload(doSilent);
 			await this.initializeCache(this.config.server.cache, forTesting);
@@ -205,7 +272,7 @@ var init_sonamu = __esmMin((() => {
 					database: sonamuKnexAdapter(),
 					...mergedFieldMappings
 				};
-				this._auth = betterAuth(authOptions);
+				this.authValue = betterAuth(authOptions);
 			}
 			if (forTesting) {
 				this.isInitialized = true;
@@ -227,11 +294,11 @@ var init_sonamu = __esmMin((() => {
 				await this.startWatcher();
 			}
 			this.isInitialized = true;
-			this._initElapsed = performance.now() - initStart;
-			this._configElapsed = configTime;
+			this.initElapsed = performance.now() - initStart;
+			this.configElapsed = configTime;
 		}
-		_initElapsed = 0;
-		_configElapsed = 0;
+		initElapsed = 0;
+		configElapsed = 0;
 		async createServer(initOptions) {
 			if (!this.isInitialized) await this.init(initOptions?.doSilent, initOptions?.enableSync);
 			const options = this.config.server;
@@ -245,7 +312,7 @@ var init_sonamu = __esmMin((() => {
 			this.websocketRuntime = new WebSocketRuntime(options.websocket);
 			if (options.storage) {
 				const { StorageManager } = await import("../storage/storage-manager.js");
-				this._storage = new StorageManager(options.storage);
+				this.storageValue = new StorageManager(options.storage);
 			}
 			if (options.plugins) await this.registerPlugins(server, options.plugins);
 			if (options.auth) await this.registerBetterAuth(server, options.auth);
@@ -261,6 +328,7 @@ var init_sonamu = __esmMin((() => {
 			if (!this.isInitialized) await this.init(options?.doSilent, options?.enableSync);
 			this.server = server;
 			this.websocketRuntime ??= new WebSocketRuntime(this.config.server.websocket);
+			await this.refreshHttpValidators();
 			const timezone = this.config.api.timezone;
 			if (timezone) {
 				const { formatInTimeZone } = await import("date-fns-tz");
@@ -268,7 +336,7 @@ var init_sonamu = __esmMin((() => {
 				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);
+						if (isStringValue(value) && ISO_DATE_REGEX.test(value)) return formatInTimeZone(new Date(value), timezone, DATE_FORMAT);
 						return value;
 					});
 				});
@@ -322,7 +390,7 @@ var init_sonamu = __esmMin((() => {
 					server.route({
 						method: api.options.httpMethod ?? "GET",
 						url: this.config.api.route.prefix + api.path,
-						handler: this.createApiHandler(api, config),
+						handler: await this.createApiHandler(api, config),
 						compress: toFastifyCompressOption(api.options.compress, globalCompressOptions)
 					});
 				}
@@ -330,24 +398,24 @@ var init_sonamu = __esmMin((() => {
 			}
 		}
 		/**
-		* dev 모드 공통: catch-all에서 syncer.apis를 동적으로 탐색하여 API 요청을 처리합니다.
+		* dev 모드 공통: catch-all에서 마지막 준비 완료 API snapshot을 탐색하여 요청을 처리합니다.
 		* server.route()로 개별 등록하면 handler가 고정되어 HMR이 동작하지 않으므로,
-		* 매 요청마다 syncer.apis를 조회하는 이 방식을 사용합니다.
+		* refresh 성공 시 교체되는 snapshot을 매 요청 조회합니다.
 		*
 		* 요청이 /api(정확히는 this.config.api.route.prefix)로 시작하지 않는 경우라면 null을 반환하며 끝냅니다.
 		*/
-		handleDevApiRequest(request, config) {
-			const matchedApi = this.findMatchedApi(request);
+		async handleDevApiRequest(request, config) {
+			const matchedApi = this.findMatchedApi(request, this.preparedApis, this.preparedModels);
 			if (!matchedApi) throw new NotFoundException(SD("error.api.notFound"));
 			if (matchedApi.websocketOptions) return this.createWebSocketUpgradeRequiredHandler();
-			return this.createApiHandler(matchedApi, config);
+			return await this.createApiHandler(matchedApi, config, this.preparedModels);
 		}
-		findMatchedApi(request) {
+		findMatchedApi(request, apis, models) {
 			const url = this.getPathnameFromUrl(request.url);
 			const method = request.method;
 			if (!url.startsWith(this.config.api.route.prefix)) return;
-			return this.syncer.apis.find((api) => {
-				if (this.syncer.models[api.modelName] === void 0) return false;
+			return apis.find((api) => {
+				if (models[api.modelName] === void 0) return false;
 				if ((api.options.httpMethod ?? "GET") !== method) return false;
 				const fullPath = this.config.api.route.prefix + api.path;
 				return this.isPathPatternMatch(fullPath, url);
@@ -355,14 +423,14 @@ var init_sonamu = __esmMin((() => {
 		}
 		/**
 		* dev api 모드: Vite 없이 API 동적 라우팅만 제공합니다.
-		* HMR을 위해 catch-all에서 매 요청마다 syncer.apis를 조회합니다.
+		* HMR을 위해 catch-all에서 매 요청마다 준비 완료 API snapshot을 조회합니다.
 		*/
 		setupDevServer(server, config) {
 			server.route({
 				method: "GET",
 				url: `${this.config.api.route.prefix}/*`,
 				handler: async (request, reply) => {
-					const handler = this.handleDevApiRequest(request, config);
+					const handler = await this.handleDevApiRequest(request, config);
 					if (handler) return handler(request, reply);
 					throw new NotFoundException(SD("error.api.notFound"));
 				},
@@ -380,7 +448,7 @@ var init_sonamu = __esmMin((() => {
 				],
 				url: `${this.config.api.route.prefix}/*`,
 				handler: async (request, reply) => {
-					const handler = this.handleDevApiRequest(request, config);
+					const handler = await this.handleDevApiRequest(request, config);
 					if (handler) return handler(request, reply);
 					throw new NotFoundException(SD("error.api.notFound"));
 				}
@@ -415,7 +483,7 @@ var init_sonamu = __esmMin((() => {
 				method: "GET",
 				url: `${this.config.api.route.prefix}/*`,
 				handler: async (request, reply) => {
-					const result = this.handleDevApiRequest(request, config);
+					const result = await this.handleDevApiRequest(request, config);
 					if (result) return result(request, reply);
 					throw new NotFoundException(SD("error.api.notFound"));
 				},
@@ -433,7 +501,7 @@ var init_sonamu = __esmMin((() => {
 				],
 				url: `${this.config.api.route.prefix}/*`,
 				handler: async (request, reply) => {
-					const result = this.handleDevApiRequest(request, config);
+					const result = await this.handleDevApiRequest(request, config);
 					if (result) return result(request, reply);
 					throw new NotFoundException(SD("error.api.notFound"));
 				}
@@ -452,8 +520,10 @@ var init_sonamu = __esmMin((() => {
 						return html;
 					}
 					try {
-						let template = await (await import("node:fs/promises")).readFile(path.join(this.viteServer.config.root, "index.html"), "utf-8");
+						let template = await fs.readFile(path.join(this.viteServer.config.root, "index.html"), "utf-8");
 						template = await this.viteServer.transformIndexHtml(url, template);
+						const { HMR_OPT_OUT_SCRIPT, isHmrDisabledByQuery } = await import("../ssr/hmr-opt-out.js");
+						if (isHmrDisabledByQuery(url)) template = template.replace("<head>", `<head>\n${HMR_OPT_OUT_SCRIPT}`);
 						reply.type("text/html");
 						return template;
 					} catch (e) {
@@ -467,7 +537,6 @@ var init_sonamu = __esmMin((() => {
 			server.addHook("onClose", async () => {
 				await this.viteServer.close();
 			});
-			const chalk = (await import("chalk")).default;
 			if ("port" in hmr) console.log(chalk.dim(`✓ Vite HMR using dedicated websocket port ${hmr.port} to avoid Fastify websocket conflicts`));
 			console.log(chalk.dim("✓ Vite dev server integrated"));
 		}
@@ -584,8 +653,10 @@ var init_sonamu = __esmMin((() => {
 			});
 			console.log(`✓ Static web server configured with ${ssrAvailable ? "SSR" : "CSR only"} support`);
 		}
-		createApiHandler(api, config) {
+		createApiHandler(api, config, models = this.syncer.models, dependencies = defaultSonamuHttpValidatorDependencies) {
+			const preparedValidator = this.getOrCreateHttpValidator(api, dependencies);
 			return async (request, reply) => {
+				const validator = preparedValidator instanceof Promise ? await preparedValidator : preparedValidator;
 				const context = await this.createContext(config, request, reply);
 				return this.asyncLocalStorage.run({ context }, async () => {
 					runGuards({
@@ -594,10 +665,8 @@ var init_sonamu = __esmMin((() => {
 						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;
+					let reqBody = /* @__PURE__ */ new Map();
 					const files = {
 						bufferedFiles: [],
 						uploadedFiles: []
@@ -638,8 +707,7 @@ var init_sonamu = __esmMin((() => {
 							const parsed = (await import("qs")).default.parse(fields);
 							Object.assign(body, parsed);
 						}
-						const { fastifyCaster } = await import("./caster.js");
-						reqBody = fastifyCaster(ReqType).parse(body);
+						reqBody = toApiArgumentMap(validator.parse(body));
 					} catch (e) {
 						const { ZodError } = await import("zod");
 						if (e instanceof ZodError) {
@@ -660,19 +728,90 @@ var init_sonamu = __esmMin((() => {
 					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];
+						else return reqBody.get(param.name);
 					});
-					return this.invokeModelMethod(api, args, reply);
+					return this.invokeModelMethod(api, args, reply, models);
 				});
 			};
 		}
+		getOrCreateHttpValidator(api, dependencies) {
+			const cached = this.httpValidators.get(api);
+			if (cached !== void 0) return cached;
+			const existing = this.pendingHttpValidators.get(api);
+			if (existing !== void 0) return existing;
+			const pending = this.buildHttpValidator(api, dependencies);
+			this.pendingHttpValidators.set(api, pending);
+			pending.then((validator) => {
+				this.httpValidators.set(api, validator);
+				this.pendingHttpValidators.delete(api);
+			}, () => {
+				this.pendingHttpValidators.delete(api);
+			});
+			return pending;
+		}
+		async buildHttpValidator(api, dependencies) {
+			const policy = normalizeZodCompilerPolicy(this.config.validation?.zodCompiler);
+			const sourceAot = process.env.HOT === "yes" || process.env.VITEST === "true";
+			if (policy.api === "aot" && !sourceAot) {
+				const registry = this.aotHttpValidatorRegistry ?? await this.loadAotHttpValidatorRegistry();
+				return this.getAotHttpValidator(api, registry);
+			}
+			return await dependencies.createValidator({
+				api,
+				policy,
+				types: this.syncer.types,
+				allowAotSourceFallback: sourceAot
+			});
+		}
+		getAotHttpValidator(api, registry) {
+			const routeKey = getHttpValidatorRouteKey(api);
+			const validator = registry.validators.get(routeKey);
+			if (validator === void 0) throw new Error(`HTTP validator registry is missing ${routeKey}`);
+			return validator;
+		}
+		async loadAotHttpValidatorRegistry(apis = this.syncer.apis, dependencies = defaultSonamuHttpValidatorDependencies) {
+			const { pathToFileURL } = await import("node:url");
+			const registryPath = path.join(this.apiRootPath, "dist/application/sonamu.validators.generated.js");
+			if (!await exists(registryPath)) throw new Error(`Generated HTTP validator registry not found: ${registryPath}`);
+			const imported = await import(pathToFileURL(registryPath).href);
+			if (!isStringValue(imported.fingerprint) || !(imported.validators instanceof Map)) throw new Error(`Invalid generated HTTP validator registry: ${registryPath}`);
+			for (const [key, validator] of imported.validators) if (!isStringValue(key) || !isObjectValue(validator) || validator === null || !("parse" in validator) || !isFunctionValue(validator.parse)) throw new Error(`Invalid HTTP validator registry entry: ${String(key)}`);
+			const registry = {
+				fingerprint: imported.fingerprint,
+				validators: imported.validators
+			};
+			dependencies.assertRegistry(apis, registry);
+			return registry;
+		}
+		async refreshHttpValidators(dependencies = defaultSonamuHttpValidatorDependencies) {
+			const policy = normalizeZodCompilerPolicy(this.config.validation?.zodCompiler);
+			const sourceAot = process.env.HOT === "yes" || process.env.VITEST === "true";
+			const nextApis = [...this.syncer.apis];
+			const nextModels = { ...this.syncer.models };
+			const restApis = nextApis.filter((api) => api.websocketOptions === void 0);
+			const next = /* @__PURE__ */ new WeakMap();
+			let nextAotRegistry;
+			if (policy.api === "aot" && !sourceAot) {
+				const registry = await this.loadAotHttpValidatorRegistry(nextApis, dependencies);
+				for (const api of restApis) next.set(api, this.getAotHttpValidator(api, registry));
+				nextAotRegistry = registry;
+			} else await Promise.all(restApis.map(async (api) => {
+				const validator = await this.buildHttpValidator(api, dependencies);
+				next.set(api, validator);
+			}));
+			this.httpValidators = next;
+			this.pendingHttpValidators = /* @__PURE__ */ new WeakMap();
+			this.aotHttpValidatorRegistry = nextAotRegistry;
+			this.preparedApis = nextApis;
+			this.preparedModels = nextModels;
+		}
 		createWebSocketUpgradeRequiredHandler() {
 			return async (_request, reply) => {
 				reply.header("connection", "Upgrade").header("upgrade", "websocket").status(426).send({ message: "WebSocket upgrade required" });
 			};
 		}
 		async handleDevWebSocketRequest(socket, request, config) {
-			const matchedApi = this.findMatchedApi(request);
+			const matchedApi = this.findMatchedApi(request, this.syncer.apis, this.syncer.models);
 			if (!matchedApi?.websocketOptions) {
 				const traceContext = this.websocketRuntime.telemetryController.createConnectionContext({ headers: request.headers });
 				this.websocketRuntime.telemetryController.emit({
@@ -692,6 +831,9 @@ var init_sonamu = __esmMin((() => {
 			}
 			await this.createWebSocketHandler(matchedApi, config)({ socket }, request);
 		}
+		createWebSocketHandlerForTesting(api, config) {
+			return this.createWebSocketHandler(api, config);
+		}
 		createWebSocketHandler(api, config) {
 			return async (connection, request) => {
 				const socket = connection.socket;
@@ -730,7 +872,7 @@ var init_sonamu = __esmMin((() => {
 					const { ApiParamType } = await import("../types/types.js");
 					const args = api.parameters.map((param) => {
 						if (ApiParamType.isContext(param.type)) return wsContext;
-						return reqBody[param.name];
+						return reqBody.get(param.name);
 					});
 					await this.asyncLocalStorage.run({ context: wsContext }, async () => {
 						await this.invokeModelMethod(api, args);
@@ -767,7 +909,7 @@ var init_sonamu = __esmMin((() => {
 			};
 		}
 		createScopedWebSocketConnection(ws, getContext) {
-			const telemetryController = this._websocketRuntime?.telemetryController;
+			const telemetryController = this.websocketRuntimeValue?.telemetryController;
 			const runInContext = (callback) => {
 				const context = getContext();
 				if (!context) return callback();
@@ -854,7 +996,7 @@ var init_sonamu = __esmMin((() => {
 								namespace: ws.namespace,
 								userId: ws.userId,
 								attributes: { event: eventName },
-								errorType: error instanceof Error ? error.name : typeof error,
+								errorType: error instanceof Error ? error.name : runtimeTypeOf(error),
 								...traceContext
 							});
 							throw error;
@@ -881,12 +1023,15 @@ var init_sonamu = __esmMin((() => {
 				}
 			};
 		}
+		createScopedWebSocketConnectionForTesting(ws, getContext) {
+			return this.createScopedWebSocketConnection(ws, getContext);
+		}
 		async parseWebSocketRequestParams(api, request) {
 			const { getZodObjectFromApi } = await import("./code-converters.js");
 			const ReqType = getZodObjectFromApi(api, this.syncer.types);
 			try {
 				const { fastifyCaster } = await import("./caster.js");
-				return fastifyCaster(ReqType).parse(request.query ?? {});
+				return toApiArgumentMap(fastifyCaster(ReqType).parse(request.query ?? {}));
 			} catch (e) {
 				const { ZodError } = await import("zod");
 				if (e instanceof ZodError) {
@@ -972,9 +1117,15 @@ var init_sonamu = __esmMin((() => {
 				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);
+		async handleDevApiRequestForTesting(request, config) {
+			return await this.handleDevApiRequest(request, config);
+		}
+		async invokeModelMethod(api, args, reply, models = this.syncer.models) {
+			const model = models[api.modelName];
+			if (model === void 0) throw new Error(`Model not found: ${api.modelName}`);
+			const method = model[api.methodName];
+			if (!isFunctionValue(method)) throw new Error(`Model method not found: ${api.modelName}.${api.methodName}`);
+			const result = await Function.prototype.apply.call(method, model, args);
 			reply?.type(api.options.contentType ?? "application/json");
 			return result;
 		}
@@ -983,7 +1134,7 @@ var init_sonamu = __esmMin((() => {
 			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 session = await this.authValue?.api.getSession({ headers }) ?? null;
 			return await Promise.resolve(config.contextProvider({
 				transport: "http",
 				request,
@@ -999,7 +1150,7 @@ var init_sonamu = __esmMin((() => {
 		async createWebSocketContext(config, request, ws) {
 			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 session = await this.authValue?.api.getSession({ headers }) ?? null;
 			const defaultContext = {
 				transport: "ws",
 				request,
@@ -1012,15 +1163,12 @@ var init_sonamu = __esmMin((() => {
 			};
 			if (config.websocketContextProvider) return { ...await Promise.resolve(config.websocketContextProvider(defaultContext, request)) };
 			const replyStub = createWebSocketReplyStub();
-			const createSSE = (_events) => {
-				throw new Error("createSSE is not available in websocket context. Define websocketContextProvider if your context setup depends on SSE helpers.");
-			};
 			const { transport: _transport, reply: _reply, createSSE: _createSSE, bufferedFiles: _bufferedFiles, uploadedFiles: _uploadedFiles, ...rest } = await Promise.resolve(config.contextProvider({
 				transport: "http",
 				request,
 				reply: replyStub,
 				headers: request.headers,
-				createSSE,
+				createSSE: createUnavailableSSE,
 				naiteStore: defaultContext.naiteStore,
 				locale,
 				user: defaultContext.user,
@@ -1152,12 +1300,9 @@ var init_sonamu = __esmMin((() => {
 			});
 		}
 		async printStartupSummary() {
-			const chalk = (await import("chalk")).default;
 			const activePreset = getSonamuEnvironment();
-			const dim = (msg) => console.log(chalk.dim(`✓ ${msg}`));
-			const green = (msg) => console.log(chalk.green(`✓ ${msg}`));
-			dim(`Config loaded${formatTime(this._configElapsed)}`);
-			green("DB");
+			printDimSummary(`Config loaded${formatTime(this.configElapsed)}`);
+			printGreenSummary("DB");
 			const { isLocal } = await import("../utils/controller.js");
 			const presetNames = Object.keys(this.dbConfig);
 			const maxLen = Math.max(...presetNames.map((n) => n.length));
@@ -1170,16 +1315,16 @@ var init_sonamu = __esmMin((() => {
 				if (name === activePreset) console.log(chalk.green(`  \u25b8 ${padded} ${addr}`) + remoteTag);
 				else console.log(chalk.dim(`    ${padded} ${addr}`) + remoteTag);
 			}
-			if (this.config.server.auth) dim(`Auth: better-auth at ${this.config.server.auth.basePath ?? "/api/auth"}/*`);
-			if (this.config.api.timezone) dim(`Timezone: ${this.config.api.timezone}`);
-			green(`Sonamu ready${formatTime(this._initElapsed)}`);
+			if (this.config.server.auth) printDimSummary(`Auth: better-auth at ${this.config.server.auth.basePath ?? "/api/auth"}/*`);
+			if (this.config.api.timezone) printDimSummary(`Timezone: ${this.config.api.timezone}`);
+			printGreenSummary(`Sonamu ready${formatTime(this.initElapsed)}`);
 		}
 		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);
+				this.cacheValue = createTestCacheManager();
+				setCacheManagerRef(this.cacheValue);
 				return;
 			}
 			if (!config) {
@@ -1187,12 +1332,12 @@ var init_sonamu = __esmMin((() => {
 				return;
 			}
 			const { createCacheManager } = await import("../cache/cache-manager.js");
-			this._cache = createCacheManager(config);
-			setCacheManagerRef(this._cache);
+			this.cacheValue = createCacheManager(config);
+			setCacheManagerRef(this.cacheValue);
 		}
 		async initializeWorkflows(options) {
 			const { WorkflowManager } = await import("../tasks/workflow-manager.js");
-			this._workflows = new WorkflowManager(DB.getDBConfig("w"));
+			this.workflowsValue = new WorkflowManager(DB.getDBConfig("w"));
 			if (!options) return;
 			const enableWorker = options.enableWorker ?? isDaemonServer();
 			const defaultWorkerOptions = {
@@ -1232,7 +1377,6 @@ var init_sonamu = __esmMin((() => {
 				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();
 			});
@@ -1240,12 +1384,12 @@ var init_sonamu = __esmMin((() => {
 		async destroy() {
 			const { BaseModel } = await import("../database/base-model.js");
 			await BaseModel.destroy();
-			if (this._websocketRuntime) await this._websocketRuntime.shutdown();
-			this._websocketRuntime = null;
+			if (this.websocketRuntimeValue) await this.websocketRuntimeValue.shutdown();
+			this.websocketRuntimeValue = null;
 			await Promise.allSettled([
-				this._workflows?.destroy() ?? Promise.resolve(),
-				this._cache?.disconnect() ?? Promise.resolve(),
-				this._devVitestManager?.shutdown() ?? Promise.resolve(),
+				this.workflowsValue?.destroy() ?? Promise.resolve(),
+				this.cacheValue?.disconnect() ?? Promise.resolve(),
+				this.devVitestManagerValue?.shutdown() ?? Promise.resolve(),
 				this.watcher?.close() ?? Promise.resolve()
 			]);
 			await dispose();
@@ -1261,6 +1405,6 @@ var init_sonamu = __esmMin((() => {
 }));
 //#endregion
 init_sonamu();
-export { Sonamu, createWebSocketReplyStub, init_sonamu, resolveWebSocketCloseDescriptor, resolveWebSocketPluginOptions };
+export { Sonamu, createWebSocketReplyStub, defaultSonamuHttpValidatorDependencies, init_sonamu, resolveWebSocketCloseDescriptor, resolveWebSocketPluginOptions };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sonamu.js","names":["mimeLookup","logtapeDispose"],"sources":["../../src/api/sonamu.ts"],"sourcesContent":["import { 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 type {} from \"@fastify/websocket\";\nimport { dispose as logtapeDispose } from \"@logtape/logtape\";\nimport { type Auth, type BetterAuthOptions } from \"better-auth\";\nimport chalk from \"chalk\";\nimport { type FSWatcher } from \"chokidar\";\nimport { type FastifyInstance, type FastifyReply, type FastifyRequest } from \"fastify\";\nimport mime, { lookup as mimeLookup } from \"mime-types\";\nimport { type WebSocket } from \"ws\";\nimport { type ZodObject } from \"zod\";\n\nimport { BASE_FIELD_MAPPINGS } from \"../auth/better-auth-entities\";\nimport { createBetterAuthRequest } from \"../auth/better-auth-request\";\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 { getSonamuEnvironment, readAllEnvironmentSnapshots } from \"../env\";\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 { WebSocketRuntime, type WebSocketConnection, type WebSocketEventMap } from \"../stream/ws\";\nimport {\n  type TelemetryContextProvider,\n  type WebSocketTelemetryConnectionContext,\n} from \"../stream/ws-telemetry\";\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 { centerText } from \"../utils/console-util\";\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, type RuntimeContext, type WebSocketContext } from \"./context\";\nimport { type ExtendedApi } from \"./decorators\";\nimport { getSecrets } from \"./secret\";\nimport { type SonamuSecrets } from \"./secret\";\nimport {\n  createWebSocketReplyStub,\n  resolveWebSocketCloseDescriptor,\n  resolveWebSocketPluginOptions,\n  resolveIntegratedViteHmrOptions,\n} from \"./websocket-helpers\";\n\nexport {\n  createWebSocketReplyStub,\n  resolveWebSocketCloseDescriptor,\n  resolveWebSocketPluginOptions,\n} from \"./websocket-helpers\";\n\nclass SonamuClass {\n  public isInitialized: boolean = false;\n  public forTesting: boolean = false;\n  public asyncLocalStorage: AsyncLocalStorage<{\n    context: RuntimeContext;\n  }> = new AsyncLocalStorage();\n\n  public getContext<T extends RuntimeContext = Context>(): T {\n    const store = this.asyncLocalStorage.getStore();\n    if (store?.context) {\n      return store.context as T;\n    }\n\n    if (process.env.NODE_ENV === \"test\") {\n      // 테스팅 환경에서 컨텍스트가 주입되지 않은 경우 빈 컨텍스트 리턴\n      return {\n        transport: \"http\",\n        request: null,\n        reply: null,\n        headers: {},\n        createSSE: (schema: ZodObject) => createMockSSEFactory(schema),\n        locale: \"\",\n        user: null,\n        session: null,\n        naiteStore: new Map<string, any>(),\n      } as unknown as T;\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<BetterAuthOptions> | null = null;\n  get auth(): Auth<BetterAuthOptions> {\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  // Sonamu가 runtime을 직접 소유해 registry/connection lifecycle을 애플리케이션 수명주기와 동기화함\n  private _websocketRuntime: WebSocketRuntime | null = null;\n  // 같은 Fastify 인스턴스에 @fastify/websocket을 중복 등록하는 것을 WeakSet으로 차단함\n  private readonly websocketPluginServers = new WeakSet<\n    FastifyInstance<Server, IncomingMessage, ServerResponse>\n  >();\n  get websocketRuntime(): WebSocketRuntime {\n    if (!this._websocketRuntime) {\n      throw new Error(\"WebSocket runtime has not been initialized.\");\n    }\n    return this._websocketRuntime;\n  }\n  set websocketRuntime(runtime: WebSocketRuntime | null) {\n    this._websocketRuntime = runtime;\n  }\n\n  // HMR 처리: 파일 시스템 감시 + HMR/sync 사이클 실행은 watcher 모듈로 위임합니다.\n  public watcher: FSWatcher | null = null;\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    const initStart = performance.now();\n\n    // API 루트 패스\n    const { findApiRootPath } = await import(\"../utils/utils\");\n    this.apiRootPath = apiRootPath ?? findApiRootPath();\n    const baseEnvBeforeConfigLoad = { ...process.env };\n\n    // 설정을 로딩하는 것부터 시작\n    const configStart = performance.now();\n    const { loadConfig } = await import(\"./config\");\n    this.config = await loadConfig(this.apiRootPath);\n    const configTime = performance.now() - configStart;\n    setSDConfig(this.config.i18n);\n    // sonamu.config.ts 기본값 설정\n    this.config.database.database = this.config.database.database ?? \"pg\";\n    this.config.database.defaultOptions = this.config.database.defaultOptions ?? {};\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    const { isLocal: isLocalEnvironment } = await import(\"../utils/controller\");\n    const environmentSnapshots = isLocalEnvironment()\n      ? readAllEnvironmentSnapshots(this.apiRootPath, baseEnvBeforeConfigLoad)\n      : undefined;\n    this.dbConfig = DB.generateDBConfig(\n      this.config.database,\n      this.config.projectName,\n      environmentSnapshots,\n    );\n    DB.setConfig(this.dbConfig);\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      const authOptions: BetterAuthOptions = {\n        database: sonamuKnexAdapter(),\n        ...mergedFieldMappings,\n      };\n      this._auth = betterAuth(authOptions);\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    this._initElapsed = performance.now() - initStart;\n    this._configElapsed = configTime;\n  }\n\n  private _initElapsed = 0;\n  private _configElapsed = 0;\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    this.websocketRuntime = new WebSocketRuntime(options.websocket);\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    if (!initOptions?.doSilent) {\n      this.printStartupSummary();\n    }\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    this.websocketRuntime ??= new WebSocketRuntime(this.config.server.websocket);\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      // Timezone 로그는 printStartupSummary에서 통합 출력\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        // @websocket route는 wsHandler로 등록하고, 같은 path의 일반 HTTP GET은 426 응답으로 upgrade를 강제함\n        if (api.websocketOptions) {\n          server.route({\n            method: \"GET\",\n            url: this.config.api.route.prefix + api.path,\n            handler: this.createWebSocketUpgradeRequiredHandler(),\n            wsHandler: this.createWebSocketHandler(api, config),\n          });\n          continue;\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 matchedApi = this.findMatchedApi(request);\n\n    if (!matchedApi) {\n      throw new NotFoundException(SD(\"error.api.notFound\"));\n    }\n\n    // websocket route를 일반 HTTP로 직접 호출한 경우 426을 돌려줘 upgrade 없이 접근하는 것을 차단함\n    if (matchedApi.websocketOptions) {\n      return this.createWebSocketUpgradeRequiredHandler();\n    }\n\n    return this.createApiHandler(matchedApi, config);\n  }\n\n  private findMatchedApi(request: FastifyRequest): ExtendedApi | undefined {\n    const url = this.getPathnameFromUrl(request.url);\n    const method = request.method;\n\n    if (!url.startsWith(this.config.api.route.prefix)) {\n      return undefined;\n    }\n\n    return 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\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    // upgrade는 실질적으로 GET에서만 성립하므로 GET + wsHandler 와 그 외 method를 별도 route로 분리함\n    server.route({\n      method: \"GET\",\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      wsHandler: async (connection, request) => {\n        await this.handleDevWebSocketRequest(connection.socket, request, config);\n      },\n    });\n\n    server.route({\n      method: [\"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        throw new NotFoundException(SD(\"error.api.notFound\"));\n      },\n    });\n  }\n\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    // @fastify/websocket 플러그인이 활성화되면 HMR websocket과 server socket이 충돌하므로 dedicated 포트로 분리함\n    const requiresDedicatedHmrServer = Boolean(this.config.server.plugins?.ws);\n    const hmr = resolveIntegratedViteHmrOptions({\n      httpServer: server.server,\n      requiresDedicatedWebSocketServer: requiresDedicatedHmrServer,\n    });\n\n    this.viteServer = await vite.createServer({\n      root: webPath,\n      server: {\n        middlewareMode: true,\n        hmr,\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    // WS upgrade 경로(GET)와 일반 HTTP 메서드를 별도 route로 분리해 websocket route가 HTML fallback에 먹히지 않도록 함\n    server.route({\n      method: \"GET\",\n      url: `${this.config.api.route.prefix}/*`,\n      handler: async (request, reply) => {\n        const result = this.handleDevApiRequest(request, config);\n        if (result) {\n          return result(request, reply);\n        }\n        throw new NotFoundException(SD(\"error.api.notFound\"));\n      },\n      wsHandler: async (connection, request) => {\n        await this.handleDevWebSocketRequest(connection.socket, request, config);\n      },\n    });\n\n    server.route({\n      method: [\"HEAD\", \"POST\", \"PUT\", \"DELETE\", \"PATCH\"],\n      url: `${this.config.api.route.prefix}/*`,\n      handler: async (request, reply) => {\n        const result = this.handleDevApiRequest(request, config);\n        if (result) {\n          return result(request, reply);\n        }\n        throw new NotFoundException(SD(\"error.api.notFound\"));\n      },\n    });\n\n    // catch-all 라우트에서 SSR/CSR 처리\n    // 개발 환경에서는 라우트별 compress 옵션을 포기하고 HMR 이점을 취합니다.\n    server.route({\n      method: [\"GET\", \"HEAD\"],\n      url: \"/*\",\n      handler: async (request, reply) => {\n        const url = request.url;\n\n        // 1. 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        // 2. 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    const chalk = (await import(\"chalk\")).default;\n    if (\"port\" in hmr) {\n      console.log(\n        chalk.dim(\n          `✓ Vite HMR using dedicated websocket port ${hmr.port} to avoid Fastify websocket conflicts`,\n        ),\n      );\n    }\n    console.log(chalk.dim(\"✓ 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        runGuards({\n          guards: api.options.guards,\n          config,\n          request,\n          api,\n        });\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  // WS path를 일반 HTTP GET으로 호출한 경우 426 + Upgrade 헤더로 명시적으로 websocket 접속을 유도함\n  private createWebSocketUpgradeRequiredHandler() {\n    return async (_request: FastifyRequest, reply: FastifyReply): Promise<void> => {\n      reply.header(\"connection\", \"Upgrade\").header(\"upgrade\", \"websocket\").status(426).send({\n        message: \"WebSocket upgrade required\",\n      });\n    };\n  }\n\n  // dev 모드의 catch-all wsHandler에서 실제 WS API로 디스패치함. 매칭되는 route가 없으면 1008로 닫음\n  private async handleDevWebSocketRequest(\n    socket: WebSocket,\n    request: FastifyRequest,\n    config: SonamuFastifyConfig,\n  ): Promise<void> {\n    const matchedApi = this.findMatchedApi(request);\n    if (!matchedApi?.websocketOptions) {\n      const traceContext = this.websocketRuntime.telemetryController.createConnectionContext({\n        headers: request.headers,\n      });\n      this.websocketRuntime.telemetryController.emit({\n        name: \"ws.connection.rejected\",\n        level: \"warn\",\n        detail: {\n          reason: \"routeNotFound\",\n          path: request.url,\n        },\n        traceId: traceContext.traceId,\n        spanId: traceContext.spanId,\n        parentSpanId: traceContext.parentSpanId,\n        sampled: traceContext.sampled,\n      });\n      socket.close(1008, \"WebSocket route not found\");\n      return;\n    }\n\n    const handler = this.createWebSocketHandler(matchedApi, config);\n    await handler({ socket }, request);\n  }\n\n  // WS route 핸들러의 실행 순서를 고정함:\n  // 1) query param 파싱을 activation 전에 끝내 handshake 실패가 registry에 노출되지 않게 함\n  // 2) `active: false`로 먼저 등록한 뒤 context 안에서 guard를 실행해 인증 정보를 참조할 수 있게 함\n  // 3) context/guard 준비가 끝난 뒤 `activate()`해 브로드캐스트가 초기화 중간 상태를 보지 못하게 함\n  // 에러 발생 시에는 resolveWebSocketCloseDescriptor 정책에 따라 close code를 매핑함\n  private createWebSocketHandler(api: ExtendedApi, config: SonamuFastifyConfig) {\n    return async (\n      connection: {\n        socket: WebSocket;\n      },\n      request: FastifyRequest,\n    ): Promise<void> => {\n      const socket = connection.socket;\n      let wsContext: WebSocketContext | null = null;\n      let rawWs: ReturnType<WebSocketRuntime[\"registerConnection\"]> | null = null;\n      let preRegisterPhase: \"guard\" | \"query\" | \"register\" | \"handler\" = \"guard\";\n      let traceContext: WebSocketTelemetryConnectionContext = {};\n\n      try {\n        traceContext = this.websocketRuntime.telemetryController.createConnectionContext({\n          headers: request.headers,\n        });\n\n        preRegisterPhase = \"query\";\n        const reqBody = await this.parseWebSocketRequestParams(api, request);\n        preRegisterPhase = \"register\";\n        rawWs = this.websocketRuntime.registerConnection(socket, {\n          outEvents: api.websocketOptions!.outEvents,\n          inEvents: api.websocketOptions!.inEvents,\n          namespace: api.websocketOptions!.namespace,\n          heartbeat: api.websocketOptions!.heartbeat,\n          active: false,\n          traceId: traceContext.traceId,\n          spanId: traceContext.spanId,\n          parentSpanId: traceContext.parentSpanId,\n          sampled: traceContext.sampled,\n        });\n\n        const scopedWs = this.createScopedWebSocketConnection(rawWs, () => wsContext);\n        wsContext = await this.createWebSocketContext(config, request, scopedWs);\n\n        await this.asyncLocalStorage.run({ context: wsContext }, async () => {\n          runGuards({\n            guards: api.options.guards,\n            config,\n            request,\n            api,\n          });\n        });\n\n        this.websocketRuntime.activateConnection(rawWs.id);\n        preRegisterPhase = \"handler\";\n\n        const { ApiParamType } = await import(\"../types/types\");\n        const args = api.parameters.map((param) => {\n          if (ApiParamType.isContext(param.type)) {\n            return wsContext;\n          }\n\n          return reqBody[param.name];\n        });\n\n        await this.asyncLocalStorage.run({ context: wsContext }, async () => {\n          await this.invokeModelMethod(api, args);\n        });\n      } catch (error) {\n        const closeDescriptor = resolveWebSocketCloseDescriptor(error);\n        if (!rawWs) {\n          this.websocketRuntime.telemetryController.emit({\n            name: \"ws.connection.rejected\",\n            level: closeDescriptor.logLevel === \"warn\" ? \"warn\" : \"error\",\n            detail: {\n              reason: preRegisterPhase,\n              code: closeDescriptor.code,\n              path: api.path,\n            },\n            traceId: traceContext.traceId,\n            spanId: traceContext.spanId,\n            parentSpanId: traceContext.parentSpanId,\n            sampled: traceContext.sampled,\n          });\n        }\n\n        if (rawWs) {\n          rawWs.close(closeDescriptor.code, closeDescriptor.reason);\n        } else if (socket.readyState < 2) {\n          socket.close(closeDescriptor.code, closeDescriptor.reason);\n        }\n\n        if (this.server?.log) {\n          const payload = {\n            err: error,\n            modelName: api.modelName,\n            methodName: api.methodName,\n            path: api.path,\n          };\n          if (closeDescriptor.logLevel === \"warn\") {\n            this.server.log.warn(payload, closeDescriptor.reason);\n          } else {\n            this.server.log.error(payload, closeDescriptor.reason);\n          }\n        } else {\n          if (closeDescriptor.logLevel === \"warn\") {\n            console.warn(closeDescriptor.reason, error);\n          } else {\n            console.error(closeDescriptor.reason, error);\n          }\n        }\n      }\n    };\n  }\n\n  // onMessage/onClose처럼 다른 tick에서 실행되는 callback은 ALS context가 끊기므로 wrapper에서 `asyncLocalStorage.run`으로 다시 감싸 복원함\n  // publish/join/leave/setUserId 같은 즉시 실행 API는 단순 위임만 하고, deferred callback에만 context 복원을 적용함\n  private createScopedWebSocketConnection<\n    TOut extends WebSocketEventMap,\n    TIn extends WebSocketEventMap,\n  >(\n    ws: WebSocketConnection<TOut, TIn>,\n    getContext: () => WebSocketContext | null,\n  ): WebSocketConnection<TOut, TIn> {\n    const telemetryController = this._websocketRuntime?.telemetryController;\n    const runInContext = <T>(callback: () => T): T => {\n      const context = getContext();\n      if (!context) {\n        return callback();\n      }\n\n      return this.asyncLocalStorage.run({ context }, callback);\n    };\n\n    return {\n      get id() {\n        return ws.id;\n      },\n      get namespace() {\n        return ws.namespace;\n      },\n      get closed() {\n        return ws.closed;\n      },\n      get userId() {\n        return ws.userId;\n      },\n      transport: \"ws\",\n      publishUntyped(event, data) {\n        ws.publishUntyped(event, data);\n      },\n      close(code, reason) {\n        ws.close(code, reason);\n      },\n      onClose(callback) {\n        ws.onClose(() => runInContext(callback));\n      },\n      onMessage(event, handler) {\n        ws.onMessage(event, (data, messageTraceContext) =>\n          runInContext(async () => {\n            const eventName = String(event);\n            const traceContext = messageTraceContext ?? getWebSocketTelemetryContext(ws);\n            const startedAt = performance.now();\n\n            telemetryController?.emit({\n              name: \"ws.handler.started\",\n              level: \"debug\",\n              connectionId: ws.id,\n              namespace: ws.namespace,\n              userId: ws.userId,\n              detail: { event: eventName },\n              ...traceContext,\n            });\n\n            try {\n              const result = await handler(data, messageTraceContext);\n              const durationMs = performance.now() - startedAt;\n              telemetryController?.emit({\n                name: \"ws.handler.completed\",\n                level: \"debug\",\n                connectionId: ws.id,\n                namespace: ws.namespace,\n                userId: ws.userId,\n                detail: { event: eventName },\n                ...traceContext,\n              });\n              telemetryController?.recordSpan({\n                operationName: \"ws.message.process\",\n                kind: \"internal\",\n                durationMs,\n                status: \"unset\",\n                connectionId: ws.id,\n                namespace: ws.namespace,\n                userId: ws.userId,\n                attributes: { event: eventName },\n                ...traceContext,\n              });\n              return result;\n            } catch (error) {\n              const durationMs = performance.now() - startedAt;\n              telemetryController?.emit({\n                name: \"ws.handler.failed\",\n                level: \"error\",\n                connectionId: ws.id,\n                namespace: ws.namespace,\n                userId: ws.userId,\n                detail: { event: eventName },\n                ...traceContext,\n              });\n              telemetryController?.recordSpan({\n                operationName: \"ws.message.process\",\n                kind: \"internal\",\n                durationMs,\n                status: \"error\",\n                connectionId: ws.id,\n                namespace: ws.namespace,\n                userId: ws.userId,\n                attributes: { event: eventName },\n                errorType: error instanceof Error ? error.name : typeof error,\n                ...traceContext,\n              });\n              throw error;\n            }\n          }),\n        );\n      },\n      publish(event, data) {\n        ws.publish(event, data);\n      },\n      waitForClose() {\n        return ws.waitForClose();\n      },\n      join(roomId) {\n        ws.join(roomId);\n      },\n      leave(roomId) {\n        ws.leave(roomId);\n      },\n      setUserId(userId) {\n        ws.setUserId(userId);\n      },\n      clearUserId() {\n        ws.clearUserId();\n      },\n    };\n  }\n\n  private async parseWebSocketRequestParams(\n    api: ExtendedApi,\n    request: FastifyRequest,\n  ): Promise<Record<string, unknown>> {\n    const { getZodObjectFromApi } = await import(\"./code-converters\");\n    const ReqType = getZodObjectFromApi(api, this.syncer.types);\n\n    try {\n      const { fastifyCaster } = await import(\"./caster\");\n      return fastifyCaster(ReqType).parse((request.query ?? {}) as Record<string, unknown>);\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      }\n\n      throw e;\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    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  // WS 경로에서는 HTTP reply가 없으므로 reply를 optional로 받아 공통 호출 경로를 유지함\n  async invokeModelMethod(\n    api: ExtendedApi,\n    args: unknown[],\n    reply?: FastifyReply,\n  ): Promise<unknown> {\n    const model = this.syncer.models[api.modelName];\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 = await Promise.resolve(\n      config.contextProvider(\n        {\n          transport: \"http\",\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    return context;\n  }\n\n  // session/locale/store 같은 공통 state는 HTTP context와 공유하되, reply/createSSE 같은 HTTP 전용 helper는 노출하지 않음\n  // 사용자가 websocketContextProvider를 주면 그대로 위임하고, 없으면 기존 contextProvider를 reply/SSE stub과 함께 재활용함\n  async createWebSocketContext(\n    config: SonamuFastifyConfig,\n    request: FastifyRequest,\n    ws: WebSocketContext[\"ws\"],\n  ): Promise<WebSocketContext> {\n    const locale =\n      this.detectLocale(request.headers[\"accept-language\"], this.config.i18n.supportedLocales) ??\n      this.config.i18n.defaultLocale;\n\n    const headers = convertFastifyHeadersToStandard(request.headers);\n    const session = (await this._auth?.api.getSession({ headers })) ?? null;\n\n    const defaultContext = {\n      transport: \"ws\" as const,\n      request,\n      headers: request.headers,\n      ws,\n      naiteStore: new Map(),\n      locale,\n      user: session?.user ?? null,\n      session: session?.session ?? null,\n    };\n\n    if (config.websocketContextProvider) {\n      return {\n        ...(await Promise.resolve(config.websocketContextProvider(defaultContext, request))),\n      };\n    }\n\n    // reply/createSSE에 의존하는 contextProvider가 있으면 즉시 에러를 던져 transport misuse를 빨리 드러냄\n    const replyStub = createWebSocketReplyStub();\n    const createSSE = <T extends ZodObject>(_events: T) => {\n      throw new Error(\n        \"createSSE is not available in websocket context. Define websocketContextProvider if your context setup depends on SSE helpers.\",\n      );\n    };\n    const httpLikeContext = await Promise.resolve(\n      config.contextProvider(\n        {\n          transport: \"http\",\n          request,\n          reply: replyStub,\n          headers: request.headers,\n          createSSE,\n          naiteStore: defaultContext.naiteStore,\n          locale,\n          user: defaultContext.user,\n          session: defaultContext.session,\n        },\n        request,\n        replyStub,\n      ),\n    );\n\n    const {\n      transport: _transport,\n      reply: _reply,\n      createSSE: _createSSE,\n      bufferedFiles: _bufferedFiles,\n      uploadedFiles: _uploadedFiles,\n      ...rest\n    } = httpLikeContext;\n\n    return {\n      ...rest,\n      transport: \"ws\",\n      request,\n      headers: request.headers,\n      ws,\n    };\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    // watcher 모듈은 file-patterns → Sonamu 순환을 피하기 위해 dynamic import 합니다.\n    const { setupWatcher } = await import(\"../syncer/watcher\");\n    this.watcher = await setupWatcher((fileEvents) => this.runHmrSyncCycle(fileEvents));\n  }\n\n  /**\n   * Watcher가 100ms batch로 모은 fileEvents 하나에 대해 한 번의 HMR/sync 사이클을 돕니다.\n   * batch 큐잉 덕에 한 시점에 하나만 실행됨이 보장됩니다 (event-batcher가 직렬화).\n   */\n  private async runHmrSyncCycle(fileEvents: Map<AbsolutePath, \"change\" | \"add\">): Promise<void> {\n    const startedAt = Date.now();\n\n    for (const [filePath, event] of fileEvents) {\n      const relativePath = path.relative(this.appRootPath, filePath);\n      console.log(chalk.bold(`Detected(${event}): ${chalk.blue(relativePath)}`));\n    }\n\n    // 본체: 변경 흡수 + 체크섬 갱신.\n    await this.syncer.hmrAndSync(fileEvents);\n    await this.syncer.renewChecksums();\n\n    const totalTime = Date.now() - startedAt;\n    const msg = `HMR Done! ${chalk.bold.white(`${totalTime}ms`)}`;\n    console.log(chalk.black.bgGreen(centerText(msg)));\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.ws) {\n      await this.ensureWebSocketPlugin(server);\n    }\n\n    if (plugins.custom) {\n      plugins.custom(server);\n    }\n  }\n\n  // @fastify/websocket은 plugins.ws가 설정된 경우에만 등록하고, 같은 server에 중복 등록되지 않도록 WeakSet으로 기록함\n  private async ensureWebSocketPlugin(\n    server: FastifyInstance<Server, IncomingMessage, ServerResponse>,\n  ): Promise<void> {\n    if (this.websocketPluginServers.has(server)) {\n      return;\n    }\n\n    const pluginOption = this.config.server.plugins?.ws;\n    if (!pluginOption) {\n      return;\n    }\n\n    const websocketPlugin = (await import(\"@fastify/websocket\")).default;\n    const resolvedPluginOptions = resolveWebSocketPluginOptions({\n      rawPluginOption: pluginOption,\n    });\n    if (resolvedPluginOptions) {\n      await server.register(websocketPlugin, resolvedPluginOptions);\n    } else {\n      await server.register(websocketPlugin);\n    }\n\n    this.websocketPluginServers.add(server);\n    this.warnOnPotentialWebSocketTimeoutConflicts(server);\n  }\n\n  // heartbeat interval이 Fastify keepAliveTimeout 이상이면 인프라가 먼저 idle 연결을 끊을 수 있어 경고만 남기고 넘어감\n  private warnOnPotentialWebSocketTimeoutConflicts(\n    server: FastifyInstance<Server, IncomingMessage, ServerResponse>,\n  ): void {\n    const heartbeats = this.syncer.apis\n      .map((api) => api.websocketOptions?.heartbeat ?? 30000)\n      .filter((heartbeat) => heartbeat > 0);\n\n    if (heartbeats.length === 0) {\n      return;\n    }\n\n    const keepAliveTimeout = this.config.server.fastify?.keepAliveTimeout;\n    if (!keepAliveTimeout || keepAliveTimeout <= 0) {\n      return;\n    }\n\n    const largestHeartbeat = Math.max(...heartbeats);\n    if (largestHeartbeat >= keepAliveTimeout) {\n      server.log.warn(\n        {\n          keepAliveTimeout,\n          largestHeartbeat,\n        },\n        \"WebSocket heartbeat is greater than or equal to keepAliveTimeout; align infrastructure idle timeouts to avoid unexpected disconnects.\",\n      );\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 response = await this.auth.handler(\n          createBetterAuthRequest(request, options.advanced?.ipAddress?.ipAddressHeaders),\n        );\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\n  private async printStartupSummary() {\n    const chalk = (await import(\"chalk\")).default;\n    const activePreset = getSonamuEnvironment();\n\n    const dim = (msg: string) => console.log(chalk.dim(`✓ ${msg}`));\n    const green = (msg: string) => console.log(chalk.green(`✓ ${msg}`));\n\n    dim(`Config loaded${formatTime(this._configElapsed)}`);\n\n    // DB preset 목록\n    green(\"DB\");\n    const { isLocal } = await import(\"../utils/controller\");\n    const presetNames = Object.keys(this.dbConfig) as (keyof SonamuDBConfig)[];\n    const maxLen = Math.max(...presetNames.map((n) => n.length));\n    for (const name of presetNames) {\n      const conn = this.dbConfig[name].connection as\n        | { host?: string; port?: number; database?: string }\n        | undefined;\n      const host = conn?.host ?? \"localhost\";\n      const addr = `@ ${host}:${conn?.port ?? 5432}/${conn?.database ?? \"(unknown)\"}`;\n      const padded = name.padEnd(maxLen);\n      const remoteTag = isLocal() && !isLocalHost(host) ? chalk.yellow(` \\u26a0 remote`) : \"\";\n\n      if (name === activePreset) {\n        console.log(chalk.green(`  \\u25b8 ${padded} ${addr}`) + remoteTag);\n      } else {\n        console.log(chalk.dim(`    ${padded} ${addr}`) + remoteTag);\n      }\n    }\n\n    if (this.config.server.auth) {\n      const basePath = this.config.server.auth.basePath ?? \"/api/auth\";\n      dim(`Auth: better-auth at ${basePath}/*`);\n    }\n    if (this.config.api.timezone) {\n      dim(`Timezone: ${this.config.api.timezone}`);\n    }\n    green(`Sonamu ready${formatTime(this._initElapsed)}`);\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  async destroy(): Promise<void> {\n    const { BaseModel } = await import(\"../database/base-model\");\n    // 먼저 처리해야함.\n    await BaseModel.destroy();\n    // WebSocket shutdown first to flush telemetry\n    if (this._websocketRuntime) {\n      await this._websocketRuntime.shutdown();\n    }\n    this._websocketRuntime = null;\n    // Then shut down remaining resources in parallel\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    ]);\n    // LogTape dispose after WS shutdown so telemetry records are flushed first\n    await logtapeDispose();\n  }\n}\n\nfunction getWebSocketTelemetryContext(\n  ws: WebSocketConnection<WebSocketEventMap, WebSocketEventMap>,\n): WebSocketTelemetryConnectionContext {\n  if (!isTelemetryContextProvider(ws)) {\n    return {};\n  }\n\n  return ws.getTelemetryContext();\n}\n\nfunction isTelemetryContextProvider(\n  ws: WebSocketConnection<WebSocketEventMap, WebSocketEventMap>,\n): ws is WebSocketConnection<WebSocketEventMap, WebSocketEventMap> & TelemetryContextProvider {\n  return \"getTelemetryContext\" in ws && typeof ws.getTelemetryContext === \"function\";\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\nfunction formatTime(ms: number): string {\n  const formatted = ms >= 1000 ? `${(ms / 1000).toFixed(2)}s` : `${Math.round(ms)}ms`;\n  return ` (${formatted})`;\n}\n\nconst LOCAL_HOSTS = new Set([\"localhost\", \"127.0.0.1\", \"0.0.0.0\", \"::1\"]);\nfunction isLocalHost(host: string): boolean {\n  return LOCAL_HOSTS.has(host) || host.endsWith(\".local\");\n}\n\n// `.every()`가 첫 guard 이후 순회를 멈추는 문제가 있어 `for...of`로 모든 guard를 순서대로 실행하도록 고정함\nfunction runGuards({\n  guards,\n  config,\n  request,\n  api,\n}: {\n  guards: ExtendedApi[\"options\"][\"guards\"] | undefined;\n  config: Pick<SonamuFastifyConfig, \"guardHandler\">;\n  request: FastifyRequest;\n  api: ExtendedApi;\n}): void {\n  for (const guard of guards ?? []) {\n    config.guardHandler(guard, request, api);\n  }\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sonamu.js","names":["mimeLookup","logtapeDispose"],"sources":["../../src/api/sonamu.ts"],"sourcesContent":["import { 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 \"@fastify/websocket\";\nimport { dispose as logtapeDispose } from \"@logtape/logtape\";\nimport { type Auth, type BetterAuthOptions } from \"better-auth\";\nimport chalk from \"chalk\";\nimport { type FSWatcher } from \"chokidar\";\nimport { type FastifyInstance, type FastifyReply, type FastifyRequest } from \"fastify\";\nimport mime, { lookup as mimeLookup } from \"mime-types\";\nimport { type WebSocket } from \"ws\";\nimport { type ZodObject } from \"zod\";\n\nimport { BASE_FIELD_MAPPINGS } from \"../auth/better-auth-entities\";\nimport { createBetterAuthRequest } from \"../auth/better-auth-request\";\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 { getSonamuEnvironment, readAllEnvironmentSnapshots } from \"../env\";\nimport { NotFoundException } from \"../exceptions/so-exceptions\";\nimport { runtimeTypeOf } from \"../runtime-type\";\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 {\n  type AnyWebSocketConnection,\n  WebSocketRuntime,\n  type WebSocketConnection,\n} from \"../stream/ws\";\nimport {\n  type TelemetryContextProvider,\n  type WebSocketTelemetryConnectionContext,\n} from \"../stream/ws-telemetry\";\nimport { type LoadedModels } from \"../syncer/module-loader\";\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 { centerText } from \"../utils/console-util\";\nimport { isDaemonServer } from \"../utils/controller\";\nimport { exists, fileExists } from \"../utils/fs-utils\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\nimport {\n  isBigIntValue,\n  isFunctionValue,\n  isNumberValue,\n  isObjectValue,\n  isStringValue,\n  isSymbolValue,\n} from \"../utils/runtime-value\";\nimport { convertFastifyHeadersToStandard, merge } from \"../utils/utils\";\nimport {\n  normalizeZodCompilerPolicy,\n  type SonamuConfig,\n  type SonamuServerOptions,\n  type SonamuTaskOptions,\n} from \"./config\";\nimport { type Context, type RuntimeContext, type WebSocketContext } from \"./context\";\nimport { type ExtendedApi } from \"./decorators\";\nimport {\n  assertHttpValidatorRegistry,\n  createHttpValidator,\n  getHttpValidatorRouteKey,\n  type HttpValidator,\n  type HttpValidatorRegistry,\n} from \"./http-validator\";\nimport { getSecrets } from \"./secret\";\nimport { type SonamuSecrets } from \"./secret\";\nimport {\n  createWebSocketReplyStub,\n  resolveWebSocketCloseDescriptor,\n  resolveWebSocketPluginOptions,\n  resolveIntegratedViteHmrOptions,\n} from \"./websocket-helpers\";\n\nexport {\n  createWebSocketReplyStub,\n  resolveWebSocketCloseDescriptor,\n  resolveWebSocketPluginOptions,\n} from \"./websocket-helpers\";\n\ninterface UploadedRequestFiles {\n  bufferedFiles: BufferedFile[];\n  uploadedFiles: UploadedFile[];\n}\n\ntype ApiArgument =\n  | string\n  | number\n  | boolean\n  | bigint\n  | symbol\n  | CallableFunction\n  | object\n  | null\n  | undefined;\ntype ApiMethodResult = ApiArgument | void;\n\nfunction toApiArgument<Value>(value: Value): ApiArgument {\n  if (value === null) return null;\n  if (value === undefined) return undefined;\n  if (value === true) return true;\n  if (value === false) return false;\n  if (isStringValue(value)) return value;\n  if (isNumberValue(value)) return value;\n  if (isBigIntValue(value)) return value;\n  if (isSymbolValue(value)) return value;\n  if (isFunctionValue(value)) return value;\n  if (isObjectValue(value)) {\n    return value;\n  }\n  throw new Error(\"지원하지 않는 API 인수 타입입니다.\");\n}\n\nfunction toApiArgumentMap<Value extends object>(value: Value): Map<string, ApiArgument> {\n  return new Map(Object.entries(value).map(([key, item]) => [key, toApiArgument(item)]));\n}\n\nfunction createUnavailableSSE<T extends ZodObject>(_events: T): never {\n  throw new Error(\n    \"createSSE is not available in websocket context. Define websocketContextProvider if your context setup depends on SSE helpers.\",\n  );\n}\n\nfunction printDimSummary(message: string): void {\n  console.log(chalk.dim(`✓ ${message}`));\n}\n\nfunction printGreenSummary(message: string): void {\n  console.log(chalk.green(`✓ ${message}`));\n}\n\nexport interface SonamuTestingSnapshot {\n  apiRootPath: AbsolutePath | null;\n  config: SonamuConfig | null;\n  syncer: Syncer | null;\n  httpValidators: WeakMap<ExtendedApi, HttpValidator>;\n  pendingHttpValidators: WeakMap<ExtendedApi, Promise<HttpValidator>>;\n  aotHttpValidatorRegistry: HttpValidatorRegistry | undefined;\n  preparedApis: readonly ExtendedApi[];\n  preparedModels: LoadedModels;\n  websocketRuntime: WebSocketRuntime | null;\n}\n\nexport interface SonamuHttpValidatorDependencies {\n  createValidator: typeof createHttpValidator;\n  assertRegistry: typeof assertHttpValidatorRegistry;\n}\n\nexport const defaultSonamuHttpValidatorDependencies: SonamuHttpValidatorDependencies = {\n  createValidator: createHttpValidator,\n  assertRegistry: assertHttpValidatorRegistry,\n};\n\nclass SonamuClass {\n  public isInitialized: boolean = false;\n  public forTesting: boolean = false;\n  public asyncLocalStorage: AsyncLocalStorage<{\n    context: RuntimeContext;\n  }> = new AsyncLocalStorage();\n  private httpValidators: WeakMap<ExtendedApi, HttpValidator> = new WeakMap();\n  private pendingHttpValidators: WeakMap<ExtendedApi, Promise<HttpValidator>> = new WeakMap();\n  private aotHttpValidatorRegistry: HttpValidatorRegistry | undefined;\n  private preparedApis: readonly ExtendedApi[] = [];\n  private preparedModels: LoadedModels = {};\n\n  public getContext<T extends RuntimeContext = Context>(): T {\n    const store = this.asyncLocalStorage.getStore();\n    if (store?.context) {\n      return /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ store.context as T;\n    }\n\n    if (process.env.NODE_ENV === \"test\") {\n      // 테스팅 환경에서 컨텍스트가 주입되지 않은 경우 빈 컨텍스트 리턴\n      const mockContext = {\n        transport: \"http\",\n        request: null,\n        reply: null,\n        headers: {},\n        createSSE: (schema: ZodObject) => createMockSSEFactory(schema),\n        locale: \"\",\n        user: null,\n        session: null,\n        naiteStore: new Map<string, any>(),\n      };\n      // SAFETY: 테스트 기본 컨텍스트는 HTTP Context이며 기본 제네릭과 일치한다.\n      return /* SAFETY: 테스트 기본 컨텍스트는 요청 범위가 없는 HTTP 컨텍스트 대체값입니다. */ mockContext as T &\n        typeof mockContext;\n    } else {\n      throw new Error(\"Sonamu cannot find context\");\n    }\n  }\n\n  private apiRootPathValue: AbsolutePath | null = null;\n  set apiRootPath(apiRootPath: AbsolutePath) {\n    this.apiRootPathValue = apiRootPath;\n  }\n  get apiRootPath(): AbsolutePath {\n    if (this.apiRootPathValue === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n    return this.apiRootPathValue;\n  }\n  get appRootPath(): string {\n    return this.apiRootPath.split(path.sep).slice(0, -1).join(path.sep);\n  }\n\n  private dbConfigValue: SonamuDBConfig | null = null;\n  set dbConfig(dbConfig: SonamuDBConfig) {\n    this.dbConfigValue = dbConfig;\n  }\n  get dbConfig(): SonamuDBConfig {\n    if (this.dbConfigValue === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n    return this.dbConfigValue;\n  }\n\n  private syncerValue: Syncer | null = null;\n  set syncer(syncer: Syncer) {\n    this.syncerValue = syncer;\n  }\n  get syncer(): Syncer {\n    if (this.syncerValue === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n    return this.syncerValue;\n  }\n\n  private configValue: SonamuConfig | null = null;\n  set config(config: SonamuConfig) {\n    this.configValue = config;\n  }\n  get config(): SonamuConfig {\n    if (this.configValue === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n    return this.configValue;\n  }\n\n  public readonly secrets: SonamuSecrets = getSecrets();\n\n  private storageValue: StorageManager | null = null;\n  /**\n   * StorageManager 인스턴스\n   */\n  get storage(): StorageManager {\n    if (!this.storageValue) {\n      throw new Error(\"Storage has not been initialized. Check storage config.\");\n    }\n    return this.storageValue;\n  }\n\n  private cacheValue: CacheManager | null = null;\n  /**\n   * CacheManager 인스턴스 (BentoCache)\n   */\n  get cache(): CacheManager {\n    if (!this.cacheValue) {\n      throw new Error(\"Cache has not been initialized. Check cache config in sonamu.config.ts.\");\n    }\n    return this.cacheValue;\n  }\n\n  private workflowsValue: WorkflowManager | null = null;\n  get workflows(): WorkflowManager {\n    if (this.workflowsValue === null) {\n      throw new Error(\"Sonamu has not been initialized\");\n    }\n\n    return this.workflowsValue;\n  }\n\n  private authValue: Auth<BetterAuthOptions> | null = null;\n  get auth(): Auth<BetterAuthOptions> {\n    if (!this.authValue) {\n      throw new Error(\"Auth has not been initialized. Check auth config in sonamu.config.ts.\");\n    }\n    return this.authValue;\n  }\n\n  private devVitestManagerValue: DevVitestManager | null = null;\n  get devVitestManager(): DevVitestManager | null {\n    return this.devVitestManagerValue;\n  }\n  set devVitestManager(manager: DevVitestManager | null) {\n    this.devVitestManagerValue = manager;\n  }\n\n  // Sonamu가 runtime을 직접 소유해 registry/connection lifecycle을 애플리케이션 수명주기와 동기화함\n  private websocketRuntimeValue: WebSocketRuntime | null = null;\n  // 같은 Fastify 인스턴스에 @fastify/websocket을 중복 등록하는 것을 WeakSet으로 차단함\n  private readonly websocketPluginServers = new WeakSet<\n    FastifyInstance<Server, IncomingMessage, ServerResponse>\n  >();\n  get websocketRuntime(): WebSocketRuntime {\n    if (!this.websocketRuntimeValue) {\n      throw new Error(\"WebSocket runtime has not been initialized.\");\n    }\n    return this.websocketRuntimeValue;\n  }\n  set websocketRuntime(runtime: WebSocketRuntime | null) {\n    this.websocketRuntimeValue = runtime;\n  }\n\n  captureTestingSnapshot(): SonamuTestingSnapshot {\n    return {\n      apiRootPath: this.apiRootPathValue,\n      config: this.configValue,\n      syncer: this.syncerValue,\n      httpValidators: this.httpValidators,\n      pendingHttpValidators: this.pendingHttpValidators,\n      aotHttpValidatorRegistry: this.aotHttpValidatorRegistry,\n      preparedApis: this.preparedApis,\n      preparedModels: this.preparedModels,\n      websocketRuntime: this.websocketRuntimeValue,\n    };\n  }\n\n  restoreTestingSnapshot(snapshot: SonamuTestingSnapshot): void {\n    this.apiRootPathValue = snapshot.apiRootPath;\n    this.configValue = snapshot.config;\n    this.syncerValue = snapshot.syncer;\n    this.httpValidators = snapshot.httpValidators;\n    this.pendingHttpValidators = snapshot.pendingHttpValidators;\n    this.aotHttpValidatorRegistry = snapshot.aotHttpValidatorRegistry;\n    this.preparedApis = snapshot.preparedApis;\n    this.preparedModels = snapshot.preparedModels;\n    this.websocketRuntimeValue = snapshot.websocketRuntime;\n  }\n\n  // HMR 처리: 파일 시스템 감시 + HMR/sync 사이클 실행은 watcher 모듈로 위임합니다.\n  public watcher: FSWatcher | null = null;\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    const initStart = performance.now();\n\n    // API 루트 패스\n    const { findApiRootPath } = await import(\"../utils/utils\");\n    this.apiRootPath = apiRootPath ?? findApiRootPath();\n    const baseEnvBeforeConfigLoad = { ...process.env };\n\n    // 설정을 로딩하는 것부터 시작\n    const configStart = performance.now();\n    const { loadConfig } = await import(\"./config\");\n    this.config = await loadConfig(this.apiRootPath);\n    const configTime = performance.now() - configStart;\n    setSDConfig(this.config.i18n);\n    // sonamu.config.ts 기본값 설정\n    this.config.database.database = this.config.database.database ?? \"pg\";\n    this.config.database.defaultOptions = this.config.database.defaultOptions ?? {};\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: RuntimeDB } = await import(\"../database/db\");\n    const { isLocal: isLocalEnvironment } = await import(\"../utils/controller\");\n    const environmentSnapshots = isLocalEnvironment()\n      ? readAllEnvironmentSnapshots(this.apiRootPath, baseEnvBeforeConfigLoad)\n      : undefined;\n    this.dbConfig = RuntimeDB.generateDBConfig(\n      this.config.database,\n      this.config.projectName,\n      environmentSnapshots,\n    );\n    RuntimeDB.setConfig(this.dbConfig);\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      const authOptions: BetterAuthOptions = {\n        database: sonamuKnexAdapter(),\n        ...mergedFieldMappings,\n      };\n      this.authValue = betterAuth(authOptions);\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    this.initElapsed = performance.now() - initStart;\n    this.configElapsed = configTime;\n  }\n\n  private initElapsed = 0;\n  private configElapsed = 0;\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    this.websocketRuntime = new WebSocketRuntime(options.websocket);\n\n    // Storage 설정 → StorageManager 생성\n    if (options.storage) {\n      const { StorageManager } = await import(\"../storage/storage-manager\");\n      this.storageValue = 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    if (!initOptions?.doSilent) {\n      this.printStartupSummary();\n    }\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    this.websocketRuntime ??= new WebSocketRuntime(this.config.server.websocket);\n    await this.refreshHttpValidators();\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 (isStringValue(value) && ISO_DATE_REGEX.test(value)) {\n            return formatInTimeZone(\n              new Date(value),\n              /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ timezone as `${string}/${string}`,\n              DATE_FORMAT,\n            );\n          }\n          return value;\n        });\n      });\n      // Timezone 로그는 printStartupSummary에서 통합 출력\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        // @websocket route는 wsHandler로 등록하고, 같은 path의 일반 HTTP GET은 426 응답으로 upgrade를 강제함\n        if (api.websocketOptions) {\n          server.route({\n            method: \"GET\",\n            url: this.config.api.route.prefix + api.path,\n            handler: this.createWebSocketUpgradeRequiredHandler(),\n            wsHandler: this.createWebSocketHandler(api, config),\n          });\n          continue;\n        }\n\n        server.route({\n          method: api.options.httpMethod ?? \"GET\",\n          url: this.config.api.route.prefix + api.path,\n          handler: await 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에서 마지막 준비 완료 API snapshot을 탐색하여 요청을 처리합니다.\n   * server.route()로 개별 등록하면 handler가 고정되어 HMR이 동작하지 않으므로,\n   * refresh 성공 시 교체되는 snapshot을 매 요청 조회합니다.\n   *\n   * 요청이 /api(정확히는 this.config.api.route.prefix)로 시작하지 않는 경우라면 null을 반환하며 끝냅니다.\n   */\n  private async handleDevApiRequest(\n    request: FastifyRequest,\n    config: SonamuFastifyConfig,\n  ): Promise<((request: FastifyRequest, reply: FastifyReply) => Promise<ApiMethodResult>) | null> {\n    const matchedApi = this.findMatchedApi(request, this.preparedApis, this.preparedModels);\n\n    if (!matchedApi) {\n      throw new NotFoundException(SD(\"error.api.notFound\"));\n    }\n\n    // websocket route를 일반 HTTP로 직접 호출한 경우 426을 돌려줘 upgrade 없이 접근하는 것을 차단함\n    if (matchedApi.websocketOptions) {\n      return this.createWebSocketUpgradeRequiredHandler();\n    }\n\n    return await this.createApiHandler(matchedApi, config, this.preparedModels);\n  }\n\n  private findMatchedApi(\n    request: FastifyRequest,\n    apis: readonly ExtendedApi[],\n    models: LoadedModels,\n  ): ExtendedApi | undefined {\n    const url = this.getPathnameFromUrl(request.url);\n    const method = request.method;\n\n    if (!url.startsWith(this.config.api.route.prefix)) {\n      return undefined;\n    }\n\n    return apis.find((api) => {\n      if (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\n  /**\n   * dev api 모드: Vite 없이 API 동적 라우팅만 제공합니다.\n   * HMR을 위해 catch-all에서 매 요청마다 준비 완료 API snapshot을 조회합니다.\n   */\n  private setupDevServer(\n    server: FastifyInstance<Server, IncomingMessage, ServerResponse>,\n    config: SonamuFastifyConfig,\n  ): void {\n    // upgrade는 실질적으로 GET에서만 성립하므로 GET + wsHandler 와 그 외 method를 별도 route로 분리함\n    server.route({\n      method: \"GET\",\n      url: `${this.config.api.route.prefix}/*`,\n      handler: async (request, reply) => {\n        const handler = await 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      wsHandler: async (connection, request) => {\n        await this.handleDevWebSocketRequest(connection.socket, request, config);\n      },\n    });\n\n    server.route({\n      method: [\"HEAD\", \"POST\", \"PUT\", \"DELETE\", \"PATCH\"],\n      url: `${this.config.api.route.prefix}/*`,\n      handler: async (request, reply) => {\n        const handler = await this.handleDevApiRequest(request, config);\n        if (handler) {\n          return handler(request, reply);\n        }\n        throw new NotFoundException(SD(\"error.api.notFound\"));\n      },\n    });\n  }\n\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    // @fastify/websocket 플러그인이 활성화되면 HMR websocket과 server socket이 충돌하므로 dedicated 포트로 분리함\n    const requiresDedicatedHmrServer = Boolean(this.config.server.plugins?.ws);\n    const hmr = resolveIntegratedViteHmrOptions({\n      httpServer: server.server,\n      requiresDedicatedWebSocketServer: requiresDedicatedHmrServer,\n    });\n\n    this.viteServer = await vite.createServer({\n      root: webPath,\n      server: {\n        middlewareMode: true,\n        hmr,\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    // WS upgrade 경로(GET)와 일반 HTTP 메서드를 별도 route로 분리해 websocket route가 HTML fallback에 먹히지 않도록 함\n    server.route({\n      method: \"GET\",\n      url: `${this.config.api.route.prefix}/*`,\n      handler: async (request, reply) => {\n        const result = await this.handleDevApiRequest(request, config);\n        if (result) {\n          return result(request, reply);\n        }\n        throw new NotFoundException(SD(\"error.api.notFound\"));\n      },\n      wsHandler: async (connection, request) => {\n        await this.handleDevWebSocketRequest(connection.socket, request, config);\n      },\n    });\n\n    server.route({\n      method: [\"HEAD\", \"POST\", \"PUT\", \"DELETE\", \"PATCH\"],\n      url: `${this.config.api.route.prefix}/*`,\n      handler: async (request, reply) => {\n        const result = await this.handleDevApiRequest(request, config);\n        if (result) {\n          return result(request, reply);\n        }\n        throw new NotFoundException(SD(\"error.api.notFound\"));\n      },\n    });\n\n    // catch-all 라우트에서 SSR/CSR 처리\n    // 개발 환경에서는 라우트별 compress 옵션을 포기하고 HMR 이점을 취합니다.\n    server.route({\n      method: [\"GET\", \"HEAD\"],\n      url: \"/*\",\n      handler: async (request, reply) => {\n        const url = request.url;\n\n        // 1. 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        // 2. CSR fallback\n        try {\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          // ?hmr=false로 연 페이지는 HMR 웹소켓만 끊어 새로고침되지 않게 한다.\n          const { HMR_OPT_OUT_SCRIPT, isHmrDisabledByQuery } = await import(\"../ssr/hmr-opt-out\");\n          if (isHmrDisabledByQuery(url)) {\n            template = template.replace(\"<head>\", `<head>\\n${HMR_OPT_OUT_SCRIPT}`);\n          }\n\n          reply.type(\"text/html\");\n          return template;\n        } catch (e) {\n          this.viteServer.ssrFixStacktrace(\n            /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ e as Error,\n          );\n          console.error(e);\n          reply.status(500);\n          return /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ (\n            e as Error\n          ).message;\n        }\n      },\n    });\n\n    // 서버 종료 시 Vite도 종료\n    server.addHook(\"onClose\", async () => {\n      await this.viteServer.close();\n    });\n\n    if (\"port\" in hmr) {\n      console.log(\n        chalk.dim(\n          `✓ Vite HMR using dedicated websocket port ${hmr.port} to avoid Fastify websocket conflicts`,\n        ),\n      );\n    }\n    console.log(chalk.dim(\"✓ 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 =\n        /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ (\n          request.params as { filename: string }\n        ).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    models: LoadedModels = this.syncer.models,\n    dependencies: SonamuHttpValidatorDependencies = defaultSonamuHttpValidatorDependencies,\n  ): (request: FastifyRequest, reply: FastifyReply) => Promise<ApiMethodResult> {\n    const preparedValidator = this.getOrCreateHttpValidator(api, dependencies);\n\n    return async (request: FastifyRequest, reply: FastifyReply): Promise<ApiMethodResult> => {\n      const validator =\n        preparedValidator instanceof Promise ? await preparedValidator : preparedValidator;\n      // Context 생성\n      const context: Context = await this.createContext(config, request, reply);\n\n      return this.asyncLocalStorage.run({ context }, async () => {\n        // guards 처리\n        runGuards({\n          guards: api.options.guards,\n          config,\n          request,\n          api,\n        });\n\n        // request 파싱\n        const which = api.options.httpMethod === \"GET\" ? \"query\" : \"body\";\n        let reqBody = new Map<string, ApiArgument>();\n        // 파일 업로드 있는 경우 임시 데이터\n        const files: UploadedRequestFiles = {\n          bufferedFiles: [],\n          uploadedFiles: [],\n        };\n\n        try {\n          const body = request[which] ?? {};\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          reqBody = toApiArgumentMap(validator.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(\n              /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ messages as LocalizedString,\n              {\n                zodError: e,\n              },\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.get(param.name);\n          }\n        });\n\n        return this.invokeModelMethod(api, args, reply, models);\n      });\n    };\n  }\n\n  private getOrCreateHttpValidator(\n    api: ExtendedApi,\n    dependencies: SonamuHttpValidatorDependencies,\n  ): HttpValidator | Promise<HttpValidator> {\n    const cached = this.httpValidators.get(api);\n    if (cached !== undefined) {\n      return cached;\n    }\n    const existing = this.pendingHttpValidators.get(api);\n    if (existing !== undefined) {\n      return existing;\n    }\n    const pending = this.buildHttpValidator(api, dependencies);\n    this.pendingHttpValidators.set(api, pending);\n    void pending.then(\n      (validator) => {\n        this.httpValidators.set(api, validator);\n        this.pendingHttpValidators.delete(api);\n      },\n      () => {\n        this.pendingHttpValidators.delete(api);\n      },\n    );\n    return pending;\n  }\n\n  private async buildHttpValidator(\n    api: ExtendedApi,\n    dependencies: SonamuHttpValidatorDependencies,\n  ): Promise<HttpValidator> {\n    const policy = normalizeZodCompilerPolicy(this.config.validation?.zodCompiler);\n    const sourceAot = process.env.HOT === \"yes\" || process.env.VITEST === \"true\";\n    if (policy.api === \"aot\" && !sourceAot) {\n      const registry = this.aotHttpValidatorRegistry ?? (await this.loadAotHttpValidatorRegistry());\n      return this.getAotHttpValidator(api, registry);\n    }\n\n    return await dependencies.createValidator({\n      api,\n      policy,\n      types: this.syncer.types,\n      allowAotSourceFallback: sourceAot,\n    });\n  }\n\n  private getAotHttpValidator(api: ExtendedApi, registry: HttpValidatorRegistry): HttpValidator {\n    const routeKey = getHttpValidatorRouteKey(api);\n    const validator = registry.validators.get(routeKey);\n    if (validator === undefined) {\n      throw new Error(`HTTP validator registry is missing ${routeKey}`);\n    }\n    return validator;\n  }\n\n  private async loadAotHttpValidatorRegistry(\n    apis: readonly ExtendedApi[] = this.syncer.apis,\n    dependencies: SonamuHttpValidatorDependencies = defaultSonamuHttpValidatorDependencies,\n  ): Promise<HttpValidatorRegistry> {\n    const { pathToFileURL } = await import(\"node:url\");\n    const registryPath = path.join(\n      this.apiRootPath,\n      \"dist/application/sonamu.validators.generated.js\",\n    );\n    if (!(await exists(registryPath))) {\n      throw new Error(`Generated HTTP validator registry not found: ${registryPath}`);\n    }\n\n    const imported =\n      /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ (await import(\n        pathToFileURL(registryPath).href\n      )) as {\n        fingerprint?: unknown;\n        validators?: unknown;\n      };\n    if (!isStringValue(imported.fingerprint) || !(imported.validators instanceof Map)) {\n      throw new Error(`Invalid generated HTTP validator registry: ${registryPath}`);\n    }\n    for (const [key, validator] of imported.validators) {\n      if (\n        !isStringValue(key) ||\n        !isObjectValue(validator) ||\n        validator === null ||\n        !(\"parse\" in validator) ||\n        !isFunctionValue(validator.parse)\n      ) {\n        throw new Error(`Invalid HTTP validator registry entry: ${String(key)}`);\n      }\n    }\n\n    const registry: HttpValidatorRegistry = {\n      fingerprint: imported.fingerprint,\n      validators: imported.validators,\n    };\n    dependencies.assertRegistry(apis, registry);\n    return registry;\n  }\n\n  async refreshHttpValidators(\n    dependencies: SonamuHttpValidatorDependencies = defaultSonamuHttpValidatorDependencies,\n  ): Promise<void> {\n    const policy = normalizeZodCompilerPolicy(this.config.validation?.zodCompiler);\n    const sourceAot = process.env.HOT === \"yes\" || process.env.VITEST === \"true\";\n    const nextApis = [...this.syncer.apis];\n    const nextModels = { ...this.syncer.models };\n    const restApis = nextApis.filter((api) => api.websocketOptions === undefined);\n    const next = new WeakMap<ExtendedApi, HttpValidator>();\n    let nextAotRegistry: HttpValidatorRegistry | undefined;\n\n    if (policy.api === \"aot\" && !sourceAot) {\n      const registry = await this.loadAotHttpValidatorRegistry(nextApis, dependencies);\n      for (const api of restApis) {\n        next.set(api, this.getAotHttpValidator(api, registry));\n      }\n      nextAotRegistry = registry;\n    } else {\n      await Promise.all(\n        restApis.map(async (api) => {\n          const validator = await this.buildHttpValidator(api, dependencies);\n          next.set(api, validator);\n        }),\n      );\n    }\n\n    // validator와 같은 revision의 API/model snapshot을 함께 공개해 HMR 중간 상태를 숨깁니다.\n    this.httpValidators = next;\n    this.pendingHttpValidators = new WeakMap();\n    this.aotHttpValidatorRegistry = nextAotRegistry;\n    this.preparedApis = nextApis;\n    this.preparedModels = nextModels;\n  }\n\n  // WS path를 일반 HTTP GET으로 호출한 경우 426 + Upgrade 헤더로 명시적으로 websocket 접속을 유도함\n  private createWebSocketUpgradeRequiredHandler() {\n    return async (_request: FastifyRequest, reply: FastifyReply): Promise<void> => {\n      reply.header(\"connection\", \"Upgrade\").header(\"upgrade\", \"websocket\").status(426).send({\n        message: \"WebSocket upgrade required\",\n      });\n    };\n  }\n\n  // dev 모드의 catch-all wsHandler에서 실제 WS API로 디스패치함. 매칭되는 route가 없으면 1008로 닫음\n  private async handleDevWebSocketRequest(\n    socket: WebSocket,\n    request: FastifyRequest,\n    config: SonamuFastifyConfig,\n  ): Promise<void> {\n    const matchedApi = this.findMatchedApi(request, this.syncer.apis, this.syncer.models);\n    if (!matchedApi?.websocketOptions) {\n      const traceContext = this.websocketRuntime.telemetryController.createConnectionContext({\n        headers: request.headers,\n      });\n      this.websocketRuntime.telemetryController.emit({\n        name: \"ws.connection.rejected\",\n        level: \"warn\",\n        detail: {\n          reason: \"routeNotFound\",\n          path: request.url,\n        },\n        traceId: traceContext.traceId,\n        spanId: traceContext.spanId,\n        parentSpanId: traceContext.parentSpanId,\n        sampled: traceContext.sampled,\n      });\n      socket.close(1008, \"WebSocket route not found\");\n      return;\n    }\n\n    const handler = this.createWebSocketHandler(matchedApi, config);\n    await handler({ socket }, request);\n  }\n\n  // WS route 핸들러의 실행 순서를 고정함:\n  // 1) query param 파싱을 activation 전에 끝내 handshake 실패가 registry에 노출되지 않게 함\n  // 2) `active: false`로 먼저 등록한 뒤 context 안에서 guard를 실행해 인증 정보를 참조할 수 있게 함\n  // 3) context/guard 준비가 끝난 뒤 `activate()`해 브로드캐스트가 초기화 중간 상태를 보지 못하게 함\n  // 에러 발생 시에는 resolveWebSocketCloseDescriptor 정책에 따라 close code를 매핑함\n  createWebSocketHandlerForTesting(api: ExtendedApi, config: SonamuFastifyConfig) {\n    return this.createWebSocketHandler(api, config);\n  }\n\n  private createWebSocketHandler(api: ExtendedApi, config: SonamuFastifyConfig) {\n    return async (\n      connection: {\n        socket: WebSocket;\n      },\n      request: FastifyRequest,\n    ): Promise<void> => {\n      const socket = connection.socket;\n      let wsContext: WebSocketContext<object, object> | null = null;\n      let rawWs: ReturnType<WebSocketRuntime[\"registerConnection\"]> | null = null;\n      let preRegisterPhase: \"guard\" | \"query\" | \"register\" | \"handler\" = \"guard\";\n      let traceContext: WebSocketTelemetryConnectionContext = {};\n\n      try {\n        traceContext = this.websocketRuntime.telemetryController.createConnectionContext({\n          headers: request.headers,\n        });\n\n        preRegisterPhase = \"query\";\n        const reqBody = await this.parseWebSocketRequestParams(api, request);\n        preRegisterPhase = \"register\";\n        rawWs = this.websocketRuntime.registerConnection(socket, {\n          outEvents: api.websocketOptions!.outEvents,\n          inEvents: api.websocketOptions!.inEvents,\n          namespace: api.websocketOptions!.namespace,\n          heartbeat: api.websocketOptions!.heartbeat,\n          active: false,\n          traceId: traceContext.traceId,\n          spanId: traceContext.spanId,\n          parentSpanId: traceContext.parentSpanId,\n          sampled: traceContext.sampled,\n        });\n\n        const scopedWs = this.createScopedWebSocketConnection(rawWs, () => wsContext);\n        wsContext = await this.createWebSocketContext(config, request, scopedWs);\n\n        await this.asyncLocalStorage.run({ context: wsContext }, async () => {\n          runGuards({\n            guards: api.options.guards,\n            config,\n            request,\n            api,\n          });\n        });\n\n        this.websocketRuntime.activateConnection(rawWs.id);\n        preRegisterPhase = \"handler\";\n\n        const { ApiParamType } = await import(\"../types/types\");\n        const args = api.parameters.map((param) => {\n          if (ApiParamType.isContext(param.type)) {\n            return wsContext;\n          }\n\n          return reqBody.get(param.name);\n        });\n\n        await this.asyncLocalStorage.run({ context: wsContext }, async () => {\n          await this.invokeModelMethod(api, args);\n        });\n      } catch (error) {\n        const closeDescriptor = resolveWebSocketCloseDescriptor(error);\n        if (!rawWs) {\n          this.websocketRuntime.telemetryController.emit({\n            name: \"ws.connection.rejected\",\n            level: closeDescriptor.logLevel === \"warn\" ? \"warn\" : \"error\",\n            detail: {\n              reason: preRegisterPhase,\n              code: closeDescriptor.code,\n              path: api.path,\n            },\n            traceId: traceContext.traceId,\n            spanId: traceContext.spanId,\n            parentSpanId: traceContext.parentSpanId,\n            sampled: traceContext.sampled,\n          });\n        }\n\n        if (rawWs) {\n          rawWs.close(closeDescriptor.code, closeDescriptor.reason);\n        } else if (socket.readyState < 2) {\n          socket.close(closeDescriptor.code, closeDescriptor.reason);\n        }\n\n        if (this.server?.log) {\n          const payload = {\n            err: error,\n            modelName: api.modelName,\n            methodName: api.methodName,\n            path: api.path,\n          };\n          if (closeDescriptor.logLevel === \"warn\") {\n            this.server.log.warn(payload, closeDescriptor.reason);\n          } else {\n            this.server.log.error(payload, closeDescriptor.reason);\n          }\n        } else {\n          if (closeDescriptor.logLevel === \"warn\") {\n            console.warn(closeDescriptor.reason, error);\n          } else {\n            console.error(closeDescriptor.reason, error);\n          }\n        }\n      }\n    };\n  }\n\n  // onMessage/onClose처럼 다른 tick에서 실행되는 callback은 ALS context가 끊기므로 wrapper에서 `asyncLocalStorage.run`으로 다시 감싸 복원함\n  // publish/join/leave/setUserId 같은 즉시 실행 API는 단순 위임만 하고, deferred callback에만 context 복원을 적용함\n  private createScopedWebSocketConnection<TOut extends object, TIn extends object>(\n    ws: WebSocketConnection<TOut, TIn>,\n    getContext: () => WebSocketContext | null,\n  ): WebSocketConnection<TOut, TIn> {\n    const telemetryController = this.websocketRuntimeValue?.telemetryController;\n    const runInContext = <T>(callback: () => T): T => {\n      const context = getContext();\n      if (!context) {\n        return callback();\n      }\n\n      return this.asyncLocalStorage.run({ context }, callback);\n    };\n\n    return {\n      get id() {\n        return ws.id;\n      },\n      get namespace() {\n        return ws.namespace;\n      },\n      get closed() {\n        return ws.closed;\n      },\n      get userId() {\n        return ws.userId;\n      },\n      transport: \"ws\",\n      publishUntyped(event, data) {\n        ws.publishUntyped(event, data);\n      },\n      close(code, reason) {\n        ws.close(code, reason);\n      },\n      onClose(callback) {\n        ws.onClose(() => runInContext(callback));\n      },\n      onMessage(event, handler) {\n        ws.onMessage(event, (data, messageTraceContext) =>\n          runInContext(async () => {\n            const eventName = String(event);\n            const traceContext = messageTraceContext ?? getWebSocketTelemetryContext(ws);\n            const startedAt = performance.now();\n\n            telemetryController?.emit({\n              name: \"ws.handler.started\",\n              level: \"debug\",\n              connectionId: ws.id,\n              namespace: ws.namespace,\n              userId: ws.userId,\n              detail: { event: eventName },\n              ...traceContext,\n            });\n\n            try {\n              const result = await handler(data, messageTraceContext);\n              const durationMs = performance.now() - startedAt;\n              telemetryController?.emit({\n                name: \"ws.handler.completed\",\n                level: \"debug\",\n                connectionId: ws.id,\n                namespace: ws.namespace,\n                userId: ws.userId,\n                detail: { event: eventName },\n                ...traceContext,\n              });\n              telemetryController?.recordSpan({\n                operationName: \"ws.message.process\",\n                kind: \"internal\",\n                durationMs,\n                status: \"unset\",\n                connectionId: ws.id,\n                namespace: ws.namespace,\n                userId: ws.userId,\n                attributes: { event: eventName },\n                ...traceContext,\n              });\n              return result;\n            } catch (error) {\n              const durationMs = performance.now() - startedAt;\n              telemetryController?.emit({\n                name: \"ws.handler.failed\",\n                level: \"error\",\n                connectionId: ws.id,\n                namespace: ws.namespace,\n                userId: ws.userId,\n                detail: { event: eventName },\n                ...traceContext,\n              });\n              telemetryController?.recordSpan({\n                operationName: \"ws.message.process\",\n                kind: \"internal\",\n                durationMs,\n                status: \"error\",\n                connectionId: ws.id,\n                namespace: ws.namespace,\n                userId: ws.userId,\n                attributes: { event: eventName },\n                errorType: error instanceof Error ? error.name : runtimeTypeOf(error),\n                ...traceContext,\n              });\n              throw error;\n            }\n          }),\n        );\n      },\n      publish(event, data) {\n        ws.publish(event, data);\n      },\n      waitForClose() {\n        return ws.waitForClose();\n      },\n      join(roomId) {\n        ws.join(roomId);\n      },\n      leave(roomId) {\n        ws.leave(roomId);\n      },\n      setUserId(userId) {\n        ws.setUserId(userId);\n      },\n      clearUserId() {\n        ws.clearUserId();\n      },\n    };\n  }\n\n  createScopedWebSocketConnectionForTesting<TOut extends object, TIn extends object>(\n    ws: WebSocketConnection<TOut, TIn>,\n    getContext: () => WebSocketContext | null,\n  ): WebSocketConnection<TOut, TIn> {\n    return this.createScopedWebSocketConnection(ws, getContext);\n  }\n\n  private async parseWebSocketRequestParams(\n    api: ExtendedApi,\n    request: FastifyRequest,\n  ): Promise<Map<string, ApiArgument>> {\n    const { getZodObjectFromApi } = await import(\"./code-converters\");\n    const ReqType = getZodObjectFromApi(api, this.syncer.types);\n\n    try {\n      const { fastifyCaster } = await import(\"./caster\");\n      return toApiArgumentMap(fastifyCaster(ReqType).parse(request.query ?? {}));\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(\n          /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ messages as LocalizedString,\n          {\n            zodError: e,\n          },\n        );\n      }\n\n      throw e;\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) {\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    params: any[],\n    config: SonamuFastifyConfig,\n    request: FastifyRequest,\n    reply: FastifyReply,\n  ): Promise<ApiMethodResult> {\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 handleDevApiRequestForTesting(request: FastifyRequest, config: SonamuFastifyConfig) {\n    return await this.handleDevApiRequest(request, config);\n  }\n\n  // WS 경로에서는 HTTP reply가 없으므로 reply를 optional로 받아 공통 호출 경로를 유지함\n  async invokeModelMethod(\n    api: ExtendedApi,\n    args: unknown[],\n    reply?: FastifyReply,\n    models: LoadedModels = this.syncer.models,\n  ): Promise<ApiMethodResult> {\n    const model = models[api.modelName];\n    if (model === undefined) {\n      throw new Error(`Model not found: ${api.modelName}`);\n    }\n    const method =\n      model[\n        /* SAFETY: 동기화기가 모델 클래스에서 수집한 API 메서드 이름만 전달한다. */ api.methodName as keyof typeof model\n      ];\n    if (!isFunctionValue(method)) {\n      throw new Error(`Model method not found: ${api.modelName}.${api.methodName}`);\n    }\n    const result = await Function.prototype.apply.call(method, 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.authValue?.api.getSession({ headers })) ?? null;\n\n    const context: Context = await Promise.resolve(\n      config.contextProvider(\n        {\n          transport: \"http\",\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    return context;\n  }\n\n  // session/locale/store 같은 공통 state는 HTTP context와 공유하되, reply/createSSE 같은 HTTP 전용 helper는 노출하지 않음\n  // 사용자가 websocketContextProvider를 주면 그대로 위임하고, 없으면 기존 contextProvider를 reply/SSE stub과 함께 재활용함\n  async createWebSocketContext(\n    config: SonamuFastifyConfig,\n    request: FastifyRequest,\n    ws: AnyWebSocketConnection,\n  ): Promise<WebSocketContext> {\n    const locale =\n      this.detectLocale(request.headers[\"accept-language\"], this.config.i18n.supportedLocales) ??\n      this.config.i18n.defaultLocale;\n\n    const headers = convertFastifyHeadersToStandard(request.headers);\n    const session = (await this.authValue?.api.getSession({ headers })) ?? null;\n\n    const defaultContext = {\n      transport: \"ws\" as const,\n      request,\n      headers: request.headers,\n      ws,\n      naiteStore: new Map(),\n      locale,\n      user: session?.user ?? null,\n      session: session?.session ?? null,\n    };\n\n    if (config.websocketContextProvider) {\n      return {\n        ...(await Promise.resolve(config.websocketContextProvider(defaultContext, request))),\n      };\n    }\n\n    // reply/createSSE에 의존하는 contextProvider가 있으면 즉시 에러를 던져 transport misuse를 빨리 드러냄\n    const replyStub = createWebSocketReplyStub();\n    const httpLikeContext = await Promise.resolve(\n      config.contextProvider(\n        {\n          transport: \"http\",\n          request,\n          reply: replyStub,\n          headers: request.headers,\n          createSSE: createUnavailableSSE,\n          naiteStore: defaultContext.naiteStore,\n          locale,\n          user: defaultContext.user,\n          session: defaultContext.session,\n        },\n        request,\n        replyStub,\n      ),\n    );\n\n    const {\n      transport: _transport,\n      reply: _reply,\n      createSSE: _createSSE,\n      bufferedFiles: _bufferedFiles,\n      uploadedFiles: _uploadedFiles,\n      ...rest\n    } = httpLikeContext;\n\n    return {\n      ...rest,\n      transport: \"ws\",\n      request,\n      headers: request.headers,\n      ws,\n    };\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    // watcher 모듈은 file-patterns → Sonamu 순환을 피하기 위해 dynamic import 합니다.\n    const { setupWatcher } = await import(\"../syncer/watcher\");\n    this.watcher = await setupWatcher((fileEvents) => this.runHmrSyncCycle(fileEvents));\n  }\n\n  /**\n   * Watcher가 100ms batch로 모은 fileEvents 하나에 대해 한 번의 HMR/sync 사이클을 돕니다.\n   * batch 큐잉 덕에 한 시점에 하나만 실행됨이 보장됩니다 (event-batcher가 직렬화).\n   */\n  private async runHmrSyncCycle(fileEvents: Map<AbsolutePath, \"change\" | \"add\">): Promise<void> {\n    const startedAt = Date.now();\n\n    for (const [filePath, event] of fileEvents) {\n      const relativePath = path.relative(this.appRootPath, filePath);\n      console.log(chalk.bold(`Detected(${event}): ${chalk.blue(relativePath)}`));\n    }\n\n    // 본체: 변경 흡수 + 체크섬 갱신.\n    await this.syncer.hmrAndSync(fileEvents);\n    await this.syncer.renewChecksums();\n\n    const totalTime = Date.now() - startedAt;\n    const msg = `HMR Done! ${chalk.bold.white(`${totalTime}ms`)}`;\n    console.log(chalk.black.bgGreen(centerText(msg)));\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: /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ [\n          \"br\",\n          \"gzip\",\n          \"deflate\",\n        ] 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(\n        /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ key as keyof typeof plugins,\n        pluginName,\n      );\n    }\n\n    if (plugins.ws) {\n      await this.ensureWebSocketPlugin(server);\n    }\n\n    if (plugins.custom) {\n      plugins.custom(server);\n    }\n  }\n\n  // @fastify/websocket은 plugins.ws가 설정된 경우에만 등록하고, 같은 server에 중복 등록되지 않도록 WeakSet으로 기록함\n  private async ensureWebSocketPlugin(\n    server: FastifyInstance<Server, IncomingMessage, ServerResponse>,\n  ): Promise<void> {\n    if (this.websocketPluginServers.has(server)) {\n      return;\n    }\n\n    const pluginOption = this.config.server.plugins?.ws;\n    if (!pluginOption) {\n      return;\n    }\n\n    const websocketPlugin = (await import(\"@fastify/websocket\")).default;\n    const resolvedPluginOptions = resolveWebSocketPluginOptions({\n      rawPluginOption: pluginOption,\n    });\n    if (resolvedPluginOptions) {\n      await server.register(websocketPlugin, resolvedPluginOptions);\n    } else {\n      await server.register(websocketPlugin);\n    }\n\n    this.websocketPluginServers.add(server);\n    this.warnOnPotentialWebSocketTimeoutConflicts(server);\n  }\n\n  // heartbeat interval이 Fastify keepAliveTimeout 이상이면 인프라가 먼저 idle 연결을 끊을 수 있어 경고만 남기고 넘어감\n  private warnOnPotentialWebSocketTimeoutConflicts(\n    server: FastifyInstance<Server, IncomingMessage, ServerResponse>,\n  ): void {\n    const heartbeats = this.syncer.apis\n      .map((api) => api.websocketOptions?.heartbeat ?? 30000)\n      .filter((heartbeat) => heartbeat > 0);\n\n    if (heartbeats.length === 0) {\n      return;\n    }\n\n    const keepAliveTimeout = this.config.server.fastify?.keepAliveTimeout;\n    if (!keepAliveTimeout || keepAliveTimeout <= 0) {\n      return;\n    }\n\n    const largestHeartbeat = Math.max(...heartbeats);\n    if (largestHeartbeat >= keepAliveTimeout) {\n      server.log.warn(\n        {\n          keepAliveTimeout,\n          largestHeartbeat,\n        },\n        \"WebSocket heartbeat is greater than or equal to keepAliveTimeout; align infrastructure idle timeouts to avoid unexpected disconnects.\",\n      );\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 response = await this.auth.handler(\n          createBetterAuthRequest(request, options.advanced?.ipAddress?.ipAddressHeaders),\n        );\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\n  private async printStartupSummary() {\n    const activePreset = getSonamuEnvironment();\n\n    printDimSummary(`Config loaded${formatTime(this.configElapsed)}`);\n\n    // DB preset 목록\n    printGreenSummary(\"DB\");\n    const { isLocal } = await import(\"../utils/controller\");\n    const presetNames =\n      /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ Object.keys(\n        this.dbConfig,\n      ) as (keyof SonamuDBConfig)[];\n    const maxLen = Math.max(...presetNames.map((n) => n.length));\n    for (const name of presetNames) {\n      const conn =\n        /* SAFETY: API 데코레이터와 Zod 검증기 등록 계약이 이 값의 타입을 보장한다. */ this\n          .dbConfig[name].connection as\n          | { host?: string; port?: number; database?: string }\n          | undefined;\n      const host = conn?.host ?? \"localhost\";\n      const addr = `@ ${host}:${conn?.port ?? 5432}/${conn?.database ?? \"(unknown)\"}`;\n      const padded = name.padEnd(maxLen);\n      const remoteTag = isLocal() && !isLocalHost(host) ? chalk.yellow(` \\u26a0 remote`) : \"\";\n\n      if (name === activePreset) {\n        console.log(chalk.green(`  \\u25b8 ${padded} ${addr}`) + remoteTag);\n      } else {\n        console.log(chalk.dim(`    ${padded} ${addr}`) + remoteTag);\n      }\n    }\n\n    if (this.config.server.auth) {\n      const basePath = this.config.server.auth.basePath ?? \"/api/auth\";\n      printDimSummary(`Auth: better-auth at ${basePath}/*`);\n    }\n    if (this.config.api.timezone) {\n      printDimSummary(`Timezone: ${this.config.api.timezone}`);\n    }\n    printGreenSummary(`Sonamu ready${formatTime(this.initElapsed)}`);\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.cacheValue = createTestCacheManager();\n      setCacheManagerRef(this.cacheValue);\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.cacheValue = createCacheManager(config);\n    setCacheManagerRef(this.cacheValue);\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.workflowsValue = 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        console.error(chalk.red(\"Failed to start server:\", err));\n        await shutdown();\n      });\n  }\n\n  async destroy(): Promise<void> {\n    const { BaseModel } = await import(\"../database/base-model\");\n    // 먼저 처리해야함.\n    await BaseModel.destroy();\n    // WebSocket shutdown first to flush telemetry\n    if (this.websocketRuntimeValue) {\n      await this.websocketRuntimeValue.shutdown();\n    }\n    this.websocketRuntimeValue = null;\n    // Then shut down remaining resources in parallel\n    await Promise.allSettled([\n      this.workflowsValue?.destroy() ?? Promise.resolve(),\n      this.cacheValue?.disconnect() ?? Promise.resolve(),\n      this.devVitestManagerValue?.shutdown() ?? Promise.resolve(),\n      this.watcher?.close() ?? Promise.resolve(),\n    ]);\n    // LogTape dispose after WS shutdown so telemetry records are flushed first\n    await logtapeDispose();\n  }\n}\n\nfunction getWebSocketTelemetryContext(\n  ws: AnyWebSocketConnection,\n): WebSocketTelemetryConnectionContext {\n  if (!isTelemetryContextProvider(ws)) {\n    return {};\n  }\n\n  return ws.getTelemetryContext();\n}\n\nfunction isTelemetryContextProvider(\n  ws: AnyWebSocketConnection,\n): ws is AnyWebSocketConnection & TelemetryContextProvider {\n  return \"getTelemetryContext\" in ws && isFunctionValue(ws.getTelemetryContext);\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\nfunction formatTime(ms: number): string {\n  const formatted = ms >= 1000 ? `${(ms / 1000).toFixed(2)}s` : `${Math.round(ms)}ms`;\n  return ` (${formatted})`;\n}\n\nconst LOCAL_HOSTS = new Set([\"localhost\", \"127.0.0.1\", \"0.0.0.0\", \"::1\"]);\nfunction isLocalHost(host: string): boolean {\n  return LOCAL_HOSTS.has(host) || host.endsWith(\".local\");\n}\n\n// `.every()`가 첫 guard 이후 순회를 멈추는 문제가 있어 `for...of`로 모든 guard를 순서대로 실행하도록 고정함\nfunction runGuards({\n  guards,\n  config,\n  request,\n  api,\n}: {\n  guards: ExtendedApi[\"options\"][\"guards\"] | undefined;\n  config: Pick<SonamuFastifyConfig, \"guardHandler\">;\n  request: FastifyRequest;\n  api: ExtendedApi;\n}): void {\n  for (const guard of guards ?? []) {\n    config.guardHandler(guard, request, api);\n  }\n}\n"],"mappings":"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"}