sonamu 0.9.8 → 0.9.10

package/dist/syncer/file-patterns.js

@@ -39,7 +39,7 @@ function getChecksumPatternGroup() {
 		workflow: api("src/application/**/*.workflow.ts"),
 		i18n: api("src/i18n/**/!(sd.generated).ts"),
 		generated: api("src/application/**/*.generated.{ts,tsx,sso.ts}"),
-		generatedCopied: targets("src/services/**/{sonamu,queries}.generated.{ts,tsx}"),
+		generatedCopied: targets("src/services/**/sonamu.generated.{ts,tsx}"),
 		httpGenerated: api("src/application/**/*.generated.http"),
 		servicesGenerated: targets("src/services/services.generated.ts"),
 		sdGenerated: anywhere("src/i18n/**/sd.generated.ts"),
@@ -87,4 +87,4 @@ var init_file_patterns = __esmMin((() => {
 //#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.*, queries.generated.ts).\n    // - api 전용 자산: api에만 만들어짐 (sonamu.generated.http).\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,queries}.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,sDAAsD;EAC/E,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,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"}

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

@@ -38,20 +38,14 @@ export declare function actionGenerateSsrQueries(): Promise<AbsolutePath[]>;
  */
 export declare function actionGenerateSsrEntryServerIfNotExists(): Promise<AbsolutePath[]>;
 /**
- * 주어진 .ts 파일들(api에 있다고 가정)을 타겟 디렉토리의 services에 갖다 둡니다.
+ * 주어진 .ts 파일들(api에 있다고 가정)을 모든 타겟 디렉토리의 services에 갖다 둡니다.
  * 이때 내부의 sonamu import는 sonamu.shared.ts import로 치환되고,
  * 경로의 /application/은 /services/로 치환됩니다.
  *
- * 기본은 Sonamu.config.sync.targets 전체를 대상으로 하며,
- * onlyTargetsStartingWith 화이트리스트로 일부 target에만 분배할 수 있습니다.
- * 가량 SSR-only인 queries.generated.ts같은 친구들은 "web"으로 시작하는 타겟들에만 보낼 수 있어요.
- * ["web"]으로 넘기면 web, web-admin, webapp 등에 모두 매치됩니다.
- *
  * @param tsPaths 복사할 파일들의 절대 경로
- * @param onlyTargetsStartingWith 분배할 target 접두어들의 화이트리스트. 미지정 시 모든 target.
  * @returns 각 타겟에 복사된 파일들의 절대 경로 배열 (flat).
  */
-export declare function actionSyncFilesToTargets(tsPaths: AbsolutePath[], onlyTargetsStartingWith?: string[]): Promise<string[]>;
+export declare function actionSyncFilesToTargets(tsPaths: AbsolutePath[]): Promise<string[]>;
 /**
  * shared 템플릿으로부터 sonamu.shared.ts 파일을 만들어서 모든 타겟 디렉토리에 갖다 둡니다.
  * 파일을 만드는 과정에서 여러 치환 가공이 일어납니다.

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

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

package/dist/syncer/syncer-actions.js

@@ -79,22 +79,15 @@ async function actionGenerateSsrEntryServerIfNotExists() {
 	}
 }
 /**
-* 주어진 .ts 파일들(api에 있다고 가정)을 타겟 디렉토리의 services에 갖다 둡니다.
+* 주어진 .ts 파일들(api에 있다고 가정)을 모든 타겟 디렉토리의 services에 갖다 둡니다.
 * 이때 내부의 sonamu import는 sonamu.shared.ts import로 치환되고,
 * 경로의 /application/은 /services/로 치환됩니다.
 *
-* 기본은 Sonamu.config.sync.targets 전체를 대상으로 하며,
-* onlyTargetsStartingWith 화이트리스트로 일부 target에만 분배할 수 있습니다.
-* 가량 SSR-only인 queries.generated.ts같은 친구들은 "web"으로 시작하는 타겟들에만 보낼 수 있어요.
-* ["web"]으로 넘기면 web, web-admin, webapp 등에 모두 매치됩니다.
-*
 * @param tsPaths 복사할 파일들의 절대 경로
-* @param onlyTargetsStartingWith 분배할 target 접두어들의 화이트리스트. 미지정 시 모든 target.
 * @returns 각 타겟에 복사된 파일들의 절대 경로 배열 (flat).
 */
-async function actionSyncFilesToTargets(tsPaths, onlyTargetsStartingWith) {
-	const allTargets = Sonamu.config.sync.targets;
-	const targets = onlyTargetsStartingWith ? allTargets.filter((t) => onlyTargetsStartingWith.some((prefix) => t.startsWith(prefix))) : allTargets;
+async function actionSyncFilesToTargets(tsPaths) {
+	const { targets } = Sonamu.config.sync;
 	const { dir: apiDir } = Sonamu.config.api;
 	return (await Promise.all(targets.map(async (target) => Promise.all(tsPaths.map(async (realSrc) => {
 		const dst = realSrc.replace(`/${apiDir}/`, `/${target}/`).replace("/application/", "/services/");
@@ -209,4 +202,4 @@ var init_syncer_actions = __esmMin((() => {
 //#endregion
 init_syncer_actions();
 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 * 기본은 Sonamu.config.sync.targets 전체를 대상으로 하며,\n * onlyTargetsStartingWith 화이트리스트로 일부 target에만 분배할 수 있습니다.\n * 가량 SSR-only인 queries.generated.ts같은 친구들은 \"web\"으로 시작하는 타겟들에만 보낼 수 있어요.\n * [\"web\"]으로 넘기면 web, web-admin, webapp 등에 모두 매치됩니다.\n *\n * @param tsPaths 복사할 파일들의 절대 경로\n * @param onlyTargetsStartingWith 분배할 target 접두어들의 화이트리스트. 미지정 시 모든 target.\n * @returns 각 타겟에 복사된 파일들의 절대 경로 배열 (flat).\n */\nexport async function actionSyncFilesToTargets(\n  tsPaths: AbsolutePath[],\n  onlyTargetsStartingWith?: string[],\n): Promise<string[]> {\n  const allTargets = Sonamu.config.sync.targets;\n  const targets = onlyTargetsStartingWith\n    ? allTargets.filter((t) => onlyTargetsStartingWith.some((prefix) => t.startsWith(prefix)))\n    : allTargets;\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":";;;;;;;;;;;;;;;AAkBA,eAAsB,mBAAmB;CACvC,MAAM,EAAE,MAAM,SAAS,OAAO,OAAO,OAAO,UAAU,EAAE;CACxD,MAAM,UAAU,YAAY,QAAQ,YAAY,aAAa,QAAQ;AAErE,OAAM,EAAE,oBAAoB,EAAE,SAAS,CAAC;AACxC,OAAM,QAAQ,IAAI,CAChB,GAAG,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,WAAW;AAClD,QAAM,UAAU,KAAK,KAAK,OAAO,aAAa,QAAQ,cAAc,EAAE,QAAQ;GAC9E,EACF,iBAAiB,iBAAiB,EAAE,EAAE,EAAE,WAAW,MAAM,CAAC,CAC3D,CAAC;;;;;;;AAQJ,eAAsB,uBACpB,aAGyB;AACzB,OAAM,EAAE,0BAA0B,YAAY;CAG9C,MAAM,eAAe,MAAM,iBACzB,YACA,EAAE,EACF,EACE,WAAW,MACZ,CACF;AAED,QAAO,CAAC,GAAG,aAAa;;;;;;AAO1B,eAAsB,2BAA2B,UAA2C;AAC1F,QAAO,iBAAiB,cAAc,EAAE,UAAU,CAAC;;;;;;AAOrD,eAAsB,wBAAiD;AACrE,SACE,MAAM,QAAQ,IAAI,CAChB,iBAAiB,iBAAiB,EAAE,EAAE,EAAE,WAAW,MAAM,CAAC,EAC1D,iBAAiB,aAAa,EAAE,EAAE,EAAE,WAAW,MAAM,CAAC,CACvD,CAAC,EACF,MAAM;;;;;;AAOV,eAAsB,sBAA6C;CACjE,MAAM,CAAC,OAAO,MAAM,iBAClB,kBACA,EAAE,UAAU,SAAS,EACrB,EAAE,WAAW,MAAM,CACpB;AACD,QAAO,IAAI;AACX,QAAO;;;;;;AAOT,eAAsB,2BAAoD;AACxE,QAAO,iBAAiB,WAAW,EAAE,EAAE,EAAE,WAAW,MAAM,CAAC;;;;;;;;;AAU7D,eAAsB,0CAAmE;AACvF,KAAI;AACF,SAAO,MAAM,iBAAiB,gBAAgB,EAAE,EAAE,EAAE,WAAW,OAAO,CAAC;UAChE,GAAG;AAGV,MAAI,aAAa,2BAA2B;AAC1C,UAAO,EAAE;;AAEX,QAAM;;;;;;;;;;;;;;;;;AAkBV,eAAsB,yBACpB,SACA,yBACmB;CACnB,MAAM,aAAa,OAAO,OAAO,KAAK;CACtC,MAAM,UAAU,0BACZ,WAAW,QAAQ,MAAM,wBAAwB,MAAM,WAAW,EAAE,WAAW,OAAO,CAAC,CAAC,GACxF;CACJ,MAAM,EAAE,KAAK,WAAW,OAAO,OAAO;AAEtC,SACE,MAAM,QAAQ,IACZ,QAAQ,IAAI,OAAO,WACjB,QAAQ,IACN,QAAQ,IAAI,OAAO,YAAY;EAC7B,MAAM,MAAM,QACT,QAAQ,IAAI,OAAO,IAAI,IAAI,OAAO,GAAG,CACrC,QAAQ,iBAAiB,aAAa;EACzC,MAAM,MAAM,QAAQ,IAAI;AACxB,MAAI,CAAE,MAAM,OAAO,IAAI,EAAG;AACxB,SAAM,MAAM,KAAK,EAAE,WAAW,MAAM,CAAC;;EAEvC,MAAM,aAAa;GACjB;GACA;GACA;GACA;GACD,CAAC,KAAK,KAAK;AACZ,QAAM,gCAAgC,SAAS,KAAK,WAAW;AAC/D,QAAM,aAAa,IAAoB;AACvC,GAAC,QAAQ,IACP,QAAQ,IACN,MAAM,KAAK,WAAW,GAAG,MAAM,KAAK,IAAI,QAAQ,GAAG,OAAO,YAAY,IAAI,GAAG,CAAC,CAC/E;AACH,SAAO;GACP,CACH,CACF,CACF,EACD,MAAM;;;;;;;;AASV,eAAsB,uCAAsD;CAC1E,MAAM,EAAE,YAAY,OAAO,OAAO;CAGlC,MAAM,gBAAgB,KAAK,KACzB,OAAO,KAAK,QAAQ,QAAQ,UAAU,QAAQ,EAC9C,mBACD;CACD,MAAM,gBAAiB,MAAM,OAAO,cAAc,GAAI,MAAM,SAAS,eAAe,QAAQ,GAAG;CAG/F,MAAM,aAAa;EACjB,SACE,OAAO,OAAO,OAAO,WACrB,UAAU,OAAO,OAAO,OAAO,QAAQ,QAAQ,YAAY,GAAG,OAAO,OAAO,OAAO,QAAQ,QAAQ;EACrG,WAAW;EACZ;AAED,MAAK,MAAM,UAAU,SAAS;EAI5B,MAAM,UAAU,KAAK,KACnB,OAAO,KAAK,QAAQ,QAAQ,UAAU,QAAQ,EAC9C,aAAa,OAAO,gBACrB;AACD,MAAI,CAAE,MAAM,OAAO,QAAQ,EAAG;AAC5B;;AAEF,MAAI,CAAE,MAAM,OAAO,KAAK,KAAK,OAAO,aAAa,OAAO,CAAC,EAAG;AAC1D,SAAM,IAAI,MACR,6CAA6C,OAAO,2FACrD;;EAGH,MAAM,WAAW,MAAM,SAAS,SAAS,QAAQ;EACjD,MAAM,gBAAgB,OAAO,QAAQ,WAAW,CAAC,QAC9C,KAAK,CAAC,KAAK,WAAW,IAAI,QAAQ,MAAM,IAAI,KAAK,MAAM,EACxD,SACD;EAGD,MAAM,WAAW,KAAK,KAAK,OAAO,aAAa,QAAQ,gCAAgC;AAGvF,MAAI,CAAE,MAAM,OAAO,KAAK,QAAQ,SAAS,CAAC,EAAG;AAC3C,SAAM,MAAM,KAAK,QAAQ,SAAS,EAAE,EAAE,WAAW,MAAM,CAAC;AACxD,WAAQ,KAAK,sBAAsB,KAAK,QAAQ,SAAS,CAAC,6BAA6B;;AAQzF,MAAI,MAAM,OAAO,SAAS,EAAE;AAC1B;;AAGF,QAAM,UAAU,UAAU,MAAM,WAAW,eAAe,SAAS,CAAC;AACpE,GAAC,QAAQ,IACP,QAAQ,IAAI,MAAM,KAAK,WAAW,GAAG,MAAM,KAAK,KAAK,SAAS,OAAO,aAAa,SAAS,CAAC,CAAC;;;;;;;;;;;;AAanG,eAAsB,6BAA4C;CAChE,MAAM,EAAE,YAAY,OAAO,OAAO;CAClC,MAAM,aAAa,OAAO,OAAO;CAEjC,MAAM,aAAa,CAAC,OAAO,GAAG,QAAQ;CAEtC,MAAM,aAAa,KAAK,KAAK,OAAO,aAAa,OAAO,OAAO,IAAI,KAAK,WAAW;AAEnF,MAAK,MAAM,UAAU,YAAY;AAC/B,MAAI;AAEF,OAAI,WAAW,OAAO;AACpB,UAAM,gBAAgB,QAAQ,YAAY,WAAW,iBAAiB;;AAGxE,SAAM,iBAAiB,MAAM,EAAE,QAAQ,EAAE,EAAE,WAAW,MAAM,CAAC;WACtD,GAAG;AACV,WAAQ,MAAM,sCAAsC,OAAO,IAAI,EAAE;;;;;;;AAQvE,eAAe,gBACb,QACA,YACA,SACe;CACf,MAAM,gBAAgB,KAAK,KAAK,OAAO,aAAa,QAAQ,WAAW;AAGvE,OAAM,MAAM,eAAe,EAAE,WAAW,MAAM,CAAC;AAE/C,MAAK,MAAM,UAAU,SAAS;EAC5B,MAAM,aAAa,KAAK,KAAK,YAAY,GAAG,OAAO,KAAK;EACxD,MAAM,aAAa,KAAK,KAAK,eAAe,GAAG,OAAO,KAAK;EAE3D,MAAM,aAAa;GACjB;GACA;GACA;GACA;GACD,CAAC,KAAK,KAAK;AACZ,QAAM,gCAAgC,YAAY,YAAY,WAAW;AACzE,QAAM,aAAa,WAA2B;AAC9C,GAAC,QAAQ,IACP,QAAQ,IAAI,MAAM,KAAK,WAAW,GAAG,MAAM,KAAK,GAAG,OAAO,YAAY,OAAO,KAAK,CAAC;;;;cAxSlD;qBAEiC;aACjC;kBACM;iBACG;gBAC4B;sBAExB;qBACL"}
+//# 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,7 +19,7 @@ export declare class Syncer {
     eventEmitter: EventEmitter;
     /**
      * 체크섬이 변경된 부분에 대해 싱크를 진행합니다.
-     * dev 서버가 처음 떴을 때, sonamu sync 할 때 실행됩니다. 이후에는 syncFromWatcher 경로를 타요.
+     * dev 서버가 처음 떴을 때, sonamu sync 할 때 실행됩니다. 이후에는 hmrAndSync 경로를 타요.
      * @returns
      */
     sync(): Promise<void>;

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

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

package/dist/syncer/syncer.js

@@ -53,7 +53,7 @@ var init_syncer = __esmMin((() => {
 		eventEmitter = new EventEmitter();
 		/**
 		* 체크섬이 변경된 부분에 대해 싱크를 진행합니다.
-		* dev 서버가 처음 떴을 때, sonamu sync 할 때 실행됩니다. 이후에는 syncFromWatcher 경로를 타요.
+		* dev 서버가 처음 떴을 때, sonamu sync 할 때 실행됩니다. 이후에는 hmrAndSync 경로를 타요.
 		* @returns
 		*/
 		async sync() {
@@ -164,11 +164,14 @@ var init_syncer = __esmMin((() => {
 			}
 		}
 		removeInvalidatedRegisteredApis(invalidatedPath) {
-			if (!invalidatedPath.endsWith(".model.ts")) {
+			const isModel = invalidatedPath.endsWith(".model.ts");
+			const isFrame = invalidatedPath.endsWith(".frame.ts");
+			if (!isModel && !isFrame) {
 				return [];
 			}
 			const entityId = EntityManager.getEntityIdFromPath(invalidatedPath);
-			const toRemove = registeredApis.filter((api) => api.modelName === `${entityId}Model`);
+			const targetModelName = `${entityId}${isModel ? "Model" : "Frame"}`;
+			const toRemove = registeredApis.filter((api) => api.modelName === targetModelName);
 			for (const api of toRemove) {
 				const idx = registeredApis.indexOf(api);
 				if (idx !== -1) {
@@ -315,8 +318,7 @@ var init_syncer = __esmMin((() => {
 			});
 			await actionGenerateServices(params);
 			await actionGenerateHttps();
-			const queries = await actionGenerateSsrQueries();
-			await actionSyncFilesToTargets(queries, ["web"]);
+			await actionGenerateSsrQueries();
 		}
 		async handleAuxiliarySymbolChanges(diffGroups) {
 			Naite.t("handleAuxiliarySymbolChanges", { diffGroups });
@@ -422,4 +424,4 @@ var init_syncer = __esmMin((() => {
 //#endregion
 init_syncer();
 export { Syncer, init_syncer };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"syncer.js","names":["SyncerActions.actionCopySharedToTargetsIfNotExists","SyncerActions.actionGenerateSsrEntryServerIfNotExists","syncTriggeringPaths: AbsolutePath[]","SyncerActions.actionGenerateInitialTypes","SyncerActions.actionSyncFilesToTargets","SyncerActions.actionGenerateSchemas","params: {\n      namesRecord: EntityNamesRecord;\n    }[]","SyncerActions.actionGenerateServices","SyncerActions.actionGenerateHttps","SyncerActions.actionGenerateSsrQueries","SyncerActions.actionSyncConfig","SyncerActions.actionSyncSonamuDictionary","keys: TemplateKey[]","p","target"],"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 할 때 실행됩니다. 이후에는 syncFromWatcher 경로를 타요.\n   * @returns\n   */\n  async sync(): Promise<void> {\n    // 초기 부트스트랩! 얘네들은 idempotent하고 가볍기 때문에 무지성 실행해도 됩니다.\n    // 얘네들은 sonamu.lock에 들어가지도 않고 따라서 HMR 경로를 타지도 않는 친구들입니다.\n    // 그래서 아무 때나 그냥 돌려주면 되는데, syncFromWatcher에서 매번 하는 것은 낭비이니 여기서 한 번만 합니다.\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    if (!invalidatedPath.endsWith(\".model.ts\" /*소스 코드를 다루는 상황이니 .ts 경로로 봅니다.*/)) {\n      return [];\n    }\n\n    const entityId = EntityManager.getEntityIdFromPath(invalidatedPath);\n    const toRemove = registeredApis.filter((api) => api.modelName === `${entityId}Model`);\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    // services.generated.ts를 target들에, sonamu.generated.http를 api에 만들어줘요.\n    await SyncerActions.actionGenerateServices(params);\n    await SyncerActions.actionGenerateHttps();\n\n    // queries.generated.ts가 만들어집니다.\n    const queries = await SyncerActions.actionGenerateSsrQueries();\n\n    // queries는 SSR 디스크립터(sonamu/ssr 의존)이므로 web target에만 분배합니다.\n    // 다른 target(app 등)이 SSR을 안 쓰면 의미 없는 dead code일 뿐이라 보내지 않습니다.\n    // TODO(병준): web에만 가게 하기 위해서 target prefix를 지정해주었습니다. 나중에 target 시스템이 개선된다면 바꿔주세요.\n    await SyncerActions.actionSyncFilesToTargets(queries, [\"web\"]);\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.actionGenerateSsrEntryServerIfNotExists","syncTriggeringPaths: AbsolutePath[]","SyncerActions.actionGenerateInitialTypes","SyncerActions.actionSyncFilesToTargets","SyncerActions.actionGenerateSchemas","params: {\n      namesRecord: EntityNamesRecord;\n    }[]","SyncerActions.actionGenerateServices","SyncerActions.actionGenerateHttps","SyncerActions.actionGenerateSsrQueries","SyncerActions.actionSyncConfig","SyncerActions.actionSyncSonamuDictionary","keys: TemplateKey[]","p","target"],"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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAWmD;cACZ;sBACkB;aAElB;wBAEwB;aAElB;mBAEgB;oBACV;kBACN;gBACF;qBAEsB;gBACW;sBACR;yBACN;qBACmC;qBAEhB;sBAE/B;CAMrC,SAAb,MAAoB;EAClB,OAAmB,EAAE;EACrB,QAAqB,EAAE;EACvB,SAAuB,EAAE;EACzB,YAA6C,IAAI,KAAK;EACtD,eAA6B,IAAI,cAAc;;;;;;EAO/C,MAAM,OAAsB;AAI1B,SAAMA,sCAAoD;AAC1D,SAAMC,yCAAuD;GAG7D,MAAM,eAAe,MAAM,gCAAgC;AAC3D,OAAI,aAAa,WAAW,GAAG;AAC7B,YAAQ,IAAI,MAAM,MAAM,QAAQ,WAAW,wBAAwB,CAAC,CAAC;AACrE;;AAMF,SAAM,wBACJ,YAAY;AAEV,UAAM,KAAK,cAAc,aAAa;AAGtC,UAAM,gBAAgB;MAExB;IAAE,iBAAiB;IAAW,aAAa;IAAO,CACnD;;;;;;;;;EAUH,MAAM,YAA2B;GAC/B,MAAM,WAAW,KAAK,KAAK,OAAO,aAAa,cAAc;AAC7D,OAAI,MAAM,OAAO,SAAS,EAAE;AAC1B,UAAM,OAAO,SAAS;;AAExB,SAAM,KAAK,MAAM;;;;;;;;;;;;;;;EAgBnB,MAAM,WAAW,YAAgE;GAC/E,MAAM,0BAA0B,KAAK,mCAAmC,WAAW;GACnF,MAAM,sBAAsB,MAAM,KAAK,oCAAoC,WAAW;AAMtF,SAAM,KAAK,yCAAyC,wBAAwB;AAI5E,OAAI,oBAAoB,SAAS,GAAG;AAClC,UAAM,KAAK,cAAc,oBAAoB;;AAY/C,SAAM,KAAK,eAAe;AAC1B,SAAM,KAAK,gBAAgB;AAC3B,SAAM,KAAK,cAAc;AACzB,SAAM,KAAK,mBAAmB;AAC9B,SAAM,KAAK,mBAAmB;AAE9B,QAAK,aAAa,KAAK,iBAAiB;;EAG1C,AAAQ,mCACN,YACqC;GACrC,MAAM,SAAS,KAAK,KAAK,OAAO,aAAa,MAAM;GACnD,MAAM,SAAS,IAAI,KAAqC;AACxD,QAAK,MAAM,CAAC,UAAU,UAAU,YAAY;AAC1C,QAAI,CAAC,SAAS,WAAW,OAAO,EAAE;AAChC;;AAEF,WAAO,IAAI,UAAU,MAAM;;AAE7B,UAAO;;EAGT,MAAc,oCACZ,YACyB;GACzB,MAAM,oBAAoB,uCAAuC;GACjE,MAAMC,sBAAsC,EAAE;AAC9C,QAAK,MAAM,CAAC,iBAAiB,YAAY;IACvC,MAAM,wBAAwB,OAAO,OAAO,kBAAkB,CAAC,MAAM,YACnE,UAAU,cAAc,QAAQ,CACjC;AACD,QAAI,CAAC,uBAAuB;AAC1B;;AAEF,wBAAoB,KAAK,aAAa;;AAGxC,UAAO;;EAGT,MAAc,yCACZ,YACA;AACA,QAAK,MAAM,CAAC,cAAc,UAAU,YAAY;AAK9C,QAAI,CAAC,QAAQ,EAAE;KACb,MAAM,mBAAoB,MAAM,IAAI,eAAe,cAAc,MAAM;AAEvE,SAAI,iBAAiB,SAAS,GAAG;AAC/B,cAAQ,IAAI,MAAM,KAAK,kBAAkB,CAAC;AAE1C,WAAK,MAAM,mBAAmB,kBAAkB;AAC9C,WAAI;QAIF,MAAM,cAAc,KAAK,gCAAgC,gBAAgB;AACzE,YAAI,YAAY,SAAS,GAAG;AAC1B,iBAAQ,IACN,MAAM,KAAK,KAAK,KAAK,SAAS,OAAO,aAAa,gBAAgB,GAAG,EACrE,MAAM,KAAK,SAAS,YAAY,OAAO,QAAQ,CAChD;eACI;AACL,iBAAQ,IAAI,MAAM,KAAK,KAAK,KAAK,SAAS,OAAO,aAAa,gBAAgB,GAAG,CAAC;;gBAE7E,GAAG;AACV,gBAAQ,MAAM,EAAE;AAChB,gBAAQ,MACN,MAAM,IAAI,oDAAoD,kBAAkB,CACjF;;;;;AAST,QAAI,CAAC,QAAQ,IAAI,OAAO,OAAO,MAAM,WAAW,WAAW,OAAO,kBAAkB;AAClF,YAAO,iBAAiB,gBAAgB,CAAC,aAAa,CAAC;AACvD,aAAQ,IACN,MAAM,IAAI,qBAAqB,KAAK,SAAS,OAAO,aAAa,aAAa,GAAG,CAClF;;;;EAKP,gCACE,iBACmC;GAEnC,MAAM,UAAU,gBAAgB,SAAS,YAAY;GACrD,MAAM,UAAU,gBAAgB,SAAS,YAAY;AACrD,OAAI,CAAC,WAAW,CAAC,SAAS;AACxB,WAAO,EAAE;;GAGX,MAAM,WAAW,cAAc,oBAAoB,gBAAgB;GACnE,MAAM,kBAAkB,GAAG,WAAW,UAAU,UAAU;GAC1D,MAAM,WAAW,eAAe,QAAQ,QAAQ,IAAI,cAAc,gBAAgB;AAClF,QAAK,MAAM,OAAO,UAAU;IAC1B,MAAM,MAAM,eAAe,QAAQ,IAAI;AACvC,QAAI,QAAQ,CAAC,GAAG;AACd,oBAAe,OAAO,KAAK,EAAE;;;AAIjC,UAAO;;EAGT,MAAM,gBAAgB;AACpB,QAAK,QAAQ,MAAM,WAAW;;EAGhC,MAAM,iBAAiB;AACrB,QAAK,SAAS,MAAM,YAAY;;EAGlC,MAAM,eAAe;AACnB,QAAK,OAAO,MAAM,UAAU;;EAG9B,MAAM,oBAAoB;AACxB,QAAK,YAAY,MAAM,eAAe;AACtC,SAAM,OAAO,UAAU,YAAY,KAAK,UAAU;;EAGpD,MAAM,oBAAmC;GACvC,MAAM,gBAAgB,KAAK,KAAK,OAAO,aAAa,UAAU;GAG9D,MAAM,EAAE,mBAAmB,MAAM,OAAO;AACxC,mBAAgB;AAGhB,OAAI,CAAE,MAAM,OAAO,cAAc,EAAG;AAClC;;GAIF,MAAM,EAAE,cAAc,MAAM,OAAO;GACnC,MAAM,EAAE,kBAAkB,MAAM,OAAO;GACvC,MAAM,EAAE,gBAAgB,MAAM,OAAO;GAGrC,MAAM,QAAQ,MAAM,UAAU,KAAK,KAAK,eAAe,YAAY,UAAU,CAAC,CAAC;AAE/E,QAAK,MAAM,QAAQ,OAAO;AACxB,QAAI;AAEF,WAAM,cAAc,KAAK;aAClB,GAAG;AACV,aAAQ,MAAM,6BAA6B,QAAQ,EAAE;;;;;;;;;;;EAY3D,MAAM,cAAc,eAAmE;GACrF,MAAM,aAAa,KAAK,oBAAoB,cAAc;GAC1D,MAAM,YAAY,OAAO,KAAK,WAAW;GAIzC,MAAM,EAAE,eAAe,gBAAgB,mBAAmB,KAAK,cAC7D,WACA,WACD;AAED,OAAI,cAAc,UAAU,QAAQ,EAAE;AACpC,UAAM,KAAK,yBAAyB,WAAW;;AAGjD,OAAI,cAAc,SAAS,QAAQ,EAAE;AACnC,UAAM,KAAK,4BAA4B,WAAW;;AAGpD,OAAI,cAAc,SAAS,YAAY,EAAE;AACvC,UAAM,KAAK,6BAA6B,WAAW;;AAGrD,OAAI,cAAc,SAAS,EAAE;AAC3B,UAAM,KAAK,oBAAoB,WAAW;;AAG5C,OAAI,cAAc,QAAQ,UAAkB,SAA4B,EAAE;AACxE,UAAM,KAAK,qCAAqC,WAAW;;AAG7D,OAAI,gBAAgB,EAAE;AAIpB,UAAM,KAAK,aAAa,gBAAgB,CAAC;;AAG3C,UAAO,EACL,WACD;;EAGH,oBAAoB,WAAuC;GACzD,MAAM,eAAe,yBAAyB;GAC9C,MAAM,YAAY,OAAO,KAAK,aAAa;AAE3C,UAAO,MAAM,YAAY,aAAa;IAEpC,MAAM,eAAe,KAAK,SAAS,OAAO,aAAa,SAAS;AAChE,QAAI,aAAa,WAAW,KAAK,CAAE,QAAO;AAE1C,SAAK,MAAM,YAAY,WAAW;AAChC,SAAI,UAAU,cAAc,aAAa,UAAU,EAAE;AACnD,aAAO;;;AAGX,WAAO;KACP;;EAGJ,AAAQ,cAAc,WAAuB,YAAwB;GACnE,MAAM,UAAU,IAAI,KAAe;;;;;;;;GASnC,MAAM,iBAAiB,GAAG,UAAsB;IAC9C,MAAM,WAAW,MAAM,QAAQ,MAAM,UAAU,SAAS,EAAE,CAAC;AAC3D,aAAS,SAAS,MAAM,QAAQ,IAAI,EAAE,CAAC;AACvC,WAAO,SAAS,SAAS;;;;;GAM3B,MAAM,uBAAuB,QAAQ,SAAS;;;;GAK9C,MAAM,uBACJ,UAAU,QAAQ,MAAM,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,SAAS,MAAM,WAAW,MAAM,EAAE,CAAC;AAE9E,UAAO;IAAE;IAAe;IAAgB;IAAgB;;EAG1D,MAAM,yBAAyB,YAAuC;AACpE,SAAM,EAAE,4BAA4B,EAAE,YAAY,CAAC;AAEnD,SAAM,cAAc,QAAQ;GAI5B,MAAM,aAAa,WAAW,QAAQ,GAAG,EAAE;AAC3C,OAAI,eAAe,WAAW;IAC5B,MAAM,WAAW,cAAc,oBAAoB,WAAW;IAC9D,MAAM,SAAS,cAAc,IAAI,SAAS;IAG1C,MAAM,eAAe,KAAK,KACxB,OAAO,aACP,mBAAmB,OAAO,MAAM,GAAG,GAAG,OAAO,MAAM,GAAG,WACvD;AAED,QAAI,OAAO,aAAa,aAAa,CAAE,MAAM,OAAO,aAAa,EAAG;KAElE,MAAM,QAAQ,MAAMC,2BAAyC,SAAS;AAGtE,WAAMC,yBAAuC,MAAM;;;GAKvD,MAAM,YAAY,MAAMC,uBAAqC;GAK7D,MAAM,gBAAgB,UAAU,QAAQ,MAAM,CAAC,EAAE,SAAS,UAAU,CAAC;AAGrE,SAAMD,yBAAuC,cAAc;;EAG7D,MAAM,4BAA4B,YAAuC;AACvE,SAAM,EAAE,+BAA+B,EAAE,YAAY,CAAC;GACtD,MAAM,cAAc,CAAC,GAAI,WAAW,SAAS,EAAE,EAAG,GAAI,WAAW,SAAS,EAAE,CAAE;AAI9E,SAAM,KAAK,gBAAgB;AAC3B,SAAM,KAAK,eAAe;AAC1B,SAAM,KAAK,cAAc;GAEzB,MAAME,SAEA,YAAY,KAAK,cAAc;AACnC,QAAI,UAAU,SAAS,YAAY,IAAI,UAAU,SAAS,YAAY,EAAE;KACtE,MAAM,WAAW,cAAc,oBAAoB,UAAU;AAC7D,YAAO,SAAS;AAChB,YAAO,EACL,aAAa,cAAc,eAAe,SAAS,EACpD;;AAEH,UAAM,IAAI,MAAM,gBAAgB;KAChC;AAEF,SAAMC,uBAAqC,OAAO;AAClD,SAAMC,qBAAmC;AACzC,SAAMC,0BAAwC;;EAGhD,MAAM,6BAA6B,YAAuC;AACxE,SAAM,EAAE,gCAAgC,EAAE,YAAY,CAAC;GACvD,MAAM,UAAU,OAAO,CAAC,GAAI,WAAW,SAAS,EAAE,EAAG,GAAI,WAAW,aAAa,EAAE,CAAE,CAAC;AACtF,SAAML,yBAAuC,QAAQ;;EAGvD,MAAM,oBAAoB,GAA8B;AACtD,SAAMM,kBAAgC;;EAGxC,MAAM,qCAAqC,GAA8B;AACvE,SAAMC,4BAA0C;;EAGlD,MAAM,aAAa,QAAuC;AACxD,OAAI,OAAO,SAAS,GAAG;AACrB,YAAQ,KACN,MAAM,OACJ,+EACD,CACF;AACD,SAAK,MAAM,KAAK,QAAQ;AACtB,aAAQ,KAAK,MAAM,OAAO,OAAO,KAAK,SAAS,OAAO,aAAa,EAAE,GAAG,CAAC;;AAE3E,YAAQ,KAAK,MAAM,IAAI,yCAAyC,CAAC;;;;;;;;;;EAWrE,MAAM,mBACJ,UACA,aACA,QACmE;GACnE,MAAM,EAAE,QAAQ,MAAM,YAAY,gBAAgB,IAAI,YAAY,CAAC,iBACjE,cAAc,eAAe,SAAS,EACtC,OACD;GAED,MAAM,UAAU,KAAK,KAAK,QAAQ,QAAQ;GAC1C,MAAM,WAAW,KAAK,KAAK,OAAO,aAAa,QAAQ;AACvD,UAAO;IACL;IACA;IACA,UAAU,MAAM,OAAO,SAAS;IACjC;;;;;;;;EASH,MAAM,YACJ,UACA,OAGqD;GACrD,MAAMC,OAAsB,YAAY;GACxC,MAAM,QAAQ,cAAc,eAAe,SAAS;GACpD,MAAM,YAAY,OAAO,KAAK,MAAM,CAAC,QAAQ,SAAS,SAAS,MAAM,SAAS;AAE9E,UAAO,MAAM,YACX,MACA,OAAO,QAAQ,QAAQ;IACrB,MAAM,MAAM,gBAAgB,IAAI,IAAI;AACpC,QAAI,IAAI,WAAW,aAAa,EAAE;AAChC,WAAM,SAAS,WAAW,OAAO,gBAAgB;MAC/C,MAAM,EAAE,kBAAQ,MAAMC,QAAM,IAAI,iBAAiB,OAAO,YAAY;AACpE,aAAO,GAAG,IAAI,IAAI,iBAAiB,MAAM,OACvC,KAAK,KAAK,OAAO,aAAaC,UAAQD,IAAE,CACzC;OACD;AACF,YAAO;;IAGT,MAAM,EAAE,QAAQ,MAAM,MAAM,IAAI,iBAAiB,MAAM;IACvD,MAAM,EAAE,YAAY,OAAO,OAAO;AAClC,QAAI,OAAO,SAAS,UAAU,EAAE;AAC9B,WAAM,SAAS,SAAS,OAAO,MAAM;AACnC,aAAO,GAAG,IAAI,IAAI,OAAO,MAAM,OAC7B,KAAK,KAAK,OAAO,aAAa,OAAO,QAAQ,WAAW,EAAE,EAAE,EAAE,CAC/D;OACD;WACG;AACL,YAAO,OAAO,MAAM,OAAO,KAAK,KAAK,OAAO,aAAa,QAAQ,EAAE,CAAC;;AAGtE,WAAO;MAET,EAAE,CACH;;;;;EAMH,MAAM,aAAa,MAAiC;AAClD,UAAO,MAAM,aAAa,KAAK;;;;;EAMjC,MAAM,UAAU,UAAmD;AACjE,UAAO,MAAM,UAAU,SAAS;;;;;EAMlC,MAAM,iBACJ,KACA,iBACA,kBACyB;AACzB,UAAO,MAAM,iBAAiB,KAAK,iBAAiB,iBAAiB;;;;;EAMvE,MAAM,eACJ,KACA,iBACwB;AACxB,UAAO,MAAM,eAAe,KAAK,gBAAgB;;;;;EAMnD,MAAM,iBAAgC;AACpC,UAAO,MAAM,gBAAgB"}

package/dist/template/template.d.ts

@@ -20,7 +20,7 @@ export declare abstract class Template {
     constructor(key: TemplateKey);
     /**
      * 템플릿 구현체가 있는 디렉토리의 모든 템플릿을 로드합니다.
-     * 템플릿이 필요(Template.find)해지기 전에 최소 한 번 호출해주셔야 합니다.
+     * 템플릿이 필요(TemplateManager.get)해지기 전에 최소 한 번 호출해주셔야 합니다.
      * @deprecated TemplateManager.autoload() 사용 권장
      */
     static autoload(): Promise<void>;
@@ -49,7 +49,6 @@ export declare abstract class Template {
      * 이 템플릿이 필요로 하는 i18n dict 키를 반환합니다.
      * 스캐폴딩 시 여러 템플릿의 키를 모아서 한 번에 처리합니다.
      *
-     * @param options - 템플릿 옵션
      * @returns 필요한 dict 키 배열 또는 null (i18n 불필요 시)
      */
     getRequiredDictKeys(): string[] | null;

package/dist/template/template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../src/template/template.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAIxE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,YAAY,CAAC,EAAE;QACb,GAAG,EAAE,WAAW,CAAC;QACjB,OAAO,EAAE,eAAe,CAAC,WAAW,CAAC,CAAC;KACvC,EAAE,CAAC;CACL,CAAC;AAEF;;GAEG;AACH,8BAAsB,QAAQ;IAGT,GAAG,EAAE,WAAW;IAFnC,OAAO,CAAC,MAAM,CAAC,SAAS,CAAyC;gBAE9C,GAAG,EAAE,WAAW;IAEnC;;;;OAIG;WACiB,QAAQ;IA8B5B;;;;;;OAMG;WACW,IAAI,CAAC,GAAG,EAAE,WAAW,GAAG,QAAQ;IAU9C;;OAEG;WACW,gBAAgB,IAAI,GAAG,CAAC,WAAW,EAAE,QAAQ,CAAC;IAI5D;;OAEG;WACW,eAAe,IAAI,IAAI;aAIrB,MAAM,CACpB,OAAO,EAAE,eAAe,CAAC,WAAW,CAAC,EACrC,GAAG,KAAK,EAAE,OAAO,EAAE,GAClB,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC;aAE/B,gBAAgB,CAC9B,KAAK,CAAC,EAAE,iBAAiB,EACzB,GAAG,KAAK,EAAE,OAAO,EAAE,GAClB;QACD,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,CAAC;KACd;IAED;;;;;;OAMG;IACI,mBAAmB,IAAI,MAAM,EAAE,GAAG,IAAI;CAI9C"}
+{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../src/template/template.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAIxE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,YAAY,CAAC,EAAE;QACb,GAAG,EAAE,WAAW,CAAC;QACjB,OAAO,EAAE,eAAe,CAAC,WAAW,CAAC,CAAC;KACvC,EAAE,CAAC;CACL,CAAC;AAEF;;GAEG;AACH,8BAAsB,QAAQ;IAGT,GAAG,EAAE,WAAW;IAFnC,OAAO,CAAC,MAAM,CAAC,SAAS,CAAyC;gBAE9C,GAAG,EAAE,WAAW;IAEnC;;;;OAIG;WACiB,QAAQ;IA8B5B;;;;;;OAMG;WACW,IAAI,CAAC,GAAG,EAAE,WAAW,GAAG,QAAQ;IAU9C;;OAEG;WACW,gBAAgB,IAAI,GAAG,CAAC,WAAW,EAAE,QAAQ,CAAC;IAI5D;;OAEG;WACW,eAAe,IAAI,IAAI;aAIrB,MAAM,CACpB,OAAO,EAAE,eAAe,CAAC,WAAW,CAAC,EACrC,GAAG,KAAK,EAAE,OAAO,EAAE,GAClB,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC;aAE/B,gBAAgB,CAC9B,KAAK,CAAC,EAAE,iBAAiB,EACzB,GAAG,KAAK,EAAE,OAAO,EAAE,GAClB;QACD,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,CAAC;KACd;IAED;;;;;OAKG;IACI,mBAAmB,IAAI,MAAM,EAAE,GAAG,IAAI;CAI9C"}

package/dist/template/template.js

@@ -15,7 +15,7 @@ var init_template = __esmMin((() => {
 		}
 		/**
 		* 템플릿 구현체가 있는 디렉토리의 모든 템플릿을 로드합니다.
-		* 템플릿이 필요(Template.find)해지기 전에 최소 한 번 호출해주셔야 합니다.
+		* 템플릿이 필요(TemplateManager.get)해지기 전에 최소 한 번 호출해주셔야 합니다.
 		* @deprecated TemplateManager.autoload() 사용 권장
 		*/
 		static async autoload() {
@@ -40,7 +40,7 @@ var init_template = __esmMin((() => {
 		static find(key) {
 			const instance = Template.templates.get(key);
 			if (!instance) {
-				throw new Error(`Template ${key} not found. It might be because you tried to find a template before loading all templates. Did you call Template.autoload()?`);
+				throw new Error(`Template ${key} not found. It might be because you tried to find a template before loading all templates. Did you call TemplateManager.autoload()?`);
 			}
 			return instance;
 		}
@@ -60,7 +60,6 @@ var init_template = __esmMin((() => {
 		* 이 템플릿이 필요로 하는 i18n dict 키를 반환합니다.
 		* 스캐폴딩 시 여러 템플릿의 키를 모아서 한 번에 처리합니다.
 		*
-		* @param options - 템플릿 옵션
 		* @returns 필요한 dict 키 배열 또는 null (i18n 불필요 시)
 		*/
 		getRequiredDictKeys() {
@@ -72,4 +71,4 @@ var init_template = __esmMin((() => {
 //#endregion
 init_template();
 export { Template, init_template };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVtcGxhdGUuanMiLCJuYW1lcyI6WyJrZXk6IFRlbXBsYXRlS2V5Il0sInNvdXJjZXMiOlsiLi4vLi4vc3JjL3RlbXBsYXRlL3RlbXBsYXRlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBwYXRoIGZyb20gXCJwYXRoXCI7XG5cbmltcG9ydCB7IHR5cGUgRW50aXR5TmFtZXNSZWNvcmQgfSBmcm9tIFwiLi4vZW50aXR5L2VudGl0eS1tYW5hZ2VyXCI7XG5pbXBvcnQgeyB0eXBlIFRlbXBsYXRlS2V5LCB0eXBlIFRlbXBsYXRlT3B0aW9ucyB9IGZyb20gXCIuLi90eXBlcy90eXBlc1wiO1xuaW1wb3J0IHsgZ2xvYkFzeW5jIH0gZnJvbSBcIi4uL3V0aWxzL2FzeW5jLXV0aWxzXCI7XG5pbXBvcnQgeyBpbXBvcnRNZW1iZXJzIH0gZnJvbSBcIi4uL3V0aWxzL2VzbS11dGlsc1wiO1xuXG5leHBvcnQgdHlwZSBSZW5kZXJlZFRlbXBsYXRlID0ge1xuICB0YXJnZXQ6IHN0cmluZztcbiAgcGF0aDogc3RyaW5nO1xuICBib2R5OiBzdHJpbmc7XG4gIGltcG9ydEtleXM6IHN0cmluZ1tdO1xuICBjdXN0b21IZWFkZXJzPzogc3RyaW5nW107XG4gIHByZVRlbXBsYXRlcz86IHtcbiAgICBrZXk6IFRlbXBsYXRlS2V5O1xuICAgIG9wdGlvbnM6IFRlbXBsYXRlT3B0aW9uc1tUZW1wbGF0ZUtleV07XG4gIH1bXTtcbn07XG5cbi8qKlxuICog7YWc7ZSM66a/7J2EIOuCmO2DgOuCtOuKlCDrsqDsnbTsiqQg7YG0656Y7Iqk7J6F64uI64ukLlxuICovXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgVGVtcGxhdGUge1xuICBwcml2YXRlIHN0YXRpYyB0ZW1wbGF0ZXM6IE1hcDxUZW1wbGF0ZUtleSwgVGVtcGxhdGU+ID0gbmV3IE1hcCgpO1xuXG4gIGNvbnN0cnVjdG9yKHB1YmxpYyBrZXk6IFRlbXBsYXRlS2V5KSB7fVxuXG4gIC8qKlxuICAgKiDthZztlIzrpr8g6rWs7ZiE7LK06rCAIOyeiOuKlCDrlJTroInthqDrpqzsnZgg66qo65OgIO2FnO2UjOumv+ydhCDroZzrk5ztlanri4jri6QuXG4gICAqIO2FnO2UjOumv+ydtCDtlYTsmpQoVGVtcGxhdGUuZmluZCntlbTsp4DquLAg7KCE7JeQIOy1nOyGjCDtlZwg67KIIO2YuOy2nO2VtOyjvOyFlOyVvCDtlanri4jri6QuXG4gICAqIEBkZXByZWNhdGVkIFRlbXBsYXRlTWFuYWdlci5hdXRvbG9hZCgpIOyCrOyaqSDqtozsnqVcbiAgICovXG4gIHB1YmxpYyBzdGF0aWMgYXN5bmMgYXV0b2xvYWQoKSB7XG4gICAgY29uc3QgdGVtcGxhdGVGaWxlcyA9IGF3YWl0IGdsb2JBc3luYyhcbiAgICAgIC8vIFNvbmFtdeydmCDsvZTrk5zrsqDsnbTsiqTripQg7ZWt7IOBIOu5jOuTnOuQnCDssYTroZwgZGlzdCDsho3sl5Ag66i466y066W066+A66GcLFxuICAgICAgLy8g7ZiE7J6sIO2MjOydvOydhCDquLDspIDsnLzroZwg66eI7LCs6rCA7KeA66GcIGRpc3Qg7IaN7JeQIOyeiOuKlCDthZztlIzrpr8g6rWs7ZiE7LK0IGpzIO2MjOydvOuTpOydhCDssL7sirXri4jri6QuXG4gICAgICBwYXRoLmpvaW4oaW1wb3J0Lm1ldGEuZGlybmFtZSwgXCJpbXBsZW1lbnRhdGlvbnMvKi50ZW1wbGF0ZS5qc1wiKSxcbiAgICApO1xuXG4gICAgZm9yIChjb25zdCB0ZW1wbGF0ZUZpbGUgb2YgdGVtcGxhdGVGaWxlcykge1xuICAgICAgLy8gb3hsaW50LWRpc2FibGUtbmV4dC1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9uby1leHBsaWNpdC1hbnkgLS0gaW1wb3J0TWVtYmVyc+ydmCDrsJjtmZgg7YOA7J6F7J2EIOuqheyLnOyggeycvOuhnCDsp4DsoJXtlaAg7IiYIOyXhuydjFxuICAgICAgY29uc3QgdGVtcGxhdGVzID0gYXdhaXQgaW1wb3J0TWVtYmVyczxhbnk+KHRlbXBsYXRlRmlsZSk7XG4gICAgICBpZiAoXG4gICAgICAgIHRlbXBsYXRlcy5sZW5ndGggPT09IDEgJiZcbiAgICAgICAgdHlwZW9mIHRlbXBsYXRlc1swXS52YWx1ZSA9PT0gXCJmdW5jdGlvblwiICYmXG4gICAgICAgIHRlbXBsYXRlc1swXS52YWx1ZS5wcm90b3R5cGUgaW5zdGFuY2VvZiBUZW1wbGF0ZVxuICAgICAgKSB7XG4gICAgICAgIC8vIO2BtOuemOyKpOydmCDsnbjsiqTthLTsiqTrpbwg7IOd7ISx7ZWY7JesIOuTseuhnVxuICAgICAgICBjb25zdCBpbnN0YW5jZSA9IG5ldyB0ZW1wbGF0ZXNbMF0udmFsdWUoKTtcbiAgICAgICAgVGVtcGxhdGUudGVtcGxhdGVzLnNldChpbnN0YW5jZS5rZXksIGluc3RhbmNlKTtcbiAgICAgIH0gZWxzZSB7XG4gICAgICAgIHRocm93IG5ldyBFcnJvcihcbiAgICAgICAgICBgVGVtcGxhdGUgJHt0ZW1wbGF0ZUZpbGV9IHNob3VsZCBleHBvcnQgb25seSBvbmUgY2xhc3MgdGhhdCBleHRlbmRzIFRlbXBsYXRlYCxcbiAgICAgICAgKTtcbiAgICAgIH1cbiAgICB9XG5cbiAgICAvLyBjb25zb2xlLmxvZyhcbiAgICAvLyAgIGNoYWxrLmdyYXkoYFtMb2FkaW5nXSBMb2FkZWQgJHt0aGlzLnRlbXBsYXRlcy5zaXplfSB0ZW1wbGF0ZXMuYClcbiAgICAvLyApO1xuICB9XG5cbiAgLyoqXG4gICAqIO2FnO2UjOumvyAqKuyduOyKpO2EtOyKpCoq66W8IGtleeuhnCDssL7slYTsmLXri4jri6QuXG4gICAqIOunjOyVvSDthZztlIzrpr/snbQg66Gc65OcKGF1dG9sb2FkKeuQmOyngCDslYrslZjqsbDrgpgg7LC+64qUIO2FnO2UjOumv+ydtCDsl4bri6TrqbQg7JeQ65+s66W8IOuNmOynkeuLiOuLpC5cbiAgICogQGRlcHJlY2F0ZWQgVGVtcGxhdGVNYW5hZ2VyLmdldCgpIOyCrOyaqSDqtozsnqVcbiAgICogQHBhcmFtIGtleVxuICAgKiBAcmV0dXJuc1xuICAgKi9cbiAgcHVibGljIHN0YXRpYyBmaW5kKGtleTogVGVtcGxhdGVLZXkpOiBUZW1wbGF0ZSB7XG4gICAgY29uc3QgaW5zdGFuY2UgPSBUZW1wbGF0ZS50ZW1wbGF0ZXMuZ2V0KGtleSk7XG4gICAgaWYgKCFpbnN0YW5jZSkge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKFxuICAgICAgICBgVGVtcGxhdGUgJHtrZXl9IG5vdCBmb3VuZC4gSXQgbWlnaHQgYmUgYmVjYXVzZSB5b3UgdHJpZWQgdG8gZmluZCBhIHRlbXBsYXRlIGJlZm9yZSBsb2FkaW5nIGFsbCB0ZW1wbGF0ZXMuIERpZCB5b3UgY2FsbCBUZW1wbGF0ZS5hdXRvbG9hZCgpP2AsXG4gICAgICApO1xuICAgIH1cbiAgICByZXR1cm4gaW5zdGFuY2U7XG4gIH1cblxuICAvKipcbiAgICog64K067aA7JqpOiBUZW1wbGF0ZU1hbmFnZXLsl5DshJwg7IKs7JqpXG4gICAqL1xuICBwdWJsaWMgc3RhdGljIF9nZXRUZW1wbGF0ZXNNYXAoKTogTWFwPFRlbXBsYXRlS2V5LCBUZW1wbGF0ZT4ge1xuICAgIHJldHVybiBUZW1wbGF0ZS50ZW1wbGF0ZXM7XG4gIH1cblxuICAvKipcbiAgICog64K067aA7JqpOiBUZW1wbGF0ZU1hbmFnZXLsl5DshJwg7IKs7JqpXG4gICAqL1xuICBwdWJsaWMgc3RhdGljIF9jbGVhclRlbXBsYXRlcygpOiB2b2lkIHtcbiAgICBUZW1wbGF0ZS50ZW1wbGF0ZXMuY2xlYXIoKTtcbiAgfVxuXG4gIHB1YmxpYyBhYnN0cmFjdCByZW5kZXIoXG4gICAgb3B0aW9uczogVGVtcGxhdGVPcHRpb25zW1RlbXBsYXRlS2V5XSxcbiAgICAuLi5leHRyYTogdW5rbm93bltdXG4gICk6IFJlbmRlcmVkVGVtcGxhdGUgfCBQcm9taXNlPFJlbmRlcmVkVGVtcGxhdGU+O1xuXG4gIHB1YmxpYyBhYnN0cmFjdCBnZXRUYXJnZXRBbmRQYXRoKFxuICAgIG5hbWVzPzogRW50aXR5TmFtZXNSZWNvcmQsXG4gICAgLi4uZXh0cmE6IHVua25vd25bXVxuICApOiB7XG4gICAgdGFyZ2V0OiBzdHJpbmc7XG4gICAgcGF0aDogc3RyaW5nO1xuICB9O1xuXG4gIC8qKlxuICAgKiDsnbQg7YWc7ZSM66a/7J20IO2VhOyalOuhnCDtlZjripQgaTE4biBkaWN0IO2CpOulvCDrsJjtmZjtlanri4jri6QuXG4gICAqIOyKpOy6kO2PtOuUqSDsi5wg7Jes65+sIO2FnO2UjOumv+ydmCDtgqTrpbwg66qo7JWE7IScIO2VnCDrsojsl5Ag7LKY66as7ZWp64uI64ukLlxuICAgKlxuICAgKiBAcGFyYW0gb3B0aW9ucyAtIO2FnO2UjOumvyDsmLXshZhcbiAgICogQHJldHVybnMg7ZWE7JqU7ZWcIGRpY3Qg7YKkIOuwsOyXtCDrmJDripQgbnVsbCAoaTE4biDrtojtlYTsmpQg7IucKVxuICAgKi9cbiAgcHVibGljIGdldFJlcXVpcmVkRGljdEtleXMoKTogc3RyaW5nW10gfCBudWxsIHtcbiAgICAvLyDquLDrs7jsoIHsnLzroZwgZGljdCDtgqTqsIAg7ZWE7JqUIOyXhuydjC4g7ZWE7JqU7ZWcIO2FnO2UjOumv+yXkOyEnCDsmKTrsoTrnbzsnbTrk5xcbiAgICByZXR1cm4gbnVsbDtcbiAgfVxufVxuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7OzttQkFJaUQ7aUJBQ0U7Q0FpQjdCLFdBQXRCLE1BQXNCLFNBQVM7RUFDN0IsT0FBZSxZQUF3QyxJQUFJLEtBQUs7RUFFaEUsWUFBWSxBQUFPQSxLQUFrQjtHQUFsQjs7Ozs7OztFQU9uQixhQUFvQixXQUFXO0dBQzdCLE1BQU0sZ0JBQWdCLE1BQU0sVUFHMUIsS0FBSyxLQUFLLE9BQU8sS0FBSyxTQUFTLGdDQUFnQyxDQUNoRTtBQUVELFFBQUssTUFBTSxnQkFBZ0IsZUFBZTtJQUV4QyxNQUFNLFlBQVksTUFBTSxjQUFtQixhQUFhO0FBQ3hELFFBQ0UsVUFBVSxXQUFXLEtBQ3JCLE9BQU8sVUFBVSxHQUFHLFVBQVUsY0FDOUIsVUFBVSxHQUFHLE1BQU0scUJBQXFCLFVBQ3hDO0tBRUEsTUFBTSxXQUFXLElBQUksVUFBVSxHQUFHLE9BQU87QUFDekMsY0FBUyxVQUFVLElBQUksU0FBUyxLQUFLLFNBQVM7V0FDekM7QUFDTCxXQUFNLElBQUksTUFDUixZQUFZLGFBQWEscURBQzFCOzs7Ozs7Ozs7OztFQWdCUCxPQUFjLEtBQUssS0FBNEI7R0FDN0MsTUFBTSxXQUFXLFNBQVMsVUFBVSxJQUFJLElBQUk7QUFDNUMsT0FBSSxDQUFDLFVBQVU7QUFDYixVQUFNLElBQUksTUFDUixZQUFZLElBQUksOEhBQ2pCOztBQUVILFVBQU87Ozs7O0VBTVQsT0FBYyxtQkFBK0M7QUFDM0QsVUFBTyxTQUFTOzs7OztFQU1sQixPQUFjLGtCQUF3QjtBQUNwQyxZQUFTLFVBQVUsT0FBTzs7Ozs7Ozs7O0VBdUI1QixBQUFPLHNCQUF1QztBQUU1QyxVQUFPIn0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/template/zod-converter.d.ts

@@ -29,7 +29,7 @@ export declare const BUILT_IN_TYPES: {
             url: z.ZodString;
             mime_type: z.ZodString;
             size: z.ZodNumber;
-        }, z.core.$strip>;
+        }, z.core.$loose>;
         readonly renderType: "json-sonamufile";
         readonly schemaName: "SonamuFileSchema";
     };
@@ -39,7 +39,7 @@ export declare const BUILT_IN_TYPES: {
             url: z.ZodString;
             mime_type: z.ZodString;
             size: z.ZodNumber;
-        }, z.core.$strip>>;
+        }, z.core.$loose>>;
         readonly renderType: "json-sonamufile-array";
         readonly schemaName: "SonamuFileArraySchema";
     };

package/dist/testing/dev-vitest-manager.d.ts

@@ -59,7 +59,7 @@ export declare class DevVitestManager {
     getStatus(): ManagerStatus;
     /**
      * 변경된 파일을 Vitest 모듈 그래프에서 무효화합니다.
-     * syncFromWatcher에서 호출되어 다음 테스트 실행 시 최신 코드를 사용하도록 합니다.
+     * hmrAndSync에서 호출되어 다음 테스트 실행 시 최신 코드를 사용하도록 합니다.
      */
     invalidateFiles(filePaths: string[]): void;
     shutdown(): Promise<void>;