@simplysm/sd-cli 14.0.42 → 14.0.44

package/src/angular/vite-angular-plugin.ts

@@ -3,12 +3,9 @@ import path from "path";
 import ts from "typescript";
 import { consola } from "consola";
 import { pathx } from "@simplysm/core-node";
+import { SdTsCompiler } from "../ts-compiler/SdTsCompiler.js";
 import { AngularSourceFileCache } from "./angular-compiler.js";
-import { getPackageSourceFiles } from "../utils/tsconfig.js";
-import {
-  AngularBuildPipeline,
-  type PipelineDiagnosticResult,
-} from "./angular-build-pipeline.js";
+import type { SerializedDiagnostic } from "../typecheck/typecheck-serialization.js";
 
 const logger = consola.withTag("sd:cli:angular");
 
@@ -21,13 +18,16 @@ export interface SdAngularPluginOptions {
 /**
  * Angular AOT 컴파일을 수행하는 Vite 플러그인 (Vitest 전용).
  *
- * AngularBuildPipeline으로 패키지의 .ts 파일을 AOT 컴파일하고,
+ * SdTsCompiler로 패키지의 .ts 파일을 AOT 컴파일하고,
  * transform 훅에서 컴파일된 JS를 반환한다.
  */
 export function sdAngularPlugin(options: SdAngularPluginOptions): Plugin {
-  let pipeline: AngularBuildPipeline | undefined;
+  let sdTsCompiler: SdTsCompiler | undefined;
   let sourceFileCache: AngularSourceFileCache | undefined;
 
+  /** emit된 파일 맵 (posix 소스 경로 → 컴파일된 JS 내용) */
+  const emittedFilesBySource = new Map<string, string>();
+
   /** Vitest watch 모드에서 변경된 파일 경로를 수집한다. buildStart 재호출 시 캐시 무효화에 사용. */
   const pendingWatchChanges = new Set<string>();
 
@@ -51,60 +51,57 @@ export function sdAngularPlugin(options: SdAngularPluginOptions): Plugin {
       }
       logger.debug("sdAngularPlugin buildStart 시작");
 
-      // tsconfig 로드
-      const tsconfigPath = path.join(resolvedPkgDir, "tsconfig.json");
-      const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
-      const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, resolvedPkgDir);
-      logger.debug(`tsconfig 파싱 완료: ${parsed.fileNames.length}개 파일`);
-
       // AngularSourceFileCache 생성 (또는 재사용)
       sourceFileCache ??= new AngularSourceFileCache();
 
-      // Vitest watch 재빌드: 변경된 파일의 캐시 무효화
-      let hadPendingChanges = false;
+      // Vitest watch 재빌드: 변경된 파일 수집
+      let modifiedFiles: ReadonlySet<string> | undefined;
       if (pendingWatchChanges.size > 0) {
-        hadPendingChanges = true;
-        logger.debug(`watch 변경 파일 ${pendingWatchChanges.size}개 캐시 무효화`);
-        sourceFileCache.invalidate(pendingWatchChanges);
+        logger.debug(`watch 변경 파일 ${pendingWatchChanges.size}개`);
+        modifiedFiles = new Set(pendingWatchChanges);
         pendingWatchChanges.clear();
       }
 
-      // Pipeline 생성 (최초) 또는 재사용
-      pipeline ??= new AngularBuildPipeline({
-        mode: "client",
-        pkgDir: resolvedPkgDir,
-        cwd: process.cwd(),
-        rootNames: getPackageSourceFiles(resolvedPkgDir, parsed),
-        compilerOptions: parsed.options,
-        angularCompilerOptions: parsed.raw?.angularCompilerOptions as
-          | Record<string, unknown>
-          | undefined,
-        sourceFileCache,
-        compilerOptionsTransformer: (opts) => ({
-          ...opts,
-          noEmit: false,
-          declaration: false,
-          declarationMap: false,
-          removeComments: false,
-          sourceMap: false,
-          inlineSourceMap: true,
-          rootDir: process.cwd(),
-        }),
-        scssCacheDir: path.join(resolvedPkgDir, ".cache", "scss"),
-      });
-
-      // Pipeline 초기화 — 이미 초기화됐고 변경 파일이 없으면 건너뜀
-      if (pipeline.getEmittedFiles().size > 0 && !hadPendingChanges) {
-        logger.debug("Pipeline 이미 초기화됨, 변경 없음 — buildStart 건너뜀");
+      // SdTsCompiler 생성 (최초 또는 buildEnd 후 재시작)
+      if (sdTsCompiler == null) {
+        emittedFilesBySource.clear();
+        sdTsCompiler = new SdTsCompiler({
+          pkgDir: resolvedPkgDir,
+          cwd: process.cwd(),
+          output: { js: true, dts: false },
+          sourceFileCache,
+          compilerOptionsTransformer: (opts) => ({
+            ...opts,
+            noEmit: false,
+            declaration: false,
+            declarationMap: false,
+            removeComments: false,
+            sourceMap: false,
+            inlineSourceMap: true,
+            rootDir: process.cwd(),
+          }),
+        });
+      }
+
+      // 이미 초기화됐고 변경 파일이 없으면 건너뜀
+      if (emittedFilesBySource.size > 0 && modifiedFiles == null) {
+        logger.debug("이미 초기화됨, 변경 없음 — buildStart 건너뜀");
         return;
       }
-      const pipelineResult = await pipeline.initialize();
+
+      // compileAsync
+      const result = await sdTsCompiler.compileAsync(modifiedFiles);
+
+      // emitResults → emittedFilesBySource 매핑
+      for (const { sourceFileName, contents } of result.emitResults ?? []) {
+        emittedFilesBySource.set(pathx.posix(sourceFileName), contents);
+      }
 
       // 진단 보고
-      reportDiagnostics(pipelineResult.diagnostics);
+      reportDiagnostics(result.diagnostics, result.program);
 
       // SCSS 에러 보고
-      for (const err of pipelineResult.scssErrors) {
+      for (const err of result.scssErrors) {
         logger.error(err);
       }
     },
@@ -113,11 +110,11 @@ export function sdAngularPlugin(options: SdAngularPluginOptions): Plugin {
       // query param 제거
       const cleanId = id.split("?")[0];
 
-      // Pipeline이 emit한 .ts 파일만 처리
+      // emit된 .ts 파일만 처리
       if (!cleanId.endsWith(".ts")) return;
 
       const normalizedId = pathx.posix(cleanId);
-      const emittedContent = pipeline?.getEmittedFile(normalizedId);
+      const emittedContent = emittedFilesBySource.get(normalizedId);
       if (emittedContent == null) return;
 
       // 인라인 소스맵 분리 (Vite 호환)
@@ -135,24 +132,33 @@ export function sdAngularPlugin(options: SdAngularPluginOptions): Plugin {
     },
 
     buildEnd() {
-      pipeline = undefined;
+      sdTsCompiler = undefined;
     },
   };
 }
 
-function reportDiagnostics(diagnostics: PipelineDiagnosticResult): void {
-  for (const error of diagnostics.errors) {
-    const loc =
-      error.file != null
-        ? `${error.file}${error.line != null ? `:${String(error.line)}` : ""}`
-        : "";
-    logger.error(`${loc !== "" ? `(${loc}) ` : ""}${error.message}`);
-  }
-  for (const warning of diagnostics.warnings) {
-    const loc =
-      warning.file != null
-        ? `${warning.file}${warning.line != null ? `:${String(warning.line)}` : ""}`
-        : "";
-    logger.warn(`${loc !== "" ? `(${loc}) ` : ""}${warning.message}`);
+function reportDiagnostics(
+  diagnostics: readonly SerializedDiagnostic[],
+  program: ts.Program,
+): void {
+  for (const d of diagnostics) {
+    let loc = "";
+    if (d.file != null) {
+      loc = d.file.fileName;
+      if (d.start != null) {
+        const sf = program.getSourceFile(d.file.fileName);
+        if (sf != null) {
+          const pos = sf.getLineAndCharacterOfPosition(d.start);
+          loc += `:${pos.line + 1}`;
+        }
+      }
+    }
+
+    const prefix = loc !== "" ? `(${loc}) ` : "";
+    if (d.category === ts.DiagnosticCategory.Error) {
+      logger.error(`${prefix}${d.messageText}`);
+    } else if (d.category === ts.DiagnosticCategory.Warning) {
+      logger.warn(`${prefix}${d.messageText}`);
+    }
   }
 }

package/src/angular/web-worker-transformer.ts

@@ -0,0 +1,117 @@
+import ts from "typescript";
+
+/**
+ * Web Worker/SharedWorker의 `new Worker(new URL('path', import.meta.url))` 패턴을
+ * 감지하여 fileProcessor로 번들된 경로로 치환하는 TypeScript transformer를 생성한다.
+ *
+ * @angular/build의 web-worker-transformer.js 원본을 이식한 구현.
+ */
+export function createWorkerTransformer(
+  fileProcessor: (workerFile: string, containingFile: string) => string,
+): ts.TransformerFactory<ts.SourceFile> {
+  return (context) => {
+    const nodeFactory = context.factory;
+
+    const visitNode = (node: ts.Node): ts.Node => {
+      // new Worker(...) 또는 new SharedWorker(...) 감지
+      if (
+        !ts.isNewExpression(node) ||
+        !ts.isIdentifier(node.expression) ||
+        (node.expression.text !== "Worker" && node.expression.text !== "SharedWorker")
+      ) {
+        return ts.visitEachChild(node, visitNode, context);
+      }
+
+      // Worker 인자: 1개 또는 2개
+      if (node.arguments == null || node.arguments.length < 1 || node.arguments.length > 2) {
+        return node;
+      }
+
+      // 첫 인자: new URL(...)
+      const workerUrlNode = node.arguments[0];
+      if (
+        !ts.isNewExpression(workerUrlNode) ||
+        !ts.isIdentifier(workerUrlNode.expression) ||
+        workerUrlNode.expression.text !== "URL"
+      ) {
+        return node;
+      }
+
+      // URL 인자: 정확히 2개
+      if (workerUrlNode.arguments == null || workerUrlNode.arguments.length !== 2) {
+        return node;
+      }
+
+      // URL 첫 인자: 문자열 리터럴
+      if (!ts.isStringLiteralLike(workerUrlNode.arguments[0])) {
+        return node;
+      }
+
+      // URL 둘째 인자: import.meta.url
+      const secondArg = workerUrlNode.arguments[1];
+      if (
+        !ts.isPropertyAccessExpression(secondArg) ||
+        !ts.isMetaProperty(secondArg.expression) ||
+        secondArg.name.text !== "url"
+      ) {
+        return node;
+      }
+
+      const filePath = workerUrlNode.arguments[0].text;
+      const importer = node.getSourceFile().fileName;
+
+      // fileProcessor 호출
+      const replacementPath = fileProcessor(filePath, importer);
+
+      // 경로가 변경되지 않았으면 원본 유지
+      if (replacementPath === filePath) {
+        return node;
+      }
+
+      // AST 치환
+      return nodeFactory.updateNewExpression(
+        node,
+        node.expression,
+        node.typeArguments,
+        ts.setTextRange(
+          nodeFactory.createNodeArray(
+            [
+              // URL 인자 치환
+              nodeFactory.updateNewExpression(
+                workerUrlNode,
+                workerUrlNode.expression,
+                workerUrlNode.typeArguments,
+                ts.setTextRange(
+                  nodeFactory.createNodeArray(
+                    [nodeFactory.createStringLiteral(replacementPath), workerUrlNode.arguments[1]],
+                    workerUrlNode.arguments.hasTrailingComma,
+                  ),
+                  workerUrlNode.arguments,
+                ),
+              ),
+              // 두 번째 인자: 기존 options가 있으면 유지, 없으면 { type: 'module' } 추가
+              node.arguments.length > 1
+                ? node.arguments[1]
+                : nodeFactory.createObjectLiteralExpression([
+                    nodeFactory.createPropertyAssignment(
+                      "type",
+                      nodeFactory.createStringLiteral("module"),
+                    ),
+                  ]),
+            ],
+            node.arguments.hasTrailingComma,
+          ),
+          node.arguments,
+        ),
+      );
+    };
+
+    return (sourceFile) => {
+      // 'Worker' 문자열이 없으면 변환을 건너뛴다
+      if (!sourceFile.text.includes("Worker")) {
+        return sourceFile;
+      }
+      return ts.visitEachChild(sourceFile, visitNode, context);
+    };
+  };
+}

package/src/capacitor/capacitor.ts

@@ -95,7 +95,7 @@ export class Capacitor {
    * 5. cap sync 또는 cap copy 실행
    */
   async initialize(): Promise<void> {
-    Capacitor._logger.debug("initialize 시작");
+    Capacitor._logger.start("initialize 중...");
     await this._acquireLock();
 
     try {
@@ -152,8 +152,8 @@ export class Capacitor {
       }
     } finally {
       await this._releaseLock();
-      Capacitor._logger.debug("initialize 완료");
     }
+    Capacitor._logger.success("initialize 완료");
   }
 
   //#region Private - 명령어 실행
@@ -278,6 +278,7 @@ export class Capacitor {
    * 3. cap run — 기기에서 앱 실행
    */
   async run(url: string): Promise<void> {
+    Capacitor._logger.start(`run 중... (url: ${url})`);
     Capacitor._logger.debug(`server.url 설정: ${url}`);
     await updateServerUrl(this._capPath, url);
 
@@ -321,6 +322,7 @@ export class Capacitor {
         throw err;
       }
     }
+    Capacitor._logger.success("run 완료");
   }
 
   //#endregion
@@ -336,7 +338,7 @@ export class Capacitor {
    * 4. 빌드 산출물 복사
    */
   async build(outPath: string): Promise<void> {
-    Capacitor._logger.debug("build 시작");
+    Capacitor._logger.start("build 중...");
 
     // 1. 웹 에셋 동기화
     Capacitor._logger.debug("cap copy 시작");
@@ -380,7 +382,7 @@ export class Capacitor {
     );
     Capacitor._logger.debug("빌드 산출물 복사 완료");
 
-    Capacitor._logger.debug("build 완료");
+    Capacitor._logger.success("build 완료");
   }
 
   //#endregion

package/src/commands/check.ts

@@ -1,4 +1,3 @@
-import { cpx } from "@simplysm/core-node";
 import { err as errNs } from "@simplysm/core-common";
 import { executeTypecheck, type TypecheckResult } from "../orchestrators/TypecheckOrchestrator";
 import { executeLint, type LintResult } from "../lint/lint-core";
@@ -8,7 +7,7 @@ import { runLintInWorker } from "../lint/lint-utils";
 
 //#region Types
 
-export type CheckType = "typecheck" | "lint" | "test";
+export type CheckType = "typecheck" | "lint";
 
 export interface CheckOptions {
   targets: string[];
@@ -26,62 +25,6 @@ interface CheckResult {
 
 //#endregion
 
-//#region Utilities
-
-async function spawnVitest(targets: string[]): Promise<CheckResult> {
-  const logger = consola.withTag("sd:cli:test");
-  try {
-    const args = ["vitest", ...targets, "--run"];
-    logger.debug("vitest 실행", { args });
-    logger.start("테스트 실행 중...");
-    const result = await cpx.spawn("pnpm", args, {
-      cwd: process.cwd(),
-      reject: false,
-      stdio: "inherit",
-    });
-    const code = result.exitCode;
-
-    logger.success("테스트 실행 완료");
-    logger.info("테스트 완료", { errorCount: code === 0 ? 0 : 1, warningCount: 0 });
-
-    return {
-      name: "TEST",
-      success: code === 0,
-      errorCount: code === 0 ? 0 : 1,
-      warningCount: 0,
-      formattedOutput: "",
-    };
-  } catch (err) {
-    logger.fail("테스트 실행 실패");
-    return {
-      name: "TEST",
-      success: false,
-      errorCount: 1,
-      warningCount: 0,
-      formattedOutput: errNs.message(err),
-    };
-  }
-}
-
-function formatSection(result: CheckResult): string {
-  const header = `\n${"=".repeat(6)} ${result.name} ${"=".repeat(6)}`;
-  const icon = result.success ? "✔" : "✖";
-
-  let summary: string;
-  if (result.name === "TEST") {
-    const testCount = result.errorCount > 0 ? `${result.errorCount}개 실패` : "";
-    summary = result.success ? `${icon} 통과` : `${icon} ${testCount}`;
-  } else {
-    summary = `${icon} ${result.errorCount}개 에러, ${result.warningCount}개 경고`;
-  }
-
-  const detail = !result.success && result.formattedOutput ? `\n${result.formattedOutput}` : "";
-
-  return `${header}\n${summary}${detail}`;
-}
-
-//#endregion
-
 //#region Main
 
 export async function runCheck(options: CheckOptions): Promise<void> {
@@ -102,8 +45,7 @@ export async function runCheck(options: CheckOptions): Promise<void> {
 
   const needsTypecheck = types.includes("typecheck");
   const needsLint = types.includes("lint");
-  const needsTest = types.includes("test");
-  logger.debug("체크 구성", { needsTypecheck, needsLint, needsTest });
+  logger.debug("체크 구성", { needsTypecheck, needsLint });
 
   logger.start(`체크 실행 중... (${types.join(", ")})`);
 
@@ -177,11 +119,6 @@ export async function runCheck(options: CheckOptions): Promise<void> {
     );
   }
 
-  // 테스트 (서브프로세스)
-  if (needsTest) {
-    tasks.push(spawnVitest(normalizedTargets));
-  }
-
   const results = await Promise.allSettled(tasks);
   logger.success("체크 실행 완료");
 
@@ -200,12 +137,20 @@ export async function runCheck(options: CheckOptions): Promise<void> {
     }];
   });
 
-  // 섹션별 출력 (순서 보장: typecheck → lint → test)
-  const order = ["TYPECHECK", "LINT", "TEST"];
+  // 섹션별 출력 (순서 보장: typecheck → lint)
+  const order = ["TYPECHECK", "LINT"];
   checkResults.sort((a, b) => order.indexOf(a.name) - order.indexOf(b.name));
 
   for (const result of checkResults) {
-    process.stdout.write(formatSection(result));
+    const header = `${result.name}: ${result.errorCount}개 에러, ${result.warningCount}개 경고`;
+    if (result.success) {
+      logger.success(header);
+    } else {
+      logger.error(header);
+      if (result.formattedOutput !== "") {
+        logger.error(result.formattedOutput);
+      }
+    }
   }
 
   // 요약
@@ -213,17 +158,13 @@ export async function runCheck(options: CheckOptions): Promise<void> {
   const totalErrors = checkResults.reduce((sum, r) => sum + r.errorCount, 0);
   const totalWarnings = checkResults.reduce((sum, r) => sum + r.warningCount, 0);
 
-  process.stdout.write(`\n\n${"=".repeat(6)} 요약 ${"=".repeat(6)}\n`);
-
   if (failed.length === 0) {
-    process.stdout.write(`✔ 전체 통과\n`);
+    logger.success(`전체 통과 — 합계: ${totalErrors}개 에러, ${totalWarnings}개 경고`);
   } else {
     const failedNames = failed.map((r) => r.name.toLowerCase()).join(", ");
-    process.stdout.write(`✖ ${failed.length}/${checkResults.length}개 실패 (${failedNames})\n`);
-  }
-  process.stdout.write(`합계: ${totalErrors}개 에러, ${totalWarnings}개 경고\n`);
-
-  if (failed.length > 0) {
+    logger.error(
+      `${failed.length}/${checkResults.length}개 실패 (${failedNames}) — 합계: ${totalErrors}개 에러, ${totalWarnings}개 경고`,
+    );
     process.exitCode = 1;
   }
 }

package/src/commands/publish/deployment-phase.ts

@@ -63,17 +63,21 @@ export async function runDeployment(
       for (let attempt = 1; attempt <= maxRetries; attempt++) {
         try {
           await publishPackage(pkg.path, pkg.config, version, projectPath, logger, dryRun);
-          logger.debug(dryRun ? `[DRY-RUN] ${pkg.name}` : pkg.name);
+          if (dryRun) {
+            logger.info(`[DRY-RUN] ${pkg.name}`);
+          } else {
+            logger.debug(pkg.name);
+          }
           publishedPackages.push(pkg.name);
           return { status: "success" as const, name: pkg.name };
         } catch (err) {
           if (attempt < maxRetries) {
             const delay = attempt * 5_000;
-            logger.debug(
-              dryRun
-                ? `[DRY-RUN] ${pkg.name} (retry ${attempt + 1}/${maxRetries})`
-                : `${pkg.name} (retry ${attempt + 1}/${maxRetries})`,
-            );
+            if (dryRun) {
+              logger.info(`[DRY-RUN] ${pkg.name} (retry ${attempt + 1}/${maxRetries})`);
+            } else {
+              logger.debug(`${pkg.name} (retry ${attempt + 1}/${maxRetries})`);
+            }
             await new Promise((resolve) => setTimeout(resolve, delay));
           } else {
             throw err;
@@ -95,7 +99,7 @@ export async function runDeployment(
       for (const r of rejectedResults) {
         logger.error(r.reason instanceof Error ? r.reason.message : r.reason);
       }
-      logger.fail(`Level ${levelIdx + 1}/${levels.length}`);
+      logger.error(`Level ${levelIdx + 1}/${levels.length}`);
     } else {
       logger.success(`Level ${levelIdx + 1}/${levels.length}`);
     }

package/src/commands/publish/npm-publisher.ts

@@ -15,7 +15,7 @@ export async function publishNpm(
   const prereleaseInfo = semver.prerelease(version);
   const args = ["publish", "--access", "public", "--no-git-checks"];
 
-  if (prereleaseInfo !== null && typeof prereleaseInfo[0] === "string") {
+  if (prereleaseInfo != null && typeof prereleaseInfo[0] === "string") {
     args.push("--tag", prereleaseInfo[0]);
   }
 

package/src/commands/publish/publish-command.ts

@@ -118,7 +118,7 @@ export async function runPublish(options: PublishOptions): Promise<void> {
   }
 
   if (publishPackages.length === 0) {
-    process.stdout.write("✔ 배포할 패키지가 없습니다.\n");
+    logger.info("배포할 패키지가 없습니다.");
     return;
   }
 

package/src/commands/publish/version-upgrade.ts

@@ -33,7 +33,7 @@ export async function upgradeVersion(
 
   // 프리릴리스 여부에 따라 증가 전략 결정
   const newVersion =
-    prereleaseInfo !== null
+    prereleaseInfo != null
       ? semver.inc(currentVersion, "prerelease")!
       : semver.inc(currentVersion, "patch")!;
 
@@ -46,28 +46,35 @@ export async function upgradeVersion(
   await fsx.write(projPkgPath, json.stringify(projPkg, { space: 2 }) + "\n");
   changedFiles.push(projPkgPath);
 
-  // 각 패키지의 package.json에 버전 설정
-  for (const pkgPath of allPkgPaths) {
-    const pkgJsonPath = path.resolve(pkgPath, "package.json");
-    const pkgJson = await fsx.readJson<PackageJson>(pkgJsonPath);
-    pkgJson.version = newVersion;
-    await fsx.write(pkgJsonPath, json.stringify(pkgJson, { space: 2 }) + "\n");
-    changedFiles.push(pkgJsonPath);
-  }
+  // 각 패키지의 package.json에 버전 설정 (병렬)
+  const pkgChangedFiles = await Promise.all(
+    allPkgPaths.map(async (pkgPath) => {
+      const pkgJsonPath = path.resolve(pkgPath, "package.json");
+      const pkgJson = await fsx.readJson<PackageJson>(pkgJsonPath);
+      pkgJson.version = newVersion;
+      await fsx.write(pkgJsonPath, json.stringify(pkgJson, { space: 2 }) + "\n");
+      return pkgJsonPath;
+    }),
+  );
+  changedFiles.push(...pkgChangedFiles);
 
   // 템플릿 파일의 @simplysm 패키지 버전 동기화
   const templateFiles = await fsx.glob(path.resolve(cwd, "packages/sd-cli/templates/**/*.hbs"));
   const versionRegex = /("@simplysm\/[^"]+"\s*:\s*)"~[^"]+"/g;
 
-  for (const templatePath of templateFiles) {
-    const content = await fsx.read(templatePath);
-    const newContent = content.replace(versionRegex, `$1"~${newVersion}"`);
+  const templateChangedFiles = await Promise.all(
+    templateFiles.map(async (templatePath) => {
+      const content = await fsx.read(templatePath);
+      const newContent = content.replace(versionRegex, `$1"~${newVersion}"`);
 
-    if (content !== newContent) {
-      await fsx.write(templatePath, newContent);
-      changedFiles.push(templatePath);
-    }
-  }
+      if (content !== newContent) {
+        await fsx.write(templatePath, newContent);
+        return templatePath;
+      }
+      return undefined;
+    }),
+  );
+  changedFiles.push(...templateChangedFiles.filter((f) => f != null));
 
   return { version: newVersion, changedFiles };
 }
@@ -81,25 +88,27 @@ export async function computePublishLevels<T extends { name: string; path: strin
 ): Promise<T[][]> {
   const pkgNames = new Set(publishPkgs.map((p) => p.name));
 
-  // 각 패키지의 워크스페이스 의존성 수집
-  const depsMap = new Map<string, Set<string>>();
-  for (const pkg of publishPkgs) {
-    const pkgJson = await fsx.readJson<PackageJson>(path.resolve(pkg.path, "package.json"));
-    const allDeps = {
-      ...pkgJson.dependencies,
-      ...pkgJson.peerDependencies,
-      ...pkgJson.optionalDependencies,
-    };
-
-    const workspaceDeps = new Set<string>();
-    for (const depName of Object.keys(allDeps)) {
-      const shortName = depName.replace(/^@simplysm\//, "");
-      if (shortName !== depName && pkgNames.has(shortName)) {
-        workspaceDeps.add(shortName);
+  // 각 패키지의 워크스페이스 의존성 수집 (병렬)
+  const depsEntries = await Promise.all(
+    publishPkgs.map(async (pkg) => {
+      const pkgJson = await fsx.readJson<PackageJson>(path.resolve(pkg.path, "package.json"));
+      const allDeps = {
+        ...pkgJson.dependencies,
+        ...pkgJson.peerDependencies,
+        ...pkgJson.optionalDependencies,
+      };
+
+      const workspaceDeps = new Set<string>();
+      for (const depName of Object.keys(allDeps)) {
+        const shortName = depName.replace(/^@simplysm\//, "");
+        if (shortName !== depName && pkgNames.has(shortName)) {
+          workspaceDeps.add(shortName);
+        }
       }
-    }
-    depsMap.set(pkg.name, workspaceDeps);
-  }
+      return [pkg.name, workspaceDeps] as const;
+    }),
+  );
+  const depsMap = new Map(depsEntries);
 
   // 위상 정렬로 레벨 분류
   const levels: T[][] = [];