sonamu 0.9.4 → 0.9.6

package/dist/syncer/syncer-actions.js

@@ -1,11 +1,14 @@
 import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { AlreadyProcessedException, init_so_exceptions } from "../exceptions/so-exceptions.js";
 import { init_controller, isTest } from "../utils/controller.js";
+import { formatCode, init_formatter } from "../utils/formatter.js";
 import { copyFileWithReplaceCoreToShared, exists, init_fs_utils } from "../utils/fs-utils.js";
 import { Sonamu, init_sonamu } from "../api/sonamu.js";
 import { Naite, init_naite } from "../naite/naite.js";
+import { init_file_tracking, trackWritten } from "./file-tracking.js";
 import { generateTemplate, init_code_generator } from "./code-generator.js";
 import assert from "assert";
-import { mkdir, writeFile } from "fs/promises";
+import { mkdir, readFile, writeFile } from "fs/promises";
 import path, { dirname } from "path";
 import chalk from "chalk";
 
@@ -29,6 +32,13 @@ async function actionGenerateServices(paramsArray) {
 	return [...servicesFile];
 }
 /**
+* Entity에 딸린 초기 types.ts를 만들어줍니다.
+* @param entityId
+*/
+async function actionGenerateInitialTypes(entityId) {
+	return generateTemplate("init_types", { entityId });
+}
+/**
 * sonamu.generated.ts와 sonamu.generated.sso.ts를 생성합니다.
 * @returns 생성된 파일 경로 배열.
 */
@@ -45,16 +55,36 @@ async function actionGenerateHttps() {
 	return res;
 }
 /**
-* queries.generated.ts 및 entry-server.generated.tsx 재생성합니다.
+* queries.generated.ts 재생성합니다.
 * @returns 생성된 파일 경로 배열.
 */
-async function actionGenerateSsr() {
-	return (await Promise.all([generateTemplate("entry_server", {}, { overwrite: true }), generateTemplate("queries", {}, { overwrite: true })])).flat();
+async function actionGenerateSsrQueries() {
+	return generateTemplate("queries", {}, { overwrite: true });
+}
+/**
+* entry-server.generated.tsx를 생성합니다.
+* 다른 액션들과 달리, 이미 파일이 있으면 그냥 놔둡니다. 그래서 함수 이름 끝에 써놨어요 ㅎ
+* 입력 의존 없는 정적 코드라 매번 overwrite는 mtime만 갱신하는 의미 없는 동작.
+* 템플릿 자체가 변경된 경우(Sonamu 업그레이드)에는 사용자가 파일을 삭제한 뒤 sync로 재생성.
+* @returns 생성된 파일 경로 배열 (이미 있으면 빈 배열).
+*/
+async function actionGenerateSsrEntryServerIfNotExists() {
+	try {
+		return await generateTemplate("entry_server", {}, { overwrite: false });
+	} catch (e) {
+		if (e instanceof AlreadyProcessedException) {
+			return [];
+		}
+		throw e;
+	}
 }
 /**
-* *.types.ts, *.functions.ts, *.generated.ts를 타겟 디렉토리에 복사합니다.
-* @param tsPaths
-* @returns 복사된 파일 경로 배열.
+* 주어진 .ts 파일들(api에 있다고 가정)을 모든 타겟 디렉토리의 services에 갖다 둡니다.
+* 이때 내부의 sonamu import는 sonamu.shared.ts import로 치환되고,
+* 경로의 /application/은 /services/로 치환됩니다.
+*
+* @param tsPaths 복사할 파일들의 절대 경로
+* @returns 각 타겟에 복사된 파일들의 절대 경로 배열 (flat).
 */
 async function actionSyncFilesToTargets(tsPaths) {
 	const { targets } = Sonamu.config.sync;
@@ -65,7 +95,6 @@ async function actionSyncFilesToTargets(tsPaths) {
 		if (!await exists(dir)) {
 			await mkdir(dir, { recursive: true });
 		}
-		!isTest() && console.log(chalk.bold("Copied: ") + chalk.blue(dst.replace(`${Sonamu.appRootPath}/`, "")));
 		const syncHeader = [
 			"/**",
 			" * @generated",
@@ -73,18 +102,104 @@ async function actionSyncFilesToTargets(tsPaths) {
 			" */"
 		].join("\n");
 		await copyFileWithReplaceCoreToShared(realSrc, dst, syncHeader);
+		await trackWritten(dst);
+		!isTest() && console.log(chalk.bold("Copied: ") + chalk.blue(dst.replace(`${Sonamu.appRootPath}/`, "")));
 		return dst;
 	}))))).flat();
 }
+/**
+* shared 템플릿으로부터 sonamu.shared.ts 파일을 만들어서 모든 타겟 디렉토리에 갖다 둡니다.
+* 파일을 만드는 과정에서 여러 치환 가공이 일어납니다.
+*
+* 다른 액션들과 달리, 이미 파일이 있으면 그냥 놔둡니다. 그래서 함수 이름 끝에 써놨어요 ㅎ
+*/
+async function actionCopySharedToTargetsIfNotExists() {
+	const { targets } = Sonamu.config.sync;
+	const dictUtilsPath = path.join(import.meta.dirname.replace("/dist/", "/src/"), "../dict/utils.ts");
+	const dictUtilsCode = await exists(dictUtilsPath) ? await readFile(dictUtilsPath, "utf-8") : "";
+	const convertMap = {
+		baseUrl: Sonamu.config.server.baseUrl ?? `http://${Sonamu.config.server.listen?.host ?? "localhost"}:${Sonamu.config.server.listen?.port ?? 3e3}`,
+		dictUtils: dictUtilsCode
+	};
+	for (const target of targets) {
+		const srcPath = path.join(import.meta.dirname.replace("/dist/", "/src/"), `../shared/${target}.shared.ts.txt`);
+		if (!await exists(srcPath)) {
+			continue;
+		}
+		if (!await exists(path.join(Sonamu.appRootPath, target))) {
+			throw new Error(`Tried to copy sonamu.shared.ts to target '${target}' but the target directory does not exist. Please check your project directory structure.`);
+		}
+		const fullText = await readFile(srcPath, "utf-8");
+		const convertedText = Object.entries(convertMap).reduce((acc, [key, value]) => acc.replace(`$[[${key}]]`, value), fullText);
+		const destPath = path.join(Sonamu.appRootPath, target, "src/services/sonamu.shared.ts");
+		if (!await exists(path.dirname(destPath))) {
+			await mkdir(path.dirname(destPath), { recursive: true });
+			console.warn(`Created directory '${path.dirname(destPath)}' because it did not exist.`);
+		}
+		if (await exists(destPath)) {
+			continue;
+		}
+		await writeFile(destPath, await formatCode(convertedText, destPath));
+		!isTest() && console.log(chalk.bold("Copied: ") + chalk.blue(path.relative(Sonamu.appRootPath, destPath)));
+	}
+}
+/**
+* Sonamu Dictionary(SD)를 모든 타겟(api + web/app 등)에 동기화합니다.
+*
+* 각 타겟에 대해:
+* - target이 api가 아니면 사용자 작성 locale 파일(ko.ts/en.ts/...)을 api → target으로 복사
+* - sd 템플릿을 렌더링해서 sd.generated.ts 생성 (overwrite)
+*
+* 한 타겟에서 실패해도 다른 타겟은 계속 진행합니다.
+*/
+async function actionSyncSonamuDictionary() {
+	const { targets } = Sonamu.config.sync;
+	const i18nConfig = Sonamu.config.i18n;
+	const targetList = ["api", ...targets];
+	const apiI18nDir = path.join(Sonamu.appRootPath, Sonamu.config.api.dir, "src/i18n");
+	for (const target of targetList) {
+		try {
+			if (target !== "api") {
+				await syncLocaleFiles(target, apiI18nDir, i18nConfig.supportedLocales);
+			}
+			await generateTemplate("sd", { target }, { overwrite: true });
+		} catch (e) {
+			console.error(`Failed to generate SD template for ${target}:`, e);
+		}
+	}
+}
+/**
+* api의 locale 파일을 web/app으로 복사합니다.
+*/
+async function syncLocaleFiles(target, apiI18nDir, locales) {
+	const targetI18nDir = path.join(Sonamu.appRootPath, target, "src/i18n");
+	await mkdir(targetI18nDir, { recursive: true });
+	for (const locale of locales) {
+		const sourceFile = path.join(apiI18nDir, `${locale}.ts`);
+		const targetFile = path.join(targetI18nDir, `${locale}.ts`);
+		const syncHeader = [
+			"/**",
+			" * @generated",
+			" * API에서 동기화된 파일입니다. 직접 수정하지 마세요.",
+			" */"
+		].join("\n");
+		await copyFileWithReplaceCoreToShared(sourceFile, targetFile, syncHeader);
+		await trackWritten(targetFile);
+		!isTest() && console.log(chalk.bold("Copied: ") + chalk.cyan(`${target}/src/i18n/${locale}.ts`));
+	}
+}
 var init_syncer_actions = __esmMin((() => {
 	init_sonamu();
+	init_so_exceptions();
 	init_naite();
 	init_controller();
+	init_formatter();
 	init_fs_utils();
 	init_code_generator();
+	init_file_tracking();
 }));
 
 //#endregion
 init_syncer_actions();
-export { actionGenerateHttps, actionGenerateSchemas, actionGenerateServices, actionGenerateSsr, actionSyncConfig, actionSyncFilesToTargets, init_syncer_actions };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+export { actionCopySharedToTargetsIfNotExists, actionGenerateHttps, actionGenerateInitialTypes, actionGenerateSchemas, actionGenerateServices, actionGenerateSsrEntryServerIfNotExists, actionGenerateSsrQueries, actionSyncConfig, actionSyncFilesToTargets, actionSyncSonamuDictionary, init_syncer_actions };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"syncer-actions.js","names":[],"sources":["../../src/syncer/syncer-actions.ts"],"sourcesContent":["import assert from \"assert\";\nimport { mkdir, readFile, writeFile } from \"fs/promises\";\nimport path, { dirname } from \"path\";\n\nimport chalk from \"chalk\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport { type EntityNamesRecord } from \"../entity/entity-manager\";\nimport { AlreadyProcessedException } from \"../exceptions/so-exceptions\";\nimport { Naite } from \"../naite/naite\";\nimport { isTest } from \"../utils/controller\";\nimport { formatCode } from \"../utils/formatter\";\nimport { copyFileWithReplaceCoreToShared, exists } from \"../utils/fs-utils\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\nimport { generateTemplate } from \"./code-generator\";\nimport { trackWritten } from \"./file-tracking\";\n\n// web/.sonamu.env 에 현재 설정값 저장\nexport async function actionSyncConfig() {\n  const { host, port } = Sonamu.config.server.listen ?? {};\n  const content = `API_HOST=${host ?? \"localhost\"}\\nAPI_PORT=${port ?? 3000}`;\n\n  Naite.t(\"actionSyncConfig\", { content });\n  await Promise.all([\n    ...Sonamu.config.sync.targets.map(async (target) => {\n      await writeFile(path.join(Sonamu.appRootPath, target, \".sonamu.env\"), content);\n    }),\n    generateTemplate(\"generated_sso\", {}, { overwrite: true }),\n  ]);\n}\n\n/**\n * services.generated.ts를 생성합니다.\n * @param paramsArray\n * @returns 생성된 파일 경로 배열.\n */\nexport async function actionGenerateServices(\n  paramsArray: {\n    namesRecord: EntityNamesRecord;\n  }[],\n): Promise<AbsolutePath[]> {\n  Naite.t(\"actionGenerateServices\", paramsArray);\n\n  // services.generated.ts 통합 파일 생성\n  const servicesFile = await generateTemplate(\n    \"services\",\n    {},\n    {\n      overwrite: true,\n    },\n  );\n\n  return [...servicesFile];\n}\n\n/**\n * Entity에 딸린 초기 types.ts를 만들어줍니다.\n * @param entityId\n */\nexport async function actionGenerateInitialTypes(entityId: string): Promise<AbsolutePath[]> {\n  return generateTemplate(\"init_types\", { entityId });\n}\n\n/**\n * sonamu.generated.ts와 sonamu.generated.sso.ts를 생성합니다.\n * @returns 생성된 파일 경로 배열.\n */\nexport async function actionGenerateSchemas(): Promise<AbsolutePath[]> {\n  return (\n    await Promise.all([\n      generateTemplate(\"generated_sso\", {}, { overwrite: true }),\n      generateTemplate(\"generated\", {}, { overwrite: true }),\n    ])\n  ).flat();\n}\n\n/**\n * sonamu.generated.http를 생성합니다.\n * @returns 생성된 파일 경로.\n */\nexport async function actionGenerateHttps(): Promise<AbsolutePath> {\n  const [res] = await generateTemplate(\n    \"generated_http\",\n    { entityId: \"dummy\" },\n    { overwrite: true },\n  );\n  assert(res);\n  return res;\n}\n\n/**\n * queries.generated.ts 재생성합니다.\n * @returns 생성된 파일 경로 배열.\n */\nexport async function actionGenerateSsrQueries(): Promise<AbsolutePath[]> {\n  return generateTemplate(\"queries\", {}, { overwrite: true });\n}\n\n/**\n * entry-server.generated.tsx를 생성합니다.\n * 다른 액션들과 달리, 이미 파일이 있으면 그냥 놔둡니다. 그래서 함수 이름 끝에 써놨어요 ㅎ\n * 입력 의존 없는 정적 코드라 매번 overwrite는 mtime만 갱신하는 의미 없는 동작.\n * 템플릿 자체가 변경된 경우(Sonamu 업그레이드)에는 사용자가 파일을 삭제한 뒤 sync로 재생성.\n * @returns 생성된 파일 경로 배열 (이미 있으면 빈 배열).\n */\nexport async function actionGenerateSsrEntryServerIfNotExists(): Promise<AbsolutePath[]> {\n  try {\n    return await generateTemplate(\"entry_server\", {}, { overwrite: false });\n  } catch (e) {\n    // generateTemplate은 overwrite: false에서 파일이 이미 있으면 예외를 던집니다.\n    // IfNotExists 의미상 \"그냥 놔둔다\"가 정상이므로 빈 배열로 변환합니다.\n    if (e instanceof AlreadyProcessedException) {\n      return [];\n    }\n    throw e;\n  }\n}\n\n/**\n * 주어진 .ts 파일들(api에 있다고 가정)을 모든 타겟 디렉토리의 services에 갖다 둡니다.\n * 이때 내부의 sonamu import는 sonamu.shared.ts import로 치환되고,\n * 경로의 /application/은 /services/로 치환됩니다.\n *\n * @param tsPaths 복사할 파일들의 절대 경로\n * @returns 각 타겟에 복사된 파일들의 절대 경로 배열 (flat).\n */\nexport async function actionSyncFilesToTargets(tsPaths: AbsolutePath[]): Promise<string[]> {\n  const { targets } = Sonamu.config.sync;\n  const { dir: apiDir } = Sonamu.config.api;\n\n  return (\n    await Promise.all(\n      targets.map(async (target) =>\n        Promise.all(\n          tsPaths.map(async (realSrc) => {\n            const dst = realSrc\n              .replace(`/${apiDir}/`, `/${target}/`)\n              .replace(\"/application/\", \"/services/\");\n            const dir = dirname(dst);\n            if (!(await exists(dir))) {\n              await mkdir(dir, { recursive: true });\n            }\n            const syncHeader = [\n              \"/**\",\n              \" * @generated\",\n              \" * API에서 동기화된 파일입니다. 직접 수정하지 마세요.\",\n              \" */\",\n            ].join(\"\\n\");\n            await copyFileWithReplaceCoreToShared(realSrc, dst, syncHeader);\n            await trackWritten(dst as AbsolutePath);\n            !isTest() &&\n              console.log(\n                chalk.bold(\"Copied: \") + chalk.blue(dst.replace(`${Sonamu.appRootPath}/`, \"\")),\n              );\n            return dst;\n          }),\n        ),\n      ),\n    )\n  ).flat();\n}\n\n/**\n * shared 템플릿으로부터 sonamu.shared.ts 파일을 만들어서 모든 타겟 디렉토리에 갖다 둡니다.\n * 파일을 만드는 과정에서 여러 치환 가공이 일어납니다.\n *\n * 다른 액션들과 달리, 이미 파일이 있으면 그냥 놔둡니다. 그래서 함수 이름 끝에 써놨어요 ㅎ\n */\nexport async function actionCopySharedToTargetsIfNotExists(): Promise<void> {\n  const { targets } = Sonamu.config.sync;\n\n  // plural.ts 내용을 읽어서 shared 파일에 삽입합니다.\n  const dictUtilsPath = path.join(\n    import.meta.dirname.replace(\"/dist/\", \"/src/\"),\n    \"../dict/utils.ts\",\n  );\n  const dictUtilsCode = (await exists(dictUtilsPath)) ? await readFile(dictUtilsPath, \"utf-8\") : \"\";\n\n  // 특정 변수 치환을 위해서 사용합니다.\n  const convertMap = {\n    baseUrl:\n      Sonamu.config.server.baseUrl ??\n      `http://${Sonamu.config.server.listen?.host ?? \"localhost\"}:${Sonamu.config.server.listen?.port ?? 3000}`,\n    dictUtils: dictUtilsCode,\n  };\n\n  for (const target of targets) {\n    // 지금 가져가려는 이 파일은 Sonamu 코드베이스의 일부입니다.\n    // 그런데 dist 속 빌드된 소스 코드 파일이 필요한 것이 아니고, src에만 있는 텍스트 파일이 필요합니다.\n    // 따라서 /src/에서 찾습니다.\n    const srcPath = path.join(\n      import.meta.dirname.replace(\"/dist/\", \"/src/\"),\n      `../shared/${target}.shared.ts.txt`,\n    );\n    if (!(await exists(srcPath))) {\n      continue;\n    }\n    if (!(await exists(path.join(Sonamu.appRootPath, target)))) {\n      throw new Error(\n        `Tried to copy sonamu.shared.ts to target '${target}' but the target directory does not exist. Please check your project directory structure.`,\n      );\n    }\n\n    const fullText = await readFile(srcPath, \"utf-8\");\n    const convertedText = Object.entries(convertMap).reduce(\n      (acc, [key, value]) => acc.replace(`$[[${key}]]`, value),\n      fullText,\n    );\n\n    // 이건 프로젝트에 .ts 소스 코드 파일을 생성하는 것이므로 src의 .ts 경로로 갑니다.\n    const destPath = path.join(Sonamu.appRootPath, target, \"src/services/sonamu.shared.ts\");\n\n    // 정말 혹시나지만 target 디렉토리는 있어도 src/services 디렉토리는 없을 수 있으므로 미리 생성해줍니다.\n    if (!(await exists(path.dirname(destPath)))) {\n      await mkdir(path.dirname(destPath), { recursive: true });\n      console.warn(`Created directory '${path.dirname(destPath)}' because it did not exist.`);\n    }\n\n    // 파일이 이미 존재하면 건너뜁니다.\n    // sonamu.shared.ts는 프로젝트에서 자유롭게 커스터마이징할 수 있어야 하므로,\n    // 최초 1회만 생성하고 이후에는 덮어쓰지 않습니다.\n    // 템플릿 내용($[[dictUtils]] 등)이 변경되었을 때 반영이 필요하면,\n    // 해당 파일을 삭제한 뒤 `pnpm sonamu sync`로 재생성하면 됩니다.\n    if (await exists(destPath)) {\n      continue;\n    }\n\n    await writeFile(destPath, await formatCode(convertedText, destPath));\n    !isTest() &&\n      console.log(chalk.bold(\"Copied: \") + chalk.blue(path.relative(Sonamu.appRootPath, destPath)));\n  }\n}\n\n/**\n * Sonamu Dictionary(SD)를 모든 타겟(api + web/app 등)에 동기화합니다.\n *\n * 각 타겟에 대해:\n * - target이 api가 아니면 사용자 작성 locale 파일(ko.ts/en.ts/...)을 api → target으로 복사\n * - sd 템플릿을 렌더링해서 sd.generated.ts 생성 (overwrite)\n *\n * 한 타겟에서 실패해도 다른 타겟은 계속 진행합니다.\n */\nexport async function actionSyncSonamuDictionary(): Promise<void> {\n  const { targets } = Sonamu.config.sync;\n  const i18nConfig = Sonamu.config.i18n;\n\n  const targetList = [\"api\", ...targets] as (\"api\" | \"web\" | \"app\")[];\n\n  const apiI18nDir = path.join(Sonamu.appRootPath, Sonamu.config.api.dir, \"src/i18n\");\n\n  for (const target of targetList) {\n    try {\n      // web/app의 경우 locale 파일들을 api에서 복사\n      if (target !== \"api\") {\n        await syncLocaleFiles(target, apiI18nDir, i18nConfig.supportedLocales);\n      }\n\n      await generateTemplate(\"sd\", { target }, { overwrite: true });\n    } catch (e) {\n      console.error(`Failed to generate SD template for ${target}:`, e);\n    }\n  }\n}\n\n/**\n * api의 locale 파일을 web/app으로 복사합니다.\n */\nasync function syncLocaleFiles(\n  target: string,\n  apiI18nDir: string,\n  locales: string[],\n): Promise<void> {\n  const targetI18nDir = path.join(Sonamu.appRootPath, target, \"src/i18n\");\n\n  // 디렉토리가 없으면 생성\n  await mkdir(targetI18nDir, { recursive: true });\n\n  for (const locale of locales) {\n    const sourceFile = path.join(apiI18nDir, `${locale}.ts`);\n    const targetFile = path.join(targetI18nDir, `${locale}.ts`);\n\n    const syncHeader = [\n      \"/**\",\n      \" * @generated\",\n      \" * API에서 동기화된 파일입니다. 직접 수정하지 마세요.\",\n      \" */\",\n    ].join(\"\\n\");\n    await copyFileWithReplaceCoreToShared(sourceFile, targetFile, syncHeader);\n    await trackWritten(targetFile as AbsolutePath);\n    !isTest() &&\n      console.log(chalk.bold(\"Copied: \") + chalk.cyan(`${target}/src/i18n/${locale}.ts`));\n  }\n}\n"],"mappings":"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"}

package/dist/syncer/syncer.d.ts

@@ -19,37 +19,59 @@ export declare class Syncer {
     eventEmitter: EventEmitter;
     /**
      * 체크섬이 변경된 부분에 대해 싱크를 진행합니다.
-     * sonamu.shared.ts는 파일이 없을 때만 1회 생성하고, 이후에는 덮어쓰지 않습니다.
+     * dev 서버가 처음 떴을 때, sonamu sync 할 때 실행됩니다. 이후에는 syncFromWatcher 경로를 타요.
      * @returns
      */
     sync(): Promise<void>;
     /**
-     * Watcher가 감지한 파일 변경 사항에 대해 싱크를 진행합니다.
-     * 주어진 변경 파일들 중 체크섬 관리 대상인 것들만 가져다가 싱크를 진행합니다.
-     * 체크섬 파일 업데이트는 여기에서 하지 않습니다. 호출자가 합니다.
-     * @param diffFilePath - 변경 파일들. 프로젝트 루트부터 "src/" 또는 "dist/"로 시작하는 상대 경로입니다. 예시: "src/application/user/user.model.ts"
+     * 강제 풀-싱크: lock을 무시하고 처음부터 다시 싱크합니다.
+     *
+     * **사용처**: git post-merge hook, CI, dev 서버의 `f` 핫키.
+     * **실패 안전성**: 도중에 프로세스가 죽어 lock 없는 상태로 남아도 무해 — 다음 sync에서
+     * lock 없으면 자연스럽게 풀-싱크가 트리거되어 새 lock이 작성됨.
      */
-    syncFromWatcher(event: string, diffFilePath: AbsolutePath): Promise<void>;
+    forceSync(): Promise<void>;
+    /**
+     * Watcher가 batch로 모은 변경 파일들에 대해 한 번의 HMR/sync 사이클을 돕니다.
+     *
+     * HMR은 api/src 안에서 일어나는 모든 파일들에 대해서 수행합니다.
+     * checksumPatternGroup 매칭 여부와 무관하게 api/src 전체 대상입니다.
+     * 가령 api/src/utils/subset-loaders.ts 같은 파일도 변경되면 HMR은 해줍니다.
+     *
+     * Sync는 checksumPatternGroup으로 매칭되는 파일들에 대해서만 수행합니다.
+     * 여기에는 web/src나 app/src 같은 다른 target의 파일이 포함될 수 있습니다.
+     * 이런 non-api 경로의 파일들은 HMR과는 아무 상관이 없으므로, invalidate을 하지 않습니다.
+     *
+     * @param fileEvents - path → event 맵. event는 "change" | "add".
+     */
+    hmrAndSync(fileEvents: Map<AbsolutePath, "change" | "add">): Promise<void>;
+    private extractHmrActionRequiredFileEvents;
+    private extractSyncTriggeringFileEventPaths;
+    private invalidateDependentsAffectedByFileEvents;
     removeInvalidatedRegisteredApis(invalidatedPath: AbsolutePath): (typeof registeredApis)[number][];
-    copySharedToTargets(targets: string[]): Promise<void>;
     autoloadTypes(): Promise<void>;
     autoloadModels(): Promise<void>;
     autoloadApis(): Promise<void>;
     autoloadWorkflows(): Promise<void>;
-    autoloadSSRRoutes(): Promise<void>;
+    autoloadSsrRoutes(): Promise<void>;
     /**
      * 실제 싱크를 수행하는 본체입니다.
      * 변경된 파일들을 타입별로 분류하고 각 타입에 맞는 액션을 실행합니다.
+     *
      * @param diffFilePaths - 변경된 파일들의 절대 경로 목록
      * @returns diffTypes - 변경된 파일의 타입 목록 (entity, types, model 등)
      */
     doSyncActions(diffFilePaths: AbsolutePath[]): Promise<{
-        diffTypes: string[];
+        diffTypes: FileType[];
     }>;
     calculateDiffGroups(diffFiles: AbsolutePath[]): DiffGroups;
-    handleTruthSourceChanges(diffGroups: DiffGroups, diffTypes: string[]): Promise<void>;
-    handleSyncableFileChanges(diffGroups: DiffGroups): Promise<FileType[]>;
+    private changeMatcher;
+    handleTruthSourceChanges(diffGroups: DiffGroups): Promise<void>;
     handleImplementationChanges(diffGroups: DiffGroups): Promise<void>;
+    handleAuxiliarySymbolChanges(diffGroups: DiffGroups): Promise<void>;
+    handleConfigChanges(_: DiffGroups): Promise<void>;
+    handleSonamuDictionaryRelatedChanges(_: DiffGroups): Promise<void>;
+    handleDrifts(drifts: AbsolutePath[]): Promise<void>;
     /**
      * 주어진 엔티티와 템플릿 키에 대해, 생성된 코드가 존재하는지 확인합니다.
      * @param entityId 엔티티 ID
@@ -93,14 +115,6 @@ export declare class Syncer {
      * 하위호환용 프록시 메소드입니다.
      */
     renewChecksums(): Promise<void>;
-    /**
-     * SD(Sonamu Dictionary) 템플릿을 생성합니다.
-     */
-    syncSD(): Promise<void>;
-    /**
-     * api의 locale 파일을 web/app으로 복사합니다.
-     */
-    private syncLocaleFiles;
 }
 export {};
 //# sourceMappingURL=syncer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"syncer.d.ts","sourceRoot":"","sources":["../../src/syncer/syncer.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"syncer.d.ts","sourceRoot":"","sources":["../../src/syncer/syncer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAQtC,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAKnD,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACxE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAKtD,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAMxD,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAGvF,KAAK,UAAU,GAAG;KACf,GAAG,IAAI,QAAQ,GAAG,YAAY,EAAE;CAClC,CAAC;AAEF,qBAAa,MAAM;IACjB,IAAI,EAAE,UAAU,CAAM;IACtB,KAAK,EAAE,WAAW,CAAM;IACxB,MAAM,EAAE,YAAY,CAAM;IAC1B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAAC,CAAa;IACvD,YAAY,EAAE,YAAY,CAAsB;IAEhD;;;;OAIG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IA6B3B;;;;;;OAMG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAQhC;;;;;;;;;;;;OAYG;IACG,UAAU,CAAC,UAAU,EAAE,GAAG,CAAC,YAAY,EAAE,QAAQ,GAAG,KAAK,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAkChF,OAAO,CAAC,kCAAkC;YAc5B,mCAAmC;YAkBnC,wCAAwC;IAkDtD,+BAA+B,CAC7B,eAAe,EAAE,YAAY,GAC5B,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,EAAE;IAiB9B,aAAa;IAIb,cAAc;IAId,YAAY;IAIZ,iBAAiB;IAKjB,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IA8BxC;;;;;;OAMG;IACG,aAAa,CAAC,aAAa,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC;QAAE,SAAS,EAAE,QAAQ,EAAE,CAAA;KAAE,CAAC;IA2CtF,mBAAmB,CAAC,SAAS,EAAE,YAAY,EAAE,GAAG,UAAU;IAkB1D,OAAO,CAAC,aAAa;IA8Bf,wBAAwB,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAkC/D,2BAA2B,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAkClE,4BAA4B,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAMnE,mBAAmB,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAIjD,oCAAoC,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAIlE,YAAY,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAczD;;;;;;OAMG;IACG,kBAAkB,CACtB,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,WAAW,EACxB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC;IAepE;;;;;OAKG;IACG,WAAW,CACf,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE;QACL,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC;KAC3B,GACA,OAAO,CAAC,MAAM,CAAC,GAAG,WAAW,GAAG,MAAM,EAAE,EAAE,OAAO,CAAC,CAAC;IAqCtD;;OAEG;IACG,YAAY,CAAC,IAAI,EAAE,eAAe,CAAC,QAAQ,CAAC;IAIlD;;OAEG;IACG,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAIlE;;OAEG;IACG,gBAAgB,CAAC,CAAC,SAAS,WAAW,EAC1C,GAAG,EAAE,CAAC,EACN,eAAe,EAAE,eAAe,CAAC,CAAC,CAAC,EACnC,gBAAgB,CAAC,EAAE,eAAe,GACjC,OAAO,CAAC,YAAY,EAAE,CAAC;IAI1B;;OAEG;IACG,cAAc,CAAC,CAAC,SAAS,MAAM,eAAe,EAClD,GAAG,EAAE,CAAC,EACN,eAAe,EAAE,eAAe,CAAC,CAAC,CAAC,GAClC,OAAO,CAAC,WAAW,EAAE,CAAC;IAIzB;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;CAGtC"}