sonamu 0.9.19 → 0.10.0

package/dist/syncer/code-generator.js

@@ -1,4 +1,4 @@
-import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { __esmMin } from "../_virtual/_rolldown/runtime.js";
 import { SD, init_sd } from "../dict/sd.js";
 import { AlreadyProcessedException, init_so_exceptions } from "../exceptions/so-exceptions.js";
 import { init_controller, isTest } from "../utils/controller.js";
@@ -13,10 +13,9 @@ import { BUILT_IN_TYPES, init_zod_converter } from "../template/zod-converter.js
 import { init_lodash_able, wrapIf } from "../utils/lodash-able.js";
 import { init_file_tracking, trackWritten } from "./file-tracking.js";
 import { unique } from "radashi";
-import { mkdir, writeFile } from "fs/promises";
 import path from "path";
+import { mkdir, writeFile } from "fs/promises";
 import chalk from "chalk";
-
 //#region src/syncer/code-generator.ts
 /**
 * 템플릿을 렌더링하고 파일로 생성합니다.
@@ -37,24 +36,18 @@ async function generateTemplate(key, templateOptions, _generateOptions) {
 		generateOptions
 	});
 	const keys = [key];
-	const pathAndCodes = (await Promise.all(keys.map(async (key$1) => {
-		return await renderTemplate(key$1, templateOptions);
+	const pathAndCodes = (await Promise.all(keys.map(async (key) => {
+		return await renderTemplate(key, templateOptions);
 	}))).flat();
 	const filteredPathAndCodes = await (async () => {
-		if (generateOptions.overwrite) {
-			return pathAndCodes;
-		} else {
-			return await filterAsync(pathAndCodes, async (pathAndCode) => {
-				const { targets } = Sonamu.config.sync;
-				const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;
-				const dstFilePaths = targets.map((target) => filePath.replace("/:target/", `/${target}/`));
-				return await everyAsync(dstFilePaths, async (dstPath) => !await exists(dstPath));
-			});
-		}
+		if (generateOptions.overwrite) return pathAndCodes;
+		else return await filterAsync(pathAndCodes, async (pathAndCode) => {
+			const { targets } = Sonamu.config.sync;
+			const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;
+			return await everyAsync(targets.map((target) => filePath.replace("/:target/", `/${target}/`)), async (dstPath) => !await exists(dstPath));
+		});
 	})();
-	if (filteredPathAndCodes.length === 0) {
-		throw new AlreadyProcessedException(SD("sonamu.error.allFilesExist"));
-	}
+	if (filteredPathAndCodes.length === 0) throw new AlreadyProcessedException(SD("sonamu.error.allFilesExist"));
 	return (await Promise.all(filteredPathAndCodes.map((pathAndCode) => writeCodeToPathEachTarget(pathAndCode)))).flat();
 }
 /**
@@ -69,15 +62,12 @@ async function renderTemplate(key, options) {
 		key,
 		options
 	});
-	const template = TemplateManager.get(key);
-	const rendered = await template.render(options);
+	const rendered = await TemplateManager.get(key).render(options);
 	const resolved = await resolveRenderedTemplate(key, rendered);
 	let preTemplateResolved = [];
-	if (rendered.preTemplates) {
-		preTemplateResolved = (await Promise.all(rendered.preTemplates.map(({ key: key$1, options: options$1 }) => {
-			return renderTemplate(key$1, options$1);
-		}))).flat();
-	}
+	if (rendered.preTemplates) preTemplateResolved = (await Promise.all(rendered.preTemplates.map(({ key, options }) => {
+		return renderTemplate(key, options);
+	}))).flat();
 	return [resolved, ...preTemplateResolved];
 }
 async function resolveRenderedTemplate(key, result) {
@@ -95,33 +85,27 @@ async function resolveRenderedTemplate(key, result) {
 			throw new Error(`[resolveRenderedTemplate:${key}] ${importKey} 모듈 경로 찾기 실패: ${error}`, { cause: error });
 		}
 		let importPath = modulePath;
-		if (modulePath.includes("/") || modulePath.includes(".")) {
-			importPath = wrapIf(path.relative(path.dirname(filePath), modulePath), (p) => [!p.startsWith("."), `./${p}`]);
-		}
+		if (modulePath.includes("/") || modulePath.includes(".")) importPath = wrapIf(path.relative(path.dirname(filePath), modulePath), (p) => [!p.startsWith("."), `./${p}`]);
 		const existsOne = r.find((importDef) => importDef.from === importPath);
-		if (existsOne) {
-			existsOne.keys = unique(existsOne.keys.concat(importKey));
-		} else {
-			r.push({
-				keys: [importKey],
-				from: importPath
-			});
-		}
+		if (existsOne) existsOne.keys = unique(existsOne.keys.concat(importKey));
+		else r.push({
+			keys: [importKey],
+			from: importPath
+		});
 		return r;
 	}, []).filter((importDef) => !filePath.endsWith(`${importDef.from.replace("./", "")}.ts`));
 	const header = [...customHeaders ?? [], ...importDefs.map((importDef) => `import { ${importDef.keys.join(", ")} } from '${importDef.from}'`)].join("\n");
 	const formatted = await (async () => {
-		if (key === "generated_http") {
-			return [header, body].join("\n\n");
-		} else {
+		if (key === "generated_http") return [header, body].join("\n\n");
+		else {
 			Naite.t("resolveRenderedTemplate:beforeFormat", {
 				key,
 				header,
 				body
 			});
-			const formatted$1 = await formatCode([header, body].join("\n\n"), `${Sonamu.appRootPath}/${filePath}`);
-			Naite.t(`resolveRenderedTemplate:formatted:${key}`, formatted$1);
-			return formatted$1;
+			const formatted = await formatCode([header, body].join("\n\n"), `${Sonamu.appRootPath}/${filePath}`);
+			Naite.t(`resolveRenderedTemplate:formatted:${key}`, formatted);
+			return formatted;
 		}
 	})();
 	return {
@@ -136,9 +120,7 @@ async function writeCodeToPathEachTarget(pathAndCode) {
 	const dstFilePaths = unique(targets.map((target) => filePath.replace("/:target/", `/${target}/`)));
 	return await Promise.all(dstFilePaths.map(async (dstFilePath) => {
 		const dir = path.dirname(dstFilePath);
-		if (!await exists(dir)) {
-			await mkdir(dir, { recursive: true });
-		}
+		if (!await exists(dir)) await mkdir(dir, { recursive: true });
 		await writeFile(dstFilePath, pathAndCode.code);
 		await trackWritten(dstFilePath);
 		!isTest() && console.log(chalk.bold("Generated: ") + chalk.blue(`${dstFilePath.replace(`${appRootPath}/`, "")}`));
@@ -160,8 +142,8 @@ var init_code_generator = __esmMin((() => {
 	init_lodash_able();
 	init_file_tracking();
 }));
-
 //#endregion
 init_code_generator();
 export { generateTemplate, init_code_generator, renderTemplate };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"code-generator.js","names":["keys: TemplateKey[]","key","filteredPathAndCodes: PathAndCode[]","preTemplateResolved: PathAndCode[]","options","formatted"],"sources":["../../src/syncer/code-generator.ts"],"sourcesContent":["import { mkdir, writeFile } from \"fs/promises\";\nimport path from \"path\";\n\nimport chalk from \"chalk\";\nimport { unique } from \"radashi\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport { SD } from \"../dict/sd\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { AlreadyProcessedException } from \"../exceptions/so-exceptions\";\nimport { Naite } from \"../naite/naite\";\nimport { type RenderedTemplate } from \"../template/template\";\nimport { TemplateManager } from \"../template/template-manager\";\nimport { BUILT_IN_TYPES } from \"../template/zod-converter\";\nimport {\n  type GenerateOptions,\n  type PathAndCode,\n  type TemplateKey,\n  type TemplateOptions,\n} from \"../types/types\";\nimport { everyAsync, filterAsync } from \"../utils/async-utils\";\nimport { isTest } from \"../utils/controller\";\nimport { formatCode } from \"../utils/formatter\";\nimport { exists } from \"../utils/fs-utils\";\nimport { wrapIf } from \"../utils/lodash-able\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\nimport { trackWritten } from \"./file-tracking\";\n\n/**\n * 템플릿을 렌더링하고 파일로 생성합니다.\n * overwrite 옵션이 false인 경우, 이미 존재하는 파일은 건너뜁니다.\n * @param key - 템플릿 키 (예: \"entity\", \"model\", \"service\" 등)\n * @param templateOptions - 템플릿 렌더링에 필요한 옵션\n * @param _generateOptions - 생성 옵션 (overwrite 여부)\n * @returns 생성된 파일 경로 배열\n */\nexport async function generateTemplate<T extends TemplateKey>(\n  key: T,\n  templateOptions: TemplateOptions[T],\n  _generateOptions?: GenerateOptions,\n): Promise<AbsolutePath[]> {\n  const generateOptions = {\n    overwrite: false,\n    ..._generateOptions,\n  };\n  Naite.t(\"generateTemplate\", { key, templateOptions, generateOptions });\n\n  // 키 children\n  const keys: TemplateKey[] = [key];\n\n  // 템플릿 렌더\n  const pathAndCodes = (\n    await Promise.all(\n      keys.map(async (key) => {\n        return await renderTemplate(key, templateOptions);\n      }),\n    )\n  ).flat();\n\n  const filteredPathAndCodes: PathAndCode[] = await (async () => {\n    if (generateOptions.overwrite) {\n      return pathAndCodes;\n    } else {\n      return await filterAsync(pathAndCodes, async (pathAndCode) => {\n        const { targets } = Sonamu.config.sync;\n        const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;\n        const dstFilePaths = targets.map((target) => filePath.replace(\"/:target/\", `/${target}/`));\n        return await everyAsync(dstFilePaths, async (dstPath) => !(await exists(dstPath)));\n      });\n    }\n  })();\n\n  if (filteredPathAndCodes.length === 0) {\n    throw new AlreadyProcessedException(SD(\"sonamu.error.allFilesExist\"));\n  }\n\n  return (\n    await Promise.all(\n      filteredPathAndCodes.map((pathAndCode) => writeCodeToPathEachTarget(pathAndCode)),\n    )\n  ).flat();\n}\n\n/**\n * 템플릿을 렌더링하여 PathAndCode 객체를 반환합니다.\n * 파일로 쓰지 않고 메모리상에서만 렌더링합니다.\n * @param key - 템플릿 키\n * @param options - 템플릿 렌더링 옵션\n * @returns 경로와 코드 쌍의 배열\n */\nexport async function renderTemplate<T extends keyof TemplateOptions>(\n  key: T,\n  options: TemplateOptions[T],\n): Promise<PathAndCode[]> {\n  Naite.t(\"renderTemplate\", { key, options });\n\n  const template = TemplateManager.get(key);\n\n  const rendered = await template.render(options);\n  const resolved = await resolveRenderedTemplate(key, rendered);\n\n  let preTemplateResolved: PathAndCode[] = [];\n  if (rendered.preTemplates) {\n    preTemplateResolved = (\n      await Promise.all(\n        rendered.preTemplates.map(({ key, options }) => {\n          return renderTemplate(key, options);\n        }),\n      )\n    ).flat();\n  }\n\n  return [resolved, ...preTemplateResolved];\n}\n\nasync function resolveRenderedTemplate(\n  key: TemplateKey,\n  result: RenderedTemplate,\n): Promise<PathAndCode> {\n  Naite.t(`resolveRenderedTemplate${key}`, { key, result });\n\n  const { target, path: filePath, body, importKeys, customHeaders } = result;\n\n  // import 할 대상의 대상 path 추출\n  const builtInSchemaNames = Object.values(BUILT_IN_TYPES).map((info) => info.schemaName as string);\n  const importDefs = importKeys\n    // 내장 타입 스키마는 이미 sonamu에서 import되므로 제외\n    .filter((importKey) => !builtInSchemaNames.includes(importKey))\n    .reduce(\n      (r, importKey) => {\n        let modulePath = importKey;\n        try {\n          modulePath = EntityManager.getModulePath(importKey);\n        } catch (error) {\n          throw new Error(\n            `[resolveRenderedTemplate:${key}] ${importKey} 모듈 경로 찾기 실패: ${error}`,\n            { cause: error },\n          );\n        }\n        let importPath = modulePath;\n        if (modulePath.includes(\"/\") || modulePath.includes(\".\")) {\n          importPath = wrapIf(path.relative(path.dirname(filePath), modulePath), (p) => [\n            !p.startsWith(\".\"),\n            `./${p}`,\n          ]);\n        }\n\n        // 같은 파일에서 import 하는 경우 keys 로 나열 처리\n        const existsOne = r.find((importDef) => importDef.from === importPath);\n        if (existsOne) {\n          existsOne.keys = unique(existsOne.keys.concat(importKey));\n        } else {\n          r.push({\n            keys: [importKey],\n            from: importPath,\n          });\n        }\n        return r;\n      },\n      [] as {\n        keys: string[];\n        from: string;\n      }[],\n    )\n    // 셀프 참조 방지\n    .filter((importDef) => !filePath.endsWith(`${importDef.from.replace(\"./\", \"\")}.ts`));\n\n  // 커스텀 헤더 포함하여 헤더 생성\n  const header = [\n    ...(customHeaders ?? []),\n    ...importDefs.map(\n      (importDef) => `import { ${importDef.keys.join(\", \")} } from '${importDef.from}'`,\n    ),\n  ].join(\"\\n\");\n\n  const formatted = await (async () => {\n    if (key === \"generated_http\") {\n      return [header, body].join(\"\\n\\n\");\n    } else {\n      Naite.t(\"resolveRenderedTemplate:beforeFormat\", { key, header, body });\n      const formatted = await formatCode(\n        [header, body].join(\"\\n\\n\"),\n        `${Sonamu.appRootPath}/${filePath}`,\n      );\n      Naite.t(`resolveRenderedTemplate:formatted:${key}`, formatted);\n      return formatted;\n    }\n  })();\n\n  return {\n    path: `${target}/${filePath}`,\n    code: formatted,\n  };\n}\n\nasync function writeCodeToPathEachTarget(pathAndCode: PathAndCode): Promise<AbsolutePath[]> {\n  const { targets } = Sonamu.config.sync;\n  const { appRootPath } = Sonamu;\n  const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}` as AbsolutePath;\n\n  const dstFilePaths = unique(\n    targets.map((target) => filePath.replace(\"/:target/\", `/${target}/`)) as AbsolutePath[],\n  );\n  return await Promise.all(\n    dstFilePaths.map(async (dstFilePath) => {\n      const dir = path.dirname(dstFilePath);\n      if (!(await exists(dir))) {\n        await mkdir(dir, { recursive: true });\n      }\n      await writeFile(dstFilePath, pathAndCode.code);\n      // 방금 우리가 쓴 path를 등록 → dev watcher의 후속 change 이벤트가\n      // 외부 변경으로 오인되지 않도록 거름 가드 자료 제공.\n      await trackWritten(dstFilePath);\n      !isTest() &&\n        console.log(\n          chalk.bold(\"Generated: \") + chalk.blue(`${dstFilePath.replace(`${appRootPath}/`, \"\")}`),\n        );\n      return dstFilePath;\n    }),\n  );\n}\n"],"mappings":"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"}
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"code-generator.js","names":[],"sources":["../../src/syncer/code-generator.ts"],"sourcesContent":["import { mkdir, writeFile } from \"fs/promises\";\nimport path from \"path\";\n\nimport chalk from \"chalk\";\nimport { unique } from \"radashi\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport { SD } from \"../dict/sd\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { AlreadyProcessedException } from \"../exceptions/so-exceptions\";\nimport { Naite } from \"../naite/naite\";\nimport { type RenderedTemplate } from \"../template/template\";\nimport { TemplateManager } from \"../template/template-manager\";\nimport { BUILT_IN_TYPES } from \"../template/zod-converter\";\nimport {\n  type GenerateOptions,\n  type PathAndCode,\n  type TemplateKey,\n  type TemplateOptions,\n} from \"../types/types\";\nimport { everyAsync, filterAsync } from \"../utils/async-utils\";\nimport { isTest } from \"../utils/controller\";\nimport { formatCode } from \"../utils/formatter\";\nimport { exists } from \"../utils/fs-utils\";\nimport { wrapIf } from \"../utils/lodash-able\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\nimport { trackWritten } from \"./file-tracking\";\n\n/**\n * 템플릿을 렌더링하고 파일로 생성합니다.\n * overwrite 옵션이 false인 경우, 이미 존재하는 파일은 건너뜁니다.\n * @param key - 템플릿 키 (예: \"entity\", \"model\", \"service\" 등)\n * @param templateOptions - 템플릿 렌더링에 필요한 옵션\n * @param _generateOptions - 생성 옵션 (overwrite 여부)\n * @returns 생성된 파일 경로 배열\n */\nexport async function generateTemplate<T extends TemplateKey>(\n  key: T,\n  templateOptions: TemplateOptions[T],\n  _generateOptions?: GenerateOptions,\n): Promise<AbsolutePath[]> {\n  const generateOptions = {\n    overwrite: false,\n    ..._generateOptions,\n  };\n  Naite.t(\"generateTemplate\", { key, templateOptions, generateOptions });\n\n  // 키 children\n  const keys: TemplateKey[] = [key];\n\n  // 템플릿 렌더\n  const pathAndCodes = (\n    await Promise.all(\n      keys.map(async (key) => {\n        return await renderTemplate(key, templateOptions);\n      }),\n    )\n  ).flat();\n\n  const filteredPathAndCodes: PathAndCode[] = await (async () => {\n    if (generateOptions.overwrite) {\n      return pathAndCodes;\n    } else {\n      return await filterAsync(pathAndCodes, async (pathAndCode) => {\n        const { targets } = Sonamu.config.sync;\n        const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;\n        const dstFilePaths = targets.map((target) => filePath.replace(\"/:target/\", `/${target}/`));\n        return await everyAsync(dstFilePaths, async (dstPath) => !(await exists(dstPath)));\n      });\n    }\n  })();\n\n  if (filteredPathAndCodes.length === 0) {\n    throw new AlreadyProcessedException(SD(\"sonamu.error.allFilesExist\"));\n  }\n\n  return (\n    await Promise.all(\n      filteredPathAndCodes.map((pathAndCode) => writeCodeToPathEachTarget(pathAndCode)),\n    )\n  ).flat();\n}\n\n/**\n * 템플릿을 렌더링하여 PathAndCode 객체를 반환합니다.\n * 파일로 쓰지 않고 메모리상에서만 렌더링합니다.\n * @param key - 템플릿 키\n * @param options - 템플릿 렌더링 옵션\n * @returns 경로와 코드 쌍의 배열\n */\nexport async function renderTemplate<T extends keyof TemplateOptions>(\n  key: T,\n  options: TemplateOptions[T],\n): Promise<PathAndCode[]> {\n  Naite.t(\"renderTemplate\", { key, options });\n\n  const template = TemplateManager.get(key);\n\n  const rendered = await template.render(options);\n  const resolved = await resolveRenderedTemplate(key, rendered);\n\n  let preTemplateResolved: PathAndCode[] = [];\n  if (rendered.preTemplates) {\n    preTemplateResolved = (\n      await Promise.all(\n        rendered.preTemplates.map(({ key, options }) => {\n          return renderTemplate(key, options);\n        }),\n      )\n    ).flat();\n  }\n\n  return [resolved, ...preTemplateResolved];\n}\n\nasync function resolveRenderedTemplate(\n  key: TemplateKey,\n  result: RenderedTemplate,\n): Promise<PathAndCode> {\n  Naite.t(`resolveRenderedTemplate${key}`, { key, result });\n\n  const { target, path: filePath, body, importKeys, customHeaders } = result;\n\n  // import 할 대상의 대상 path 추출\n  const builtInSchemaNames = Object.values(BUILT_IN_TYPES).map((info) => info.schemaName as string);\n  const importDefs = importKeys\n    // 내장 타입 스키마는 이미 sonamu에서 import되므로 제외\n    .filter((importKey) => !builtInSchemaNames.includes(importKey))\n    .reduce(\n      (r, importKey) => {\n        let modulePath = importKey;\n        try {\n          modulePath = EntityManager.getModulePath(importKey);\n        } catch (error) {\n          throw new Error(\n            `[resolveRenderedTemplate:${key}] ${importKey} 모듈 경로 찾기 실패: ${error}`,\n            { cause: error },\n          );\n        }\n        let importPath = modulePath;\n        if (modulePath.includes(\"/\") || modulePath.includes(\".\")) {\n          importPath = wrapIf(path.relative(path.dirname(filePath), modulePath), (p) => [\n            !p.startsWith(\".\"),\n            `./${p}`,\n          ]);\n        }\n\n        // 같은 파일에서 import 하는 경우 keys 로 나열 처리\n        const existsOne = r.find((importDef) => importDef.from === importPath);\n        if (existsOne) {\n          existsOne.keys = unique(existsOne.keys.concat(importKey));\n        } else {\n          r.push({\n            keys: [importKey],\n            from: importPath,\n          });\n        }\n        return r;\n      },\n      [] as {\n        keys: string[];\n        from: string;\n      }[],\n    )\n    // 셀프 참조 방지\n    .filter((importDef) => !filePath.endsWith(`${importDef.from.replace(\"./\", \"\")}.ts`));\n\n  // 커스텀 헤더 포함하여 헤더 생성\n  const header = [\n    ...(customHeaders ?? []),\n    ...importDefs.map(\n      (importDef) => `import { ${importDef.keys.join(\", \")} } from '${importDef.from}'`,\n    ),\n  ].join(\"\\n\");\n\n  const formatted = await (async () => {\n    if (key === \"generated_http\") {\n      return [header, body].join(\"\\n\\n\");\n    } else {\n      Naite.t(\"resolveRenderedTemplate:beforeFormat\", { key, header, body });\n      const formatted = await formatCode(\n        [header, body].join(\"\\n\\n\"),\n        `${Sonamu.appRootPath}/${filePath}`,\n      );\n      Naite.t(`resolveRenderedTemplate:formatted:${key}`, formatted);\n      return formatted;\n    }\n  })();\n\n  return {\n    path: `${target}/${filePath}`,\n    code: formatted,\n  };\n}\n\nasync function writeCodeToPathEachTarget(pathAndCode: PathAndCode): Promise<AbsolutePath[]> {\n  const { targets } = Sonamu.config.sync;\n  const { appRootPath } = Sonamu;\n  const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}` as AbsolutePath;\n\n  const dstFilePaths = unique(\n    targets.map((target) => filePath.replace(\"/:target/\", `/${target}/`)) as AbsolutePath[],\n  );\n  return await Promise.all(\n    dstFilePaths.map(async (dstFilePath) => {\n      const dir = path.dirname(dstFilePath);\n      if (!(await exists(dir))) {\n        await mkdir(dir, { recursive: true });\n      }\n      await writeFile(dstFilePath, pathAndCode.code);\n      // 방금 우리가 쓴 path를 등록 → dev watcher의 후속 change 이벤트가\n      // 외부 변경으로 오인되지 않도록 거름 가드 자료 제공.\n      await trackWritten(dstFilePath);\n      !isTest() &&\n        console.log(\n          chalk.bold(\"Generated: \") + chalk.blue(`${dstFilePath.replace(`${appRootPath}/`, \"\")}`),\n        );\n      return dstFilePath;\n    }),\n  );\n}\n"],"mappings":"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"}

package/dist/syncer/entity-operations.js

@@ -1,4 +1,4 @@
-import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { __esmMin } from "../_virtual/_rolldown/runtime.js";
 import { SD, init_sd } from "../dict/sd.js";
 import { BadRequestException, init_so_exceptions } from "../exceptions/so-exceptions.js";
 import { init_controller, isTest } from "../utils/controller.js";
@@ -8,16 +8,13 @@ import { EntityManager, init_entity_manager } from "../entity/entity-manager.js"
 import { generateTemplate, init_code_generator } from "./code-generator.js";
 import { rm } from "fs/promises";
 import chalk from "chalk";
-
 //#region src/syncer/entity-operations.ts
 /**
 * 새로운 엔티티를 생성합니다.
 * entityId는 반드시 CamelCase 형식이어야 합니다.
 */
 async function createEntity(form) {
-	if (!/^[A-Z][a-zA-Z0-9]*$/.test(form.entityId)) {
-		throw new BadRequestException(SD("sonamu.error.entityIdCamelCase"));
-	}
+	if (!/^[A-Z][a-zA-Z0-9]*$/.test(form.entityId)) throw new BadRequestException(SD("sonamu.error.entityIdCamelCase"));
 	await generateTemplate("entity", form);
 	await EntityManager.reload();
 }
@@ -29,27 +26,20 @@ async function createEntity(form) {
 async function delEntity(entityId) {
 	const entity = EntityManager.get(entityId);
 	const delPaths = (() => {
-		if (entity.parentId) {
-			return [`${Sonamu.apiRootPath}/src/application/${entity.names.parentFs}/${entity.names.fs}.entity.json`];
-		} else {
-			return [
-				`${Sonamu.apiRootPath}/src/application/${entity.names.fs}`,
-				`${Sonamu.apiRootPath}/dist/application/${entity.names.fs}`,
-				...Sonamu.config.sync.targets.flatMap((target) => [`${Sonamu.appRootPath}/${target}/src/services/${entity.names.fs}`])
-			];
-		}
+		if (entity.parentId) return [`${Sonamu.apiRootPath}/src/application/${entity.names.parentFs}/${entity.names.fs}.entity.json`];
+		else return [
+			`${Sonamu.apiRootPath}/src/application/${entity.names.fs}`,
+			`${Sonamu.apiRootPath}/dist/application/${entity.names.fs}`,
+			...Sonamu.config.sync.targets.flatMap((target) => [`${Sonamu.appRootPath}/${target}/src/services/${entity.names.fs}`])
+		];
 	})();
-	for (const delPath of delPaths) {
-		if (await exists(delPath)) {
-			!isTest() && console.log(chalk.red(`DELETE ${delPath}`));
-			await rm(delPath, {
-				recursive: true,
-				force: true
-			});
-		} else {
-			!isTest() && console.log(chalk.yellow(`NOT_EXISTS ${delPath}`));
-		}
-	}
+	for (const delPath of delPaths) if (await exists(delPath)) {
+		!isTest() && console.log(chalk.red(`DELETE ${delPath}`));
+		await rm(delPath, {
+			recursive: true,
+			force: true
+		});
+	} else !isTest() && console.log(chalk.yellow(`NOT_EXISTS ${delPath}`));
 	await EntityManager.reload();
 	return { delPaths };
 }
@@ -62,8 +52,8 @@ var init_entity_operations = __esmMin((() => {
 	init_fs_utils();
 	init_code_generator();
 }));
-
 //#endregion
 init_entity_operations();
 export { createEntity, delEntity, init_entity_operations };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/syncer/event-batcher.js

@@ -1,5 +1,4 @@
-import { __esmMin } from "../_virtual/rolldown_runtime.js";
-
+import { __esmMin } from "../_virtual/_rolldown/runtime.js";
 //#region src/syncer/event-batcher.ts
 /**
 * 파일 변경 이벤트를 batch로 모아 한 번에 처리하는 throttler를 만듭니다.
@@ -24,22 +23,18 @@ import { __esmMin } from "../_virtual/rolldown_runtime.js";
 */
 function createFileEventBatcher(options) {
 	const { delayMs, onFlush } = options;
-	const pending = new Map();
+	const pending = /* @__PURE__ */ new Map();
 	let flushTimer = null;
 	let isFlushing = false;
 	const scheduleFlush = () => {
-		if (flushTimer !== null) {
-			clearTimeout(flushTimer);
-		}
+		if (flushTimer !== null) clearTimeout(flushTimer);
 		flushTimer = setTimeout(() => {
 			flushTimer = null;
-			void runFlush();
+			runFlush();
 		}, delayMs);
 	};
 	const runFlush = async () => {
-		if (isFlushing || pending.size === 0) {
-			return;
-		}
+		if (isFlushing || pending.size === 0) return;
 		isFlushing = true;
 		try {
 			const batch = new Map(pending);
@@ -51,9 +46,7 @@ function createFileEventBatcher(options) {
 			}
 		} finally {
 			isFlushing = false;
-			if (pending.size > 0) {
-				scheduleFlush();
-			}
+			if (pending.size > 0) scheduleFlush();
 		}
 	};
 	return (path, event) => {
@@ -62,8 +55,8 @@ function createFileEventBatcher(options) {
 	};
 }
 var init_event_batcher = __esmMin((() => {}));
-
 //#endregion
 init_event_batcher();
 export { createFileEventBatcher, init_event_batcher };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnQtYmF0Y2hlci5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi9zcmMvc3luY2VyL2V2ZW50LWJhdGNoZXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgdHlwZSBBYnNvbHV0ZVBhdGggfSBmcm9tIFwiLi4vdXRpbHMvcGF0aC11dGlsc1wiO1xuXG4vKipcbiAqIO2MjOydvCDrs4Dqsr0g7J2067Kk7Yq466W8IGJhdGNo66GcIOuqqOyVhCDtlZwg67KI7JeQIOyymOumrO2VmOuKlCB0aHJvdHRsZXLrpbwg66eM65Ot64uI64ukLlxuICpcbiAqIOuPmeyekTpcbiAqIC0g6rCZ7J2AIHBhdGjqsIAg7Jes65+sIOuyiCBwdXNo65CY66m0IOuniOyngOuniSBldmVudOuhnCBkZWR1cGXrkKnri4jri6QuXG4gKiAtIOuniOyngOuniSBwdXNoIO2bhCBgZGVsYXlNc2Ag64+Z7JWIIOy2lOqwgCBwdXNo6rCAIOyXhuycvOuptCDtlZwg67KI7JeQIGZsdXNo65Cp64uI64ukICh0cmFpbGluZyBkZWJvdW5jZSkuXG4gKiAtIGZsdXNoIOuPhOykkSDrk6TslrTsmKTripQgcHVzaOuKlCDri6TsnYwgYmF0Y2jroZwg7YGQ7J6J65Cp64uI64ukLlxuICogLSDtlZwg7Iuc7KCQ7JeQIG9uRmx1c2jripQg64uoIO2VmOuCmOunjCDsp4TtlonrkKnri4jri6Qg4oCUIOydtOuhnOyNqCBvbkZsdXNoIOuCtOu2gOyXkOyEnCDsnbzslrTrgpjripRcbiAqICAg7J6R7JeF7J20IOuLpOuluCBvbkZsdXNoIO2YuOy2nOqzvCDsnbjthLDrpqzruIzrkJjsp4Ag7JWK7J2M7J2EIOuztOyepe2VqeuLiOuLpC5cbiAqXG4gKiDtmLjstpzsnpDripQgcHVzaOunjCDtlZjrqbQg65Cp64uI64ukLiDrgrTrtoAg7YGQL+2DgOydtOuouCDsg4Htg5zripQg7Lqh7IqQ7ZmU65CY7Ja0IOyeiOqzoCwgb25GbHVzaOqwgFxuICog67Cb64qUIGZpbGVFdmVudHPripQgZGVkdXBl65CcIE1hcOyeheuLiOuLpC5cbiAqXG4gKiBAZXhhbXBsZVxuICogY29uc3QgcHVzaCA9IGNyZWF0ZUZpbGVFdmVudEJhdGNoZXIoe1xuICogICBkZWxheU1zOiAxMDAsXG4gKiAgIG9uRmx1c2g6IChmaWxlRXZlbnRzKSA9PiBoYW5kbGVCYXRjaChmaWxlRXZlbnRzKSxcbiAqIH0pO1xuICogcHVzaChcIi9wYXRoL2EudHNcIiBhcyBBYnNvbHV0ZVBhdGgsIFwiY2hhbmdlXCIpO1xuICogcHVzaChcIi9wYXRoL2IudHNcIiBhcyBBYnNvbHV0ZVBhdGgsIFwiY2hhbmdlXCIpOyAvLyAxMDBtcyDtm4Qg65GYIOuLpCDtlZwg67KI7JeQIG9uRmx1c2jroZxcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNyZWF0ZUZpbGVFdmVudEJhdGNoZXI8RmlsZUV2ZW50VCBleHRlbmRzIHN0cmluZz4ob3B0aW9uczoge1xuICBkZWxheU1zOiBudW1iZXI7XG4gIG9uRmx1c2g6IChmaWxlRXZlbnRzOiBNYXA8QWJzb2x1dGVQYXRoLCBGaWxlRXZlbnRUPikgPT4gUHJvbWlzZTx2b2lkPjtcbn0pOiAocGF0aDogQWJzb2x1dGVQYXRoLCBldmVudDogRmlsZUV2ZW50VCkgPT4gdm9pZCB7XG4gIGNvbnN0IHsgZGVsYXlNcywgb25GbHVzaCB9ID0gb3B0aW9ucztcbiAgY29uc3QgcGVuZGluZyA9IG5ldyBNYXA8QWJzb2x1dGVQYXRoLCBGaWxlRXZlbnRUPigpO1xuICBsZXQgZmx1c2hUaW1lcjogTm9kZUpTLlRpbWVvdXQgfCBudWxsID0gbnVsbDtcbiAgbGV0IGlzRmx1c2hpbmcgPSBmYWxzZTtcblxuICBjb25zdCBzY2hlZHVsZUZsdXNoID0gKCk6IHZvaWQgPT4ge1xuICAgIGlmIChmbHVzaFRpbWVyICE9PSBudWxsKSB7XG4gICAgICBjbGVhclRpbWVvdXQoZmx1c2hUaW1lcik7XG4gICAgfVxuICAgIGZsdXNoVGltZXIgPSBzZXRUaW1lb3V0KCgpID0+IHtcbiAgICAgIGZsdXNoVGltZXIgPSBudWxsO1xuICAgICAgdm9pZCBydW5GbHVzaCgpO1xuICAgIH0sIGRlbGF5TXMpO1xuICB9O1xuXG4gIGNvbnN0IHJ1bkZsdXNoID0gYXN5bmMgKCk6IFByb21pc2U8dm9pZD4gPT4ge1xuICAgIC8vIGZsdXNoIOuPhOykkSDstpTqsIAgcHVzaOuhnCDrmJAg64uk66W4IHJ1bkZsdXNo6rCAIO2KuOumrOqxsOuQnCDqsr3smrAsIO2VnCDrsojsl5Ag7ZWY64KY66eMIOynhO2WieuQmOqyjCDtlanri4jri6QuXG4gICAgLy8g7KeE7ZaJIOykkeyduCBmbHVzaOqwgCDrgZ3rgpjrqbQgZmluYWxseeyXkOyEnCDri6TsnYwgYmF0Y2jrpbwg7J6Q64+Z7Jy866GcIOuLpOyLnCDsiqTsvIDspITtlanri4jri6QuXG4gICAgaWYgKGlzRmx1c2hpbmcgfHwgcGVuZGluZy5zaXplID09PSAwKSB7XG4gICAgICByZXR1cm47XG4gICAgfVxuICAgIGlzRmx1c2hpbmcgPSB0cnVlO1xuICAgIHRyeSB7XG4gICAgICAvLyDtmITsnqzquYzsp4Ag66qo7J24IOuzgOqyveydhCBzbmFwc2hvdOycvOuhnCDsnqHqs6Ag7YGQ64qUIOu5hOybgeuLiOuLpC5cbiAgICAgIC8vIOydtCBiYXRjaOqwgCDsspjrpqzrkJjripQg64+Z7JWIIOuTpOyWtOyYpOuKlCDsg4gg67OA6rK97J2AIOuLpOydjCBiYXRjaOuhnCDrqqjsnoXri4jri6QuXG4gICAgICBjb25zdCBiYXRjaCA9IG5ldyBNYXAocGVuZGluZyk7XG4gICAgICBwZW5kaW5nLmNsZWFyKCk7XG4gICAgICB0cnkge1xuICAgICAgICBhd2FpdCBvbkZsdXNoKGJhdGNoKTtcbiAgICAgIH0gY2F0Y2ggKGUpIHtcbiAgICAgICAgY29uc29sZS5lcnJvcihlKTtcbiAgICAgIH1cbiAgICB9IGZpbmFsbHkge1xuICAgICAgaXNGbHVzaGluZyA9IGZhbHNlO1xuICAgICAgaWYgKHBlbmRpbmcuc2l6ZSA+IDApIHtcbiAgICAgICAgc2NoZWR1bGVGbHVzaCgpO1xuICAgICAgfVxuICAgIH1cbiAgfTtcblxuICByZXR1cm4gKHBhdGgsIGV2ZW50KSA9PiB7XG4gICAgcGVuZGluZy5zZXQocGF0aCwgZXZlbnQpO1xuICAgIHNjaGVkdWxlRmx1c2goKTtcbiAgfTtcbn1cbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUF1QkEsU0FBZ0IsdUJBQWtELFNBR2Q7Q0FDbEQsTUFBTSxFQUFFLFNBQVMsWUFBWTtDQUM3QixNQUFNLDBCQUFVLElBQUksSUFBOEI7Q0FDbEQsSUFBSSxhQUFvQztDQUN4QyxJQUFJLGFBQWE7Q0FFakIsTUFBTSxzQkFBNEI7RUFDaEMsSUFBSSxlQUFlLE1BQ2pCLGFBQWEsVUFBVTtFQUV6QixhQUFhLGlCQUFpQjtHQUM1QixhQUFhO0dBQ2IsQUFBSyxTQUFTO0VBQ2hCLEdBQUcsT0FBTztDQUNaO0NBRUEsTUFBTSxXQUFXLFlBQTJCO0VBRzFDLElBQUksY0FBYyxRQUFRLFNBQVMsR0FDakM7RUFFRixhQUFhO0VBQ2IsSUFBSTtHQUdGLE1BQU0sUUFBUSxJQUFJLElBQUksT0FBTztHQUM3QixRQUFRLE1BQU07R0FDZCxJQUFJO0lBQ0YsTUFBTSxRQUFRLEtBQUs7R0FDckIsU0FBUyxHQUFHO0lBQ1YsUUFBUSxNQUFNLENBQUM7R0FDakI7RUFDRixVQUFVO0dBQ1IsYUFBYTtHQUNiLElBQUksUUFBUSxPQUFPLEdBQ2pCLGNBQWM7RUFFbEI7Q0FDRjtDQUVBLFFBQVEsTUFBTSxVQUFVO0VBQ3RCLFFBQVEsSUFBSSxNQUFNLEtBQUs7RUFDdkIsY0FBYztDQUNoQjtBQUNGIn0=

package/dist/syncer/file-patterns.js

@@ -1,7 +1,6 @@
-import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { __esmMin } from "../_virtual/_rolldown/runtime.js";
 import { Sonamu, init_sonamu } from "../api/sonamu.js";
 import path from "path";
-
 //#region src/syncer/file-patterns.ts
 /**
 * Syncer가 관심 가지고 지켜보는 파일들입니다.
@@ -83,8 +82,8 @@ var init_file_patterns = __esmMin((() => {
 		"**/.turbo/**"
 	];
 }));
-
 //#endregion
 init_file_patterns();
 export { GLOB_EXCLUDE, getChecksumPatternGroup, getChecksumPatternGroupInAbsolutePath, init_file_patterns };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"file-patterns.js","names":[],"sources":["../../src/syncer/file-patterns.ts"],"sourcesContent":["import path from \"path\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport { type AbsolutePath, type AppRelativePath } from \"../utils/path-utils\";\n\n/**\n * Syncer가 관심 가지고 지켜보는 파일들입니다.\n * 이 파일들에 변경이 생기면 추가적인 작업(이하 \"싱크\" 또는 \"싱크 액션\")을 수행합니다.\n * 이 작업이라 함은 파일 복사 또는 템플릿 렌더링을 통한 code generation을 의미합니다.\n *\n * 경로 형식: appRoot 기준 상대 경로 (target 디렉토리로 시작, 예: \"api/src/...\", \"web/src/...\")\n * 사용: getChecksumPatternGroupInAbsolutePath()로 절대 경로 변환 후 glob 사용\n *\n * 두 가지 의미적 영역:\n * - 입력 (사용자 작성): api 디렉토리에만 위치. 사용자가 직접 편집.\n * - 출력 (sonamu 생성/복사): api 또는 target 디렉토리에 sonamu가 만들어내는 파일.\n *\n * 추적 밖 자산 (부트스트랩 phase에서 매번 보장):\n * - sonamu.shared.ts: 사용자가 커스터마이즈하는 자산. IfNotExists로 1회 생성 후 손대지 않음.\n * - entry-server.generated.tsx: 입력 의존 없는 정적 코드. 매번 overwrite generate.\n *\n * 위 둘은 sync()의 부트스트랩 phase에서 변경 검출 사이클과 무관하게 보장됩니다.\n * 추적 사이클 안에서 할 액션이 없는 자산이라 패턴 그룹에 포함되지 않습니다.\n *\n * 위치 카테고리는 api/targets/anywhere 헬퍼로 명시적으로 표현합니다.\n *\n * FileType은 이 함수의 반환 타입에서 자동 추론됩니다. 키 추가 시 별도 enum/배열을\n * 동기화할 필요 없이 여기 한 군데만 수정하면 됩니다.\n */\nexport function getChecksumPatternGroup() {\n  // 헬퍼 함수들 만들어서 가져옵니다.\n  const { api, targets, anywhere } = globBuilders();\n\n  return {\n    // Sonamu 입장에서 soruce가 되는 파일들입니다.\n    // 이 친구들이 변경되면 이들로부터 액션을 수행하고 파일을 생성합니다.\n    // 모노리포에서 이 source들은 api 프로젝트에 한정되므로, api에 있는 친구들만 리스팅합니다.\n    config: api(\"src/sonamu.config.ts\"),\n    entity: api(\"src/application/**/*.entity.json\"),\n    frame: api(\"src/application/**/*.frame.ts\"),\n    functions: api(\"src/application/**/*.functions.ts\"),\n    model: api(\"src/application/**/*.model.ts\"),\n    types: api(\"src/application/**/*.types.ts\"),\n    workflow: api(\"src/application/**/*.workflow.ts\"),\n    i18n: api(\"src/i18n/**/!(sd.generated).ts\"),\n\n    // Sonamu가 출력하는 생성 파일들입니다.\n    // 이 친구들도 정합성 검증 차원에서 sonamu.lock에 기록해야 하고,\n    // 또한 변경시 그 사실을 syncer가 알기는 해야 합니다(비록 별다른 처리가 없는 경우도 있지만).\n    //\n    // 자산 본성에 따라 위치 카테고리가 다르기 때문에, 본성별로 분리해서 표기합니다.\n    // - 양쪽-필요 자산: api에 정본이 만들어진 뒤 target에 복사됨 (sonamu.generated.{ts,tsx}).\n    // - api 전용 자산: api에만 만들어짐 (sonamu.generated.http, queries.generated.ts).\n    // - target 전용 자산: target에만 만들어짐 (services.generated.ts는 services.template의 :target 분배).\n    //\n    // 여기에는 Sonamu의 모든 sync 산출물이 있는 것은 아닙니다.\n    // sonamu.shared.ts와 entry-server.generated.tsx와 같은\n    // sync 초반 1회성 부트스트랩 파일들은 관리 안 하기 때문에 여기에 리스팅도 안 합니다.\n    generated: api(\"src/application/**/*.generated.{ts,tsx,sso.ts}\"),\n    generatedCopied: targets(\"src/services/**/sonamu.generated.{ts,tsx}\"),\n    httpGenerated: api(\"src/application/**/*.generated.http\"),\n    servicesGenerated: targets(\"src/services/services.generated.ts\"),\n    sdGenerated: anywhere(\"src/i18n/**/sd.generated.ts\"),\n    typesCopied: targets(\"src/services/**/*.types.ts\"),\n    functionsCopied: targets(\"src/services/**/*.functions.ts\"),\n    i18nCopied: targets(\"src/i18n/**/!(sd.generated).ts\"),\n  } satisfies Record<string, AppRelativePath>;\n}\n\n/**\n * 위치 카테고리별 글롭 빌더를 만들어 반환합니다.\n * - api(rest): api 디렉토리에 한정\n * - targets(rest): target 디렉토리들에 한정 (web, app 등)\n * - anywhere(rest): api와 target 모두\n */\nfunction globBuilders() {\n  const apiDir = Sonamu.config.api.dir;\n  const targetDirs = Sonamu.config.sync.targets;\n\n  // Node 내장 fs.glob의 brace expansion은 단일 멤버 {x}를 풀지 않으므로, 멤버가 1개일 때는 alternation 없이 직접 결합합니다.\n  const braceJoin = (dirs: readonly string[]) =>\n    dirs.length === 1 ? dirs[0] : `{${dirs.join(\",\")}}`;\n\n  return {\n    api: (pathFromApi: string) => `${apiDir}/${pathFromApi}` as AppRelativePath,\n    targets: (pathFromTarget: string) =>\n      `${braceJoin(targetDirs)}/${pathFromTarget}` as AppRelativePath,\n    anywhere: (pathFromAnywhere: string) =>\n      `${braceJoin([apiDir, ...targetDirs])}/${pathFromAnywhere}` as AppRelativePath,\n  };\n}\n\n/**\n * FileType은 getChecksumPatternGroup의 반환 객체 키에서 자동 추론됩니다.\n * 별도 배열/enum 동기화 불필요 — 패턴 그룹 함수가 진실의 단일 원천.\n */\nexport type FileType = keyof ReturnType<typeof getChecksumPatternGroup>;\nexport type GlobPattern<T extends AppRelativePath | AbsolutePath> = Record<FileType, T>;\n\n/**\n * 빌드 산출물 디렉토리는 alternation 글롭이 의도치 않게 휘말릴 수 있으므로 안전망으로 제외.\n * Node 내장 fs.glob의 exclude 옵션과 함께 사용합니다.\n */\nexport const GLOB_EXCLUDE = [\"**/node_modules/**\", \"**/dist/**\", \"**/build/**\", \"**/.turbo/**\"];\n\n/**\n * appRoot 기준 상대 경로 패턴을 절대 경로 패턴으로 변환합니다.\n *\n * @returns 절대 경로 기반 Glob 패턴 맵\n */\nexport function getChecksumPatternGroupInAbsolutePath(): GlobPattern<AbsolutePath> {\n  const group = getChecksumPatternGroup();\n  return Object.fromEntries(\n    Object.entries(group).map(([key, value]) => [\n      key,\n      path.join(Sonamu.appRootPath, value), // appRoot 상대 경로 → 절대 경로\n    ]),\n  ) as GlobPattern<AbsolutePath>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,0BAA0B;CAExC,MAAM,EAAE,KAAK,SAAS,aAAa,cAAc;AAEjD,QAAO;EAIL,QAAQ,IAAI,uBAAuB;EACnC,QAAQ,IAAI,mCAAmC;EAC/C,OAAO,IAAI,gCAAgC;EAC3C,WAAW,IAAI,oCAAoC;EACnD,OAAO,IAAI,gCAAgC;EAC3C,OAAO,IAAI,gCAAgC;EAC3C,UAAU,IAAI,mCAAmC;EACjD,MAAM,IAAI,iCAAiC;EAc3C,WAAW,IAAI,iDAAiD;EAChE,iBAAiB,QAAQ,4CAA4C;EACrE,eAAe,IAAI,sCAAsC;EACzD,mBAAmB,QAAQ,qCAAqC;EAChE,aAAa,SAAS,8BAA8B;EACpD,aAAa,QAAQ,6BAA6B;EAClD,iBAAiB,QAAQ,iCAAiC;EAC1D,YAAY,QAAQ,iCAAiC;EACtD;;;;;;;;AASH,SAAS,eAAe;CACtB,MAAM,SAAS,OAAO,OAAO,IAAI;CACjC,MAAM,aAAa,OAAO,OAAO,KAAK;CAGtC,MAAM,aAAa,SACjB,KAAK,WAAW,IAAI,KAAK,KAAK,IAAI,KAAK,KAAK,IAAI,CAAC;AAEnD,QAAO;EACL,MAAM,gBAAwB,GAAG,OAAO,GAAG;EAC3C,UAAU,mBACR,GAAG,UAAU,WAAW,CAAC,GAAG;EAC9B,WAAW,qBACT,GAAG,UAAU,CAAC,QAAQ,GAAG,WAAW,CAAC,CAAC,GAAG;EAC5C;;;;;;;AAqBH,SAAgB,wCAAmE;CACjF,MAAM,QAAQ,yBAAyB;AACvC,QAAO,OAAO,YACZ,OAAO,QAAQ,MAAM,CAAC,KAAK,CAAC,KAAK,WAAW,CAC1C,KACA,KAAK,KAAK,OAAO,aAAa,MAAM,CACrC,CAAC,CACH;;;;cAnHoC;CAqG1B,eAAe;EAAC;EAAsB;EAAc;EAAe;EAAe"}
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"file-patterns.js","names":[],"sources":["../../src/syncer/file-patterns.ts"],"sourcesContent":["import path from \"path\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport { type AbsolutePath, type AppRelativePath } from \"../utils/path-utils\";\n\n/**\n * Syncer가 관심 가지고 지켜보는 파일들입니다.\n * 이 파일들에 변경이 생기면 추가적인 작업(이하 \"싱크\" 또는 \"싱크 액션\")을 수행합니다.\n * 이 작업이라 함은 파일 복사 또는 템플릿 렌더링을 통한 code generation을 의미합니다.\n *\n * 경로 형식: appRoot 기준 상대 경로 (target 디렉토리로 시작, 예: \"api/src/...\", \"web/src/...\")\n * 사용: getChecksumPatternGroupInAbsolutePath()로 절대 경로 변환 후 glob 사용\n *\n * 두 가지 의미적 영역:\n * - 입력 (사용자 작성): api 디렉토리에만 위치. 사용자가 직접 편집.\n * - 출력 (sonamu 생성/복사): api 또는 target 디렉토리에 sonamu가 만들어내는 파일.\n *\n * 추적 밖 자산 (부트스트랩 phase에서 매번 보장):\n * - sonamu.shared.ts: 사용자가 커스터마이즈하는 자산. IfNotExists로 1회 생성 후 손대지 않음.\n * - entry-server.generated.tsx: 입력 의존 없는 정적 코드. 매번 overwrite generate.\n *\n * 위 둘은 sync()의 부트스트랩 phase에서 변경 검출 사이클과 무관하게 보장됩니다.\n * 추적 사이클 안에서 할 액션이 없는 자산이라 패턴 그룹에 포함되지 않습니다.\n *\n * 위치 카테고리는 api/targets/anywhere 헬퍼로 명시적으로 표현합니다.\n *\n * FileType은 이 함수의 반환 타입에서 자동 추론됩니다. 키 추가 시 별도 enum/배열을\n * 동기화할 필요 없이 여기 한 군데만 수정하면 됩니다.\n */\nexport function getChecksumPatternGroup() {\n  // 헬퍼 함수들 만들어서 가져옵니다.\n  const { api, targets, anywhere } = globBuilders();\n\n  return {\n    // Sonamu 입장에서 soruce가 되는 파일들입니다.\n    // 이 친구들이 변경되면 이들로부터 액션을 수행하고 파일을 생성합니다.\n    // 모노리포에서 이 source들은 api 프로젝트에 한정되므로, api에 있는 친구들만 리스팅합니다.\n    config: api(\"src/sonamu.config.ts\"),\n    entity: api(\"src/application/**/*.entity.json\"),\n    frame: api(\"src/application/**/*.frame.ts\"),\n    functions: api(\"src/application/**/*.functions.ts\"),\n    model: api(\"src/application/**/*.model.ts\"),\n    types: api(\"src/application/**/*.types.ts\"),\n    workflow: api(\"src/application/**/*.workflow.ts\"),\n    i18n: api(\"src/i18n/**/!(sd.generated).ts\"),\n\n    // Sonamu가 출력하는 생성 파일들입니다.\n    // 이 친구들도 정합성 검증 차원에서 sonamu.lock에 기록해야 하고,\n    // 또한 변경시 그 사실을 syncer가 알기는 해야 합니다(비록 별다른 처리가 없는 경우도 있지만).\n    //\n    // 자산 본성에 따라 위치 카테고리가 다르기 때문에, 본성별로 분리해서 표기합니다.\n    // - 양쪽-필요 자산: api에 정본이 만들어진 뒤 target에 복사됨 (sonamu.generated.{ts,tsx}).\n    // - api 전용 자산: api에만 만들어짐 (sonamu.generated.http, queries.generated.ts).\n    // - target 전용 자산: target에만 만들어짐 (services.generated.ts는 services.template의 :target 분배).\n    //\n    // 여기에는 Sonamu의 모든 sync 산출물이 있는 것은 아닙니다.\n    // sonamu.shared.ts와 entry-server.generated.tsx와 같은\n    // sync 초반 1회성 부트스트랩 파일들은 관리 안 하기 때문에 여기에 리스팅도 안 합니다.\n    generated: api(\"src/application/**/*.generated.{ts,tsx,sso.ts}\"),\n    generatedCopied: targets(\"src/services/**/sonamu.generated.{ts,tsx}\"),\n    httpGenerated: api(\"src/application/**/*.generated.http\"),\n    servicesGenerated: targets(\"src/services/services.generated.ts\"),\n    sdGenerated: anywhere(\"src/i18n/**/sd.generated.ts\"),\n    typesCopied: targets(\"src/services/**/*.types.ts\"),\n    functionsCopied: targets(\"src/services/**/*.functions.ts\"),\n    i18nCopied: targets(\"src/i18n/**/!(sd.generated).ts\"),\n  } satisfies Record<string, AppRelativePath>;\n}\n\n/**\n * 위치 카테고리별 글롭 빌더를 만들어 반환합니다.\n * - api(rest): api 디렉토리에 한정\n * - targets(rest): target 디렉토리들에 한정 (web, app 등)\n * - anywhere(rest): api와 target 모두\n */\nfunction globBuilders() {\n  const apiDir = Sonamu.config.api.dir;\n  const targetDirs = Sonamu.config.sync.targets;\n\n  // Node 내장 fs.glob의 brace expansion은 단일 멤버 {x}를 풀지 않으므로, 멤버가 1개일 때는 alternation 없이 직접 결합합니다.\n  const braceJoin = (dirs: readonly string[]) =>\n    dirs.length === 1 ? dirs[0] : `{${dirs.join(\",\")}}`;\n\n  return {\n    api: (pathFromApi: string) => `${apiDir}/${pathFromApi}` as AppRelativePath,\n    targets: (pathFromTarget: string) =>\n      `${braceJoin(targetDirs)}/${pathFromTarget}` as AppRelativePath,\n    anywhere: (pathFromAnywhere: string) =>\n      `${braceJoin([apiDir, ...targetDirs])}/${pathFromAnywhere}` as AppRelativePath,\n  };\n}\n\n/**\n * FileType은 getChecksumPatternGroup의 반환 객체 키에서 자동 추론됩니다.\n * 별도 배열/enum 동기화 불필요 — 패턴 그룹 함수가 진실의 단일 원천.\n */\nexport type FileType = keyof ReturnType<typeof getChecksumPatternGroup>;\nexport type GlobPattern<T extends AppRelativePath | AbsolutePath> = Record<FileType, T>;\n\n/**\n * 빌드 산출물 디렉토리는 alternation 글롭이 의도치 않게 휘말릴 수 있으므로 안전망으로 제외.\n * Node 내장 fs.glob의 exclude 옵션과 함께 사용합니다.\n */\nexport const GLOB_EXCLUDE = [\"**/node_modules/**\", \"**/dist/**\", \"**/build/**\", \"**/.turbo/**\"];\n\n/**\n * appRoot 기준 상대 경로 패턴을 절대 경로 패턴으로 변환합니다.\n *\n * @returns 절대 경로 기반 Glob 패턴 맵\n */\nexport function getChecksumPatternGroupInAbsolutePath(): GlobPattern<AbsolutePath> {\n  const group = getChecksumPatternGroup();\n  return Object.fromEntries(\n    Object.entries(group).map(([key, value]) => [\n      key,\n      path.join(Sonamu.appRootPath, value), // appRoot 상대 경로 → 절대 경로\n    ]),\n  ) as GlobPattern<AbsolutePath>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,0BAA0B;CAExC,MAAM,EAAE,KAAK,SAAS,aAAa,aAAa;CAEhD,OAAO;EAIL,QAAQ,IAAI,sBAAsB;EAClC,QAAQ,IAAI,kCAAkC;EAC9C,OAAO,IAAI,+BAA+B;EAC1C,WAAW,IAAI,mCAAmC;EAClD,OAAO,IAAI,+BAA+B;EAC1C,OAAO,IAAI,+BAA+B;EAC1C,UAAU,IAAI,kCAAkC;EAChD,MAAM,IAAI,gCAAgC;EAc1C,WAAW,IAAI,gDAAgD;EAC/D,iBAAiB,QAAQ,2CAA2C;EACpE,eAAe,IAAI,qCAAqC;EACxD,mBAAmB,QAAQ,oCAAoC;EAC/D,aAAa,SAAS,6BAA6B;EACnD,aAAa,QAAQ,4BAA4B;EACjD,iBAAiB,QAAQ,gCAAgC;EACzD,YAAY,QAAQ,gCAAgC;CACtD;AACF;;;;;;;AAQA,SAAS,eAAe;CACtB,MAAM,SAAS,OAAO,OAAO,IAAI;CACjC,MAAM,aAAa,OAAO,OAAO,KAAK;CAGtC,MAAM,aAAa,SACjB,KAAK,WAAW,IAAI,KAAK,KAAK,IAAI,KAAK,KAAK,GAAG,EAAE;CAEnD,OAAO;EACL,MAAM,gBAAwB,GAAG,OAAO,GAAG;EAC3C,UAAU,mBACR,GAAG,UAAU,UAAU,EAAE,GAAG;EAC9B,WAAW,qBACT,GAAG,UAAU,CAAC,QAAQ,GAAG,UAAU,CAAC,EAAE,GAAG;CAC7C;AACF;;;;;;AAoBA,SAAgB,wCAAmE;CACjF,MAAM,QAAQ,wBAAwB;CACtC,OAAO,OAAO,YACZ,OAAO,QAAQ,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,WAAW,CAC1C,KACA,KAAK,KAAK,OAAO,aAAa,KAAK,CACrC,CAAC,CACH;AACF;;;aApHsC;CAqGzB,eAAe;EAAC;EAAsB;EAAc;EAAe;CAAc"}

package/dist/syncer/file-tracking.js

@@ -1,6 +1,5 @@
-import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { __esmMin } from "../_virtual/_rolldown/runtime.js";
 import { stat } from "fs/promises";
-
 //#region src/syncer/file-tracking.ts
 /**
 * 우리가 디스크에 write한 path를 등록합니다. write 직후 호출하세요.
@@ -16,18 +15,15 @@ async function trackWritten(filePath) {
 */
 async function isLastChangedByMe(filePath) {
 	const registered = fileWrittenAt.get(filePath);
-	if (registered === undefined) {
-		return false;
-	}
-	const fileStat = await stat(filePath);
-	return fileStat.mtimeMs <= registered;
+	if (registered === void 0) return false;
+	return (await stat(filePath)).mtimeMs <= registered;
 }
 var fileWrittenAt;
 var init_file_tracking = __esmMin((() => {
-	fileWrittenAt = new Map();
+	fileWrittenAt = /* @__PURE__ */ new Map();
 }));
-
 //#endregion
 init_file_tracking();
 export { fileWrittenAt, init_file_tracking, isLastChangedByMe, trackWritten };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS10cmFja2luZy5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi9zcmMvc3luY2VyL2ZpbGUtdHJhY2tpbmcudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgc3RhdCB9IGZyb20gXCJmcy9wcm9taXNlc1wiO1xuXG5pbXBvcnQgeyB0eXBlIEFic29sdXRlUGF0aCB9IGZyb20gXCIuLi91dGlscy9wYXRoLXV0aWxzXCI7XG5cbmV4cG9ydCBjb25zdCBmaWxlV3JpdHRlbkF0ID0gbmV3IE1hcDxBYnNvbHV0ZVBhdGgsIG51bWJlcj4oKTtcblxuLyoqXG4gKiDsmrDrpqzqsIAg65SU7Iqk7YGs7JeQIHdyaXRl7ZWcIHBhdGjrpbwg65Ox66Gd7ZWp64uI64ukLiB3cml0ZSDsp4Htm4Qg7Zi47Lac7ZWY7IS47JqULlxuICog65SU7Iqk7YGs7JeQ7IScIG10aW1l7J2EIOyngeygkSDsnb3slrQg7KCV7ZmV7ZWcIOqwkuycvOuhnCDrk7HroZ3tlanri4jri6QuXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiB0cmFja1dyaXR0ZW4oZmlsZVBhdGg6IEFic29sdXRlUGF0aCk6IFByb21pc2U8dm9pZD4ge1xuICBjb25zdCBmaWxlU3RhdCA9IGF3YWl0IHN0YXQoZmlsZVBhdGgpO1xuICBmaWxlV3JpdHRlbkF0LnNldChmaWxlUGF0aCwgZmlsZVN0YXQubXRpbWVNcyk7XG59XG5cbi8qKlxuICog7KO87Ja07KeEIHBhdGjqsIAg6rCA7J6lIOy1nOq3vCDsmrDrpqwgd3JpdGUg7J207ZuE66GcIOyZuOu2gOyXkOyEnCDsiJjsoJXrkJwg7KCBIOyXhuuKlOyngCDtmZXsnbjtlanri4jri6QuXG4gKiB0cnVl66m0IFwi64K06rCAIOyTtCDqt7jrjIDroZwg64Ko7JWE7J6I7J2MXCIsIGZhbHNl66m0IFwi7Jm467aA7JeQ7IScIOyImOygleuQkOqxsOuCmCDsmrDrpqzqsIAg7JO0IOyggSDsl4bsnYxcIi5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGlzTGFzdENoYW5nZWRCeU1lKGZpbGVQYXRoOiBBYnNvbHV0ZVBhdGgpOiBQcm9taXNlPGJvb2xlYW4+IHtcbiAgY29uc3QgcmVnaXN0ZXJlZCA9IGZpbGVXcml0dGVuQXQuZ2V0KGZpbGVQYXRoKTtcbiAgaWYgKHJlZ2lzdGVyZWQgPT09IHVuZGVmaW5lZCkge1xuICAgIHJldHVybiBmYWxzZTtcbiAgfVxuICBjb25zdCBmaWxlU3RhdCA9IGF3YWl0IHN0YXQoZmlsZVBhdGgpO1xuICByZXR1cm4gZmlsZVN0YXQubXRpbWVNcyA8PSByZWdpc3RlcmVkO1xufVxuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7OztBQVVBLGVBQXNCLGFBQWEsVUFBdUM7Q0FDeEUsTUFBTSxXQUFXLE1BQU0sS0FBSyxTQUFTO0FBQ3JDLGVBQWMsSUFBSSxVQUFVLFNBQVMsUUFBUTs7Ozs7O0FBTy9DLGVBQXNCLGtCQUFrQixVQUEwQztDQUNoRixNQUFNLGFBQWEsY0FBYyxJQUFJLFNBQVM7QUFDOUMsS0FBSSxlQUFlLFdBQVc7QUFDNUIsU0FBTzs7Q0FFVCxNQUFNLFdBQVcsTUFBTSxLQUFLLFNBQVM7QUFDckMsUUFBTyxTQUFTLFdBQVc7Ozs7Q0FyQmhCLGdCQUFnQixJQUFJLEtBQTJCIn0=
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS10cmFja2luZy5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi9zcmMvc3luY2VyL2ZpbGUtdHJhY2tpbmcudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgc3RhdCB9IGZyb20gXCJmcy9wcm9taXNlc1wiO1xuXG5pbXBvcnQgeyB0eXBlIEFic29sdXRlUGF0aCB9IGZyb20gXCIuLi91dGlscy9wYXRoLXV0aWxzXCI7XG5cbmV4cG9ydCBjb25zdCBmaWxlV3JpdHRlbkF0ID0gbmV3IE1hcDxBYnNvbHV0ZVBhdGgsIG51bWJlcj4oKTtcblxuLyoqXG4gKiDsmrDrpqzqsIAg65SU7Iqk7YGs7JeQIHdyaXRl7ZWcIHBhdGjrpbwg65Ox66Gd7ZWp64uI64ukLiB3cml0ZSDsp4Htm4Qg7Zi47Lac7ZWY7IS47JqULlxuICog65SU7Iqk7YGs7JeQ7IScIG10aW1l7J2EIOyngeygkSDsnb3slrQg7KCV7ZmV7ZWcIOqwkuycvOuhnCDrk7HroZ3tlanri4jri6QuXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiB0cmFja1dyaXR0ZW4oZmlsZVBhdGg6IEFic29sdXRlUGF0aCk6IFByb21pc2U8dm9pZD4ge1xuICBjb25zdCBmaWxlU3RhdCA9IGF3YWl0IHN0YXQoZmlsZVBhdGgpO1xuICBmaWxlV3JpdHRlbkF0LnNldChmaWxlUGF0aCwgZmlsZVN0YXQubXRpbWVNcyk7XG59XG5cbi8qKlxuICog7KO87Ja07KeEIHBhdGjqsIAg6rCA7J6lIOy1nOq3vCDsmrDrpqwgd3JpdGUg7J207ZuE66GcIOyZuOu2gOyXkOyEnCDsiJjsoJXrkJwg7KCBIOyXhuuKlOyngCDtmZXsnbjtlanri4jri6QuXG4gKiB0cnVl66m0IFwi64K06rCAIOyTtCDqt7jrjIDroZwg64Ko7JWE7J6I7J2MXCIsIGZhbHNl66m0IFwi7Jm467aA7JeQ7IScIOyImOygleuQkOqxsOuCmCDsmrDrpqzqsIAg7JO0IOyggSDsl4bsnYxcIi5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGlzTGFzdENoYW5nZWRCeU1lKGZpbGVQYXRoOiBBYnNvbHV0ZVBhdGgpOiBQcm9taXNlPGJvb2xlYW4+IHtcbiAgY29uc3QgcmVnaXN0ZXJlZCA9IGZpbGVXcml0dGVuQXQuZ2V0KGZpbGVQYXRoKTtcbiAgaWYgKHJlZ2lzdGVyZWQgPT09IHVuZGVmaW5lZCkge1xuICAgIHJldHVybiBmYWxzZTtcbiAgfVxuICBjb25zdCBmaWxlU3RhdCA9IGF3YWl0IHN0YXQoZmlsZVBhdGgpO1xuICByZXR1cm4gZmlsZVN0YXQubXRpbWVNcyA8PSByZWdpc3RlcmVkO1xufVxuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7O0FBVUEsZUFBc0IsYUFBYSxVQUF1QztDQUN4RSxNQUFNLFdBQVcsTUFBTSxLQUFLLFFBQVE7Q0FDcEMsY0FBYyxJQUFJLFVBQVUsU0FBUyxPQUFPO0FBQzlDOzs7OztBQU1BLGVBQXNCLGtCQUFrQixVQUEwQztDQUNoRixNQUFNLGFBQWEsY0FBYyxJQUFJLFFBQVE7Q0FDN0MsSUFBSSxlQUFlLFFBQ2pCLE9BQU87Q0FHVCxRQUFPLE1BRGdCLEtBQUssUUFBUSxFQUM3QixDQUFTLFdBQVc7QUFDN0I7OztDQXRCYSxnQ0FBZ0IsSUFBSSxJQUEwQiJ9

package/dist/syncer/index.js

@@ -5,7 +5,6 @@ import { generateTemplate, init_code_generator, renderTemplate } from "./code-ge
 import { createEntity, delEntity, init_entity_operations } from "./entity-operations.js";
 import { init_module_loader, loadApis, loadModels, loadTypes, loadWorkflows } from "./module-loader.js";
 import { Syncer, init_syncer } from "./syncer.js";
-
 //#region src/syncer/index.ts
 init_api_parser();
 init_checksum();
@@ -14,7 +13,7 @@ init_entity_operations();
 init_file_patterns();
 init_module_loader();
 init_syncer();
-
 //#endregion
 export { GLOB_EXCLUDE, Syncer, createEntity, delEntity, findChangedFilesUsingChecksums, generateTemplate, getChecksumPatternGroup, getChecksumPatternGroupInAbsolutePath, loadApis, loadModels, loadTypes, loadWorkflows, readApisFromFile, renderTemplate, renewChecksums };
+
 //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL3N5bmNlci9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9hcGktcGFyc2VyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jaGVja3N1bVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vY29kZS1nZW5lcmF0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2VudGl0eS1vcGVyYXRpb25zXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9maWxlLXBhdHRlcm5zXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9tb2R1bGUtbG9hZGVyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zeW5jZXJcIjtcbiJdLCJtYXBwaW5ncyI6IiJ9

package/dist/syncer/module-loader.js

@@ -1,4 +1,4 @@
-import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { __esmMin } from "../_virtual/_rolldown/runtime.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";
@@ -6,7 +6,6 @@ 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 path from "path";
-
 //#region src/syncer/module-loader.ts
 /**
 * *.model.ts와 *.frame.ts 파일들에서 API 메소드를 파싱하여 로드합니다.
@@ -14,34 +13,24 @@ import path from "path";
 * 따라서 loadModels()를 먼저 호출해야 합니다.
 */
 async function loadApis() {
-	const modelPathsPattern = path.join(Sonamu.apiRootPath, "src/application/**/*.{model,frame}.ts");
-	const modelPaths = await globAsync(modelPathsPattern);
+	const modelPaths = await globAsync(path.join(Sonamu.apiRootPath, "src/application/**/*.{model,frame}.ts"));
 	const apis = [];
 	for (const filePath of modelPaths) {
 		const parsedApis = await readApisFromFile(filePath);
 		apis.push(...parsedApis);
 	}
-	for (const api of apis) {
-		if (api.path === "") {
-			throw new Error(`API ${api.modelName}.${api.methodName} has no path. Please attach @api decorator to the method.`);
-		}
-	}
+	for (const api of apis) if (api.path === "") throw new Error(`API ${api.modelName}.${api.methodName} has no path. Please attach @api decorator to the method.`);
 	return apis;
 }
 /**
 * *.model.ts와 *.frame.ts 파일들에서 Model/Frame 클래스 인스턴스를 로드합니다.
 */
 async function loadModels() {
-	const modelPathsPattern = path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.{model,frame}.ts"));
-	const modelPaths = await globAsync(modelPathsPattern);
+	const modelPaths = await globAsync(path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.{model,frame}.ts")));
 	const models = {};
 	for (const filePath of modelPaths) {
 		const importedMembers = await importMembers(filePath);
-		for (const { name, value } of importedMembers) {
-			if (name.endsWith("Model") || name.endsWith("Frame")) {
-				models[name] = value;
-			}
-		}
+		for (const { name, value } of importedMembers) if (name.endsWith("Model") || name.endsWith("Frame")) models[name] = value;
 	}
 	return models;
 }
@@ -54,11 +43,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$1.ZodType) types[name] = value;
 	}
 	return types;
 }
@@ -66,9 +51,8 @@ async function loadTypes() {
 * *.workflow.ts 파일들에서 Workflow 메타데이터를 로드합니다.
 */
 async function loadWorkflows() {
-	const workflowPathsPattern = path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.workflow.ts"));
-	const workflowPaths = await globAsync(workflowPathsPattern);
-	const workflows = new Map();
+	const workflowPaths = await globAsync(path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.workflow.ts")));
+	const workflows = /* @__PURE__ */ new Map();
 	for (const filePath of workflowPaths) {
 		const importedMembers = await importMembers(filePath);
 		workflows.set(filePath, importedMembers.filter(({ value }) => {
@@ -86,8 +70,8 @@ var init_module_loader = __esmMin((() => {
 	init_path_utils();
 	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":["apis: LoadedApis","models: LoadedModels","types: LoadedTypes","z","workflows: Map<string, WorkflowMetadata[]>"],"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;CAKpD,MAAM,oBAAoB,KAAK,KAC7B,OAAO,aACP,wCACD;CACD,MAAM,aAAc,MAAM,UAAU,kBAAkB;CAEtD,MAAMA,OAAmB,EAAE;AAC3B,MAAK,MAAM,YAAY,YAAY;EACjC,MAAM,aAAa,MAAM,iBAAiB,SAAS;AACnD,OAAK,KAAK,GAAG,WAAW;;AAM1B,MAAK,MAAM,OAAO,MAAM;AACtB,MAAI,IAAI,SAAS,IAAI;AAGnB,SAAM,IAAI,MACR,OAAO,IAAI,UAAU,GAAG,IAAI,WAAW,2DACxC;;;AAIL,QAAO;;;;;AAMT,eAAsB,aAAoC;CACxD,MAAM,oBAAoB,KAAK,KAC7B,OAAO,aACP,YAAY,wCAAwC,CACrD;CACD,MAAM,aAAa,MAAM,UAAU,kBAAkB;CAErD,MAAMC,SAAuB,EAAE;AAC/B,MAAK,MAAM,YAAY,YAAY;EACjC,MAAM,kBAAkB,MAAM,cAA+C,SAAS;AAEtF,OAAK,MAAM,EAAE,MAAM,WAAW,iBAAiB;AAC7C,OAAI,KAAK,SAAS,QAAQ,IAAI,KAAK,SAAS,QAAQ,EAAE;AACpD,WAAO,QAAQ;;;;AAKrB,QAAO;;;;;AAMT,eAAsB,YAAkC;CACtD,MAAM,oBAAoB,CACxB,KAAK,KAAK,OAAO,aAAa,YAAY,gCAAgC,CAAC,EAC3E,KAAK,KAAK,OAAO,aAAa,YAAY,oCAAoC,CAAC,CAChF;CACD,MAAM,aACJ,MAAM,QAAQ,IAAI,kBAAkB,KAAK,YAAY,UAAU,QAAQ,CAAC,CAAC,EACzE,MAAM;CAER,MAAMC,QAAqB,EAAE;AAC7B,MAAK,MAAM,YAAY,WAAW;EAChC,MAAM,kBAAkB,MAAM,cAAyB,SAAS;AAChE,OAAK,MAAM,EAAE,MAAM,WAAW,iBAAiB;AAC7C,OAAI,iBAAiBC,IAAE,SAAS;AAC9B,UAAM,QAAQ;;;;AAKpB,QAAO;;;;;AAMT,eAAsB,gBAAgB;CACpC,MAAM,uBAAuB,KAAK,KAChC,OAAO,aACP,YAAY,mCAAmC,CAChD;CACD,MAAM,gBAAgB,MAAM,UAAU,qBAAqB;CAC3D,MAAMC,YAA6C,IAAI,KAAK;AAC5D,MAAK,MAAM,YAAY,eAAe;EACpC,MAAM,kBAAkB,MAAM,cAAc,SAAS;AACrD,YAAU,IACR,UACA,gBACG,QAAQ,EAAE,YAAY;AACrB,UACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACV,MAAM,SAAS,cACf,QAAQ,SACR,OAAO,MAAM,OAAO;IAEtB,CACD,KAAK,EAAE,YAAY;AAClB,UAAO;IACP,CACL;;AAGH,QAAO;;;cAvI8B;mBAGU;iBACE;kBACD;kBAEF"}
+
+//# 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"}