sonamu 0.10.11 → 0.10.13

package/dist/syncer/file-tracking.js

@@ -1,12 +1,12 @@
 import { __esmMin } from "../_virtual/_rolldown/runtime.js";
-import { stat } from "fs/promises";
+import { init_filesystem_dependencies, syncerFilesystem } from "./filesystem-dependencies.js";
 //#region src/syncer/file-tracking.ts
 /**
 * 우리가 디스크에 write한 path를 등록합니다. write 직후 호출하세요.
 * 디스크에서 mtime을 직접 읽어 정확한 값으로 등록합니다.
 */
 async function trackWritten(filePath) {
-	const fileStat = await stat(filePath);
+	const fileStat = await syncerFilesystem.stat(filePath);
 	fileWrittenAt.set(filePath, fileStat.mtimeMs);
 }
 /**
@@ -16,14 +16,15 @@ async function trackWritten(filePath) {
 async function isLastChangedByMe(filePath) {
 	const registered = fileWrittenAt.get(filePath);
 	if (registered === void 0) return false;
-	return (await stat(filePath)).mtimeMs <= registered;
+	return (await syncerFilesystem.stat(filePath)).mtimeMs <= registered;
 }
 var fileWrittenAt;
 var init_file_tracking = __esmMin((() => {
+	init_filesystem_dependencies();
 	fileWrittenAt = /* @__PURE__ */ new Map();
 }));
 //#endregion
 init_file_tracking();
 export { fileWrittenAt, init_file_tracking, isLastChangedByMe, trackWritten };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS10cmFja2luZy5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi9zcmMvc3luY2VyL2ZpbGUtdHJhY2tpbmcudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgc3RhdCB9IGZyb20gXCJmcy9wcm9taXNlc1wiO1xuXG5pbXBvcnQgeyB0eXBlIEFic29sdXRlUGF0aCB9IGZyb20gXCIuLi91dGlscy9wYXRoLXV0aWxzXCI7XG5cbmV4cG9ydCBjb25zdCBmaWxlV3JpdHRlbkF0ID0gbmV3IE1hcDxBYnNvbHV0ZVBhdGgsIG51bWJlcj4oKTtcblxuLyoqXG4gKiDsmrDrpqzqsIAg65SU7Iqk7YGs7JeQIHdyaXRl7ZWcIHBhdGjrpbwg65Ox66Gd7ZWp64uI64ukLiB3cml0ZSDsp4Htm4Qg7Zi47Lac7ZWY7IS47JqULlxuICog65SU7Iqk7YGs7JeQ7IScIG10aW1l7J2EIOyngeygkSDsnb3slrQg7KCV7ZmV7ZWcIOqwkuycvOuhnCDrk7HroZ3tlanri4jri6QuXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiB0cmFja1dyaXR0ZW4oZmlsZVBhdGg6IEFic29sdXRlUGF0aCk6IFByb21pc2U8dm9pZD4ge1xuICBjb25zdCBmaWxlU3RhdCA9IGF3YWl0IHN0YXQoZmlsZVBhdGgpO1xuICBmaWxlV3JpdHRlbkF0LnNldChmaWxlUGF0aCwgZmlsZVN0YXQubXRpbWVNcyk7XG59XG5cbi8qKlxuICog7KO87Ja07KeEIHBhdGjqsIAg6rCA7J6lIOy1nOq3vCDsmrDrpqwgd3JpdGUg7J207ZuE66GcIOyZuOu2gOyXkOyEnCDsiJjsoJXrkJwg7KCBIOyXhuuKlOyngCDtmZXsnbjtlanri4jri6QuXG4gKiB0cnVl66m0IFwi64K06rCAIOyTtCDqt7jrjIDroZwg64Ko7JWE7J6I7J2MXCIsIGZhbHNl66m0IFwi7Jm467aA7JeQ7IScIOyImOygleuQkOqxsOuCmCDsmrDrpqzqsIAg7JO0IOyggSDsl4bsnYxcIi5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGlzTGFzdENoYW5nZWRCeU1lKGZpbGVQYXRoOiBBYnNvbHV0ZVBhdGgpOiBQcm9taXNlPGJvb2xlYW4+IHtcbiAgY29uc3QgcmVnaXN0ZXJlZCA9IGZpbGVXcml0dGVuQXQuZ2V0KGZpbGVQYXRoKTtcbiAgaWYgKHJlZ2lzdGVyZWQgPT09IHVuZGVmaW5lZCkge1xuICAgIHJldHVybiBmYWxzZTtcbiAgfVxuICBjb25zdCBmaWxlU3RhdCA9IGF3YWl0IHN0YXQoZmlsZVBhdGgpO1xuICByZXR1cm4gZmlsZVN0YXQubXRpbWVNcyA8PSByZWdpc3RlcmVkO1xufVxuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7O0FBVUEsZUFBc0IsYUFBYSxVQUF1QztDQUN4RSxNQUFNLFdBQVcsTUFBTSxLQUFLLFFBQVE7Q0FDcEMsY0FBYyxJQUFJLFVBQVUsU0FBUyxPQUFPO0FBQzlDOzs7OztBQU1BLGVBQXNCLGtCQUFrQixVQUEwQztDQUNoRixNQUFNLGFBQWEsY0FBYyxJQUFJLFFBQVE7Q0FDN0MsSUFBSSxlQUFlLFFBQ2pCLE9BQU87Q0FHVCxRQUFPLE1BRGdCLEtBQUssUUFBUSxFQUM3QixDQUFTLFdBQVc7QUFDN0I7OztDQXRCYSxnQ0FBZ0IsSUFBSSxJQUEwQiJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/syncer/filesystem-dependencies.d.ts

@@ -0,0 +1,15 @@
+import { type MakeDirectoryOptions, type PathLike, type RmOptions, type Stats } from "node:fs";
+export type SyncerFilesystemDependencies = {
+    access(path: PathLike, mode?: number): Promise<void>;
+    mkdir(path: PathLike, options?: MakeDirectoryOptions): Promise<string | undefined>;
+    readFile(path: PathLike, encoding: BufferEncoding): Promise<string>;
+    rm(path: PathLike, options?: RmOptions): Promise<void>;
+    stat(path: PathLike): Promise<Stats>;
+    unlink(path: PathLike): Promise<void>;
+    writeFile(path: PathLike, data: string | NodeJS.ArrayBufferView, encoding?: BufferEncoding): Promise<void>;
+};
+export declare const syncerFilesystem: SyncerFilesystemDependencies;
+export declare function syncerFileExists(path: PathLike): Promise<boolean>;
+/** 테스트와 임베딩 환경에서 Syncer의 파일시스템 경계를 교체합니다. */
+export declare function configureSyncerFilesystem(dependencies: Partial<SyncerFilesystemDependencies>): () => void;
+//# sourceMappingURL=filesystem-dependencies.d.ts.map

package/dist/syncer/filesystem-dependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem-dependencies.d.ts","sourceRoot":"","sources":["../../src/syncer/filesystem-dependencies.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,oBAAoB,EACzB,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,KAAK,KAAK,EACX,MAAM,SAAS,CAAC;AAGjB,MAAM,MAAM,4BAA4B,GAAG;IACzC,MAAM,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,KAAK,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IACnF,QAAQ,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACpE,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvD,IAAI,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IACrC,MAAM,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtC,SAAS,CACP,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,eAAe,EACrC,QAAQ,CAAC,EAAE,cAAc,GACxB,OAAO,CAAC,IAAI,CAAC,CAAC;CAClB,CAAC;AAYF,eAAO,MAAM,gBAAgB,EAAE,4BAA8C,CAAC;AAE9E,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAOvE;AAED,6CAA6C;AAC7C,wBAAgB,yBAAyB,CACvC,YAAY,EAAE,OAAO,CAAC,4BAA4B,CAAC,GAClD,MAAM,IAAI,CAyBZ"}

package/dist/syncer/filesystem-dependencies.js

@@ -0,0 +1,53 @@
+import { __esmMin } from "../_virtual/_rolldown/runtime.js";
+import { access, mkdir, readFile, rm, stat, unlink, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+//#region src/syncer/filesystem-dependencies.ts
+async function syncerFileExists(path) {
+	try {
+		await syncerFilesystem.access(path, constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** 테스트와 임베딩 환경에서 Syncer의 파일시스템 경계를 교체합니다. */
+function configureSyncerFilesystem(dependencies) {
+	const restorers = [];
+	const override = (key) => {
+		if (!(key in dependencies)) return;
+		const previousDependency = syncerFilesystem[key];
+		Object.assign(syncerFilesystem, { [key]: dependencies[key] });
+		restorers.push(() => Object.assign(syncerFilesystem, { [key]: previousDependency }));
+	};
+	override("access");
+	override("mkdir");
+	override("readFile");
+	override("rm");
+	override("stat");
+	override("unlink");
+	override("writeFile");
+	let configured = true;
+	return () => {
+		if (!configured) return;
+		configured = false;
+		for (const restore of restorers) restore();
+	};
+}
+var defaults, syncerFilesystem;
+var init_filesystem_dependencies = __esmMin((() => {
+	defaults = {
+		access: (path, mode) => access(path, mode),
+		mkdir: (path, options) => mkdir(path, options),
+		readFile: (path, encoding) => readFile(path, encoding),
+		rm: (path, options) => rm(path, options),
+		stat: (path) => stat(path),
+		unlink: (path) => unlink(path),
+		writeFile: (path, data, encoding) => writeFile(path, data, encoding)
+	};
+	syncerFilesystem = { ...defaults };
+}));
+//#endregion
+init_filesystem_dependencies();
+export { configureSyncerFilesystem, init_filesystem_dependencies, syncerFileExists, syncerFilesystem };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/syncer/module-loader.d.ts

@@ -27,5 +27,5 @@ export declare function loadTypes(): Promise<LoadedTypes>;
 /**
  * *.workflow.ts 파일들에서 Workflow 메타데이터를 로드합니다.
  */
-export declare function loadWorkflows(): Promise<Map<string, WorkflowMetadata[]>>;
+export declare function loadWorkflows(): Promise<Map<string, WorkflowMetadata<unknown, unknown, unknown>[]>>;
 //# sourceMappingURL=module-loader.d.ts.map

package/dist/syncer/module-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module-loader.d.ts","sourceRoot":"","sources":["../../src/syncer/module-loader.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAO3D,MAAM,MAAM,UAAU,GAAG,WAAW,EAAE,CAAC;AAEvC,MAAM,MAAM,WAAW,GAAG;IAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,CAAA;CAAE,CAAC;AAE5D,MAAM,MAAM,YAAY,GAAG;IACzB,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,GAAG,cAAc,CAAC;CACtD,CAAC;AAEF;;;;GAIG;AACH,wBAAsB,QAAQ,IAAI,OAAO,CAAC,UAAU,CAAC,CA+BpD;AAED;;GAEG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,YAAY,CAAC,CAmBxD;AAED;;GAEG;AACH,wBAAsB,SAAS,IAAI,OAAO,CAAC,WAAW,CAAC,CAoBtD;AAED;;GAEG;AACH,wBAAsB,aAAa,6CA6BlC"}
+{"version":3,"file":"module-loader.d.ts","sourceRoot":"","sources":["../../src/syncer/module-loader.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAQ3D,MAAM,MAAM,UAAU,GAAG,WAAW,EAAE,CAAC;AAEvC,MAAM,MAAM,WAAW,GAAG;IAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,CAAA;CAAE,CAAC;AAE5D,MAAM,MAAM,YAAY,GAAG;IACzB,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,GAAG,cAAc,CAAC;CACtD,CAAC;AAEF;;;;GAIG;AACH,wBAAsB,QAAQ,IAAI,OAAO,CAAC,UAAU,CAAC,CAkCpD;AAED;;GAEG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,YAAY,CAAC,CAmBxD;AAED;;GAEG;AACH,wBAAsB,SAAS,IAAI,OAAO,CAAC,WAAW,CAAC,CAoBtD;AAED;;GAEG;AACH,wBAAsB,aAAa,wEA6BlC"}

package/dist/syncer/module-loader.js

@@ -1,10 +1,11 @@
 import { __esmMin } from "../_virtual/_rolldown/runtime.js";
+import { init_runtime_value, isFunctionValue, isObjectValue } from "../utils/runtime-value.js";
 import { globAsync, init_async_utils } from "../utils/async-utils.js";
 import { Sonamu, init_sonamu } from "../api/sonamu.js";
 import { importMembers, init_esm_utils } from "../utils/esm-utils.js";
 import { init_path_utils, runtimePath } from "../utils/path-utils.js";
 import { init_api_parser, readApisFromFile } from "./api-parser.js";
-import { z as z$1 } from "zod";
+import { z } from "zod";
 import path from "path";
 //#region src/syncer/module-loader.ts
 /**
@@ -43,7 +44,7 @@ async function loadTypes() {
 	const types = {};
 	for (const filePath of typePaths) {
 		const importedMembers = await importMembers(filePath);
-		for (const { name, value } of importedMembers) if (value instanceof z$1.ZodType) types[name] = value;
+		for (const { name, value } of importedMembers) if (value instanceof z.ZodType) types[name] = value;
 	}
 	return types;
 }
@@ -56,7 +57,7 @@ async function loadWorkflows() {
 	for (const filePath of workflowPaths) {
 		const importedMembers = await importMembers(filePath);
 		workflows.set(filePath, importedMembers.filter(({ value }) => {
-			return typeof value === "object" && value !== null && "type" in value && value.type === "workflow" && "fn" in value && typeof value.fn === "function";
+			return isObjectValue(value) && value !== null && "type" in value && value.type === "workflow" && "fn" in value && isFunctionValue(value.fn);
 		}).map(({ value }) => {
 			return value;
 		}));
@@ -68,10 +69,11 @@ var init_module_loader = __esmMin((() => {
 	init_async_utils();
 	init_esm_utils();
 	init_path_utils();
+	init_runtime_value();
 	init_api_parser();
 }));
 //#endregion
 init_module_loader();
 export { init_module_loader, loadApis, loadModels, loadTypes, loadWorkflows };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"module-loader.js","names":["z"],"sources":["../../src/syncer/module-loader.ts"],"sourcesContent":["import path from \"path\";\n\nimport { z } from \"zod\";\n\nimport { type BaseFrameClass } from \"../api/base-frame\";\nimport { type ExtendedApi } from \"../api/decorators\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { type BaseModelClass } from \"../database/base-model\";\nimport { type WorkflowMetadata } from \"../tasks/decorator\";\nimport { globAsync } from \"../utils/async-utils\";\nimport { importMembers } from \"../utils/esm-utils\";\nimport { runtimePath } from \"../utils/path-utils\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\nimport { readApisFromFile } from \"./api-parser\";\n\nexport type LoadedApis = ExtendedApi[];\n\nexport type LoadedTypes = { [typeName: string]: z.ZodType };\n\nexport type LoadedModels = {\n  [modelName: string]: BaseModelClass | BaseFrameClass;\n};\n\n/**\n * *.model.ts와 *.frame.ts 파일들에서 API 메소드를 파싱하여 로드합니다.\n * registeredApis에 API가 등록되어 있어야 하기 때문에, *.model.ts 파일들을 먼저 import해야 합니다.\n * 따라서 loadModels()를 먼저 호출해야 합니다.\n */\nexport async function loadApis(): Promise<LoadedApis> {\n  // 얘는 특이하게도 환경에 따라 .ts나 .js를 import하는 경우가 아니고,\n  // 타입이 살아있는 .ts 소스 코드만을 읽어야 합니다.\n  // 이것은 dev서버(hot reload)가 아닌 production 환경에서도 동일합니다.\n  // 모델들의 .ts 파일이 있어야 이를 읽어서 라우트를 등록할 수 있어요!\n  const modelPathsPattern = path.join(\n    Sonamu.apiRootPath,\n    \"src/application/**/*.{model,frame}.ts\", // !! runtimePath 안 씀 주의 !!\n  );\n  const modelPaths = (await globAsync(modelPathsPattern)) as AbsolutePath[];\n\n  const apis: LoadedApis = [];\n  for (const filePath of modelPaths) {\n    const parsedApis = await readApisFromFile(filePath);\n    apis.push(...parsedApis);\n  }\n  // console.log(\n  //   chalk.gray(`[Loading] Loaded APIs from \"*.model.ts\" files: ${count} files.`)\n  // );\n\n  for (const api of apis) {\n    if (api.path === \"\") {\n      // api의 경로(path)가 \"텅 비어있음\"인 상태입니다.\n      // 이는 @api와 함께 사용해야 하는 데코레이터가 @api 없이 붙은 상황입니다.\n      throw new Error(\n        `API ${api.modelName}.${api.methodName} has no path. Please attach @api decorator to the method.`,\n      );\n    }\n  }\n\n  return apis;\n}\n\n/**\n * *.model.ts와 *.frame.ts 파일들에서 Model/Frame 클래스 인스턴스를 로드합니다.\n */\nexport async function loadModels(): Promise<LoadedModels> {\n  const modelPathsPattern = path.join(\n    Sonamu.apiRootPath,\n    runtimePath(\"src/application/**/*.{model,frame}.ts\"),\n  );\n  const modelPaths = await globAsync(modelPathsPattern);\n\n  const models: LoadedModels = {};\n  for (const filePath of modelPaths) {\n    const importedMembers = await importMembers<BaseModelClass | BaseFrameClass>(filePath);\n\n    for (const { name, value } of importedMembers) {\n      if (name.endsWith(\"Model\") || name.endsWith(\"Frame\")) {\n        models[name] = value;\n      }\n    }\n  }\n\n  return models;\n}\n\n/**\n * *.types.ts와 *.generated.ts 파일들에서 Zod 스키마를 로드합니다.\n */\nexport async function loadTypes(): Promise<LoadedTypes> {\n  const typePathsPatterns = [\n    path.join(Sonamu.apiRootPath, runtimePath(\"src/application/**/*.types.ts\")),\n    path.join(Sonamu.apiRootPath, runtimePath(\"src/application/**/*.generated.ts\")),\n  ];\n  const typePaths = (\n    await Promise.all(typePathsPatterns.map((pattern) => globAsync(pattern)))\n  ).flat();\n\n  const types: LoadedTypes = {};\n  for (const filePath of typePaths) {\n    const importedMembers = await importMembers<z.ZodType>(filePath);\n    for (const { name, value } of importedMembers) {\n      if (value instanceof z.ZodType) {\n        types[name] = value;\n      }\n    }\n  }\n\n  return types;\n}\n\n/**\n * *.workflow.ts 파일들에서 Workflow 메타데이터를 로드합니다.\n */\nexport async function loadWorkflows() {\n  const workflowPathsPattern = path.join(\n    Sonamu.apiRootPath,\n    runtimePath(\"src/application/**/*.workflow.ts\"),\n  );\n  const workflowPaths = await globAsync(workflowPathsPattern);\n  const workflows: Map<string, WorkflowMetadata[]> = new Map();\n  for (const filePath of workflowPaths) {\n    const importedMembers = await importMembers(filePath);\n    workflows.set(\n      filePath,\n      importedMembers\n        .filter(({ value }) => {\n          return (\n            typeof value === \"object\" &&\n            value !== null &&\n            \"type\" in value &&\n            value.type === \"workflow\" &&\n            \"fn\" in value &&\n            typeof value.fn === \"function\"\n          );\n        })\n        .map(({ value }) => {\n          return value as WorkflowMetadata;\n        }),\n    );\n  }\n\n  return workflows;\n}\n"],"mappings":";;;;;;;;;;;;;;AA4BA,eAAsB,WAAgC;CASpD,MAAM,aAAc,MAAM,UAJA,KAAK,KAC7B,OAAO,aACP,uCAEkC,CAAiB;CAErD,MAAM,OAAmB,CAAC;CAC1B,KAAK,MAAM,YAAY,YAAY;EACjC,MAAM,aAAa,MAAM,iBAAiB,QAAQ;EAClD,KAAK,KAAK,GAAG,UAAU;CACzB;CAKA,KAAK,MAAM,OAAO,MAChB,IAAI,IAAI,SAAS,IAGf,MAAM,IAAI,MACR,OAAO,IAAI,UAAU,GAAG,IAAI,WAAW,0DACzC;CAIJ,OAAO;AACT;;;;AAKA,eAAsB,aAAoC;CAKxD,MAAM,aAAa,MAAM,UAJC,KAAK,KAC7B,OAAO,aACP,YAAY,uCAAuC,CAElB,CAAiB;CAEpD,MAAM,SAAuB,CAAC;CAC9B,KAAK,MAAM,YAAY,YAAY;EACjC,MAAM,kBAAkB,MAAM,cAA+C,QAAQ;EAErF,KAAK,MAAM,EAAE,MAAM,WAAW,iBAC5B,IAAI,KAAK,SAAS,OAAO,KAAK,KAAK,SAAS,OAAO,GACjD,OAAO,QAAQ;CAGrB;CAEA,OAAO;AACT;;;;AAKA,eAAsB,YAAkC;CACtD,MAAM,oBAAoB,CACxB,KAAK,KAAK,OAAO,aAAa,YAAY,+BAA+B,CAAC,GAC1E,KAAK,KAAK,OAAO,aAAa,YAAY,mCAAmC,CAAC,CAChF;CACA,MAAM,aACJ,MAAM,QAAQ,IAAI,kBAAkB,KAAK,YAAY,UAAU,OAAO,CAAC,CAAC,EAAA,CACxE,KAAK;CAEP,MAAM,QAAqB,CAAC;CAC5B,KAAK,MAAM,YAAY,WAAW;EAChC,MAAM,kBAAkB,MAAM,cAAyB,QAAQ;EAC/D,KAAK,MAAM,EAAE,MAAM,WAAW,iBAC5B,IAAI,iBAAiBA,IAAE,SACrB,MAAM,QAAQ;CAGpB;CAEA,OAAO;AACT;;;;AAKA,eAAsB,gBAAgB;CAKpC,MAAM,gBAAgB,MAAM,UAJC,KAAK,KAChC,OAAO,aACP,YAAY,kCAAkC,CAEV,CAAoB;CAC1D,MAAM,4BAA6C,IAAI,IAAI;CAC3D,KAAK,MAAM,YAAY,eAAe;EACpC,MAAM,kBAAkB,MAAM,cAAc,QAAQ;EACpD,UAAU,IACR,UACA,gBACG,QAAQ,EAAE,YAAY;GACrB,OACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACV,MAAM,SAAS,cACf,QAAQ,SACR,OAAO,MAAM,OAAO;EAExB,CAAC,CAAC,CACD,KAAK,EAAE,YAAY;GAClB,OAAO;EACT,CAAC,CACL;CACF;CAEA,OAAO;AACT;;aAxIsC;kBAGU;gBACE;iBACD;iBAEF"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"module-loader.js","names":[],"sources":["../../src/syncer/module-loader.ts"],"sourcesContent":["import path from \"path\";\n\nimport { z } from \"zod\";\n\nimport { type BaseFrameClass } from \"../api/base-frame\";\nimport { type ExtendedApi } from \"../api/decorators\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { type BaseModelClass } from \"../database/base-model\";\nimport { type WorkflowMetadata } from \"../tasks/decorator\";\nimport { globAsync } from \"../utils/async-utils\";\nimport { importMembers } from \"../utils/esm-utils\";\nimport { runtimePath } from \"../utils/path-utils\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\nimport { isFunctionValue, isObjectValue } from \"../utils/runtime-value\";\nimport { readApisFromFile } from \"./api-parser\";\n\nexport type LoadedApis = ExtendedApi[];\n\nexport type LoadedTypes = { [typeName: string]: z.ZodType };\n\nexport type LoadedModels = {\n  [modelName: string]: BaseModelClass | BaseFrameClass;\n};\n\n/**\n * *.model.ts와 *.frame.ts 파일들에서 API 메소드를 파싱하여 로드합니다.\n * registeredApis에 API가 등록되어 있어야 하기 때문에, *.model.ts 파일들을 먼저 import해야 합니다.\n * 따라서 loadModels()를 먼저 호출해야 합니다.\n */\nexport async function loadApis(): Promise<LoadedApis> {\n  // 얘는 특이하게도 환경에 따라 .ts나 .js를 import하는 경우가 아니고,\n  // 타입이 살아있는 .ts 소스 코드만을 읽어야 합니다.\n  // 이것은 dev서버(hot reload)가 아닌 production 환경에서도 동일합니다.\n  // 모델들의 .ts 파일이 있어야 이를 읽어서 라우트를 등록할 수 있어요!\n  const modelPathsPattern = path.join(\n    Sonamu.apiRootPath,\n    \"src/application/**/*.{model,frame}.ts\", // !! runtimePath 안 씀 주의 !!\n  );\n  const modelPaths =\n    /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ (await globAsync(\n      modelPathsPattern,\n    )) as AbsolutePath[];\n\n  const apis: LoadedApis = [];\n  for (const filePath of modelPaths) {\n    const parsedApis = await readApisFromFile(filePath);\n    apis.push(...parsedApis);\n  }\n  // console.log(\n  //   chalk.gray(`[Loading] Loaded APIs from \"*.model.ts\" files: ${count} files.`)\n  // );\n\n  for (const api of apis) {\n    if (api.path === \"\") {\n      // api의 경로(path)가 \"텅 비어있음\"인 상태입니다.\n      // 이는 @api와 함께 사용해야 하는 데코레이터가 @api 없이 붙은 상황입니다.\n      throw new Error(\n        `API ${api.modelName}.${api.methodName} has no path. Please attach @api decorator to the method.`,\n      );\n    }\n  }\n\n  return apis;\n}\n\n/**\n * *.model.ts와 *.frame.ts 파일들에서 Model/Frame 클래스 인스턴스를 로드합니다.\n */\nexport async function loadModels(): Promise<LoadedModels> {\n  const modelPathsPattern = path.join(\n    Sonamu.apiRootPath,\n    runtimePath(\"src/application/**/*.{model,frame}.ts\"),\n  );\n  const modelPaths = await globAsync(modelPathsPattern);\n\n  const models: LoadedModels = {};\n  for (const filePath of modelPaths) {\n    const importedMembers = await importMembers<BaseModelClass | BaseFrameClass>(filePath);\n\n    for (const { name, value } of importedMembers) {\n      if (name.endsWith(\"Model\") || name.endsWith(\"Frame\")) {\n        models[name] = value;\n      }\n    }\n  }\n\n  return models;\n}\n\n/**\n * *.types.ts와 *.generated.ts 파일들에서 Zod 스키마를 로드합니다.\n */\nexport async function loadTypes(): Promise<LoadedTypes> {\n  const typePathsPatterns = [\n    path.join(Sonamu.apiRootPath, runtimePath(\"src/application/**/*.types.ts\")),\n    path.join(Sonamu.apiRootPath, runtimePath(\"src/application/**/*.generated.ts\")),\n  ];\n  const typePaths = (\n    await Promise.all(typePathsPatterns.map((pattern) => globAsync(pattern)))\n  ).flat();\n\n  const types: LoadedTypes = {};\n  for (const filePath of typePaths) {\n    const importedMembers = await importMembers<z.ZodType>(filePath);\n    for (const { name, value } of importedMembers) {\n      if (value instanceof z.ZodType) {\n        types[name] = value;\n      }\n    }\n  }\n\n  return types;\n}\n\n/**\n * *.workflow.ts 파일들에서 Workflow 메타데이터를 로드합니다.\n */\nexport async function loadWorkflows() {\n  const workflowPathsPattern = path.join(\n    Sonamu.apiRootPath,\n    runtimePath(\"src/application/**/*.workflow.ts\"),\n  );\n  const workflowPaths = await globAsync(workflowPathsPattern);\n  const workflows: Map<string, WorkflowMetadata[]> = new Map();\n  for (const filePath of workflowPaths) {\n    const importedMembers = await importMembers(filePath);\n    workflows.set(\n      filePath,\n      importedMembers\n        .filter(({ value }) => {\n          return (\n            isObjectValue(value) &&\n            value !== null &&\n            \"type\" in value &&\n            value.type === \"workflow\" &&\n            \"fn\" in value &&\n            isFunctionValue(value.fn)\n          );\n        })\n        .map(({ value }) => {\n          return /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ value as WorkflowMetadata;\n        }),\n    );\n  }\n\n  return workflows;\n}\n"],"mappings":";;;;;;;;;;;;;;;AA6BA,eAAsB,WAAgC;CASpD,MAAM,aACwD,MAAM,UAL1C,KAAK,KAC7B,OAAO,aACP,uCAIE,CACF;CAEF,MAAM,OAAmB,CAAC;CAC1B,KAAK,MAAM,YAAY,YAAY;EACjC,MAAM,aAAa,MAAM,iBAAiB,QAAQ;EAClD,KAAK,KAAK,GAAG,UAAU;CACzB;CAKA,KAAK,MAAM,OAAO,MAChB,IAAI,IAAI,SAAS,IAGf,MAAM,IAAI,MACR,OAAO,IAAI,UAAU,GAAG,IAAI,WAAW,0DACzC;CAIJ,OAAO;AACT;;;;AAKA,eAAsB,aAAoC;CAKxD,MAAM,aAAa,MAAM,UAJC,KAAK,KAC7B,OAAO,aACP,YAAY,uCAAuC,CAElB,CAAiB;CAEpD,MAAM,SAAuB,CAAC;CAC9B,KAAK,MAAM,YAAY,YAAY;EACjC,MAAM,kBAAkB,MAAM,cAA+C,QAAQ;EAErF,KAAK,MAAM,EAAE,MAAM,WAAW,iBAC5B,IAAI,KAAK,SAAS,OAAO,KAAK,KAAK,SAAS,OAAO,GACjD,OAAO,QAAQ;CAGrB;CAEA,OAAO;AACT;;;;AAKA,eAAsB,YAAkC;CACtD,MAAM,oBAAoB,CACxB,KAAK,KAAK,OAAO,aAAa,YAAY,+BAA+B,CAAC,GAC1E,KAAK,KAAK,OAAO,aAAa,YAAY,mCAAmC,CAAC,CAChF;CACA,MAAM,aACJ,MAAM,QAAQ,IAAI,kBAAkB,KAAK,YAAY,UAAU,OAAO,CAAC,CAAC,EAAA,CACxE,KAAK;CAEP,MAAM,QAAqB,CAAC;CAC5B,KAAK,MAAM,YAAY,WAAW;EAChC,MAAM,kBAAkB,MAAM,cAAyB,QAAQ;EAC/D,KAAK,MAAM,EAAE,MAAM,WAAW,iBAC5B,IAAI,iBAAiB,EAAE,SACrB,MAAM,QAAQ;CAGpB;CAEA,OAAO;AACT;;;;AAKA,eAAsB,gBAAgB;CAKpC,MAAM,gBAAgB,MAAM,UAJC,KAAK,KAChC,OAAO,aACP,YAAY,kCAAkC,CAEV,CAAoB;CAC1D,MAAM,4BAA6C,IAAI,IAAI;CAC3D,KAAK,MAAM,YAAY,eAAe;EACpC,MAAM,kBAAkB,MAAM,cAAc,QAAQ;EACpD,UAAU,IACR,UACA,gBACG,QAAQ,EAAE,YAAY;GACrB,OACE,cAAc,KAAK,KACnB,UAAU,QACV,UAAU,SACV,MAAM,SAAS,cACf,QAAQ,SACR,gBAAgB,MAAM,EAAE;EAE5B,CAAC,CAAC,CACD,KAAK,EAAE,YAAY;GAClB,OAAkE;EACpE,CAAC,CACL;CACF;CAEA,OAAO;AACT;;aA5IsC;kBAGU;gBACE;iBACD;oBAEsB;iBACxB"}

package/dist/syncer/syncer-actions.d.ts

@@ -24,6 +24,10 @@ export declare function actionGenerateSchemas(): Promise<AbsolutePath[]>;
  * @returns 생성된 파일 경로.
  */
 export declare function actionGenerateHttps(): Promise<AbsolutePath>;
+/**
+ * 최종 REST caster를 담는 API 전용 validator registry를 재생성합니다.
+ */
+export declare function actionGenerateHttpValidators(): Promise<AbsolutePath>;
 /**
  * queries.generated.ts 재생성합니다.
  * @returns 생성된 파일 경로 배열.

package/dist/syncer/syncer-actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"syncer-actions.d.ts","sourceRoot":"","sources":["../../src/syncer/syncer-actions.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAMlE,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAKxD,wBAAsB,gBAAgB,kBAWrC;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,WAAW,EAAE;IACX,WAAW,EAAE,iBAAiB,CAAC;CAChC,EAAE,GACF,OAAO,CAAC,YAAY,EAAE,CAAC,CAazB;AAED;;;GAGG;AACH,wBAAsB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAE1F;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAOrE;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,YAAY,CAAC,CAQjE;AAED;;;GAGG;AACH,wBAAsB,wBAAwB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAExE;AAED;;;;;;GAMG;AACH,wBAAsB,uCAAuC,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAWvF;AAED;;;;;;;GAOG;AACH,wBAAsB,wBAAwB,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAkCzF;AAED;;;;;GAKG;AACH,wBAAsB,oCAAoC,IAAI,OAAO,CAAC,IAAI,CAAC,CA+D1E;AAED;;;;;;;;GAQG;AACH,wBAAsB,0BAA0B,IAAI,OAAO,CAAC,IAAI,CAAC,CAoBhE"}
+{"version":3,"file":"syncer-actions.d.ts","sourceRoot":"","sources":["../../src/syncer/syncer-actions.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAKlE,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAQxD,wBAAsB,gBAAgB,kBAcrC;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,WAAW,EAAE;IACX,WAAW,EAAE,iBAAiB,CAAC;CAChC,EAAE,GACF,OAAO,CAAC,YAAY,EAAE,CAAC,CAazB;AAED;;;GAGG;AACH,wBAAsB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAE1F;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAOrE;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,YAAY,CAAC,CAQjE;AAED;;GAEG;AACH,wBAAsB,4BAA4B,IAAI,OAAO,CAAC,YAAY,CAAC,CAmB1E;AAED;;;GAGG;AACH,wBAAsB,wBAAwB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAExE;AAED;;;;;;GAMG;AACH,wBAAsB,uCAAuC,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAWvF;AAED;;;;;;;GAOG;AACH,wBAAsB,wBAAwB,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAoCzF;AAED;;;;;GAKG;AACH,wBAAsB,oCAAoC,IAAI,OAAO,CAAC,IAAI,CAAC,CAiE1E;AAED;;;;;;;;GAQG;AACH,wBAAsB,0BAA0B,IAAI,OAAO,CAAC,IAAI,CAAC,CAwBhE"}

package/dist/syncer/syncer-actions.js

@@ -1,23 +1,24 @@
 import { __esmMin } from "../_virtual/_rolldown/runtime.js";
+import { init_runtime_value, isObjectValue } from "../utils/runtime-value.js";
 import { AlreadyProcessedException, init_so_exceptions } from "../exceptions/so-exceptions.js";
 import { init_controller, isTest } from "../utils/controller.js";
 import { formatCode, init_formatter } from "../utils/formatter.js";
-import { copyFileWithReplaceCoreToShared, exists, init_fs_utils } from "../utils/fs-utils.js";
 import { Sonamu, init_sonamu } from "../api/sonamu.js";
 import { Naite, init_naite } from "../naite/naite.js";
+import { init_filesystem_dependencies, syncerFileExists, syncerFilesystem } from "./filesystem-dependencies.js";
 import { init_file_tracking, trackWritten } from "./file-tracking.js";
 import { generateTemplate, init_code_generator } from "./code-generator.js";
+import { copyFileWithReplaceCoreToShared, init_file_copy } from "./file-copy.js";
 import assert from "assert";
 import path, { dirname } from "path";
 import chalk from "chalk";
-import { mkdir, readFile, writeFile } from "fs/promises";
 //#region src/syncer/syncer-actions.ts
 async function actionSyncConfig() {
 	const { host, port } = Sonamu.config.server.listen ?? {};
 	const content = `API_HOST=${host ?? "localhost"}\nAPI_PORT=${port ?? 3e3}`;
 	Naite.t("actionSyncConfig", { content });
-	await Promise.all([...Sonamu.config.sync.targets.map(async (target) => {
-		await writeFile(path.join(Sonamu.appRootPath, target, ".sonamu.env"), content);
+	await Promise.all([...Sonamu.config.sync.targets.map((target) => {
+		return syncerFilesystem.writeFile(path.join(Sonamu.appRootPath, target, ".sonamu.env"), content);
 	}), generateTemplate("generated_sso", {}, { overwrite: true })]);
 }
 /**
@@ -53,6 +54,20 @@ async function actionGenerateHttps() {
 	return res;
 }
 /**
+* 최종 REST caster를 담는 API 전용 validator registry를 재생성합니다.
+*/
+async function actionGenerateHttpValidators() {
+	const registryPath = path.join(Sonamu.apiRootPath, "src/application/sonamu.validators.generated.ts");
+	const policy = Sonamu.config.validation?.zodCompiler;
+	if (!(isObjectValue(policy) && policy !== null && policy.api === "aot")) {
+		if (await syncerFileExists(registryPath)) await syncerFilesystem.unlink(registryPath);
+		return registryPath;
+	}
+	const [generatedPath] = await generateTemplate("http_validators", {}, { overwrite: true });
+	assert(generatedPath);
+	return generatedPath;
+}
+/**
 * queries.generated.ts 재생성합니다.
 * @returns 생성된 파일 경로 배열.
 */
@@ -88,7 +103,7 @@ async function actionSyncFilesToTargets(tsPaths) {
 	return (await Promise.all(targets.map(async (target) => Promise.all(tsPaths.map(async (realSrc) => {
 		const dst = realSrc.replace(`/${apiDir}/`, `/${target}/`).replace("/application/", "/services/");
 		const dir = dirname(dst);
-		if (!await exists(dir)) await mkdir(dir, { recursive: true });
+		if (!await syncerFileExists(dir)) await syncerFilesystem.mkdir(dir, { recursive: true });
 		await copyFileWithReplaceCoreToShared(realSrc, dst, [
 			"/**",
 			" * @generated",
@@ -109,24 +124,24 @@ async function actionSyncFilesToTargets(tsPaths) {
 async function actionCopySharedToTargetsIfNotExists() {
 	const { targets } = Sonamu.config.sync;
 	const dictUtilsPath = path.join(import.meta.dirname.replace("/dist/", "/src/"), "../dict/utils.ts");
-	const dictUtilsCode = await exists(dictUtilsPath) ? await readFile(dictUtilsPath, "utf-8") : "";
+	const dictUtilsCode = await syncerFileExists(dictUtilsPath) ? await syncerFilesystem.readFile(dictUtilsPath, "utf-8") : "";
 	const convertMap = {
 		baseUrl: Sonamu.config.server.baseUrl ?? `http://${Sonamu.config.server.listen?.host ?? "localhost"}:${Sonamu.config.server.listen?.port ?? 3e3}`,
 		dictUtils: dictUtilsCode
 	};
 	for (const target of targets) {
 		const srcPath = path.join(import.meta.dirname.replace("/dist/", "/src/"), `../shared/${target}.shared.ts.txt`);
-		if (!await exists(srcPath)) continue;
-		if (!await exists(path.join(Sonamu.appRootPath, target))) throw new Error(`Tried to copy sonamu.shared.ts to target '${target}' but the target directory does not exist. Please check your project directory structure.`);
-		const fullText = await readFile(srcPath, "utf-8");
+		if (!await syncerFileExists(srcPath)) continue;
+		if (!await syncerFileExists(path.join(Sonamu.appRootPath, target))) throw new Error(`Tried to copy sonamu.shared.ts to target '${target}' but the target directory does not exist. Please check your project directory structure.`);
+		const fullText = await syncerFilesystem.readFile(srcPath, "utf-8");
 		const convertedText = Object.entries(convertMap).reduce((acc, [key, value]) => acc.replace(`$[[${key}]]`, value), fullText);
 		const destPath = path.join(Sonamu.appRootPath, target, "src/services/sonamu.shared.ts");
-		if (!await exists(path.dirname(destPath))) {
-			await mkdir(path.dirname(destPath), { recursive: true });
+		if (!await syncerFileExists(path.dirname(destPath))) {
+			await syncerFilesystem.mkdir(path.dirname(destPath), { recursive: true });
 			console.warn(`Created directory '${path.dirname(destPath)}' because it did not exist.`);
 		}
-		if (await exists(destPath)) continue;
-		await writeFile(destPath, await formatCode(convertedText, destPath));
+		if (await syncerFileExists(destPath)) continue;
+		await syncerFilesystem.writeFile(destPath, await formatCode(convertedText, destPath));
 		!isTest() && console.log(chalk.bold("Copied: ") + chalk.blue(path.relative(Sonamu.appRootPath, destPath)));
 	}
 }
@@ -156,7 +171,7 @@ async function actionSyncSonamuDictionary() {
 */
 async function syncLocaleFiles(target, apiI18nDir, locales) {
 	const targetI18nDir = path.join(Sonamu.appRootPath, target, "src/i18n");
-	await mkdir(targetI18nDir, { recursive: true });
+	await syncerFilesystem.mkdir(targetI18nDir, { recursive: true });
 	for (const locale of locales) {
 		const sourceFile = path.join(apiI18nDir, `${locale}.ts`);
 		const targetFile = path.join(targetI18nDir, `${locale}.ts`);
@@ -176,12 +191,14 @@ var init_syncer_actions = __esmMin((() => {
 	init_naite();
 	init_controller();
 	init_formatter();
-	init_fs_utils();
+	init_runtime_value();
 	init_code_generator();
+	init_file_copy();
 	init_file_tracking();
+	init_filesystem_dependencies();
 }));
 //#endregion
 init_syncer_actions();
-export { actionCopySharedToTargetsIfNotExists, actionGenerateHttps, actionGenerateInitialTypes, actionGenerateSchemas, actionGenerateServices, actionGenerateSsrEntryServerIfNotExists, actionGenerateSsrQueries, actionSyncConfig, actionSyncFilesToTargets, actionSyncSonamuDictionary, init_syncer_actions };
+export { actionCopySharedToTargetsIfNotExists, actionGenerateHttpValidators, actionGenerateHttps, actionGenerateInitialTypes, actionGenerateSchemas, actionGenerateServices, actionGenerateSsrEntryServerIfNotExists, actionGenerateSsrQueries, actionSyncConfig, actionSyncFilesToTargets, actionSyncSonamuDictionary, init_syncer_actions };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"syncer-actions.js","names":[],"sources":["../../src/syncer/syncer-actions.ts"],"sourcesContent":["import assert from \"assert\";\nimport { mkdir, readFile, writeFile } from \"fs/promises\";\nimport path, { dirname } from \"path\";\n\nimport chalk from \"chalk\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport { type EntityNamesRecord } from \"../entity/entity-manager\";\nimport { AlreadyProcessedException } from \"../exceptions/so-exceptions\";\nimport { Naite } from \"../naite/naite\";\nimport { isTest } from \"../utils/controller\";\nimport { formatCode } from \"../utils/formatter\";\nimport { copyFileWithReplaceCoreToShared, exists } from \"../utils/fs-utils\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\nimport { generateTemplate } from \"./code-generator\";\nimport { trackWritten } from \"./file-tracking\";\n\n// web/.sonamu.env 에 현재 설정값 저장\nexport async function actionSyncConfig() {\n  const { host, port } = Sonamu.config.server.listen ?? {};\n  const content = `API_HOST=${host ?? \"localhost\"}\\nAPI_PORT=${port ?? 3000}`;\n\n  Naite.t(\"actionSyncConfig\", { content });\n  await Promise.all([\n    ...Sonamu.config.sync.targets.map(async (target) => {\n      await writeFile(path.join(Sonamu.appRootPath, target, \".sonamu.env\"), content);\n    }),\n    generateTemplate(\"generated_sso\", {}, { overwrite: true }),\n  ]);\n}\n\n/**\n * services.generated.ts를 생성합니다.\n * @param paramsArray\n * @returns 생성된 파일 경로 배열.\n */\nexport async function actionGenerateServices(\n  paramsArray: {\n    namesRecord: EntityNamesRecord;\n  }[],\n): Promise<AbsolutePath[]> {\n  Naite.t(\"actionGenerateServices\", paramsArray);\n\n  // services.generated.ts 통합 파일 생성\n  const servicesFile = await generateTemplate(\n    \"services\",\n    {},\n    {\n      overwrite: true,\n    },\n  );\n\n  return [...servicesFile];\n}\n\n/**\n * Entity에 딸린 초기 types.ts를 만들어줍니다.\n * @param entityId\n */\nexport async function actionGenerateInitialTypes(entityId: string): Promise<AbsolutePath[]> {\n  return generateTemplate(\"init_types\", { entityId });\n}\n\n/**\n * sonamu.generated.ts와 sonamu.generated.sso.ts를 생성합니다.\n * @returns 생성된 파일 경로 배열.\n */\nexport async function actionGenerateSchemas(): Promise<AbsolutePath[]> {\n  return (\n    await Promise.all([\n      generateTemplate(\"generated_sso\", {}, { overwrite: true }),\n      generateTemplate(\"generated\", {}, { overwrite: true }),\n    ])\n  ).flat();\n}\n\n/**\n * sonamu.generated.http를 생성합니다.\n * @returns 생성된 파일 경로.\n */\nexport async function actionGenerateHttps(): Promise<AbsolutePath> {\n  const [res] = await generateTemplate(\n    \"generated_http\",\n    { entityId: \"dummy\" },\n    { overwrite: true },\n  );\n  assert(res);\n  return res;\n}\n\n/**\n * queries.generated.ts 재생성합니다.\n * @returns 생성된 파일 경로 배열.\n */\nexport async function actionGenerateSsrQueries(): Promise<AbsolutePath[]> {\n  return generateTemplate(\"queries\", {}, { overwrite: true });\n}\n\n/**\n * entry-server.generated.tsx를 생성합니다.\n * 다른 액션들과 달리, 이미 파일이 있으면 그냥 놔둡니다. 그래서 함수 이름 끝에 써놨어요 ㅎ\n * 입력 의존 없는 정적 코드라 매번 overwrite는 mtime만 갱신하는 의미 없는 동작.\n * 템플릿 자체가 변경된 경우(Sonamu 업그레이드)에는 사용자가 파일을 삭제한 뒤 sync로 재생성.\n * @returns 생성된 파일 경로 배열 (이미 있으면 빈 배열).\n */\nexport async function actionGenerateSsrEntryServerIfNotExists(): Promise<AbsolutePath[]> {\n  try {\n    return await generateTemplate(\"entry_server\", {}, { overwrite: false });\n  } catch (e) {\n    // generateTemplate은 overwrite: false에서 파일이 이미 있으면 예외를 던집니다.\n    // IfNotExists 의미상 \"그냥 놔둔다\"가 정상이므로 빈 배열로 변환합니다.\n    if (e instanceof AlreadyProcessedException) {\n      return [];\n    }\n    throw e;\n  }\n}\n\n/**\n * 주어진 .ts 파일들(api에 있다고 가정)을 모든 타겟 디렉토리의 services에 갖다 둡니다.\n * 이때 내부의 sonamu import는 sonamu.shared.ts import로 치환되고,\n * 경로의 /application/은 /services/로 치환됩니다.\n *\n * @param tsPaths 복사할 파일들의 절대 경로\n * @returns 각 타겟에 복사된 파일들의 절대 경로 배열 (flat).\n */\nexport async function actionSyncFilesToTargets(tsPaths: AbsolutePath[]): Promise<string[]> {\n  const { targets } = Sonamu.config.sync;\n  const { dir: apiDir } = Sonamu.config.api;\n\n  return (\n    await Promise.all(\n      targets.map(async (target) =>\n        Promise.all(\n          tsPaths.map(async (realSrc) => {\n            const dst = realSrc\n              .replace(`/${apiDir}/`, `/${target}/`)\n              .replace(\"/application/\", \"/services/\");\n            const dir = dirname(dst);\n            if (!(await exists(dir))) {\n              await mkdir(dir, { recursive: true });\n            }\n            const syncHeader = [\n              \"/**\",\n              \" * @generated\",\n              \" * API에서 동기화된 파일입니다. 직접 수정하지 마세요.\",\n              \" */\",\n            ].join(\"\\n\");\n            await copyFileWithReplaceCoreToShared(realSrc, dst, syncHeader);\n            await trackWritten(dst as AbsolutePath);\n            !isTest() &&\n              console.log(\n                chalk.bold(\"Copied: \") + chalk.blue(dst.replace(`${Sonamu.appRootPath}/`, \"\")),\n              );\n            return dst;\n          }),\n        ),\n      ),\n    )\n  ).flat();\n}\n\n/**\n * shared 템플릿으로부터 sonamu.shared.ts 파일을 만들어서 모든 타겟 디렉토리에 갖다 둡니다.\n * 파일을 만드는 과정에서 여러 치환 가공이 일어납니다.\n *\n * 다른 액션들과 달리, 이미 파일이 있으면 그냥 놔둡니다. 그래서 함수 이름 끝에 써놨어요 ㅎ\n */\nexport async function actionCopySharedToTargetsIfNotExists(): Promise<void> {\n  const { targets } = Sonamu.config.sync;\n\n  // plural.ts 내용을 읽어서 shared 파일에 삽입합니다.\n  const dictUtilsPath = path.join(\n    import.meta.dirname.replace(\"/dist/\", \"/src/\"),\n    \"../dict/utils.ts\",\n  );\n  const dictUtilsCode = (await exists(dictUtilsPath)) ? await readFile(dictUtilsPath, \"utf-8\") : \"\";\n\n  // 특정 변수 치환을 위해서 사용합니다.\n  const convertMap = {\n    baseUrl:\n      Sonamu.config.server.baseUrl ??\n      `http://${Sonamu.config.server.listen?.host ?? \"localhost\"}:${Sonamu.config.server.listen?.port ?? 3000}`,\n    dictUtils: dictUtilsCode,\n  };\n\n  for (const target of targets) {\n    // 지금 가져가려는 이 파일은 Sonamu 코드베이스의 일부입니다.\n    // 그런데 dist 속 빌드된 소스 코드 파일이 필요한 것이 아니고, src에만 있는 텍스트 파일이 필요합니다.\n    // 따라서 /src/에서 찾습니다.\n    const srcPath = path.join(\n      import.meta.dirname.replace(\"/dist/\", \"/src/\"),\n      `../shared/${target}.shared.ts.txt`,\n    );\n    if (!(await exists(srcPath))) {\n      continue;\n    }\n    if (!(await exists(path.join(Sonamu.appRootPath, target)))) {\n      throw new Error(\n        `Tried to copy sonamu.shared.ts to target '${target}' but the target directory does not exist. Please check your project directory structure.`,\n      );\n    }\n\n    const fullText = await readFile(srcPath, \"utf-8\");\n    const convertedText = Object.entries(convertMap).reduce(\n      (acc, [key, value]) => acc.replace(`$[[${key}]]`, value),\n      fullText,\n    );\n\n    // 이건 프로젝트에 .ts 소스 코드 파일을 생성하는 것이므로 src의 .ts 경로로 갑니다.\n    const destPath = path.join(Sonamu.appRootPath, target, \"src/services/sonamu.shared.ts\");\n\n    // 정말 혹시나지만 target 디렉토리는 있어도 src/services 디렉토리는 없을 수 있으므로 미리 생성해줍니다.\n    if (!(await exists(path.dirname(destPath)))) {\n      await mkdir(path.dirname(destPath), { recursive: true });\n      console.warn(`Created directory '${path.dirname(destPath)}' because it did not exist.`);\n    }\n\n    // 파일이 이미 존재하면 건너뜁니다.\n    // sonamu.shared.ts는 프로젝트에서 자유롭게 커스터마이징할 수 있어야 하므로,\n    // 최초 1회만 생성하고 이후에는 덮어쓰지 않습니다.\n    // 템플릿 내용($[[dictUtils]] 등)이 변경되었을 때 반영이 필요하면,\n    // 해당 파일을 삭제한 뒤 `pnpm sonamu sync`로 재생성하면 됩니다.\n    if (await exists(destPath)) {\n      continue;\n    }\n\n    await writeFile(destPath, await formatCode(convertedText, destPath));\n    !isTest() &&\n      console.log(chalk.bold(\"Copied: \") + chalk.blue(path.relative(Sonamu.appRootPath, destPath)));\n  }\n}\n\n/**\n * Sonamu Dictionary(SD)를 모든 타겟(api + web/app 등)에 동기화합니다.\n *\n * 각 타겟에 대해:\n * - target이 api가 아니면 사용자 작성 locale 파일(ko.ts/en.ts/...)을 api → target으로 복사\n * - sd 템플릿을 렌더링해서 sd.generated.ts 생성 (overwrite)\n *\n * 한 타겟에서 실패해도 다른 타겟은 계속 진행합니다.\n */\nexport async function actionSyncSonamuDictionary(): Promise<void> {\n  const { targets } = Sonamu.config.sync;\n  const i18nConfig = Sonamu.config.i18n;\n\n  const targetList = [\"api\", ...targets] as (\"api\" | \"web\" | \"app\")[];\n\n  const apiI18nDir = path.join(Sonamu.appRootPath, Sonamu.config.api.dir, \"src/i18n\");\n\n  for (const target of targetList) {\n    try {\n      // web/app의 경우 locale 파일들을 api에서 복사\n      if (target !== \"api\") {\n        await syncLocaleFiles(target, apiI18nDir, i18nConfig.supportedLocales);\n      }\n\n      await generateTemplate(\"sd\", { target }, { overwrite: true });\n    } catch (e) {\n      console.error(`Failed to generate SD template for ${target}:`, e);\n    }\n  }\n}\n\n/**\n * api의 locale 파일을 web/app으로 복사합니다.\n */\nasync function syncLocaleFiles(\n  target: string,\n  apiI18nDir: string,\n  locales: string[],\n): Promise<void> {\n  const targetI18nDir = path.join(Sonamu.appRootPath, target, \"src/i18n\");\n\n  // 디렉토리가 없으면 생성\n  await mkdir(targetI18nDir, { recursive: true });\n\n  for (const locale of locales) {\n    const sourceFile = path.join(apiI18nDir, `${locale}.ts`);\n    const targetFile = path.join(targetI18nDir, `${locale}.ts`);\n\n    const syncHeader = [\n      \"/**\",\n      \" * @generated\",\n      \" * API에서 동기화된 파일입니다. 직접 수정하지 마세요.\",\n      \" */\",\n    ].join(\"\\n\");\n    await copyFileWithReplaceCoreToShared(sourceFile, targetFile, syncHeader);\n    await trackWritten(targetFile as AbsolutePath);\n    !isTest() &&\n      console.log(chalk.bold(\"Copied: \") + chalk.cyan(`${target}/src/i18n/${locale}.ts`));\n  }\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"syncer-actions.js","names":[],"sources":["../../src/syncer/syncer-actions.ts"],"sourcesContent":["import assert from \"assert\";\nimport path, { dirname } from \"path\";\n\nimport chalk from \"chalk\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport { type EntityNamesRecord } from \"../entity/entity-manager\";\nimport { AlreadyProcessedException } from \"../exceptions/so-exceptions\";\nimport { Naite } from \"../naite/naite\";\nimport { isTest } from \"../utils/controller\";\nimport { formatCode } from \"../utils/formatter\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\nimport { isObjectValue } from \"../utils/runtime-value\";\nimport { generateTemplate } from \"./code-generator\";\nimport { copyFileWithReplaceCoreToShared } from \"./file-copy\";\nimport { trackWritten } from \"./file-tracking\";\nimport { syncerFileExists, syncerFilesystem } from \"./filesystem-dependencies\";\n\n// web/.sonamu.env 에 현재 설정값 저장\nexport async function actionSyncConfig() {\n  const { host, port } = Sonamu.config.server.listen ?? {};\n  const content = `API_HOST=${host ?? \"localhost\"}\\nAPI_PORT=${port ?? 3000}`;\n\n  Naite.t(\"actionSyncConfig\", { content });\n  await Promise.all([\n    ...Sonamu.config.sync.targets.map((target) => {\n      return syncerFilesystem.writeFile(\n        path.join(Sonamu.appRootPath, target, \".sonamu.env\"),\n        content,\n      );\n    }),\n    generateTemplate(\"generated_sso\", {}, { overwrite: true }),\n  ]);\n}\n\n/**\n * services.generated.ts를 생성합니다.\n * @param paramsArray\n * @returns 생성된 파일 경로 배열.\n */\nexport async function actionGenerateServices(\n  paramsArray: {\n    namesRecord: EntityNamesRecord;\n  }[],\n): Promise<AbsolutePath[]> {\n  Naite.t(\"actionGenerateServices\", paramsArray);\n\n  // services.generated.ts 통합 파일 생성\n  const servicesFile = await generateTemplate(\n    \"services\",\n    {},\n    {\n      overwrite: true,\n    },\n  );\n\n  return [...servicesFile];\n}\n\n/**\n * Entity에 딸린 초기 types.ts를 만들어줍니다.\n * @param entityId\n */\nexport async function actionGenerateInitialTypes(entityId: string): Promise<AbsolutePath[]> {\n  return generateTemplate(\"init_types\", { entityId });\n}\n\n/**\n * sonamu.generated.ts와 sonamu.generated.sso.ts를 생성합니다.\n * @returns 생성된 파일 경로 배열.\n */\nexport async function actionGenerateSchemas(): Promise<AbsolutePath[]> {\n  return (\n    await Promise.all([\n      generateTemplate(\"generated_sso\", {}, { overwrite: true }),\n      generateTemplate(\"generated\", {}, { overwrite: true }),\n    ])\n  ).flat();\n}\n\n/**\n * sonamu.generated.http를 생성합니다.\n * @returns 생성된 파일 경로.\n */\nexport async function actionGenerateHttps(): Promise<AbsolutePath> {\n  const [res] = await generateTemplate(\n    \"generated_http\",\n    { entityId: \"dummy\" },\n    { overwrite: true },\n  );\n  assert(res);\n  return res;\n}\n\n/**\n * 최종 REST caster를 담는 API 전용 validator registry를 재생성합니다.\n */\nexport async function actionGenerateHttpValidators(): Promise<AbsolutePath> {\n  const registryPath =\n    /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ path.join(\n      Sonamu.apiRootPath,\n      \"src/application/sonamu.validators.generated.ts\",\n    ) as AbsolutePath;\n  const policy = Sonamu.config.validation?.zodCompiler;\n  const isAot = isObjectValue(policy) && policy !== null && policy.api === \"aot\";\n  if (!isAot) {\n    // opt-out/JIT 전환 뒤 AOT compile import가 애플리케이션에 남지 않도록 산출물도 함께 정리합니다.\n    if (await syncerFileExists(registryPath)) {\n      await syncerFilesystem.unlink(registryPath);\n    }\n    return registryPath;\n  }\n\n  const [generatedPath] = await generateTemplate(\"http_validators\", {}, { overwrite: true });\n  assert(generatedPath);\n  return generatedPath;\n}\n\n/**\n * queries.generated.ts 재생성합니다.\n * @returns 생성된 파일 경로 배열.\n */\nexport async function actionGenerateSsrQueries(): Promise<AbsolutePath[]> {\n  return generateTemplate(\"queries\", {}, { overwrite: true });\n}\n\n/**\n * entry-server.generated.tsx를 생성합니다.\n * 다른 액션들과 달리, 이미 파일이 있으면 그냥 놔둡니다. 그래서 함수 이름 끝에 써놨어요 ㅎ\n * 입력 의존 없는 정적 코드라 매번 overwrite는 mtime만 갱신하는 의미 없는 동작.\n * 템플릿 자체가 변경된 경우(Sonamu 업그레이드)에는 사용자가 파일을 삭제한 뒤 sync로 재생성.\n * @returns 생성된 파일 경로 배열 (이미 있으면 빈 배열).\n */\nexport async function actionGenerateSsrEntryServerIfNotExists(): Promise<AbsolutePath[]> {\n  try {\n    return await generateTemplate(\"entry_server\", {}, { overwrite: false });\n  } catch (e) {\n    // generateTemplate은 overwrite: false에서 파일이 이미 있으면 예외를 던집니다.\n    // IfNotExists 의미상 \"그냥 놔둔다\"가 정상이므로 빈 배열로 변환합니다.\n    if (e instanceof AlreadyProcessedException) {\n      return [];\n    }\n    throw e;\n  }\n}\n\n/**\n * 주어진 .ts 파일들(api에 있다고 가정)을 모든 타겟 디렉토리의 services에 갖다 둡니다.\n * 이때 내부의 sonamu import는 sonamu.shared.ts import로 치환되고,\n * 경로의 /application/은 /services/로 치환됩니다.\n *\n * @param tsPaths 복사할 파일들의 절대 경로\n * @returns 각 타겟에 복사된 파일들의 절대 경로 배열 (flat).\n */\nexport async function actionSyncFilesToTargets(tsPaths: AbsolutePath[]): Promise<string[]> {\n  const { targets } = Sonamu.config.sync;\n  const { dir: apiDir } = Sonamu.config.api;\n\n  return (\n    await Promise.all(\n      targets.map(async (target) =>\n        Promise.all(\n          tsPaths.map(async (realSrc) => {\n            const dst = realSrc\n              .replace(`/${apiDir}/`, `/${target}/`)\n              .replace(\"/application/\", \"/services/\");\n            const dir = dirname(dst);\n            if (!(await syncerFileExists(dir))) {\n              await syncerFilesystem.mkdir(dir, { recursive: true });\n            }\n            const syncHeader = [\n              \"/**\",\n              \" * @generated\",\n              \" * API에서 동기화된 파일입니다. 직접 수정하지 마세요.\",\n              \" */\",\n            ].join(\"\\n\");\n            await copyFileWithReplaceCoreToShared(realSrc, dst, syncHeader);\n            await trackWritten(\n              /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ dst as AbsolutePath,\n            );\n            !isTest() &&\n              console.log(\n                chalk.bold(\"Copied: \") + chalk.blue(dst.replace(`${Sonamu.appRootPath}/`, \"\")),\n              );\n            return dst;\n          }),\n        ),\n      ),\n    )\n  ).flat();\n}\n\n/**\n * shared 템플릿으로부터 sonamu.shared.ts 파일을 만들어서 모든 타겟 디렉토리에 갖다 둡니다.\n * 파일을 만드는 과정에서 여러 치환 가공이 일어납니다.\n *\n * 다른 액션들과 달리, 이미 파일이 있으면 그냥 놔둡니다. 그래서 함수 이름 끝에 써놨어요 ㅎ\n */\nexport async function actionCopySharedToTargetsIfNotExists(): Promise<void> {\n  const { targets } = Sonamu.config.sync;\n\n  // plural.ts 내용을 읽어서 shared 파일에 삽입합니다.\n  const dictUtilsPath = path.join(\n    import.meta.dirname.replace(\"/dist/\", \"/src/\"),\n    \"../dict/utils.ts\",\n  );\n  const dictUtilsCode = (await syncerFileExists(dictUtilsPath))\n    ? await syncerFilesystem.readFile(dictUtilsPath, \"utf-8\")\n    : \"\";\n\n  // 특정 변수 치환을 위해서 사용합니다.\n  const convertMap = {\n    baseUrl:\n      Sonamu.config.server.baseUrl ??\n      `http://${Sonamu.config.server.listen?.host ?? \"localhost\"}:${Sonamu.config.server.listen?.port ?? 3000}`,\n    dictUtils: dictUtilsCode,\n  };\n\n  for (const target of targets) {\n    // 지금 가져가려는 이 파일은 Sonamu 코드베이스의 일부입니다.\n    // 그런데 dist 속 빌드된 소스 코드 파일이 필요한 것이 아니고, src에만 있는 텍스트 파일이 필요합니다.\n    // 따라서 /src/에서 찾습니다.\n    const srcPath = path.join(\n      import.meta.dirname.replace(\"/dist/\", \"/src/\"),\n      `../shared/${target}.shared.ts.txt`,\n    );\n    if (!(await syncerFileExists(srcPath))) {\n      continue;\n    }\n    if (!(await syncerFileExists(path.join(Sonamu.appRootPath, target)))) {\n      throw new Error(\n        `Tried to copy sonamu.shared.ts to target '${target}' but the target directory does not exist. Please check your project directory structure.`,\n      );\n    }\n\n    const fullText = await syncerFilesystem.readFile(srcPath, \"utf-8\");\n    const convertedText = Object.entries(convertMap).reduce(\n      (acc, [key, value]) => acc.replace(`$[[${key}]]`, value),\n      fullText,\n    );\n\n    // 이건 프로젝트에 .ts 소스 코드 파일을 생성하는 것이므로 src의 .ts 경로로 갑니다.\n    const destPath = path.join(Sonamu.appRootPath, target, \"src/services/sonamu.shared.ts\");\n\n    // 정말 혹시나지만 target 디렉토리는 있어도 src/services 디렉토리는 없을 수 있으므로 미리 생성해줍니다.\n    if (!(await syncerFileExists(path.dirname(destPath)))) {\n      await syncerFilesystem.mkdir(path.dirname(destPath), { recursive: true });\n      console.warn(`Created directory '${path.dirname(destPath)}' because it did not exist.`);\n    }\n\n    // 파일이 이미 존재하면 건너뜁니다.\n    // sonamu.shared.ts는 프로젝트에서 자유롭게 커스터마이징할 수 있어야 하므로,\n    // 최초 1회만 생성하고 이후에는 덮어쓰지 않습니다.\n    // 템플릿 내용($[[dictUtils]] 등)이 변경되었을 때 반영이 필요하면,\n    // 해당 파일을 삭제한 뒤 `pnpm sonamu sync`로 재생성하면 됩니다.\n    if (await syncerFileExists(destPath)) {\n      continue;\n    }\n\n    await syncerFilesystem.writeFile(destPath, await formatCode(convertedText, destPath));\n    !isTest() &&\n      console.log(chalk.bold(\"Copied: \") + chalk.blue(path.relative(Sonamu.appRootPath, destPath)));\n  }\n}\n\n/**\n * Sonamu Dictionary(SD)를 모든 타겟(api + web/app 등)에 동기화합니다.\n *\n * 각 타겟에 대해:\n * - target이 api가 아니면 사용자 작성 locale 파일(ko.ts/en.ts/...)을 api → target으로 복사\n * - sd 템플릿을 렌더링해서 sd.generated.ts 생성 (overwrite)\n *\n * 한 타겟에서 실패해도 다른 타겟은 계속 진행합니다.\n */\nexport async function actionSyncSonamuDictionary(): Promise<void> {\n  const { targets } = Sonamu.config.sync;\n  const i18nConfig = Sonamu.config.i18n;\n\n  const targetList =\n    /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ [\n      \"api\",\n      ...targets,\n    ] as (\"api\" | \"web\" | \"app\")[];\n\n  const apiI18nDir = path.join(Sonamu.appRootPath, Sonamu.config.api.dir, \"src/i18n\");\n\n  for (const target of targetList) {\n    try {\n      // web/app의 경우 locale 파일들을 api에서 복사\n      if (target !== \"api\") {\n        await syncLocaleFiles(target, apiI18nDir, i18nConfig.supportedLocales);\n      }\n\n      await generateTemplate(\"sd\", { target }, { overwrite: true });\n    } catch (e) {\n      console.error(`Failed to generate SD template for ${target}:`, e);\n    }\n  }\n}\n\n/**\n * api의 locale 파일을 web/app으로 복사합니다.\n */\nasync function syncLocaleFiles(\n  target: string,\n  apiI18nDir: string,\n  locales: string[],\n): Promise<void> {\n  const targetI18nDir = path.join(Sonamu.appRootPath, target, \"src/i18n\");\n\n  // 디렉토리가 없으면 생성\n  await syncerFilesystem.mkdir(targetI18nDir, { recursive: true });\n\n  for (const locale of locales) {\n    const sourceFile = path.join(apiI18nDir, `${locale}.ts`);\n    const targetFile = path.join(targetI18nDir, `${locale}.ts`);\n\n    const syncHeader = [\n      \"/**\",\n      \" * @generated\",\n      \" * API에서 동기화된 파일입니다. 직접 수정하지 마세요.\",\n      \" */\",\n    ].join(\"\\n\");\n    await copyFileWithReplaceCoreToShared(sourceFile, targetFile, syncHeader);\n    await trackWritten(\n      /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ targetFile as AbsolutePath,\n    );\n    !isTest() &&\n      console.log(chalk.bold(\"Copied: \") + chalk.cyan(`${target}/src/i18n/${locale}.ts`));\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAmBA,eAAsB,mBAAmB;CACvC,MAAM,EAAE,MAAM,SAAS,OAAO,OAAO,OAAO,UAAU,CAAC;CACvD,MAAM,UAAU,YAAY,QAAQ,YAAY,aAAa,QAAQ;CAErE,MAAM,EAAE,oBAAoB,EAAE,QAAQ,CAAC;CACvC,MAAM,QAAQ,IAAI,CAChB,GAAG,OAAO,OAAO,KAAK,QAAQ,KAAK,WAAW;EAC5C,OAAO,iBAAiB,UACtB,KAAK,KAAK,OAAO,aAAa,QAAQ,aAAa,GACnD,OACF;CACF,CAAC,GACD,iBAAiB,iBAAiB,CAAC,GAAG,EAAE,WAAW,KAAK,CAAC,CAC3D,CAAC;AACH;;;;;;AAOA,eAAsB,uBACpB,aAGyB;CACzB,MAAM,EAAE,0BAA0B,WAAW;CAW7C,OAAO,CAAC,GAAG,MARgB,iBACzB,YACA,CAAC,GACD,EACE,WAAW,KACb,CACF,CAEuB;AACzB;;;;;AAMA,eAAsB,2BAA2B,UAA2C;CAC1F,OAAO,iBAAiB,cAAc,EAAE,SAAS,CAAC;AACpD;;;;;AAMA,eAAsB,wBAAiD;CACrE,QACE,MAAM,QAAQ,IAAI,CAChB,iBAAiB,iBAAiB,CAAC,GAAG,EAAE,WAAW,KAAK,CAAC,GACzD,iBAAiB,aAAa,CAAC,GAAG,EAAE,WAAW,KAAK,CAAC,CACvD,CAAC,EAAA,CACD,KAAK;AACT;;;;;AAMA,eAAsB,sBAA6C;CACjE,MAAM,CAAC,OAAO,MAAM,iBAClB,kBACA,EAAE,UAAU,QAAQ,GACpB,EAAE,WAAW,KAAK,CACpB;CACA,OAAO,GAAG;CACV,OAAO;AACT;;;;AAKA,eAAsB,+BAAsD;CAC1E,MAAM,eACuD,KAAK,KAC9D,OAAO,aACP,gDACF;CACF,MAAM,SAAS,OAAO,OAAO,YAAY;CAEzC,IAAI,EADU,cAAc,MAAM,KAAK,WAAW,QAAQ,OAAO,QAAQ,QAC7D;EAEV,IAAI,MAAM,iBAAiB,YAAY,GACrC,MAAM,iBAAiB,OAAO,YAAY;EAE5C,OAAO;CACT;CAEA,MAAM,CAAC,iBAAiB,MAAM,iBAAiB,mBAAmB,CAAC,GAAG,EAAE,WAAW,KAAK,CAAC;CACzF,OAAO,aAAa;CACpB,OAAO;AACT;;;;;AAMA,eAAsB,2BAAoD;CACxE,OAAO,iBAAiB,WAAW,CAAC,GAAG,EAAE,WAAW,KAAK,CAAC;AAC5D;;;;;;;;AASA,eAAsB,0CAAmE;CACvF,IAAI;EACF,OAAO,MAAM,iBAAiB,gBAAgB,CAAC,GAAG,EAAE,WAAW,MAAM,CAAC;CACxE,SAAS,GAAG;EAGV,IAAI,aAAa,2BACf,OAAO,CAAC;EAEV,MAAM;CACR;AACF;;;;;;;;;AAUA,eAAsB,yBAAyB,SAA4C;CACzF,MAAM,EAAE,YAAY,OAAO,OAAO;CAClC,MAAM,EAAE,KAAK,WAAW,OAAO,OAAO;CAEtC,QACE,MAAM,QAAQ,IACZ,QAAQ,IAAI,OAAO,WACjB,QAAQ,IACN,QAAQ,IAAI,OAAO,YAAY;EAC7B,MAAM,MAAM,QACT,QAAQ,IAAI,OAAO,IAAI,IAAI,OAAO,EAAE,CAAC,CACrC,QAAQ,iBAAiB,YAAY;EACxC,MAAM,MAAM,QAAQ,GAAG;EACvB,IAAI,CAAE,MAAM,iBAAiB,GAAG,GAC9B,MAAM,iBAAiB,MAAM,KAAK,EAAE,WAAW,KAAK,CAAC;EAQvD,MAAM,gCAAgC,SAAS,KAN5B;GACjB;GACA;GACA;GACA;EACF,CAAC,CAAC,KAAK,IAC6C,CAAU;EAC9D,MAAM,aACuD,GAC7D;EACA,CAAC,OAAO,KACN,QAAQ,IACN,MAAM,KAAK,UAAU,IAAI,MAAM,KAAK,IAAI,QAAQ,GAAG,OAAO,YAAY,IAAI,EAAE,CAAC,CAC/E;EACF,OAAO;CACT,CAAC,CACH,CACF,CACF,EAAA,CACA,KAAK;AACT;;;;;;;AAQA,eAAsB,uCAAsD;CAC1E,MAAM,EAAE,YAAY,OAAO,OAAO;CAGlC,MAAM,gBAAgB,KAAK,KACzB,OAAO,KAAK,QAAQ,QAAQ,UAAU,OAAO,GAC7C,kBACF;CACA,MAAM,gBAAiB,MAAM,iBAAiB,aAAa,IACvD,MAAM,iBAAiB,SAAS,eAAe,OAAO,IACtD;CAGJ,MAAM,aAAa;EACjB,SACE,OAAO,OAAO,OAAO,WACrB,UAAU,OAAO,OAAO,OAAO,QAAQ,QAAQ,YAAY,GAAG,OAAO,OAAO,OAAO,QAAQ,QAAQ;EACrG,WAAW;CACb;CAEA,KAAK,MAAM,UAAU,SAAS;EAI5B,MAAM,UAAU,KAAK,KACnB,OAAO,KAAK,QAAQ,QAAQ,UAAU,OAAO,GAC7C,aAAa,OAAO,eACtB;EACA,IAAI,CAAE,MAAM,iBAAiB,OAAO,GAClC;EAEF,IAAI,CAAE,MAAM,iBAAiB,KAAK,KAAK,OAAO,aAAa,MAAM,CAAC,GAChE,MAAM,IAAI,MACR,6CAA6C,OAAO,0FACtD;EAGF,MAAM,WAAW,MAAM,iBAAiB,SAAS,SAAS,OAAO;EACjE,MAAM,gBAAgB,OAAO,QAAQ,UAAU,CAAC,CAAC,QAC9C,KAAK,CAAC,KAAK,WAAW,IAAI,QAAQ,MAAM,IAAI,KAAK,KAAK,GACvD,QACF;EAGA,MAAM,WAAW,KAAK,KAAK,OAAO,aAAa,QAAQ,+BAA+B;EAGtF,IAAI,CAAE,MAAM,iBAAiB,KAAK,QAAQ,QAAQ,CAAC,GAAI;GACrD,MAAM,iBAAiB,MAAM,KAAK,QAAQ,QAAQ,GAAG,EAAE,WAAW,KAAK,CAAC;GACxE,QAAQ,KAAK,sBAAsB,KAAK,QAAQ,QAAQ,EAAE,4BAA4B;EACxF;EAOA,IAAI,MAAM,iBAAiB,QAAQ,GACjC;EAGF,MAAM,iBAAiB,UAAU,UAAU,MAAM,WAAW,eAAe,QAAQ,CAAC;EACpF,CAAC,OAAO,KACN,QAAQ,IAAI,MAAM,KAAK,UAAU,IAAI,MAAM,KAAK,KAAK,SAAS,OAAO,aAAa,QAAQ,CAAC,CAAC;CAChG;AACF;;;;;;;;;;AAWA,eAAsB,6BAA4C;CAChE,MAAM,EAAE,YAAY,OAAO,OAAO;CAClC,MAAM,aAAa,OAAO,OAAO;CAEjC,MAAM,aACuD,CACzD,OACA,GAAG,OACL;CAEF,MAAM,aAAa,KAAK,KAAK,OAAO,aAAa,OAAO,OAAO,IAAI,KAAK,UAAU;CAElF,KAAK,MAAM,UAAU,YACnB,IAAI;EAEF,IAAI,WAAW,OACb,MAAM,gBAAgB,QAAQ,YAAY,WAAW,gBAAgB;EAGvE,MAAM,iBAAiB,MAAM,EAAE,OAAO,GAAG,EAAE,WAAW,KAAK,CAAC;CAC9D,SAAS,GAAG;EACV,QAAQ,MAAM,sCAAsC,OAAO,IAAI,CAAC;CAClE;AAEJ;;;;AAKA,eAAe,gBACb,QACA,YACA,SACe;CACf,MAAM,gBAAgB,KAAK,KAAK,OAAO,aAAa,QAAQ,UAAU;CAGtE,MAAM,iBAAiB,MAAM,eAAe,EAAE,WAAW,KAAK,CAAC;CAE/D,KAAK,MAAM,UAAU,SAAS;EAC5B,MAAM,aAAa,KAAK,KAAK,YAAY,GAAG,OAAO,IAAI;EACvD,MAAM,aAAa,KAAK,KAAK,eAAe,GAAG,OAAO,IAAI;EAQ1D,MAAM,gCAAgC,YAAY,YAN/B;GACjB;GACA;GACA;GACA;EACF,CAAC,CAAC,KAAK,IACuD,CAAU;EACxE,MAAM,aACuD,UAC7D;EACA,CAAC,OAAO,KACN,QAAQ,IAAI,MAAM,KAAK,UAAU,IAAI,MAAM,KAAK,GAAG,OAAO,YAAY,OAAO,IAAI,CAAC;CACtF;AACF;;aArUsC;oBAEiC;YACjC;iBACM;gBACG;oBAEO;qBACH;gBACU;oBACf;8BACgC"}

package/dist/syncer/syncer.d.ts

@@ -6,23 +6,34 @@ import { type GenerateOptions, type PathAndCode } from "../types/types";
 import { TemplateKey } from "../types/types";
 import { type TemplateOptions } from "../types/types";
 import { type AbsolutePath } from "../utils/path-utils";
+import { findChangedFilesUsingChecksums, renewChecksums } from "./checksum";
 import { type FileType } from "./file-patterns";
 import { type LoadedApis, type LoadedModels, type LoadedTypes } from "./module-loader";
-type DiffGroups = {
-    [key in FileType]: AbsolutePath[];
-};
+import * as SyncerActions from "./syncer-actions";
+type DiffGroupKey = FileType | "unknown";
+type DiffGroups = Partial<Record<DiffGroupKey, AbsolutePath[]>>;
+export interface SyncerDependencies {
+    actionCopySharedToTargetsIfNotExists: typeof SyncerActions.actionCopySharedToTargetsIfNotExists;
+    actionGenerateHttpValidators: typeof SyncerActions.actionGenerateHttpValidators;
+    actionGenerateSsrEntryServerIfNotExists: typeof SyncerActions.actionGenerateSsrEntryServerIfNotExists;
+    findChangedFilesUsingChecksums: typeof findChangedFilesUsingChecksums;
+    renewChecksums: typeof renewChecksums;
+}
 export declare class Syncer {
+    private readonly dependencies;
     apis: LoadedApis;
     types: LoadedTypes;
     models: LoadedModels;
     workflows: Map<string, WorkflowMetadata[]>;
     eventEmitter: EventEmitter;
+    constructor(dependencies?: SyncerDependencies);
     /**
      * 체크섬이 변경된 부분에 대해 싱크를 진행합니다.
      * dev 서버가 처음 떴을 때, sonamu sync 할 때 실행됩니다. 이후에는 hmrAndSync 경로를 타요.
      * @returns
      */
     sync(): Promise<void>;
+    private reconcileHttpValidatorRegistry;
     /**
      * 강제 풀-싱크: lock을 무시하고 처음부터 다시 싱크합니다.
      *
@@ -64,13 +75,13 @@ export declare class Syncer {
     doSyncActions(diffFilePaths: AbsolutePath[]): Promise<{
         diffTypes: FileType[];
     }>;
-    calculateDiffGroups(diffFiles: AbsolutePath[]): DiffGroups;
+    calculateDiffGroups(diffFiles: AbsolutePath[]): Partial<Record<DiffGroupKey, `/${string}`[]>>;
     private changeMatcher;
     handleTruthSourceChanges(diffGroups: DiffGroups): Promise<void>;
     handleImplementationChanges(diffGroups: DiffGroups): Promise<void>;
     handleAuxiliarySymbolChanges(diffGroups: DiffGroups): Promise<void>;
-    handleConfigChanges(_: DiffGroups): Promise<void>;
-    handleSonamuDictionaryRelatedChanges(_: DiffGroups): Promise<void>;
+    handleConfigChanges(): Promise<void>;
+    handleSonamuDictionaryRelatedChanges(): Promise<void>;
     handleDrifts(drifts: AbsolutePath[]): Promise<void>;
     /**
      * 주어진 엔티티와 템플릿 키에 대해, 생성된 코드가 존재하는지 확인합니다.

package/dist/syncer/syncer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"syncer.d.ts","sourceRoot":"","sources":["../../src/syncer/syncer.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"syncer.d.ts","sourceRoot":"","sources":["../../src/syncer/syncer.ts"],"names":[],"mappings":"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"}