sonamu 0.10.12 → 0.10.13

package/dist/syncer/syncer.js

@@ -1,31 +1,31 @@
 import { __esmMin } from "../_virtual/_rolldown/runtime.js";
+import { init_runtime_value, isObjectValue } from "../utils/runtime-value.js";
 import { centerText, init_console_util } from "../utils/console-util.js";
 import { init_controller, isTest } from "../utils/controller.js";
 import { init_async_utils, mapAsync, reduceAsync } from "../utils/async-utils.js";
 import { init_process_utils, runWithGracefulShutdown } from "../utils/process-utils.js";
-import { exists, init_fs_utils } from "../utils/fs-utils.js";
-import { Sonamu, init_sonamu } from "../api/sonamu.js";
 import { TemplateKey, init_types } from "../types/types.js";
+import { Sonamu, init_sonamu } from "../api/sonamu.js";
 import { EntityManager, init_entity_manager } from "../entity/entity-manager.js";
 import { Naite, init_naite } from "../naite/naite.js";
 import { init_decorators, registeredApis } from "../api/decorators.js";
 import { TemplateManager, init_template_manager } from "../template/template-manager.js";
 import { getChecksumPatternGroup, getChecksumPatternGroupInAbsolutePath, init_file_patterns } from "./file-patterns.js";
+import { init_filesystem_dependencies, syncerFileExists, syncerFilesystem } from "./filesystem-dependencies.js";
 import { findChangedFilesUsingChecksums, init_checksum, renewChecksums } from "./checksum.js";
 import { generateTemplate, init_code_generator, renderTemplate } from "./code-generator.js";
 import { createEntity, delEntity, init_entity_operations } from "./entity-operations.js";
 import { init_module_loader, loadApis, loadModels, loadTypes, loadWorkflows } from "./module-loader.js";
-import { actionCopySharedToTargetsIfNotExists, actionGenerateHttps, actionGenerateInitialTypes, actionGenerateSchemas, actionGenerateServices, actionGenerateSsrEntryServerIfNotExists, actionGenerateSsrQueries, actionSyncConfig, actionSyncFilesToTargets, actionSyncSonamuDictionary, init_syncer_actions } from "./syncer-actions.js";
-import { group, unique } from "radashi";
+import { actionCopySharedToTargetsIfNotExists, actionGenerateHttpValidators, actionGenerateHttps, actionGenerateInitialTypes, actionGenerateSchemas, actionGenerateServices, actionGenerateSsrEntryServerIfNotExists, actionGenerateSsrQueries, actionSyncConfig, actionSyncFilesToTargets, actionSyncSonamuDictionary, init_syncer_actions } from "./syncer-actions.js";
+import { unique } from "radashi";
 import assert from "assert";
 import path from "path";
 import chalk from "chalk";
-import { unlink } from "fs/promises";
 import { minimatch } from "minimatch";
 import { EventEmitter } from "events";
 import { hot } from "@sonamu-kit/hmr-hook";
 //#region src/syncer/syncer.ts
-var Syncer;
+var defaultSyncerDependencies, Syncer;
 var init_syncer = __esmMin((() => {
 	init_decorators();
 	init_sonamu();
@@ -36,41 +36,62 @@ var init_syncer = __esmMin((() => {
 	init_async_utils();
 	init_console_util();
 	init_controller();
-	init_fs_utils();
 	init_process_utils();
+	init_runtime_value();
 	init_checksum();
 	init_code_generator();
 	init_entity_operations();
 	init_file_patterns();
+	init_filesystem_dependencies();
 	init_module_loader();
 	init_syncer_actions();
+	defaultSyncerDependencies = {
+		actionCopySharedToTargetsIfNotExists,
+		actionGenerateHttpValidators,
+		actionGenerateSsrEntryServerIfNotExists,
+		findChangedFilesUsingChecksums,
+		renewChecksums
+	};
 	Syncer = class {
+		dependencies;
 		apis = [];
 		types = {};
 		models = {};
 		workflows = /* @__PURE__ */ new Map();
 		eventEmitter = new EventEmitter();
+		constructor(dependencies = defaultSyncerDependencies) {
+			this.dependencies = dependencies;
+		}
 		/**
 		* 체크섬이 변경된 부분에 대해 싱크를 진행합니다.
 		* dev 서버가 처음 떴을 때, sonamu sync 할 때 실행됩니다. 이후에는 hmrAndSync 경로를 타요.
 		* @returns
 		*/
 		async sync() {
-			await actionCopySharedToTargetsIfNotExists();
-			await actionGenerateSsrEntryServerIfNotExists();
-			const changedFiles = await findChangedFilesUsingChecksums();
+			await this.dependencies.actionCopySharedToTargetsIfNotExists();
+			await this.dependencies.actionGenerateSsrEntryServerIfNotExists();
+			const changedFiles = await this.dependencies.findChangedFilesUsingChecksums();
 			if (changedFiles.length === 0) {
+				if (await this.reconcileHttpValidatorRegistry()) await this.dependencies.renewChecksums();
 				console.log(chalk.black.bgGreen(centerText("All files are synced!")));
 				return;
 			}
 			await runWithGracefulShutdown(async () => {
 				await this.doSyncActions(changedFiles);
-				await renewChecksums();
+				await this.reconcileHttpValidatorRegistry();
+				await this.dependencies.renewChecksums();
 			}, {
 				whenThisHappens: "SIGUSR2",
 				waitForUpTo: 2e4
 			});
 		}
+		async reconcileHttpValidatorRegistry() {
+			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") === await syncerFileExists(registryPath)) return false;
+			await this.dependencies.actionGenerateHttpValidators();
+			return true;
+		}
 		/**
 		* 강제 풀-싱크: lock을 무시하고 처음부터 다시 싱크합니다.
 		*
@@ -80,7 +101,7 @@ var init_syncer = __esmMin((() => {
 		*/
 		async forceSync() {
 			const lockPath = path.join(Sonamu.apiRootPath, "sonamu.lock");
-			if (await exists(lockPath)) await unlink(lockPath);
+			if (await syncerFileExists(lockPath)) await syncerFilesystem.unlink(lockPath);
 			await this.sync();
 		}
 		/**
@@ -106,6 +127,7 @@ var init_syncer = __esmMin((() => {
 			await this.autoloadApis();
 			await this.autoloadWorkflows();
 			await this.autoloadSsrRoutes();
+			await Sonamu.refreshHttpValidators();
 			this.eventEmitter.emit("onHMRCompleted");
 		}
 		extractHmrActionRequiredFileEvents(fileEvents) {
@@ -177,7 +199,7 @@ var init_syncer = __esmMin((() => {
 			const ssrConfigPath = path.join(Sonamu.apiRootPath, "src/ssr");
 			const { clearSSRRoutes } = await import("../ssr/index.js");
 			clearSSRRoutes();
-			if (!await exists(ssrConfigPath)) return;
+			if (!await syncerFileExists(ssrConfigPath)) return;
 			const { globAsync } = await import("../utils/async-utils.js");
 			const { importMembers } = await import("../utils/esm-utils.js");
 			const { runtimePath } = await import("../utils/path-utils.js");
@@ -202,20 +224,36 @@ var init_syncer = __esmMin((() => {
 			if (changeMatches("entity", "types")) await this.handleTruthSourceChanges(diffGroups);
 			if (changeMatches("model", "frame")) await this.handleImplementationChanges(diffGroups);
 			if (changeMatches("types", "functions")) await this.handleAuxiliarySymbolChanges(diffGroups);
-			if (changeMatches("config")) await this.handleConfigChanges(diffGroups);
-			if (changeMatches("i18n", "entity", "config")) await this.handleSonamuDictionaryRelatedChanges(diffGroups);
+			if (changeMatches("config")) await this.handleConfigChanges();
+			if (changeMatches("i18n", "entity", "config")) await this.handleSonamuDictionaryRelatedChanges();
+			const metadataChanged = diffTypes.some((type) => [
+				"entity",
+				"types",
+				"model",
+				"frame",
+				"config"
+			].includes(type));
+			if (changeMatches("httpValidatorsGenerated") && !metadataChanged) await this.dependencies.actionGenerateHttpValidators();
+			if (metadataChanged) {
+				await this.autoloadTypes();
+				await this.autoloadModels();
+				await this.autoloadApis();
+				await this.dependencies.actionGenerateHttpValidators();
+			}
 			if (nothingMatches()) await this.handleDrifts(unhandledPaths());
 			return { diffTypes };
 		}
 		calculateDiffGroups(diffFiles) {
 			const patternGroup = getChecksumPatternGroup();
 			const fileTypes = Object.keys(patternGroup);
-			return group(diffFiles, (filePath) => {
+			const diffGroups = {};
+			for (const filePath of diffFiles) {
 				const relativePath = path.relative(Sonamu.appRootPath, filePath);
-				if (relativePath.startsWith("..")) return "unknown";
-				for (const fileType of fileTypes) if (minimatch(relativePath, patternGroup[fileType])) return fileType;
-				return "unknown";
-			});
+				const fileType = fileTypes.find((candidate) => minimatch(relativePath, patternGroup[candidate]));
+				const groupKey = relativePath.startsWith("..") ? "unknown" : fileType ?? "unknown";
+				(diffGroups[groupKey] ??= []).push(filePath);
+			}
+			return diffGroups;
 		}
 		changeMatcher(diffTypes, diffGroups) {
 			const handled = /* @__PURE__ */ new Set();
@@ -253,7 +291,7 @@ var init_syncer = __esmMin((() => {
 				const entityId = EntityManager.getEntityIdFromPath(entityPath);
 				const entity = EntityManager.get(entityId);
 				const typeFilePath = path.join(Sonamu.apiRootPath, `src/application/${entity.names.fs}/${entity.names.fs}.types.ts`);
-				if (entity.parentId === void 0 && !await exists(typeFilePath)) await actionSyncFilesToTargets(await actionGenerateInitialTypes(entityId));
+				if (entity.parentId === void 0 && !await syncerFileExists(typeFilePath)) await actionSyncFilesToTargets(await actionGenerateInitialTypes(entityId));
 			}
 			await actionSyncFilesToTargets((await actionGenerateSchemas()).filter((p) => !p.endsWith(".sso.ts")));
 		}
@@ -278,10 +316,14 @@ var init_syncer = __esmMin((() => {
 			Naite.t("handleAuxiliarySymbolChanges", { diffGroups });
 			await actionSyncFilesToTargets(unique([...diffGroups.types ?? [], ...diffGroups.functions ?? []]));
 		}
-		async handleConfigChanges(_) {
+		async handleConfigChanges() {
+			if (process.env.HOT === "yes") {
+				const { loadConfig } = await import("../api/config.js");
+				Sonamu.config = await loadConfig(Sonamu.apiRootPath);
+			}
 			await actionSyncConfig();
 		}
-		async handleSonamuDictionaryRelatedChanges(_) {
+		async handleSonamuDictionaryRelatedChanges() {
 			await actionSyncSonamuDictionary();
 		}
 		async handleDrifts(drifts) {
@@ -305,7 +347,7 @@ var init_syncer = __esmMin((() => {
 			return {
 				subPath,
 				fullPath,
-				isExists: await exists(fullPath)
+				isExists: await syncerFileExists(fullPath)
 			};
 		}
 		/**
@@ -323,16 +365,16 @@ var init_syncer = __esmMin((() => {
 				if (key.startsWith("view_enums")) {
 					await mapAsync(enumsKeys, async (componentId) => {
 						const { target, path: p } = tpl.getTargetAndPath(names, componentId);
-						result[`${key}__${componentId}`] = await exists(path.join(Sonamu.appRootPath, target, p));
+						result[`${key}__${componentId}`] = await syncerFileExists(path.join(Sonamu.appRootPath, target, p));
 					});
 					return result;
 				}
 				const { target, path: p } = tpl.getTargetAndPath(names);
 				const { targets } = Sonamu.config.sync;
 				if (target.includes(":target")) await mapAsync(targets, async (t) => {
-					result[`${key}__${t}`] = await exists(path.join(Sonamu.appRootPath, target.replace(":target", t), p));
+					result[`${key}__${t}`] = await syncerFileExists(path.join(Sonamu.appRootPath, target.replace(":target", t), p));
 				});
-				else result[key] = await exists(path.join(Sonamu.appRootPath, target, p));
+				else result[key] = await syncerFileExists(path.join(Sonamu.appRootPath, target, p));
 				return result;
 			}, {});
 		}
@@ -364,7 +406,7 @@ var init_syncer = __esmMin((() => {
 		* 하위호환용 프록시 메소드입니다.
 		*/
 		async renewChecksums() {
-			return await renewChecksums();
+			return await this.dependencies.renewChecksums();
 		}
 	};
 }));
@@ -372,4 +414,4 @@ var init_syncer = __esmMin((() => {
 init_syncer();
 export { Syncer, init_syncer };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"syncer.js","names":["SyncerActions.actionCopySharedToTargetsIfNotExists","SyncerActions.actionGenerateSsrEntryServerIfNotExists","SyncerActions.actionGenerateInitialTypes","SyncerActions.actionSyncFilesToTargets","SyncerActions.actionGenerateSchemas","SyncerActions.actionGenerateServices","SyncerActions.actionGenerateHttps","SyncerActions.actionGenerateSsrQueries","SyncerActions.actionSyncConfig","SyncerActions.actionSyncSonamuDictionary"],"sources":["../../src/syncer/syncer.ts"],"sourcesContent":["import assert from \"assert\";\nimport { EventEmitter } from \"events\";\nimport { unlink } from \"fs/promises\";\nimport path from \"path\";\n\nimport { hot } from \"@sonamu-kit/hmr-hook\";\nimport chalk from \"chalk\";\nimport { minimatch } from \"minimatch\";\nimport { group, unique } from \"radashi\";\nimport { type z } from \"zod\";\n\nimport { registeredApis } from \"../api/decorators\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { type EntityNamesRecord } from \"../entity/entity-manager\";\nimport { Naite } from \"../naite/naite\";\nimport { type WorkflowMetadata } from \"../tasks/decorator\";\nimport { TemplateManager } from \"../template/template-manager\";\nimport { type GenerateOptions, type PathAndCode } from \"../types/types\";\nimport { TemplateKey } from \"../types/types\";\nimport { type TemplateOptions } from \"../types/types\";\nimport { mapAsync, reduceAsync } from \"../utils/async-utils\";\nimport { centerText } from \"../utils/console-util\";\nimport { isTest } from \"../utils/controller\";\nimport { exists } from \"../utils/fs-utils\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\nimport { runWithGracefulShutdown } from \"../utils/process-utils\";\nimport { findChangedFilesUsingChecksums, renewChecksums } from \"./checksum\";\nimport { generateTemplate, renderTemplate } from \"./code-generator\";\nimport { createEntity, delEntity } from \"./entity-operations\";\nimport { getChecksumPatternGroup, getChecksumPatternGroupInAbsolutePath } from \"./file-patterns\";\nimport { type FileType } from \"./file-patterns\";\nimport { loadApis, loadModels, loadTypes, loadWorkflows } from \"./module-loader\";\nimport { type LoadedApis, type LoadedModels, type LoadedTypes } from \"./module-loader\";\nimport * as SyncerActions from \"./syncer-actions\";\n\ntype DiffGroups = {\n  [key in FileType]: AbsolutePath[];\n};\n\nexport class Syncer {\n  apis: LoadedApis = [];\n  types: LoadedTypes = {};\n  models: LoadedModels = {};\n  workflows: Map<string, WorkflowMetadata[]> = new Map();\n  eventEmitter: EventEmitter = new EventEmitter();\n\n  /**\n   * 체크섬이 변경된 부분에 대해 싱크를 진행합니다.\n   * dev 서버가 처음 떴을 때, sonamu sync 할 때 실행됩니다. 이후에는 hmrAndSync 경로를 타요.\n   * @returns\n   */\n  async sync(): Promise<void> {\n    // 초기 부트스트랩! 얘네들은 idempotent하고 가볍기 때문에 무지성 실행해도 됩니다.\n    // 얘네들은 sonamu.lock에 들어가지도 않고 따라서 HMR 경로를 타지도 않는 친구들입니다.\n    // 그래서 아무 때나 그냥 돌려주면 되는데, hmrAndSync에서 매번 하는 것은 낭비이니 여기서 한 번만 합니다.\n    await SyncerActions.actionCopySharedToTargetsIfNotExists();\n    await SyncerActions.actionGenerateSsrEntryServerIfNotExists();\n\n    // 바뀐 것이 없으면 그냥 넘어가요.\n    const changedFiles = await findChangedFilesUsingChecksums();\n    if (changedFiles.length === 0) {\n      console.log(chalk.black.bgGreen(centerText(\"All files are synced!\")));\n      return;\n    }\n\n    // 여기서 실제 싱크 동작을 수행합니다.\n    // 다만 싱크 중에 프로세스가 죽으면 꼬여버리기 때문에,\n    // 시그널에도 잠시 버틸 수 있는 환경 속에서 싱크를 실행합니다.\n    await runWithGracefulShutdown(\n      async () => {\n        // 얘가 싱크 작업 수행하는 본체입니다.\n        await this.doSyncActions(changedFiles);\n\n        // 싱크 액션이 끝나면 항상 체크섬을 다시 갱신합니다.\n        await renewChecksums();\n      },\n      { whenThisHappens: \"SIGUSR2\", waitForUpTo: 20000 },\n    );\n  }\n\n  /**\n   * 강제 풀-싱크: lock을 무시하고 처음부터 다시 싱크합니다.\n   *\n   * **사용처**: git post-merge hook, CI, dev 서버의 `f` 핫키.\n   * **실패 안전성**: 도중에 프로세스가 죽어 lock 없는 상태로 남아도 무해 — 다음 sync에서\n   * lock 없으면 자연스럽게 풀-싱크가 트리거되어 새 lock이 작성됨.\n   */\n  async forceSync(): Promise<void> {\n    const lockPath = path.join(Sonamu.apiRootPath, \"sonamu.lock\");\n    if (await exists(lockPath)) {\n      await unlink(lockPath);\n    }\n    await this.sync();\n  }\n\n  /**\n   * Watcher가 batch로 모은 변경 파일들에 대해 한 번의 HMR/sync 사이클을 돕니다.\n   *\n   * HMR은 api/src 안에서 일어나는 모든 파일들에 대해서 수행합니다.\n   * checksumPatternGroup 매칭 여부와 무관하게 api/src 전체 대상입니다.\n   * 가령 api/src/utils/subset-loaders.ts 같은 파일도 변경되면 HMR은 해줍니다.\n   *\n   * Sync는 checksumPatternGroup으로 매칭되는 파일들에 대해서만 수행합니다.\n   * 여기에는 web/src나 app/src 같은 다른 target의 파일이 포함될 수 있습니다.\n   * 이런 non-api 경로의 파일들은 HMR과는 아무 상관이 없으므로, invalidate을 하지 않습니다.\n   *\n   * @param fileEvents - path → event 맵. event는 \"change\" | \"add\".\n   */\n  async hmrAndSync(fileEvents: Map<AbsolutePath, \"change\" | \"add\">): Promise<void> {\n    const hmrActionRequiredEvents = this.extractHmrActionRequiredFileEvents(fileEvents);\n    const syncTriggeringPaths = await this.extractSyncTriggeringFileEventPaths(fileEvents);\n\n    // HMR 영역: 파일 이벤트 중 api의 모듈 그래프에 있는 파일들에 대한 변동은 hmrActionRequiredEvents로 잡힙니다.\n    // 이 친구들은 invalidate 처리해줍니다.\n    // 이 호출은 아래 sync보다 무조건 먼저 일어나야 합니다!\n    // 왜냐하면 sync에서는 변경된 model 코드를 새로 import해서 처리해야 하는 경우도 있기 때문입니다.\n    await this.invalidateDependentsAffectedByFileEvents(hmrActionRequiredEvents);\n\n    // Sync 영역: checksumPatternGroup에 명시된 파일들에 대한 변동은 syncTriggeringPaths로 잡힙니다.\n    // 이 친구들은 적절한 sync 작업으로 대응합니다.\n    if (syncTriggeringPaths.length > 0) {\n      await this.doSyncActions(syncTriggeringPaths);\n    }\n\n    // 싱크 작업이 끝났으면 무지성 로드를 수행합니다.\n    // 싱크를 안 한 경우에도 로드는 해야 해요. 위에서 관련있는 친구들은 다 invalidate 되었거든요!\n    //\n    // 변경된 파일들에 대해서 새롭게 당겨오는(load) 행위는 doSyncActions에서 하지 않습니다.\n    // doSyncActions에서는 파일을 읽고 만드는 싱크 행위만 합니다.\n    // 거기서 딱 변경된 부분에 영향받는 autoload만 선별해서 수행하려면 너무 지저분하고 복잡해집니다.\n    //\n    // 퍼포먼스 영향은 무시해도 좋습니다.\n    // 어차피 hmr-hook에 의해 invalidate된 부분들이 아니라면 캐시 그대로 유지합니다.\n    await this.autoloadTypes();\n    await this.autoloadModels();\n    await this.autoloadApis();\n    await this.autoloadWorkflows();\n    await this.autoloadSsrRoutes();\n\n    this.eventEmitter.emit(\"onHMRCompleted\");\n  }\n\n  private extractHmrActionRequiredFileEvents(\n    fileEvents: Map<AbsolutePath, \"change\" | \"add\">,\n  ): Map<AbsolutePath, \"change\" | \"add\"> {\n    const apiSrc = path.join(Sonamu.apiRootPath, \"src\");\n    const result = new Map<AbsolutePath, \"change\" | \"add\">();\n    for (const [filePath, event] of fileEvents) {\n      if (!filePath.startsWith(apiSrc)) {\n        continue;\n      }\n      result.set(filePath, event);\n    }\n    return result;\n  }\n\n  private async extractSyncTriggeringFileEventPaths(\n    fileEvents: Map<AbsolutePath, \"change\" | \"add\">,\n  ): Promise<AbsolutePath[]> {\n    const checkPatternGroup = getChecksumPatternGroupInAbsolutePath();\n    const syncTriggeringPaths: AbsolutePath[] = [];\n    for (const [diffFilePath] of fileEvents) {\n      const isInCheckPatternGroup = Object.values(checkPatternGroup).some((pattern) =>\n        minimatch(diffFilePath, pattern),\n      );\n      if (!isInCheckPatternGroup) {\n        continue;\n      }\n      syncTriggeringPaths.push(diffFilePath);\n    }\n\n    return syncTriggeringPaths;\n  }\n\n  private async invalidateDependentsAffectedByFileEvents(\n    fileEvents: Map<AbsolutePath, \"change\" | \"add\">,\n  ) {\n    for (const [diffFilePath, event] of fileEvents) {\n      // 변경된 파일과 dependent 파일들을 invalidate 합니다.\n      // 한 번 이상 import된 친구들에 대해서만 실제 작업이 일어납니다.\n      // 그러니 안심하고 invalidate 해도 됩니다.\n      // 테스트 환경에서는 hot.invalidateFile시 초기 에러가 발생하기 때문에 invalidate 하지 않습니다.\n      if (!isTest()) {\n        const invalidatedPaths = (await hot.invalidateFile(diffFilePath, event)) as AbsolutePath[];\n\n        if (invalidatedPaths.length > 0) {\n          console.log(chalk.bold(`🔄 Invalidated:`));\n\n          for (const invalidatedPath of invalidatedPaths) {\n            try {\n              // 만약 model.ts 파일이 변경(invalidate)되었다? 그러면 registeredApis 중에서 이 모델에 해당하는 api들은 지워줘요.\n              // registeredApis는 통으로 다 날려버릴 수 없습니다. registeredApis에 올라오는 친구들은 초기 로드시 또는 HMR시에만 등록되기 때문입니다.\n              // 따라서 model.ts 파일의 변경으로 다음번 새로운 eval이 예상되는 이 시점에서만, 이 모델에서 나온 registeredApis들을 지워줄 수 있습니다.\n              const removedApis = this.removeInvalidatedRegisteredApis(invalidatedPath);\n              if (removedApis.length > 0) {\n                console.log(\n                  chalk.blue(`- ${path.relative(Sonamu.apiRootPath, invalidatedPath)}`),\n                  chalk.gray(`(with ${removedApis.length} APIs)`),\n                );\n              } else {\n                console.log(chalk.blue(`- ${path.relative(Sonamu.apiRootPath, invalidatedPath)}`));\n              }\n            } catch (e) {\n              console.error(e);\n              console.error(\n                chalk.red(`Failed to remove invalidated registered APIs for ${invalidatedPath}`),\n              );\n            }\n          }\n        }\n      }\n\n      // devRunner 활성화 시, 변경된 소스 파일을 Vitest 모듈 그래프에서도 무효화합니다.\n      // Vite의 moduleGraph.invalidateModule()이 importer 방향으로 재귀적 cascade하므로,\n      // 소스 파일 하나만 무효화하면 이를 import하는 테스트 파일도 자동으로 무효화됩니다.\n      if (!isTest() && Sonamu.config.test?.devRunner?.enabled && Sonamu.devVitestManager) {\n        Sonamu.devVitestManager.invalidateFiles([diffFilePath]);\n        console.log(\n          chalk.dim(`Test invalidated: ${path.relative(Sonamu.apiRootPath, diffFilePath)}`),\n        );\n      }\n    }\n  }\n\n  removeInvalidatedRegisteredApis(\n    invalidatedPath: AbsolutePath,\n  ): (typeof registeredApis)[number][] {\n    // 소스 코드를 다루는 상황이니 .ts 경로로 봅니다.\n    const isModel = invalidatedPath.endsWith(\".model.ts\");\n    const isFrame = invalidatedPath.endsWith(\".frame.ts\");\n    if (!isModel && !isFrame) {\n      return [];\n    }\n\n    const entityId = EntityManager.getEntityIdFromPath(invalidatedPath);\n    const targetModelName = `${entityId}${isModel ? \"Model\" : \"Frame\"}`;\n    const toRemove = registeredApis.filter((api) => api.modelName === targetModelName);\n    for (const api of toRemove) {\n      const idx = registeredApis.indexOf(api);\n      if (idx !== -1) {\n        registeredApis.splice(idx, 1);\n      }\n    }\n\n    return toRemove;\n  }\n\n  async autoloadTypes() {\n    this.types = await loadTypes();\n  }\n\n  async autoloadModels() {\n    this.models = await loadModels();\n  }\n\n  async autoloadApis() {\n    this.apis = await loadApis();\n  }\n\n  async autoloadWorkflows() {\n    this.workflows = await loadWorkflows();\n    await Sonamu.workflows.synchronize(this.workflows);\n  }\n\n  async autoloadSsrRoutes(): Promise<void> {\n    const ssrConfigPath = path.join(Sonamu.apiRootPath, \"src/ssr\");\n\n    // 기존 routes 초기화\n    const { clearSSRRoutes } = await import(\"../ssr\");\n    clearSSRRoutes();\n\n    // ssr 폴더 없으면 스킵\n    if (!(await exists(ssrConfigPath))) {\n      return;\n    }\n\n    // ssr 폴더 안의 모든 .ts 파일 로드\n    const { globAsync } = await import(\"../utils/async-utils\");\n    const { importMembers } = await import(\"../utils/esm-utils\");\n    const { runtimePath } = await import(\"../utils/path-utils\");\n\n    // runtimePath를 사용하여 개발/프로덕션 환경에 맞는 확장자 처리\n    const files = await globAsync(path.join(ssrConfigPath, runtimePath(\"**/*.ts\")));\n\n    for (const file of files) {\n      try {\n        // importMembers를 사용하면 파일의 side effect(registerSSR 호출)가 실행됨\n        await importMembers(file);\n      } catch (e) {\n        console.error(`Failed to load SSR route: ${file}`, e);\n      }\n    }\n  }\n\n  /**\n   * 실제 싱크를 수행하는 본체입니다.\n   * 변경된 파일들을 타입별로 분류하고 각 타입에 맞는 액션을 실행합니다.\n   *\n   * @param diffFilePaths - 변경된 파일들의 절대 경로 목록\n   * @returns diffTypes - 변경된 파일의 타입 목록 (entity, types, model 등)\n   */\n  async doSyncActions(diffFilePaths: AbsolutePath[]): Promise<{ diffTypes: FileType[] }> {\n    const diffGroups = this.calculateDiffGroups(diffFilePaths);\n    const diffTypes = Object.keys(diffGroups) as FileType[];\n\n    // 여기는 별로 중요한 파트는 아닙니다.\n    // 아래의 if 전개를 깔끔하게 하려고 만든 DSL 같은 거라서, 무시하셔도 됩니다.\n    const { changeMatches, nothingMatches, unhandledPaths } = this.changeMatcher(\n      diffTypes,\n      diffGroups,\n    );\n\n    if (changeMatches(\"entity\", \"types\")) {\n      await this.handleTruthSourceChanges(diffGroups);\n    }\n\n    if (changeMatches(\"model\", \"frame\")) {\n      await this.handleImplementationChanges(diffGroups);\n    }\n\n    if (changeMatches(\"types\", \"functions\")) {\n      await this.handleAuxiliarySymbolChanges(diffGroups);\n    }\n\n    if (changeMatches(\"config\")) {\n      await this.handleConfigChanges(diffGroups);\n    }\n\n    if (changeMatches(\"i18n\", \"entity\" /*레이블*/, \"config\" /*defaultLocale등*/)) {\n      await this.handleSonamuDictionaryRelatedChanges(diffGroups);\n    }\n\n    if (nothingMatches()) {\n      // 파일 변경은 감지되었으나 저 위 어느 changeMatches에도 걸리지 않은 파일들이 drifts입니다.\n      // syncer는 소스의 변경에는 반응하지만 산출물의 변경(drift)에는 직접적으로 반응하지 않습니다.\n      // 대신 이 drift에 대해 경고 정도만 출력해줍니다.\n      await this.handleDrifts(unhandledPaths());\n    }\n\n    return {\n      diffTypes,\n    };\n  }\n\n  calculateDiffGroups(diffFiles: AbsolutePath[]): DiffGroups {\n    const patternGroup = getChecksumPatternGroup();\n    const fileTypes = Object.keys(patternGroup) as FileType[];\n\n    return group(diffFiles, (filePath) => {\n      // 절대 경로 → appRoot 기준 상대 경로 (예: \"api/src/...\", \"web/src/...\")\n      const relativePath = path.relative(Sonamu.appRootPath, filePath);\n      if (relativePath.startsWith(\"..\")) return \"unknown\";\n\n      for (const fileType of fileTypes) {\n        if (minimatch(relativePath, patternGroup[fileType])) {\n          return fileType;\n        }\n      }\n      return \"unknown\";\n    }) as unknown as DiffGroups;\n  }\n\n  private changeMatcher(diffTypes: FileType[], diffGroups: DiffGroups) {\n    const handled = new Set<FileType>();\n\n    /**\n     * 변경 사항이 인자로 받은 FileType들 중 하나 이상을 포함하는지 확인합니다.\n     * 가령 [\"entity\"]가 변경된 호출에서 changeMatches(\"entity\")는 trye를 반환하며,\n     * [\"types\", \"i18n\"]이 변경된 호출에서 changeMatches(\"types\", \"functions\")도 true를 반환하지만,\n     * [\"functions\"]가 변경된 호출에서 changeMatches(\"frame\")은 false를 반환합니다.\n     * @param types\n     */\n    const changeMatches = (...types: FileType[]) => {\n      const matching = types.filter((t) => diffTypes.includes(t));\n      matching.forEach((t) => handled.add(t));\n      return matching.length > 0;\n    };\n\n    /**\n     * changeMatches로 매칭된 것이 하나도 없는지 여부를 가져옵니다.\n     */\n    const nothingMatches = () => handled.size === 0;\n\n    /**\n     * 어떤 changeMatches 호출에도 걸리지 않은 FileType들의 실제 파일 경로를 모아서 반환합니다.\n     */\n    const unhandledPaths = (): AbsolutePath[] =>\n      diffTypes.filter((t) => !handled.has(t)).flatMap((t) => diffGroups[t] ?? []);\n\n    return { changeMatches, nothingMatches, unhandledPaths };\n  }\n\n  async handleTruthSourceChanges(diffGroups: DiffGroups): Promise<void> {\n    Naite.t(\"handleTruthSourceChanges\", { diffGroups });\n\n    await EntityManager.reload();\n\n    // types 생성(entity 새로 추가된 경우)\n    // parentId가 없고, types가 없는 경우에만 생성\n    const entityPath = diffGroups.entity?.at(0);\n    if (entityPath !== undefined) {\n      const entityId = EntityManager.getEntityIdFromPath(entityPath);\n      const entity = EntityManager.get(entityId);\n\n      // 프로젝트에 생성되어야 하는 .ts 파일의 경로입니다.\n      const typeFilePath = path.join(\n        Sonamu.apiRootPath,\n        `src/application/${entity.names.fs}/${entity.names.fs}.types.ts`,\n      ) as AbsolutePath;\n\n      if (entity.parentId === undefined && !(await exists(typeFilePath))) {\n        // *.types.ts가 만들어집니다.\n        const types = await SyncerActions.actionGenerateInitialTypes(entityId);\n\n        // 그걸 타겟에 갖다둬요.\n        await SyncerActions.actionSyncFilesToTargets(types);\n      }\n    }\n\n    // sonamu.generated.ts와 sonamu.generated.sso.ts가 만들어집니다.\n    const generated = await SyncerActions.actionGenerateSchemas();\n\n    // 모든 것들을 target에 보내지는 않습니다.\n    // sonamu.generated.sso.ts는 service-side-only니까 배제합니다.\n    // TODO(병준): 이 하드코드를 누가 해결 좀 해주세요. 일단은 감당 가능하니 놔두겠습니다...\n    const distributable = generated.filter((p) => !p.endsWith(\".sso.ts\"));\n\n    // 이제 보낼 것들만 target에 보내요.\n    await SyncerActions.actionSyncFilesToTargets(distributable);\n  }\n\n  async handleImplementationChanges(diffGroups: DiffGroups): Promise<void> {\n    Naite.t(\"handleImplementationChanges\", { diffGroups });\n    const mergedGroup = [...(diffGroups.model ?? []), ...(diffGroups.frame ?? [])];\n\n    // generated_http.template.ts에서 syncer.types를 씁니다.\n    // service.template.ts에서 syncer.apis를 씁니다.\n    await this.autoloadModels();\n    await this.autoloadTypes();\n    await this.autoloadApis();\n\n    const params: {\n      namesRecord: EntityNamesRecord;\n    }[] = mergedGroup.map((modelPath) => {\n      if (modelPath.endsWith(\".model.ts\") || modelPath.endsWith(\".frame.ts\")) {\n        const entityId = EntityManager.getEntityIdFromPath(modelPath);\n        assert(entityId);\n        return {\n          namesRecord: EntityManager.getNamesFromId(entityId),\n        };\n      }\n      throw new Error(\"not reachable\");\n    });\n\n    await SyncerActions.actionGenerateServices(params);\n    await SyncerActions.actionGenerateHttps();\n    await SyncerActions.actionGenerateSsrQueries();\n  }\n\n  async handleAuxiliarySymbolChanges(diffGroups: DiffGroups): Promise<void> {\n    Naite.t(\"handleAuxiliarySymbolChanges\", { diffGroups });\n    const tsPaths = unique([...(diffGroups.types ?? []), ...(diffGroups.functions ?? [])]);\n    await SyncerActions.actionSyncFilesToTargets(tsPaths);\n  }\n\n  async handleConfigChanges(_: DiffGroups): Promise<void> {\n    await SyncerActions.actionSyncConfig();\n  }\n\n  async handleSonamuDictionaryRelatedChanges(_: DiffGroups): Promise<void> {\n    await SyncerActions.actionSyncSonamuDictionary();\n  }\n\n  async handleDrifts(drifts: AbsolutePath[]): Promise<void> {\n    if (drifts.length > 0) {\n      console.warn(\n        chalk.yellow(\n          \"⚠️ Sonamu가 자동 생성한 파일에 대한 변경이 감지되었습니다. 파일이 Sonamu watcher 외부에서 변경된 것으로 추정됩니다.\",\n        ),\n      );\n      for (const p of drifts) {\n        console.warn(chalk.yellow(`  - ${path.relative(Sonamu.appRootPath, p)}`));\n      }\n      console.warn(chalk.dim(\"  → `pnpm sonamu sync --force`를 권장합니다.\"));\n    }\n  }\n\n  /**\n   * 주어진 엔티티와 템플릿 키에 대해, 생성된 코드가 존재하는지 확인합니다.\n   * @param entityId 엔티티 ID\n   * @param templateKey 템플릿 키\n   * @param enumId 열거형 ID\n   * @returns 생성된 코드가 존재하는지 여부\n   */\n  async checkExistsGenCode(\n    entityId: string,\n    templateKey: TemplateKey,\n    enumId?: string,\n  ): Promise<{ subPath: string; fullPath: string; isExists: boolean }> {\n    const { target, path: genPath } = TemplateManager.get(templateKey).getTargetAndPath(\n      EntityManager.getNamesFromId(entityId),\n      enumId,\n    );\n\n    const subPath = path.join(target, genPath);\n    const fullPath = path.join(Sonamu.appRootPath, subPath);\n    return {\n      subPath,\n      fullPath,\n      isExists: await exists(fullPath),\n    };\n  }\n\n  /**\n   * 주어진 엔티티와 열거형에 대해, 생성된 코드가 존재하는지 확인합니다.\n   * @param entityId 엔티티 ID\n   * @param enums 열거형 레이블\n   * @returns 생성된 코드가 존재하는지 여부\n   */\n  async checkExists(\n    entityId: string,\n    enums: {\n      [name: string]: z.ZodEnum;\n    },\n  ): Promise<Record<`${TemplateKey}${string}`, boolean>> {\n    const keys: TemplateKey[] = TemplateKey.options;\n    const names = EntityManager.getNamesFromId(entityId);\n    const enumsKeys = Object.keys(enums).filter((name) => name !== names.constant);\n\n    return await reduceAsync(\n      keys,\n      async (result, key) => {\n        const tpl = TemplateManager.get(key);\n        if (key.startsWith(\"view_enums\")) {\n          await mapAsync(enumsKeys, async (componentId) => {\n            const { target, path: p } = tpl.getTargetAndPath(names, componentId);\n            result[`${key}__${componentId}`] = await exists(\n              path.join(Sonamu.appRootPath, target, p),\n            );\n          });\n          return result;\n        }\n\n        const { target, path: p } = tpl.getTargetAndPath(names);\n        const { targets } = Sonamu.config.sync;\n        if (target.includes(\":target\")) {\n          await mapAsync(targets, async (t) => {\n            result[`${key}__${t}`] = await exists(\n              path.join(Sonamu.appRootPath, target.replace(\":target\", t), p),\n            );\n          });\n        } else {\n          result[key] = await exists(path.join(Sonamu.appRootPath, target, p));\n        }\n\n        return result;\n      },\n      {} as Record<`${TemplateKey}${string}`, boolean>,\n    );\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async createEntity(form: TemplateOptions[\"entity\"]) {\n    return await createEntity(form);\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async delEntity(entityId: string): Promise<{ delPaths: string[] }> {\n    return await delEntity(entityId);\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async generateTemplate<T extends TemplateKey>(\n    key: T,\n    templateOptions: TemplateOptions[T],\n    _generateOptions?: GenerateOptions,\n  ): Promise<AbsolutePath[]> {\n    return await generateTemplate(key, templateOptions, _generateOptions);\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async renderTemplate<T extends keyof TemplateOptions>(\n    key: T,\n    templateOptions: TemplateOptions[T],\n  ): Promise<PathAndCode[]> {\n    return await renderTemplate(key, templateOptions);\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async renewChecksums(): Promise<void> {\n    return await renewChecksums();\n  }\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"syncer.js","names":["SyncerActions.actionCopySharedToTargetsIfNotExists","SyncerActions.actionGenerateHttpValidators","SyncerActions.actionGenerateSsrEntryServerIfNotExists","SyncerActions.actionGenerateInitialTypes","SyncerActions.actionSyncFilesToTargets","SyncerActions.actionGenerateSchemas","SyncerActions.actionGenerateServices","SyncerActions.actionGenerateHttps","SyncerActions.actionGenerateSsrQueries","SyncerActions.actionSyncConfig","SyncerActions.actionSyncSonamuDictionary"],"sources":["../../src/syncer/syncer.ts"],"sourcesContent":["import assert from \"assert\";\nimport { EventEmitter } from \"events\";\nimport path from \"path\";\n\nimport { hot } from \"@sonamu-kit/hmr-hook\";\nimport chalk from \"chalk\";\nimport { minimatch } from \"minimatch\";\nimport { unique } from \"radashi\";\nimport { type z } from \"zod\";\n\nimport { registeredApis } from \"../api/decorators\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { type EntityNamesRecord } from \"../entity/entity-manager\";\nimport { Naite } from \"../naite/naite\";\nimport { type WorkflowMetadata } from \"../tasks/decorator\";\nimport { TemplateManager } from \"../template/template-manager\";\nimport { type GenerateOptions, type PathAndCode } from \"../types/types\";\nimport { TemplateKey } from \"../types/types\";\nimport { type TemplateOptions } from \"../types/types\";\nimport { mapAsync, reduceAsync } from \"../utils/async-utils\";\nimport { centerText } from \"../utils/console-util\";\nimport { isTest } from \"../utils/controller\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\nimport { runWithGracefulShutdown } from \"../utils/process-utils\";\nimport { isObjectValue } from \"../utils/runtime-value\";\nimport { findChangedFilesUsingChecksums, renewChecksums } from \"./checksum\";\nimport { generateTemplate, renderTemplate } from \"./code-generator\";\nimport { createEntity, delEntity } from \"./entity-operations\";\nimport { getChecksumPatternGroup, getChecksumPatternGroupInAbsolutePath } from \"./file-patterns\";\nimport { type FileType } from \"./file-patterns\";\nimport { syncerFileExists, syncerFilesystem } from \"./filesystem-dependencies\";\nimport { loadApis, loadModels, loadTypes, loadWorkflows } from \"./module-loader\";\nimport { type LoadedApis, type LoadedModels, type LoadedTypes } from \"./module-loader\";\nimport * as SyncerActions from \"./syncer-actions\";\n\ntype DiffGroupKey = FileType | \"unknown\";\ntype DiffGroups = Partial<Record<DiffGroupKey, AbsolutePath[]>>;\n\nexport interface SyncerDependencies {\n  actionCopySharedToTargetsIfNotExists: typeof SyncerActions.actionCopySharedToTargetsIfNotExists;\n  actionGenerateHttpValidators: typeof SyncerActions.actionGenerateHttpValidators;\n  actionGenerateSsrEntryServerIfNotExists: typeof SyncerActions.actionGenerateSsrEntryServerIfNotExists;\n  findChangedFilesUsingChecksums: typeof findChangedFilesUsingChecksums;\n  renewChecksums: typeof renewChecksums;\n}\n\nconst defaultSyncerDependencies: SyncerDependencies = {\n  actionCopySharedToTargetsIfNotExists: SyncerActions.actionCopySharedToTargetsIfNotExists,\n  actionGenerateHttpValidators: SyncerActions.actionGenerateHttpValidators,\n  actionGenerateSsrEntryServerIfNotExists: SyncerActions.actionGenerateSsrEntryServerIfNotExists,\n  findChangedFilesUsingChecksums,\n  renewChecksums,\n};\n\nexport class Syncer {\n  apis: LoadedApis = [];\n  types: LoadedTypes = {};\n  models: LoadedModels = {};\n  workflows: Map<string, WorkflowMetadata[]> = new Map();\n  eventEmitter: EventEmitter = new EventEmitter();\n\n  constructor(private readonly dependencies: SyncerDependencies = defaultSyncerDependencies) {}\n\n  /**\n   * 체크섬이 변경된 부분에 대해 싱크를 진행합니다.\n   * dev 서버가 처음 떴을 때, sonamu sync 할 때 실행됩니다. 이후에는 hmrAndSync 경로를 타요.\n   * @returns\n   */\n  async sync(): Promise<void> {\n    // 초기 부트스트랩! 얘네들은 idempotent하고 가볍기 때문에 무지성 실행해도 됩니다.\n    // 얘네들은 sonamu.lock에 들어가지도 않고 따라서 HMR 경로를 타지도 않는 친구들입니다.\n    // 그래서 아무 때나 그냥 돌려주면 되는데, hmrAndSync에서 매번 하는 것은 낭비이니 여기서 한 번만 합니다.\n    await this.dependencies.actionCopySharedToTargetsIfNotExists();\n    await this.dependencies.actionGenerateSsrEntryServerIfNotExists();\n\n    // 바뀐 것이 없으면 그냥 넘어가요.\n    const changedFiles = await this.dependencies.findChangedFilesUsingChecksums();\n    if (changedFiles.length === 0) {\n      if (await this.reconcileHttpValidatorRegistry()) {\n        await this.dependencies.renewChecksums();\n      }\n      console.log(chalk.black.bgGreen(centerText(\"All files are synced!\")));\n      return;\n    }\n\n    // 여기서 실제 싱크 동작을 수행합니다.\n    // 다만 싱크 중에 프로세스가 죽으면 꼬여버리기 때문에,\n    // 시그널에도 잠시 버틸 수 있는 환경 속에서 싱크를 실행합니다.\n    await runWithGracefulShutdown(\n      async () => {\n        // 얘가 싱크 작업 수행하는 본체입니다.\n        await this.doSyncActions(changedFiles);\n        await this.reconcileHttpValidatorRegistry();\n\n        // 싱크 액션이 끝나면 항상 체크섬을 다시 갱신합니다.\n        await this.dependencies.renewChecksums();\n      },\n      { whenThisHappens: \"SIGUSR2\", waitForUpTo: 20000 },\n    );\n  }\n\n  private async reconcileHttpValidatorRegistry(): Promise<boolean> {\n    const registryPath = path.join(\n      Sonamu.apiRootPath,\n      \"src/application/sonamu.validators.generated.ts\",\n    );\n    const policy = Sonamu.config.validation?.zodCompiler;\n    const isAot = isObjectValue(policy) && policy !== null && policy.api === \"aot\";\n    if (isAot === (await syncerFileExists(registryPath))) {\n      return false;\n    }\n\n    // 변경 목록이 registry 삭제를 놓쳐도 checksum 갱신 전에 정책과 산출물을 다시 맞춥니다.\n    await this.dependencies.actionGenerateHttpValidators();\n    return true;\n  }\n\n  /**\n   * 강제 풀-싱크: lock을 무시하고 처음부터 다시 싱크합니다.\n   *\n   * **사용처**: git post-merge hook, CI, dev 서버의 `f` 핫키.\n   * **실패 안전성**: 도중에 프로세스가 죽어 lock 없는 상태로 남아도 무해 — 다음 sync에서\n   * lock 없으면 자연스럽게 풀-싱크가 트리거되어 새 lock이 작성됨.\n   */\n  async forceSync(): Promise<void> {\n    const lockPath = path.join(Sonamu.apiRootPath, \"sonamu.lock\");\n    if (await syncerFileExists(lockPath)) {\n      await syncerFilesystem.unlink(lockPath);\n    }\n    await this.sync();\n  }\n\n  /**\n   * Watcher가 batch로 모은 변경 파일들에 대해 한 번의 HMR/sync 사이클을 돕니다.\n   *\n   * HMR은 api/src 안에서 일어나는 모든 파일들에 대해서 수행합니다.\n   * checksumPatternGroup 매칭 여부와 무관하게 api/src 전체 대상입니다.\n   * 가령 api/src/utils/subset-loaders.ts 같은 파일도 변경되면 HMR은 해줍니다.\n   *\n   * Sync는 checksumPatternGroup으로 매칭되는 파일들에 대해서만 수행합니다.\n   * 여기에는 web/src나 app/src 같은 다른 target의 파일이 포함될 수 있습니다.\n   * 이런 non-api 경로의 파일들은 HMR과는 아무 상관이 없으므로, invalidate을 하지 않습니다.\n   *\n   * @param fileEvents - path → event 맵. event는 \"change\" | \"add\".\n   */\n  async hmrAndSync(fileEvents: Map<AbsolutePath, \"change\" | \"add\">): Promise<void> {\n    const hmrActionRequiredEvents = this.extractHmrActionRequiredFileEvents(fileEvents);\n    const syncTriggeringPaths = await this.extractSyncTriggeringFileEventPaths(fileEvents);\n\n    // HMR 영역: 파일 이벤트 중 api의 모듈 그래프에 있는 파일들에 대한 변동은 hmrActionRequiredEvents로 잡힙니다.\n    // 이 친구들은 invalidate 처리해줍니다.\n    // 이 호출은 아래 sync보다 무조건 먼저 일어나야 합니다!\n    // 왜냐하면 sync에서는 변경된 model 코드를 새로 import해서 처리해야 하는 경우도 있기 때문입니다.\n    await this.invalidateDependentsAffectedByFileEvents(hmrActionRequiredEvents);\n\n    // Sync 영역: checksumPatternGroup에 명시된 파일들에 대한 변동은 syncTriggeringPaths로 잡힙니다.\n    // 이 친구들은 적절한 sync 작업으로 대응합니다.\n    if (syncTriggeringPaths.length > 0) {\n      await this.doSyncActions(syncTriggeringPaths);\n    }\n\n    // 싱크 작업이 끝났으면 무지성 로드를 수행합니다.\n    // 싱크를 안 한 경우에도 로드는 해야 해요. 위에서 관련있는 친구들은 다 invalidate 되었거든요!\n    //\n    // 변경된 파일들에 대해서 새롭게 당겨오는(load) 행위는 doSyncActions에서 하지 않습니다.\n    // doSyncActions에서는 파일을 읽고 만드는 싱크 행위만 합니다.\n    // 거기서 딱 변경된 부분에 영향받는 autoload만 선별해서 수행하려면 너무 지저분하고 복잡해집니다.\n    //\n    // 퍼포먼스 영향은 무시해도 좋습니다.\n    // 어차피 hmr-hook에 의해 invalidate된 부분들이 아니라면 캐시 그대로 유지합니다.\n    await this.autoloadTypes();\n    await this.autoloadModels();\n    await this.autoloadApis();\n    await this.autoloadWorkflows();\n    await this.autoloadSsrRoutes();\n    await Sonamu.refreshHttpValidators();\n\n    this.eventEmitter.emit(\"onHMRCompleted\");\n  }\n\n  private extractHmrActionRequiredFileEvents(\n    fileEvents: Map<AbsolutePath, \"change\" | \"add\">,\n  ): Map<AbsolutePath, \"change\" | \"add\"> {\n    const apiSrc = path.join(Sonamu.apiRootPath, \"src\");\n    const result = new Map<AbsolutePath, \"change\" | \"add\">();\n    for (const [filePath, event] of fileEvents) {\n      if (!filePath.startsWith(apiSrc)) {\n        continue;\n      }\n      result.set(filePath, event);\n    }\n    return result;\n  }\n\n  private async extractSyncTriggeringFileEventPaths(\n    fileEvents: Map<AbsolutePath, \"change\" | \"add\">,\n  ): Promise<AbsolutePath[]> {\n    const checkPatternGroup = getChecksumPatternGroupInAbsolutePath();\n    const syncTriggeringPaths: AbsolutePath[] = [];\n    for (const [diffFilePath] of fileEvents) {\n      const isInCheckPatternGroup = Object.values(checkPatternGroup).some((pattern) =>\n        minimatch(diffFilePath, pattern),\n      );\n      if (!isInCheckPatternGroup) {\n        continue;\n      }\n      syncTriggeringPaths.push(diffFilePath);\n    }\n\n    return syncTriggeringPaths;\n  }\n\n  private async invalidateDependentsAffectedByFileEvents(\n    fileEvents: Map<AbsolutePath, \"change\" | \"add\">,\n  ) {\n    for (const [diffFilePath, event] of fileEvents) {\n      // 변경된 파일과 dependent 파일들을 invalidate 합니다.\n      // 한 번 이상 import된 친구들에 대해서만 실제 작업이 일어납니다.\n      // 그러니 안심하고 invalidate 해도 됩니다.\n      // 테스트 환경에서는 hot.invalidateFile시 초기 에러가 발생하기 때문에 invalidate 하지 않습니다.\n      if (!isTest()) {\n        const invalidatedPaths =\n          /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ (await hot.invalidateFile(\n            diffFilePath,\n            event,\n          )) as AbsolutePath[];\n\n        if (invalidatedPaths.length > 0) {\n          console.log(chalk.bold(`🔄 Invalidated:`));\n\n          for (const invalidatedPath of invalidatedPaths) {\n            try {\n              // 만약 model.ts 파일이 변경(invalidate)되었다? 그러면 registeredApis 중에서 이 모델에 해당하는 api들은 지워줘요.\n              // registeredApis는 통으로 다 날려버릴 수 없습니다. registeredApis에 올라오는 친구들은 초기 로드시 또는 HMR시에만 등록되기 때문입니다.\n              // 따라서 model.ts 파일의 변경으로 다음번 새로운 eval이 예상되는 이 시점에서만, 이 모델에서 나온 registeredApis들을 지워줄 수 있습니다.\n              const removedApis = this.removeInvalidatedRegisteredApis(invalidatedPath);\n              if (removedApis.length > 0) {\n                console.log(\n                  chalk.blue(`- ${path.relative(Sonamu.apiRootPath, invalidatedPath)}`),\n                  chalk.gray(`(with ${removedApis.length} APIs)`),\n                );\n              } else {\n                console.log(chalk.blue(`- ${path.relative(Sonamu.apiRootPath, invalidatedPath)}`));\n              }\n            } catch (e) {\n              console.error(e);\n              console.error(\n                chalk.red(`Failed to remove invalidated registered APIs for ${invalidatedPath}`),\n              );\n            }\n          }\n        }\n      }\n\n      // devRunner 활성화 시, 변경된 소스 파일을 Vitest 모듈 그래프에서도 무효화합니다.\n      // Vite의 moduleGraph.invalidateModule()이 importer 방향으로 재귀적 cascade하므로,\n      // 소스 파일 하나만 무효화하면 이를 import하는 테스트 파일도 자동으로 무효화됩니다.\n      if (!isTest() && Sonamu.config.test?.devRunner?.enabled && Sonamu.devVitestManager) {\n        Sonamu.devVitestManager.invalidateFiles([diffFilePath]);\n        console.log(\n          chalk.dim(`Test invalidated: ${path.relative(Sonamu.apiRootPath, diffFilePath)}`),\n        );\n      }\n    }\n  }\n\n  removeInvalidatedRegisteredApis(\n    invalidatedPath: AbsolutePath,\n  ): (typeof registeredApis)[number][] {\n    // 소스 코드를 다루는 상황이니 .ts 경로로 봅니다.\n    const isModel = invalidatedPath.endsWith(\".model.ts\");\n    const isFrame = invalidatedPath.endsWith(\".frame.ts\");\n    if (!isModel && !isFrame) {\n      return [];\n    }\n\n    const entityId = EntityManager.getEntityIdFromPath(invalidatedPath);\n    const targetModelName = `${entityId}${isModel ? \"Model\" : \"Frame\"}`;\n    const toRemove = registeredApis.filter((api) => api.modelName === targetModelName);\n    for (const api of toRemove) {\n      const idx = registeredApis.indexOf(api);\n      if (idx !== -1) {\n        registeredApis.splice(idx, 1);\n      }\n    }\n\n    return toRemove;\n  }\n\n  async autoloadTypes() {\n    this.types = await loadTypes();\n  }\n\n  async autoloadModels() {\n    this.models = await loadModels();\n  }\n\n  async autoloadApis() {\n    this.apis = await loadApis();\n  }\n\n  async autoloadWorkflows() {\n    this.workflows = await loadWorkflows();\n    await Sonamu.workflows.synchronize(this.workflows);\n  }\n\n  async autoloadSsrRoutes(): Promise<void> {\n    const ssrConfigPath = path.join(Sonamu.apiRootPath, \"src/ssr\");\n\n    // 기존 routes 초기화\n    const { clearSSRRoutes } = await import(\"../ssr\");\n    clearSSRRoutes();\n\n    // ssr 폴더 없으면 스킵\n    if (!(await syncerFileExists(ssrConfigPath))) {\n      return;\n    }\n\n    // ssr 폴더 안의 모든 .ts 파일 로드\n    const { globAsync } = await import(\"../utils/async-utils\");\n    const { importMembers } = await import(\"../utils/esm-utils\");\n    const { runtimePath } = await import(\"../utils/path-utils\");\n\n    // runtimePath를 사용하여 개발/프로덕션 환경에 맞는 확장자 처리\n    const files = await globAsync(path.join(ssrConfigPath, runtimePath(\"**/*.ts\")));\n\n    for (const file of files) {\n      try {\n        // importMembers를 사용하면 파일의 side effect(registerSSR 호출)가 실행됨\n        await importMembers(file);\n      } catch (e) {\n        console.error(`Failed to load SSR route: ${file}`, e);\n      }\n    }\n  }\n\n  /**\n   * 실제 싱크를 수행하는 본체입니다.\n   * 변경된 파일들을 타입별로 분류하고 각 타입에 맞는 액션을 실행합니다.\n   *\n   * @param diffFilePaths - 변경된 파일들의 절대 경로 목록\n   * @returns diffTypes - 변경된 파일의 타입 목록 (entity, types, model 등)\n   */\n  async doSyncActions(diffFilePaths: AbsolutePath[]): Promise<{ diffTypes: FileType[] }> {\n    const diffGroups = this.calculateDiffGroups(diffFilePaths);\n    const diffTypes =\n      /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ Object.keys(\n        diffGroups,\n      ) as FileType[];\n\n    // 여기는 별로 중요한 파트는 아닙니다.\n    // 아래의 if 전개를 깔끔하게 하려고 만든 DSL 같은 거라서, 무시하셔도 됩니다.\n    const { changeMatches, nothingMatches, unhandledPaths } = this.changeMatcher(\n      diffTypes,\n      diffGroups,\n    );\n\n    if (changeMatches(\"entity\", \"types\")) {\n      await this.handleTruthSourceChanges(diffGroups);\n    }\n\n    if (changeMatches(\"model\", \"frame\")) {\n      await this.handleImplementationChanges(diffGroups);\n    }\n\n    if (changeMatches(\"types\", \"functions\")) {\n      await this.handleAuxiliarySymbolChanges(diffGroups);\n    }\n\n    if (changeMatches(\"config\")) {\n      await this.handleConfigChanges();\n    }\n\n    if (changeMatches(\"i18n\", \"entity\" /*레이블*/, \"config\" /*defaultLocale등*/)) {\n      await this.handleSonamuDictionaryRelatedChanges();\n    }\n\n    const metadataChanged = diffTypes.some((type) =>\n      [\"entity\", \"types\", \"model\", \"frame\", \"config\"].includes(type),\n    );\n    if (changeMatches(\"httpValidatorsGenerated\") && !metadataChanged) {\n      // registry 자체 drift는 최신 in-memory metadata로 즉시 덮어써 lock 갱신 전에 정합성을 복구합니다.\n      await this.dependencies.actionGenerateHttpValidators();\n    }\n\n    if (metadataChanged) {\n      // 모든 생성/복사 액션 뒤 최신 metadata를 다시 읽어 registry를 한 번만 확정합니다.\n      await this.autoloadTypes();\n      await this.autoloadModels();\n      await this.autoloadApis();\n      await this.dependencies.actionGenerateHttpValidators();\n    }\n\n    if (nothingMatches()) {\n      // 파일 변경은 감지되었으나 저 위 어느 changeMatches에도 걸리지 않은 파일들이 drifts입니다.\n      // syncer는 소스의 변경에는 반응하지만 산출물의 변경(drift)에는 직접적으로 반응하지 않습니다.\n      // 대신 이 drift에 대해 경고 정도만 출력해줍니다.\n      await this.handleDrifts(unhandledPaths());\n    }\n\n    return {\n      diffTypes,\n    };\n  }\n\n  calculateDiffGroups(diffFiles: AbsolutePath[]) {\n    const patternGroup = getChecksumPatternGroup();\n    const fileTypes =\n      /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ Object.keys(\n        patternGroup,\n      ) as FileType[];\n\n    const diffGroups: DiffGroups = {};\n    for (const filePath of diffFiles) {\n      // 절대 경로를 appRoot 기준 상대 경로로 바꿔 체크섬 패턴과 비교한다.\n      const relativePath = path.relative(Sonamu.appRootPath, filePath);\n      const fileType = fileTypes.find((candidate) =>\n        minimatch(relativePath, patternGroup[candidate]),\n      );\n      const groupKey: DiffGroupKey = relativePath.startsWith(\"..\")\n        ? \"unknown\"\n        : (fileType ?? \"unknown\");\n      (diffGroups[groupKey] ??= []).push(filePath);\n    }\n    return diffGroups;\n  }\n\n  private changeMatcher(diffTypes: FileType[], diffGroups: DiffGroups) {\n    const handled = new Set<FileType>();\n\n    /**\n     * 변경 사항이 인자로 받은 FileType들 중 하나 이상을 포함하는지 확인합니다.\n     * 가령 [\"entity\"]가 변경된 호출에서 changeMatches(\"entity\")는 trye를 반환하며,\n     * [\"types\", \"i18n\"]이 변경된 호출에서 changeMatches(\"types\", \"functions\")도 true를 반환하지만,\n     * [\"functions\"]가 변경된 호출에서 changeMatches(\"frame\")은 false를 반환합니다.\n     * @param types\n     */\n    const changeMatches = (...types: FileType[]) => {\n      const matching = types.filter((t) => diffTypes.includes(t));\n      matching.forEach((t) => handled.add(t));\n      return matching.length > 0;\n    };\n\n    /**\n     * changeMatches로 매칭된 것이 하나도 없는지 여부를 가져옵니다.\n     */\n    const nothingMatches = () => handled.size === 0;\n\n    /**\n     * 어떤 changeMatches 호출에도 걸리지 않은 FileType들의 실제 파일 경로를 모아서 반환합니다.\n     */\n    const unhandledPaths = (): AbsolutePath[] =>\n      diffTypes.filter((t) => !handled.has(t)).flatMap((t) => diffGroups[t] ?? []);\n\n    return { changeMatches, nothingMatches, unhandledPaths };\n  }\n\n  async handleTruthSourceChanges(diffGroups: DiffGroups): Promise<void> {\n    Naite.t(\"handleTruthSourceChanges\", { diffGroups });\n\n    await EntityManager.reload();\n\n    // types 생성(entity 새로 추가된 경우)\n    // parentId가 없고, types가 없는 경우에만 생성\n    const entityPath = diffGroups.entity?.at(0);\n    if (entityPath !== undefined) {\n      const entityId = EntityManager.getEntityIdFromPath(entityPath);\n      const entity = EntityManager.get(entityId);\n\n      // 프로젝트에 생성되어야 하는 .ts 파일의 경로입니다.\n      const typeFilePath =\n        /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ path.join(\n          Sonamu.apiRootPath,\n          `src/application/${entity.names.fs}/${entity.names.fs}.types.ts`,\n        ) as AbsolutePath;\n\n      if (entity.parentId === undefined && !(await syncerFileExists(typeFilePath))) {\n        // *.types.ts가 만들어집니다.\n        const types = await SyncerActions.actionGenerateInitialTypes(entityId);\n\n        // 그걸 타겟에 갖다둬요.\n        await SyncerActions.actionSyncFilesToTargets(types);\n      }\n    }\n\n    // sonamu.generated.ts와 sonamu.generated.sso.ts가 만들어집니다.\n    const generated = await SyncerActions.actionGenerateSchemas();\n\n    // 모든 것들을 target에 보내지는 않습니다.\n    // sonamu.generated.sso.ts는 service-side-only니까 배제합니다.\n    // TODO(병준): 이 하드코드를 누가 해결 좀 해주세요. 일단은 감당 가능하니 놔두겠습니다...\n    const distributable = generated.filter((p) => !p.endsWith(\".sso.ts\"));\n\n    // 이제 보낼 것들만 target에 보내요.\n    await SyncerActions.actionSyncFilesToTargets(distributable);\n  }\n\n  async handleImplementationChanges(diffGroups: DiffGroups): Promise<void> {\n    Naite.t(\"handleImplementationChanges\", { diffGroups });\n    const mergedGroup = [...(diffGroups.model ?? []), ...(diffGroups.frame ?? [])];\n\n    // generated_http.template.ts에서 syncer.types를 씁니다.\n    // service.template.ts에서 syncer.apis를 씁니다.\n    await this.autoloadModels();\n    await this.autoloadTypes();\n    await this.autoloadApis();\n\n    const params: {\n      namesRecord: EntityNamesRecord;\n    }[] = mergedGroup.map((modelPath) => {\n      if (modelPath.endsWith(\".model.ts\") || modelPath.endsWith(\".frame.ts\")) {\n        const entityId = EntityManager.getEntityIdFromPath(modelPath);\n        assert(entityId);\n        return {\n          namesRecord: EntityManager.getNamesFromId(entityId),\n        };\n      }\n      throw new Error(\"not reachable\");\n    });\n\n    await SyncerActions.actionGenerateServices(params);\n    await SyncerActions.actionGenerateHttps();\n    await SyncerActions.actionGenerateSsrQueries();\n  }\n\n  async handleAuxiliarySymbolChanges(diffGroups: DiffGroups): Promise<void> {\n    Naite.t(\"handleAuxiliarySymbolChanges\", { diffGroups });\n    const tsPaths = unique([...(diffGroups.types ?? []), ...(diffGroups.functions ?? [])]);\n    await SyncerActions.actionSyncFilesToTargets(tsPaths);\n  }\n\n  async handleConfigChanges(): Promise<void> {\n    if (process.env.HOT === \"yes\") {\n      const { loadConfig } = await import(\"../api/config\");\n      Sonamu.config = await loadConfig(Sonamu.apiRootPath);\n    }\n    await SyncerActions.actionSyncConfig();\n  }\n\n  async handleSonamuDictionaryRelatedChanges(): Promise<void> {\n    await SyncerActions.actionSyncSonamuDictionary();\n  }\n\n  async handleDrifts(drifts: AbsolutePath[]): Promise<void> {\n    if (drifts.length > 0) {\n      console.warn(\n        chalk.yellow(\n          \"⚠️ Sonamu가 자동 생성한 파일에 대한 변경이 감지되었습니다. 파일이 Sonamu watcher 외부에서 변경된 것으로 추정됩니다.\",\n        ),\n      );\n      for (const p of drifts) {\n        console.warn(chalk.yellow(`  - ${path.relative(Sonamu.appRootPath, p)}`));\n      }\n      console.warn(chalk.dim(\"  → `pnpm sonamu sync --force`를 권장합니다.\"));\n    }\n  }\n\n  /**\n   * 주어진 엔티티와 템플릿 키에 대해, 생성된 코드가 존재하는지 확인합니다.\n   * @param entityId 엔티티 ID\n   * @param templateKey 템플릿 키\n   * @param enumId 열거형 ID\n   * @returns 생성된 코드가 존재하는지 여부\n   */\n  async checkExistsGenCode(\n    entityId: string,\n    templateKey: TemplateKey,\n    enumId?: string,\n  ): Promise<{ subPath: string; fullPath: string; isExists: boolean }> {\n    const { target, path: genPath } = TemplateManager.get(templateKey).getTargetAndPath(\n      EntityManager.getNamesFromId(entityId),\n      enumId,\n    );\n\n    const subPath = path.join(target, genPath);\n    const fullPath = path.join(Sonamu.appRootPath, subPath);\n    return {\n      subPath,\n      fullPath,\n      isExists: await syncerFileExists(fullPath),\n    };\n  }\n\n  /**\n   * 주어진 엔티티와 열거형에 대해, 생성된 코드가 존재하는지 확인합니다.\n   * @param entityId 엔티티 ID\n   * @param enums 열거형 레이블\n   * @returns 생성된 코드가 존재하는지 여부\n   */\n  async checkExists(\n    entityId: string,\n    enums: {\n      [name: string]: z.ZodEnum;\n    },\n  ): Promise<Record<`${TemplateKey}${string}`, boolean>> {\n    const keys: TemplateKey[] = TemplateKey.options;\n    const names = EntityManager.getNamesFromId(entityId);\n    const enumsKeys = Object.keys(enums).filter((name) => name !== names.constant);\n\n    return await reduceAsync(\n      keys,\n      async (result, key) => {\n        const tpl = TemplateManager.get(key);\n        if (key.startsWith(\"view_enums\")) {\n          await mapAsync(enumsKeys, async (componentId) => {\n            const { target, path: p } = tpl.getTargetAndPath(names, componentId);\n            result[`${key}__${componentId}`] = await syncerFileExists(\n              path.join(Sonamu.appRootPath, target, p),\n            );\n          });\n          return result;\n        }\n\n        const { target, path: p } = tpl.getTargetAndPath(names);\n        const { targets } = Sonamu.config.sync;\n        if (target.includes(\":target\")) {\n          await mapAsync(targets, async (t) => {\n            result[`${key}__${t}`] = await syncerFileExists(\n              path.join(Sonamu.appRootPath, target.replace(\":target\", t), p),\n            );\n          });\n        } else {\n          result[key] = await syncerFileExists(path.join(Sonamu.appRootPath, target, p));\n        }\n\n        return result;\n      },\n      /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ {} as Record<\n        `${TemplateKey}${string}`,\n        boolean\n      >,\n    );\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async createEntity(form: TemplateOptions[\"entity\"]) {\n    return await createEntity(form);\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async delEntity(entityId: string): Promise<{ delPaths: string[] }> {\n    return await delEntity(entityId);\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async generateTemplate<T extends TemplateKey>(\n    key: T,\n    templateOptions: TemplateOptions[T],\n    _generateOptions?: GenerateOptions,\n  ): Promise<AbsolutePath[]> {\n    return await generateTemplate(key, templateOptions, _generateOptions);\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async renderTemplate<T extends keyof TemplateOptions>(\n    key: T,\n    templateOptions: TemplateOptions[T],\n  ): Promise<PathAndCode[]> {\n    return await renderTemplate(key, templateOptions);\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async renewChecksums(): Promise<void> {\n    return await this.dependencies.renewChecksums();\n  }\n}\n"],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"watcher.d.ts","sourceRoot":"","sources":["../../src/syncer/watcher.ts"],"names":[],"mappings":"AAKA,OAAiB,EAAE,KAAK,SAAS,EAAE,MAAM,UAAU,CAAC;AAIpD,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAKxD;;;GAGG;AACH,wBAAsB,YAAY,CAChC,YAAY,EAAE,CAAC,UAAU,EAAE,GAAG,CAAC,YAAY,EAAE,QAAQ,GAAG,KAAK,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAC/E,OAAO,CAAC,SAAS,CAAC,CAyDpB"}
+{"version":3,"file":"watcher.d.ts","sourceRoot":"","sources":["../../src/syncer/watcher.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,SAAS,EAAS,MAAM,UAAU,CAAC;AAIjD,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAKxD;;;GAGG;AACH,wBAAsB,YAAY,CAChC,YAAY,EAAE,CAAC,UAAU,EAAE,GAAG,CAAC,YAAY,EAAE,QAAQ,GAAG,KAAK,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAC/E,OAAO,CAAC,SAAS,CAAC,CA0DpB"}

package/dist/syncer/watcher.js

@@ -8,14 +8,14 @@ import { strict } from "assert";
 import path from "path";
 import chalk from "chalk";
 import { minimatch } from "minimatch";
-import chokidar from "chokidar";
+import { watch } from "chokidar";
 //#region src/syncer/watcher.ts
 /**
 * Watcher를 설정합니다.
 * 이 친구는 진짜로 syncer가 받아야 할 변경 이벤트들만 추려서 batch로 전달해줍니다.
 */
 async function setupWatcher(onFileEvents) {
-	const watcher = chokidar.watch(apiAndTargetsSrcPaths(), {
+	const watcher = watch(apiAndTargetsSrcPaths(), {
 		ignored: ignoreIfExtensionIsNotOneOf(".ts", ".json", ".http"),
 		persistent: true,
 		ignoreInitial: true
@@ -88,4 +88,4 @@ __esmMin((() => {
 }))();
 export { setupWatcher };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"watcher.js","names":[],"sources":["../../src/syncer/watcher.ts"],"sourcesContent":["import { strict as assert } from \"assert\";\nimport { type Stats } from \"node:fs\";\nimport path from \"path\";\n\nimport chalk from \"chalk\";\nimport chokidar, { type FSWatcher } from \"chokidar\";\nimport { minimatch } from \"minimatch\";\n\nimport { Sonamu } from \"../api\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\nimport { createFileEventBatcher } from \"./event-batcher\";\nimport { getChecksumPatternGroupInAbsolutePath } from \"./file-patterns\";\nimport { isLastChangedByMe } from \"./file-tracking\";\n\n/**\n * Watcher를 설정합니다.\n * 이 친구는 진짜로 syncer가 받아야 할 변경 이벤트들만 추려서 batch로 전달해줍니다.\n */\nexport async function setupWatcher(\n  onFileEvents: (fileEvents: Map<AbsolutePath, \"change\" | \"add\">) => Promise<void>,\n): Promise<FSWatcher> {\n  // api 본인뿐 아니라 sync target들의 src도 봅니다.\n  // target 산출물(sonamu.generated, services.generated, i18n copy 등)이 외부에서\n  // 변경되는 경우를 drift로 잡아 워닝을 띄우기 위함입니다.\n  const watcher = chokidar.watch(apiAndTargetsSrcPaths(), {\n    ignored: ignoreIfExtensionIsNotOneOf(\".ts\", \".json\", \".http\"),\n    persistent: true,\n    ignoreInitial: true,\n  });\n\n  // 100ms 안에 들어온 변경들을 한 batch로 모아 한 사이클로 처리합니다.\n  const pushFileEvent = createFileEventBatcher<\"change\" | \"add\">({\n    delayMs: 100,\n    onFlush: async (fileEvents) => {\n      const realChanges = new Map<AbsolutePath, \"change\" | \"add\">();\n      for (const [p, e] of fileEvents) {\n        // self-write echo는 flush 시점에 거릅니다.\n        // watcher.on에서 즉시 거르면 너무 이릅니다.\n        // 여기에서는 파일이 디스크에 쓰이고 나서 약간의 딜레이가 있기 때문에\n        // \"디스크에 썼지만 아직 trackWritten이 완료되기 전 상태\" 같은 문제가 사라집니다.\n        if (!(await isLastChangedByMe(p))) {\n          realChanges.set(p, e);\n        }\n      }\n      if (realChanges.size > 0) {\n        await onFileEvents(realChanges);\n      }\n    },\n  });\n\n  watcher.on(\"all\", (event: string, filePath: string) => {\n    const absolutePath = filePath as AbsolutePath;\n    assert(\n      absolutePath.startsWith(Sonamu.appRootPath),\n      \"File path is not within the app root path\",\n    );\n\n    if (!isWantedEvent(event)) {\n      return;\n    }\n\n    if (isConfigChange(absolutePath)) {\n      triggerSelfRestart(event, filePath);\n      return;\n    }\n\n    if (isOutOfScope(absolutePath)) {\n      return;\n    }\n\n    // 여기까지 왔다면 syncer가 진짜로 처리해야 할 변경사항이라고 보면 됩니다.\n    // 이 호출은 이벤트를 batcher에 쌓습니다.\n    // 이후 때가 되면 이렇게 쌓인 이벤트를 들고 onFileEvents 콜백이 호출됩니다.\n    pushFileEvent(absolutePath, event);\n  });\n\n  return watcher;\n}\n\nfunction apiAndTargetsSrcPaths() {\n  return [\n    path.join(Sonamu.apiRootPath, \"src\"),\n    ...Sonamu.config.sync.targets.map((t) => path.join(Sonamu.appRootPath, t, \"src\")),\n  ];\n}\n\n/**\n * chokidar의 `ignored` 옵션에 박는 헬퍼.\n * 주어진 확장자가 *아닌* 파일은 무시합니다 — 즉 주어진 확장자만 watch 대상.\n *\n * chokidar `ignored`는 `true`를 반환하면 해당 경로를 무시합니다.\n * 따라서 \"이 확장자만 허용\"을 표현하려면 *다른 확장자에 대해 true*를 반환해야 합니다.\n */\nfunction ignoreIfExtensionIsNotOneOf(...allowedExtensions: `.${string}`[]) {\n  const isAllowed = (ext: string) => (allowedExtensions as string[]).includes(ext);\n\n  return (p: string, stats?: Stats) => !!stats?.isFile() && !isAllowed(path.extname(p));\n}\n\nfunction isWantedEvent(event: string): event is \"change\" | \"add\" {\n  return event === \"change\" || event === \"add\";\n}\n\nfunction isConfigChange(filePath: AbsolutePath): boolean {\n  return filePath === path.join(Sonamu.apiRootPath, \"src\", \"sonamu.config.ts\");\n}\n\nfunction triggerSelfRestart(event: string, filePath: string): void {\n  const relativePath = filePath.replace(Sonamu.apiRootPath, \"api\");\n  console.log(chalk.bold(`Detected(${event}): ${chalk.blue(relativePath)} - Restarting...`));\n  process.kill(process.pid, \"SIGUSR2\");\n}\n\n/**\n * 스코프 정의:\n * - api/src 안의 모든 변경은 스코프 안 (HMR 대상이 될 수 있으므로)\n * - api/src 밖이라면 checksumPatternGroup 패턴에 매칭되는 경로만 스코프 안\n *\n * 그 외(예: web/src/App.tsx 같은 target의 비추적 파일)는 스코프 밖이라 무시합니다.\n */\nfunction isOutOfScope(filePath: AbsolutePath): boolean {\n  const apiSrc = path.join(Sonamu.apiRootPath, \"src\");\n  if (filePath.startsWith(apiSrc)) {\n    return false;\n  }\n  const checkPatternGroup = getChecksumPatternGroupInAbsolutePath();\n  return !Object.values(checkPatternGroup).some((pattern) => minimatch(filePath, pattern));\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAkBA,eAAsB,aACpB,cACoB;CAIpB,MAAM,UAAU,SAAS,MAAM,sBAAsB,GAAG;EACtD,SAAS,4BAA4B,OAAO,SAAS,OAAO;EAC5D,YAAY;EACZ,eAAe;CACjB,CAAC;CAGD,MAAM,gBAAgB,uBAAyC;EAC7D,SAAS;EACT,SAAS,OAAO,eAAe;GAC7B,MAAM,8BAAc,IAAI,IAAoC;GAC5D,KAAK,MAAM,CAAC,GAAG,MAAM,YAKnB,IAAI,CAAE,MAAM,kBAAkB,CAAC,GAC7B,YAAY,IAAI,GAAG,CAAC;GAGxB,IAAI,YAAY,OAAO,GACrB,MAAM,aAAa,WAAW;EAElC;CACF,CAAC;CAED,QAAQ,GAAG,QAAQ,OAAe,aAAqB;EACrD,MAAM,eAAe;EACrB,OACE,aAAa,WAAW,OAAO,WAAW,GAC1C,2CACF;EAEA,IAAI,CAAC,cAAc,KAAK,GACtB;EAGF,IAAI,eAAe,YAAY,GAAG;GAChC,mBAAmB,OAAO,QAAQ;GAClC;EACF;EAEA,IAAI,aAAa,YAAY,GAC3B;EAMF,cAAc,cAAc,KAAK;CACnC,CAAC;CAED,OAAO;AACT;AAEA,SAAS,wBAAwB;CAC/B,OAAO,CACL,KAAK,KAAK,OAAO,aAAa,KAAK,GACnC,GAAG,OAAO,OAAO,KAAK,QAAQ,KAAK,MAAM,KAAK,KAAK,OAAO,aAAa,GAAG,KAAK,CAAC,CAClF;AACF;;;;;;;;AASA,SAAS,4BAA4B,GAAG,mBAAmC;CACzE,MAAM,aAAa,QAAiB,kBAA+B,SAAS,GAAG;CAE/E,QAAQ,GAAW,UAAkB,CAAC,CAAC,OAAO,OAAO,KAAK,CAAC,UAAU,KAAK,QAAQ,CAAC,CAAC;AACtF;AAEA,SAAS,cAAc,OAA0C;CAC/D,OAAO,UAAU,YAAY,UAAU;AACzC;AAEA,SAAS,eAAe,UAAiC;CACvD,OAAO,aAAa,KAAK,KAAK,OAAO,aAAa,OAAO,kBAAkB;AAC7E;AAEA,SAAS,mBAAmB,OAAe,UAAwB;CACjE,MAAM,eAAe,SAAS,QAAQ,OAAO,aAAa,KAAK;CAC/D,QAAQ,IAAI,MAAM,KAAK,YAAY,MAAM,KAAK,MAAM,KAAK,YAAY,EAAE,iBAAiB,CAAC;CACzF,QAAQ,KAAK,QAAQ,KAAK,SAAS;AACrC;;;;;;;;AASA,SAAS,aAAa,UAAiC;CACrD,MAAM,SAAS,KAAK,KAAK,OAAO,aAAa,KAAK;CAClD,IAAI,SAAS,WAAW,MAAM,GAC5B,OAAO;CAET,MAAM,oBAAoB,sCAAsC;CAChE,OAAO,CAAC,OAAO,OAAO,iBAAiB,CAAC,CAAC,MAAM,YAAY,UAAU,UAAU,OAAO,CAAC;AACzF;;;UAvH+B;oBAEyB;oBACe;oBACpB"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"watcher.js","names":[],"sources":["../../src/syncer/watcher.ts"],"sourcesContent":["import { strict as assert } from \"assert\";\nimport { type Stats } from \"node:fs\";\nimport path from \"path\";\n\nimport chalk from \"chalk\";\nimport { type FSWatcher, watch } from \"chokidar\";\nimport { minimatch } from \"minimatch\";\n\nimport { Sonamu } from \"../api\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\nimport { createFileEventBatcher } from \"./event-batcher\";\nimport { getChecksumPatternGroupInAbsolutePath } from \"./file-patterns\";\nimport { isLastChangedByMe } from \"./file-tracking\";\n\n/**\n * Watcher를 설정합니다.\n * 이 친구는 진짜로 syncer가 받아야 할 변경 이벤트들만 추려서 batch로 전달해줍니다.\n */\nexport async function setupWatcher(\n  onFileEvents: (fileEvents: Map<AbsolutePath, \"change\" | \"add\">) => Promise<void>,\n): Promise<FSWatcher> {\n  // api 본인뿐 아니라 sync target들의 src도 봅니다.\n  // target 산출물(sonamu.generated, services.generated, i18n copy 등)이 외부에서\n  // 변경되는 경우를 drift로 잡아 워닝을 띄우기 위함입니다.\n  const watcher = watch(apiAndTargetsSrcPaths(), {\n    ignored: ignoreIfExtensionIsNotOneOf(\".ts\", \".json\", \".http\"),\n    persistent: true,\n    ignoreInitial: true,\n  });\n\n  // 100ms 안에 들어온 변경들을 한 batch로 모아 한 사이클로 처리합니다.\n  const pushFileEvent = createFileEventBatcher<\"change\" | \"add\">({\n    delayMs: 100,\n    onFlush: async (fileEvents) => {\n      const realChanges = new Map<AbsolutePath, \"change\" | \"add\">();\n      for (const [p, e] of fileEvents) {\n        // self-write echo는 flush 시점에 거릅니다.\n        // watcher.on에서 즉시 거르면 너무 이릅니다.\n        // 여기에서는 파일이 디스크에 쓰이고 나서 약간의 딜레이가 있기 때문에\n        // \"디스크에 썼지만 아직 trackWritten이 완료되기 전 상태\" 같은 문제가 사라집니다.\n        if (!(await isLastChangedByMe(p))) {\n          realChanges.set(p, e);\n        }\n      }\n      if (realChanges.size > 0) {\n        await onFileEvents(realChanges);\n      }\n    },\n  });\n\n  watcher.on(\"all\", (event: string, filePath: string) => {\n    const absolutePath =\n      /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ filePath as AbsolutePath;\n    assert(\n      absolutePath.startsWith(Sonamu.appRootPath),\n      \"File path is not within the app root path\",\n    );\n\n    if (!isWantedEvent(event)) {\n      return;\n    }\n\n    if (isConfigChange(absolutePath)) {\n      triggerSelfRestart(event, filePath);\n      return;\n    }\n\n    if (isOutOfScope(absolutePath)) {\n      return;\n    }\n\n    // 여기까지 왔다면 syncer가 진짜로 처리해야 할 변경사항이라고 보면 됩니다.\n    // 이 호출은 이벤트를 batcher에 쌓습니다.\n    // 이후 때가 되면 이렇게 쌓인 이벤트를 들고 onFileEvents 콜백이 호출됩니다.\n    pushFileEvent(absolutePath, event);\n  });\n\n  return watcher;\n}\n\nfunction apiAndTargetsSrcPaths() {\n  return [\n    path.join(Sonamu.apiRootPath, \"src\"),\n    ...Sonamu.config.sync.targets.map((t) => path.join(Sonamu.appRootPath, t, \"src\")),\n  ];\n}\n\n/**\n * chokidar의 `ignored` 옵션에 박는 헬퍼.\n * 주어진 확장자가 *아닌* 파일은 무시합니다 — 즉 주어진 확장자만 watch 대상.\n *\n * chokidar `ignored`는 `true`를 반환하면 해당 경로를 무시합니다.\n * 따라서 \"이 확장자만 허용\"을 표현하려면 *다른 확장자에 대해 true*를 반환해야 합니다.\n */\nfunction ignoreIfExtensionIsNotOneOf(...allowedExtensions: `.${string}`[]) {\n  const isAllowed = (ext: string) =>\n    /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ (\n      allowedExtensions as string[]\n    ).includes(ext);\n\n  return (p: string, stats?: Stats) => !!stats?.isFile() && !isAllowed(path.extname(p));\n}\n\nfunction isWantedEvent(event: string): event is \"change\" | \"add\" {\n  return event === \"change\" || event === \"add\";\n}\n\nfunction isConfigChange(filePath: AbsolutePath): boolean {\n  return filePath === path.join(Sonamu.apiRootPath, \"src\", \"sonamu.config.ts\");\n}\n\nfunction triggerSelfRestart(event: string, filePath: string): void {\n  const relativePath = filePath.replace(Sonamu.apiRootPath, \"api\");\n  console.log(chalk.bold(`Detected(${event}): ${chalk.blue(relativePath)} - Restarting...`));\n  process.kill(process.pid, \"SIGUSR2\");\n}\n\n/**\n * 스코프 정의:\n * - api/src 안의 모든 변경은 스코프 안 (HMR 대상이 될 수 있으므로)\n * - api/src 밖이라면 checksumPatternGroup 패턴에 매칭되는 경로만 스코프 안\n *\n * 그 외(예: web/src/App.tsx 같은 target의 비추적 파일)는 스코프 밖이라 무시합니다.\n */\nfunction isOutOfScope(filePath: AbsolutePath): boolean {\n  const apiSrc = path.join(Sonamu.apiRootPath, \"src\");\n  if (filePath.startsWith(apiSrc)) {\n    return false;\n  }\n  const checkPatternGroup = getChecksumPatternGroupInAbsolutePath();\n  return !Object.values(checkPatternGroup).some((pattern) => minimatch(filePath, pattern));\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAkBA,eAAsB,aACpB,cACoB;CAIpB,MAAM,UAAU,MAAM,sBAAsB,GAAG;EAC7C,SAAS,4BAA4B,OAAO,SAAS,OAAO;EAC5D,YAAY;EACZ,eAAe;CACjB,CAAC;CAGD,MAAM,gBAAgB,uBAAyC;EAC7D,SAAS;EACT,SAAS,OAAO,eAAe;GAC7B,MAAM,8BAAc,IAAI,IAAoC;GAC5D,KAAK,MAAM,CAAC,GAAG,MAAM,YAKnB,IAAI,CAAE,MAAM,kBAAkB,CAAC,GAC7B,YAAY,IAAI,GAAG,CAAC;GAGxB,IAAI,YAAY,OAAO,GACrB,MAAM,aAAa,WAAW;EAElC;CACF,CAAC;CAED,QAAQ,GAAG,QAAQ,OAAe,aAAqB;EACrD,MAAM,eACuD;EAC7D,OACE,aAAa,WAAW,OAAO,WAAW,GAC1C,2CACF;EAEA,IAAI,CAAC,cAAc,KAAK,GACtB;EAGF,IAAI,eAAe,YAAY,GAAG;GAChC,mBAAmB,OAAO,QAAQ;GAClC;EACF;EAEA,IAAI,aAAa,YAAY,GAC3B;EAMF,cAAc,cAAc,KAAK;CACnC,CAAC;CAED,OAAO;AACT;AAEA,SAAS,wBAAwB;CAC/B,OAAO,CACL,KAAK,KAAK,OAAO,aAAa,KAAK,GACnC,GAAG,OAAO,OAAO,KAAK,QAAQ,KAAK,MAAM,KAAK,KAAK,OAAO,aAAa,GAAG,KAAK,CAAC,CAClF;AACF;;;;;;;;AASA,SAAS,4BAA4B,GAAG,mBAAmC;CACzE,MAAM,aAAa,QAEf,kBACA,SAAS,GAAG;CAEhB,QAAQ,GAAW,UAAkB,CAAC,CAAC,OAAO,OAAO,KAAK,CAAC,UAAU,KAAK,QAAQ,CAAC,CAAC;AACtF;AAEA,SAAS,cAAc,OAA0C;CAC/D,OAAO,UAAU,YAAY,UAAU;AACzC;AAEA,SAAS,eAAe,UAAiC;CACvD,OAAO,aAAa,KAAK,KAAK,OAAO,aAAa,OAAO,kBAAkB;AAC7E;AAEA,SAAS,mBAAmB,OAAe,UAAwB;CACjE,MAAM,eAAe,SAAS,QAAQ,OAAO,aAAa,KAAK;CAC/D,QAAQ,IAAI,MAAM,KAAK,YAAY,MAAM,KAAK,MAAM,KAAK,YAAY,EAAE,iBAAiB,CAAC;CACzF,QAAQ,KAAK,QAAQ,KAAK,SAAS;AACrC;;;;;;;;AASA,SAAS,aAAa,UAAiC;CACrD,MAAM,SAAS,KAAK,KAAK,OAAO,aAAa,KAAK;CAClD,IAAI,SAAS,WAAW,MAAM,GAC5B,OAAO;CAET,MAAM,oBAAoB,sCAAsC;CAChE,OAAO,CAAC,OAAO,OAAO,iBAAiB,CAAC,CAAC,MAAM,YAAY,UAAU,UAAU,OAAO,CAAC;AACzF;;;UA3H+B;oBAEyB;oBACe;oBACpB"}

package/dist/tasks/decorator.d.ts

@@ -1,18 +1,18 @@
 import { type RetryPolicy, type SchemaInput, type SchemaOutput, type StandardSchemaV1, type WorkflowSpec } from "@sonamu-kit/tasks/internal";
 import { type Executable } from "../types/types";
 import { type WorkflowFunction } from "./workflow-manager";
-export interface WorkflowMetadata {
+export interface WorkflowMetadata<RawInput = unknown, Input = unknown, Output = unknown> {
     type: "workflow";
     id: string;
     name: string;
     version: string | null;
-    schema: StandardSchemaV1<unknown, unknown> | undefined;
+    schema: StandardSchemaV1<RawInput, Input> | undefined;
     schedules: {
         name: string;
         expression: string;
-        input: Executable<SchemaInput<unknown, unknown> | undefined>;
+        input: Executable<RawInput | undefined>;
     }[];
-    fn: WorkflowFunction<unknown, unknown>;
+    fn: WorkflowFunction<Input, Output>;
     retryPolicy?: RetryPolicy;
 }
 export type DefineWorkflowOptions<Input, Output, TSchema extends StandardSchemaV1 | undefined = undefined> = Omit<WorkflowSpec<SchemaOutput<TSchema, Input>, Output, SchemaInput<TSchema, Input>>, "name"> & {
@@ -24,6 +24,6 @@ export type DefineWorkflowOptions<Input, Output, TSchema extends StandardSchemaV
     }[];
     retryPolicy?: RetryPolicy;
 };
-export declare function workflow<Input, Output, TSchema extends StandardSchemaV1 | undefined = undefined>(options: DefineWorkflowOptions<Input, Output, TSchema>): (fn: WorkflowFunction<SchemaOutput<TSchema, Input>, Output>) => WorkflowMetadata;
-export declare function workflow<Input, Output, TSchema extends StandardSchemaV1 | undefined = undefined>(options: DefineWorkflowOptions<Input, Output, TSchema>, fn: WorkflowFunction<SchemaOutput<TSchema, Input>, Output>): WorkflowMetadata;
+export declare function workflow<Input, Output, TSchema extends StandardSchemaV1 | undefined = undefined>(options: DefineWorkflowOptions<Input, Output, TSchema>): (fn: WorkflowFunction<SchemaOutput<TSchema, Input>, Output>) => WorkflowMetadata<SchemaInput<TSchema, Input>, SchemaOutput<TSchema, Input>, Output>;
+export declare function workflow<Input, Output, TSchema extends StandardSchemaV1 | undefined = undefined>(options: DefineWorkflowOptions<Input, Output, TSchema>, fn: WorkflowFunction<SchemaOutput<TSchema, Input>, Output>): WorkflowMetadata<SchemaInput<TSchema, Input>, SchemaOutput<TSchema, Input>, Output>;
 //# sourceMappingURL=decorator.d.ts.map

package/dist/tasks/decorator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decorator.d.ts","sourceRoot":"","sources":["../../src/tasks/decorator.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,YAAY,EAClB,MAAM,4BAA4B,CAAC;AAGpC,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAG3D,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,UAAU,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,MAAM,EAAE,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;IACvD,SAAS,EAAE;QACT,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC;QACnB,KAAK,EAAE,UAAU,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC,CAAC;KAC9D,EAAE,CAAC;IACJ,EAAE,EAAE,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IACvC,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAGD,MAAM,MAAM,qBAAqB,CAC/B,KAAK,EACL,MAAM,EACN,OAAO,SAAS,gBAAgB,GAAG,SAAS,GAAG,SAAS,IACtD,IAAI,CACN,YAAY,CAAC,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,EAC/E,MAAM,CACP,GAAG;IACF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE;QACV,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,CAAC;QACnB,KAAK,CAAC,EAAE,UAAU,CAAC,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,GAAG,SAAS,CAAC,CAAC;KAC7D,EAAE,CAAC;IACJ,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B,CAAC;AAIF,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,SAAS,gBAAgB,GAAG,SAAS,GAAG,SAAS,EAC9F,OAAO,EAAE,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,GACrD,CAAC,EAAE,EAAE,gBAAgB,CAAC,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,KAAK,gBAAgB,CAAC;AACpF,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,SAAS,gBAAgB,GAAG,SAAS,GAAG,SAAS,EAC9F,OAAO,EAAE,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EACtD,EAAE,EAAE,gBAAgB,CAAC,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,GACzD,gBAAgB,CAAC"}
+{"version":3,"file":"decorator.d.ts","sourceRoot":"","sources":["../../src/tasks/decorator.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,YAAY,EAClB,MAAM,4BAA4B,CAAC;AAGpC,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAG3D,MAAM,WAAW,gBAAgB,CAAC,QAAQ,GAAG,OAAO,EAAE,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,OAAO;IACrF,IAAI,EAAE,UAAU,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,MAAM,EAAE,gBAAgB,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG,SAAS,CAAC;IACtD,SAAS,EAAE;QACT,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC;QACnB,KAAK,EAAE,UAAU,CAAC,QAAQ,GAAG,SAAS,CAAC,CAAC;KACzC,EAAE,CAAC;IACJ,EAAE,EAAE,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACpC,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAGD,MAAM,MAAM,qBAAqB,CAC/B,KAAK,EACL,MAAM,EACN,OAAO,SAAS,gBAAgB,GAAG,SAAS,GAAG,SAAS,IACtD,IAAI,CACN,YAAY,CAAC,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,EAC/E,MAAM,CACP,GAAG;IACF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE;QACV,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,CAAC;QACnB,KAAK,CAAC,EAAE,UAAU,CAAC,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,GAAG,SAAS,CAAC,CAAC;KAC7D,EAAE,CAAC;IACJ,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B,CAAC;AAIF,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,SAAS,gBAAgB,GAAG,SAAS,GAAG,SAAS,EAC9F,OAAO,EAAE,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,GACrD,CACD,EAAE,EAAE,gBAAgB,CAAC,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,KACvD,gBAAgB,CAAC,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,CAAC;AACzF,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,SAAS,gBAAgB,GAAG,SAAS,GAAG,SAAS,EAC9F,OAAO,EAAE,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EACtD,EAAE,EAAE,gBAAgB,CAAC,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,GACzD,gBAAgB,CAAC,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,CAAC"}

package/dist/tasks/decorator.js

@@ -2,9 +2,9 @@ import inflection from "inflection";
 import { randomUUID } from "node:crypto";
 //#region src/tasks/decorator.ts
 function workflow(options, fn) {
-	const decorated = (fn) => {
+	const decorated = (workflowFunction) => {
 		const id = randomUUID();
-		const workflowName = options.name ?? inflection.underscore(fn.name);
+		const workflowName = options.name ?? inflection.underscore(workflowFunction.name);
 		return {
 			type: "workflow",
 			id,
@@ -18,7 +18,7 @@ function workflow(options, fn) {
 					input: schedule.input
 				};
 			}),
-			fn,
+			fn: workflowFunction,
 			retryPolicy: options.retryPolicy
 		};
 	};
@@ -28,4 +28,4 @@ function workflow(options, fn) {
 //#endregion
 export { workflow };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVjb3JhdG9yLmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90YXNrcy9kZWNvcmF0b3IudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgcmFuZG9tVVVJRCB9IGZyb20gXCJub2RlOmNyeXB0b1wiO1xuXG5pbXBvcnQge1xuICB0eXBlIFJldHJ5UG9saWN5LFxuICB0eXBlIFNjaGVtYUlucHV0LFxuICB0eXBlIFNjaGVtYU91dHB1dCxcbiAgdHlwZSBTdGFuZGFyZFNjaGVtYVYxLFxuICB0eXBlIFdvcmtmbG93U3BlYyxcbn0gZnJvbSBcIkBzb25hbXUta2l0L3Rhc2tzL2ludGVybmFsXCI7XG5pbXBvcnQgaW5mbGVjdGlvbiBmcm9tIFwiaW5mbGVjdGlvblwiO1xuXG5pbXBvcnQgeyB0eXBlIEV4ZWN1dGFibGUgfSBmcm9tIFwiLi4vdHlwZXMvdHlwZXNcIjtcbmltcG9ydCB7IHR5cGUgV29ya2Zsb3dGdW5jdGlvbiB9IGZyb20gXCIuL3dvcmtmbG93LW1hbmFnZXJcIjtcblxuLy8g7JuM7YGs7ZSM66Gc7Jqw7J2YIOuplO2DgOuNsOydtO2EsCDqsJ3ssrRcbmV4cG9ydCBpbnRlcmZhY2UgV29ya2Zsb3dNZXRhZGF0YSB7XG4gIHR5cGU6IFwid29ya2Zsb3dcIjtcbiAgaWQ6IHN0cmluZztcbiAgbmFtZTogc3RyaW5nO1xuICB2ZXJzaW9uOiBzdHJpbmcgfCBudWxsO1xuICBzY2hlbWE6IFN0YW5kYXJkU2NoZW1hVjE8dW5rbm93biwgdW5rbm93bj4gfCB1bmRlZmluZWQ7XG4gIHNjaGVkdWxlczoge1xuICAgIG5hbWU6IHN0cmluZztcbiAgICBleHByZXNzaW9uOiBzdHJpbmc7XG4gICAgaW5wdXQ6IEV4ZWN1dGFibGU8U2NoZW1hSW5wdXQ8dW5rbm93biwgdW5rbm93bj4gfCB1bmRlZmluZWQ+O1xuICB9W107XG4gIGZuOiBXb3JrZmxvd0Z1bmN0aW9uPHVua25vd24sIHVua25vd24+O1xuICByZXRyeVBvbGljeT86IFJldHJ5UG9saWN5O1xufVxuXG4vLyDsm4ztgaztlIzroZzsmrAg7KCV7J2YIOqzvOygleyXkOyEnOydmCDsmLXshZhcbmV4cG9ydCB0eXBlIERlZmluZVdvcmtmbG93T3B0aW9uczxcbiAgSW5wdXQsXG4gIE91dHB1dCxcbiAgVFNjaGVtYSBleHRlbmRzIFN0YW5kYXJkU2NoZW1hVjEgfCB1bmRlZmluZWQgPSB1bmRlZmluZWQsXG4+ID0gT21pdDxcbiAgV29ya2Zsb3dTcGVjPFNjaGVtYU91dHB1dDxUU2NoZW1hLCBJbnB1dD4sIE91dHB1dCwgU2NoZW1hSW5wdXQ8VFNjaGVtYSwgSW5wdXQ+PixcbiAgXCJuYW1lXCJcbj4gJiB7XG4gIG5hbWU/OiBzdHJpbmc7XG4gIHNjaGVkdWxlcz86IHtcbiAgICBuYW1lPzogc3RyaW5nO1xuICAgIGV4cHJlc3Npb246IHN0cmluZztcbiAgICBpbnB1dD86IEV4ZWN1dGFibGU8U2NoZW1hSW5wdXQ8VFNjaGVtYSwgSW5wdXQ+IHwgdW5kZWZpbmVkPjtcbiAgfVtdO1xuICByZXRyeVBvbGljeT86IFJldHJ5UG9saWN5O1xufTtcblxuLy8g7JuM7YGs7ZSM66Gc7JqwIOygleydmOulvCDsnITtlZwg642w7L2U66CI7J207YSwLFxuLy8g7J206rKD65Ok7J2AIHN5bmNlcuyXkOyEnCDtlZzrsojsl5AgbG9hZO2VnCDri6TsnYwsIFdvcmtmbG93TWFuYWdlcuyXkOyEnCBzeW5jaHJvbml6ZeulvCDthrXtlbQg65Ox66Gd65CoLlxuZXhwb3J0IGZ1bmN0aW9uIHdvcmtmbG93PElucHV0LCBPdXRwdXQsIFRTY2hlbWEgZXh0ZW5kcyBTdGFuZGFyZFNjaGVtYVYxIHwgdW5kZWZpbmVkID0gdW5kZWZpbmVkPihcbiAgb3B0aW9uczogRGVmaW5lV29ya2Zsb3dPcHRpb25zPElucHV0LCBPdXRwdXQsIFRTY2hlbWE+LFxuKTogKGZuOiBXb3JrZmxvd0Z1bmN0aW9uPFNjaGVtYU91dHB1dDxUU2NoZW1hLCBJbnB1dD4sIE91dHB1dD4pID0+IFdvcmtmbG93TWV0YWRhdGE7XG5leHBvcnQgZnVuY3Rpb24gd29ya2Zsb3c8SW5wdXQsIE91dHB1dCwgVFNjaGVtYSBleHRlbmRzIFN0YW5kYXJkU2NoZW1hVjEgfCB1bmRlZmluZWQgPSB1bmRlZmluZWQ+KFxuICBvcHRpb25zOiBEZWZpbmVXb3JrZmxvd09wdGlvbnM8SW5wdXQsIE91dHB1dCwgVFNjaGVtYT4sXG4gIGZuOiBXb3JrZmxvd0Z1bmN0aW9uPFNjaGVtYU91dHB1dDxUU2NoZW1hLCBJbnB1dD4sIE91dHB1dD4sXG4pOiBXb3JrZmxvd01ldGFkYXRhO1xuZXhwb3J0IGZ1bmN0aW9uIHdvcmtmbG93PElucHV0LCBPdXRwdXQsIFRTY2hlbWEgZXh0ZW5kcyBTdGFuZGFyZFNjaGVtYVYxIHwgdW5kZWZpbmVkID0gdW5kZWZpbmVkPihcbiAgb3B0aW9uczogRGVmaW5lV29ya2Zsb3dPcHRpb25zPElucHV0LCBPdXRwdXQsIFRTY2hlbWE+LFxuICBmbj86IFdvcmtmbG93RnVuY3Rpb248U2NoZW1hT3V0cHV0PFRTY2hlbWEsIElucHV0PiwgT3V0cHV0Pixcbik6XG4gIHwgV29ya2Zsb3dNZXRhZGF0YVxuICB8ICgoZm46IFdvcmtmbG93RnVuY3Rpb248U2NoZW1hT3V0cHV0PFRTY2hlbWEsIElucHV0PiwgT3V0cHV0PikgPT4gV29ya2Zsb3dNZXRhZGF0YSkge1xuICBjb25zdCBkZWNvcmF0ZWQgPSAoZm46IFdvcmtmbG93RnVuY3Rpb248U2NoZW1hT3V0cHV0PFRTY2hlbWEsIElucHV0PiwgT3V0cHV0PikgPT4ge1xuICAgIGNvbnN0IGlkID0gcmFuZG9tVVVJRCgpO1xuICAgIGNvbnN0IHdvcmtmbG93TmFtZSA9IG9wdGlvbnMubmFtZSA/PyBpbmZsZWN0aW9uLnVuZGVyc2NvcmUoZm4ubmFtZSk7XG5cbiAgICBjb25zdCBtZXRhZGF0YTogV29ya2Zsb3dNZXRhZGF0YSA9IHtcbiAgICAgIHR5cGU6IFwid29ya2Zsb3dcIiBhcyBjb25zdCxcbiAgICAgIGlkLFxuICAgICAgbmFtZTogd29ya2Zsb3dOYW1lLFxuICAgICAgc2NoZW1hOiBvcHRpb25zLnNjaGVtYSxcbiAgICAgIHZlcnNpb246IG9wdGlvbnMudmVyc2lvbiA/PyBudWxsLFxuICAgICAgc2NoZWR1bGVzOiAob3B0aW9ucy5zY2hlZHVsZXMgPz8gW10pLm1hcCgoc2NoZWR1bGUpID0+IHtcbiAgICAgICAgcmV0dXJuIHtcbiAgICAgICAgICBuYW1lOiBzY2hlZHVsZS5uYW1lID8/IGAke3dvcmtmbG93TmFtZX1bJHtzY2hlZHVsZS5leHByZXNzaW9ufV1gLFxuICAgICAgICAgIGV4cHJlc3Npb246IHNjaGVkdWxlLmV4cHJlc3Npb24sXG4gICAgICAgICAgaW5wdXQ6IHNjaGVkdWxlLmlucHV0LFxuICAgICAgICB9O1xuICAgICAgfSksXG4gICAgICBmbjogZm4gYXMgV29ya2Zsb3dGdW5jdGlvbjx1bmtub3duLCB1bmtub3duPixcbiAgICAgIHJldHJ5UG9saWN5OiBvcHRpb25zLnJldHJ5UG9saWN5LFxuICAgIH07XG5cbiAgICByZXR1cm4gbWV0YWRhdGE7XG4gIH07XG5cbiAgaWYgKCFmbikge1xuICAgIHJldHVybiBkZWNvcmF0ZWQ7XG4gIH1cblxuICByZXR1cm4gZGVjb3JhdGVkKGZuKTtcbn1cbiJdLCJtYXBwaW5ncyI6Ijs7O0FBeURBLFNBQWdCLFNBQ2QsU0FDQSxJQUdxRjtDQUNyRixNQUFNLGFBQWEsT0FBK0Q7RUFDaEYsTUFBTSxLQUFLLFdBQVc7RUFDdEIsTUFBTSxlQUFlLFFBQVEsUUFBUSxXQUFXLFdBQVcsR0FBRyxJQUFJO0VBbUJsRSxPQUFPO0dBaEJMLE1BQU07R0FDTjtHQUNBLE1BQU07R0FDTixRQUFRLFFBQVE7R0FDaEIsU0FBUyxRQUFRLFdBQVc7R0FDNUIsWUFBWSxRQUFRLGFBQWEsQ0FBQyxFQUFBLENBQUcsS0FBSyxhQUFhO0lBQ3JELE9BQU87S0FDTCxNQUFNLFNBQVMsUUFBUSxHQUFHLGFBQWEsR0FBRyxTQUFTLFdBQVc7S0FDOUQsWUFBWSxTQUFTO0tBQ3JCLE9BQU8sU0FBUztJQUNsQjtHQUNGLENBQUM7R0FDRztHQUNKLGFBQWEsUUFBUTtFQUdoQjtDQUNUO0NBRUEsSUFBSSxDQUFDLElBQ0gsT0FBTztDQUdULE9BQU8sVUFBVSxFQUFFO0FBQ3JCIn0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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