@simplysm/sd-cli 14.0.7 → 14.0.9

package/src/utils/package-utils.ts

@@ -2,6 +2,7 @@ import path from "path";
 import fs from "fs";
 import { consola } from "consola";
 import { SdError } from "@simplysm/core-common";
+import { pathx } from "@simplysm/core-node";
 import type {
   BuildTarget,
   SdBuildPackageConfig,
@@ -36,8 +37,8 @@ export function iteratePackages(
  */
 export function findPackageRoot(startDir: string): string {
   let dir = startDir;
-  while (!fs.existsSync(path.join(dir, "package.json"))) {
-    const parent = path.dirname(dir);
+  while (!fs.existsSync(pathx.posix(path.join(dir, "package.json")))) {
+    const parent = pathx.posix(path.dirname(dir));
     if (parent === dir) throw new Error("package.json not found");
     dir = parent;
   }
@@ -49,13 +50,14 @@ export function findPackageRoot(startDir: string): string {
  * Returns a map of directory name → relative path (e.g., "orm" → "tests/orm").
  */
 export function discoverWorkspacePackages(cwd: string): Map<string, string> {
+  logger.debug("워크스페이스 패키지 탐색 시작");
   const map = new Map<string, string>();
   for (const dir of ["packages", "tests"]) {
-    const baseDir = path.join(cwd, dir);
+    const baseDir = pathx.posix(path.join(cwd, dir));
     if (!fs.existsSync(baseDir)) continue;
     for (const entry of fs.readdirSync(baseDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      if (!fs.existsSync(path.join(baseDir, entry.name, "package.json"))) continue;
+      if (!fs.existsSync(pathx.posix(path.join(baseDir, entry.name, "package.json")))) continue;
       if (map.has(entry.name)) {
         throw new SdError(
           `Duplicate workspace package name: ${entry.name} (${map.get(entry.name)} and ${dir}/${entry.name})`,
@@ -64,6 +66,7 @@ export function discoverWorkspacePackages(cwd: string): Map<string, string> {
       map.set(entry.name, `${dir}/${entry.name}`);
     }
   }
+  logger.debug(`워크스페이스 패키지 탐색 완료 (${map.size}개)`);
   return map;
 }
 
@@ -73,10 +76,24 @@ export function discoverWorkspacePackages(cwd: string): Map<string, string> {
  * Also builds a pathMap (name → relative path) for all packages.
  * Throws SdError if a tests package name collides with an sd.config.ts package name.
  */
+/**
+ * Build pathMap from sd.config.ts packages only (without tests packages).
+ */
+export function buildPathMapFromConfig(
+  configPackages: Record<string, SdPackageConfig | undefined>,
+): Map<string, string> {
+  const pathMap = new Map<string, string>();
+  for (const name of Object.keys(configPackages)) {
+    pathMap.set(name, `packages/${name}`);
+  }
+  return pathMap;
+}
+
 export function mergeTestsPackagesIntoConfig(
   configPackages: Record<string, SdPackageConfig | undefined>,
   workspacePackages: Map<string, string>,
 ): { merged: Record<string, SdPackageConfig | undefined>; pathMap: Map<string, string> } {
+  logger.debug("tests 패키지 병합 시작");
   const pathMap = new Map<string, string>();
   const merged: Record<string, SdPackageConfig | undefined> = { ...configPackages };
 
@@ -99,6 +116,7 @@ export function mergeTestsPackagesIntoConfig(
     pathMap.set(name, relPath);
   }
 
+  logger.debug(`tests 패키지 병합 완료 (총 ${Object.keys(merged).length}개)`);
   return { merged, pathMap };
 }
 
@@ -114,7 +132,7 @@ export function collectDeps(
 ): DepsResult {
   const startTime = performance.now();
   logger.debug("의존성 수집 시작");
-  const rootPkgJsonPath = path.join(cwd, "package.json");
+  const rootPkgJsonPath = pathx.posix(path.join(cwd, "package.json"));
   const rootPkgJson = JSON.parse(fs.readFileSync(rootPkgJsonPath, "utf-8")) as { name: string };
   const scopeMatch = rootPkgJson.name.match(/^(@[^/]+)\//);
   const workspaceScope = scopeMatch != null ? scopeMatch[1] : undefined;
@@ -132,7 +150,7 @@ export function collectDeps(
   const visited = new Set<string>();
 
   function traverse(dir: string): void {
-    const pkgJsonPath = path.join(dir, "package.json");
+    const pkgJsonPath = pathx.posix(path.join(dir, "package.json"));
     if (!fs.existsSync(pkgJsonPath)) return;
 
     const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8")) as {
@@ -147,8 +165,8 @@ export function collectDeps(
       // Check for workspace package
       if (workspaceScope != null && dep.startsWith(workspaceScope + "/")) {
         const dirName = dep.slice(workspaceScope.length + 1);
-        const depDir = path.join(cwd, "packages", dirName);
-        if (fs.existsSync(path.join(depDir, "package.json"))) {
+        const depDir = pathx.posix(path.join(cwd, "packages", dirName));
+        if (fs.existsSync(pathx.posix(path.join(depDir, "package.json")))) {
           workspaceDeps.push(dirName);
           traverse(depDir);
           continue;
@@ -159,8 +177,8 @@ export function collectDeps(
       const matched = replaceDepsPatterns.find((p) => p.regex.test(dep));
       if (matched != null) {
         replaceDeps.push(dep);
-        const depNodeModulesDir = path.join(cwd, "node_modules", ...dep.split("/"));
-        if (fs.existsSync(path.join(depNodeModulesDir, "package.json"))) {
+        const depNodeModulesDir = pathx.posix(path.join(cwd, "node_modules", ...dep.split("/")));
+        if (fs.existsSync(pathx.posix(path.join(depNodeModulesDir, "package.json")))) {
           traverse(depNodeModulesDir);
         }
         continue;
@@ -180,7 +198,7 @@ export function collectDeps(
  * in dependencies or peerDependencies.
  */
 export function hasAngularCoreDependency(pkgDir: string): boolean {
-  const pkgJsonPath = path.join(pkgDir, "package.json");
+  const pkgJsonPath = pathx.posix(path.join(pkgDir, "package.json"));
   if (!fs.existsSync(pkgJsonPath)) return false;
   try {
     const content = fs.readFileSync(pkgJsonPath, "utf-8");
@@ -226,6 +244,7 @@ export function filterPackagesByTargets(
   packages: Record<string, SdPackageConfig | undefined>,
   targets: string[],
 ): Record<string, SdPackageConfig> {
+  logger.debug(`패키지 필터링 시작 (targets: ${targets.length > 0 ? targets.join(", ") : "전체"})`);
   const result: Record<string, SdPackageConfig> = {};
 
   for (const [name, config] of Object.entries(packages)) {
@@ -246,6 +265,7 @@ export function filterPackagesByTargets(
     }
   }
 
+  logger.debug(`패키지 필터링 완료 (${Object.keys(result).length}개)`);
   return result;
 }
 
@@ -268,12 +288,13 @@ export function classifyWatchPackages(
   cwd: string,
   pathMap: Map<string, string>,
 ): WatchClassifiedPackages {
+  logger.debug("watch 패키지 분류 시작");
   const libraryPackages: WatchClassifiedPackages["libraryPackages"] = [];
   const watchHookPackages: WatchClassifiedPackages["watchHookPackages"] = [];
 
   for (const { name, config } of iteratePackages(allPackages, [])) {
     const relPath = pathMap.get(name) ?? `packages/${name}`;
-    const pkgDir = path.join(cwd, relPath);
+    const pkgDir = pathx.posix(path.join(cwd, relPath));
     if (isLibraryTarget(config.target)) {
       const buildConfig = config as SdBuildPackageConfig;
       libraryPackages.push({ name, dir: pkgDir, config: buildConfig });
@@ -289,6 +310,7 @@ export function classifyWatchPackages(
     }
   }
 
+  logger.debug(`watch 패키지 분류 완료 (library: ${libraryPackages.length}, watchHook: ${watchHookPackages.length})`);
   return { libraryPackages, watchHookPackages };
 }
 
@@ -307,6 +329,7 @@ export function classifyDevPackages(
   cwd: string,
   pathMap: Map<string, string>,
 ): DevClassifiedPackages {
+  logger.debug("dev 패키지 분류 시작");
   const serverPackages: DevClassifiedPackages["serverPackages"] = [];
   const clientPackages: DevClassifiedPackages["clientPackages"] = [];
   const serverClientsMap = new Map<string, string[]>();
@@ -324,7 +347,7 @@ export function classifyDevPackages(
   // Second pass: classify all packages
   for (const { name, config } of entries) {
     const relPath = pathMap.get(name) ?? `packages/${name}`;
-    const pkgDir = path.join(cwd, relPath);
+    const pkgDir = pathx.posix(path.join(cwd, relPath));
     if (config.target === "server") {
       serverPackages.push({
         name,
@@ -355,6 +378,7 @@ export function classifyDevPackages(
     // Library and scripts packages are excluded from dev mode
   }
 
+  logger.debug(`dev 패키지 분류 완료 (server: ${serverPackages.length}, client: ${clientPackages.length})`);
   return { serverPackages, clientPackages, serverClientsMap };
 }
 

package/src/utils/rebuild-manager.ts

@@ -2,7 +2,7 @@ import { EventEmitter } from "node:events";
 import { consola } from "consola";
 
 interface RebuildManagerEvents {
-  batchComplete: [];
+  batchComplete: [completedKeys: string[]];
 }
 
 export class RebuildManager extends EventEmitter<RebuildManagerEvents> {
@@ -19,6 +19,7 @@ export class RebuildManager extends EventEmitter<RebuildManagerEvents> {
   }
 
   registerBuild(key: string, title: string): () => void {
+    this._logger.debug(`빌드 등록: ${key} (${title})`);
     let resolver!: () => void;
     const promise = new Promise<void>((resolve) => {
       resolver = resolve;
@@ -35,6 +36,7 @@ export class RebuildManager extends EventEmitter<RebuildManagerEvents> {
 
   private async _runBatch(): Promise<void> {
     if (this._isRunning || this._pendingBuilds.size === 0) {
+      this._logger.debug(`배치 건너뜀 (running: ${String(this._isRunning)}, pending: ${this._pendingBuilds.size})`);
       return;
     }
 
@@ -60,7 +62,7 @@ export class RebuildManager extends EventEmitter<RebuildManagerEvents> {
 
     this._logger.success(`리빌드 실행 완료 (${titles})`);
 
-    this.emit("batchComplete");
+    this.emit("batchComplete", Array.from(batchBuilds.keys()));
 
     this._isRunning = false;
 

package/src/utils/replace-deps.ts

@@ -133,7 +133,7 @@ export interface WatchReplaceDepResult {
 async function collectSearchRoots(projectRoot: string): Promise<string[]> {
   const searchRoots = [projectRoot];
 
-  const workspaceYamlPath = path.join(projectRoot, "pnpm-workspace.yaml");
+  const workspaceYamlPath = pathx.posix(path.join(projectRoot, "pnpm-workspace.yaml"));
   try {
     const yamlContent = await fs.promises.readFile(workspaceYamlPath, "utf-8");
     const workspaceGlobs = parseWorkspaceGlobs(yamlContent);
@@ -171,7 +171,7 @@ async function resolveAllReplaceDepEntries(
   const searchRoots = await collectSearchRoots(projectRoot);
 
   for (const searchRoot of searchRoots) {
-    const nodeModulesDir = path.join(searchRoot, "node_modules");
+    const nodeModulesDir = pathx.posix(path.join(searchRoot, "node_modules"));
 
     try {
       await fs.promises.access(nodeModulesDir);
@@ -192,8 +192,8 @@ async function resolveAllReplaceDepEntries(
     const matchedEntries = resolveReplaceDepEntries(replaceDeps, targetNames);
 
     for (const { targetName, sourcePath } of matchedEntries) {
-      const targetPath = path.join(nodeModulesDir, targetName);
-      const resolvedSourcePath = path.resolve(projectRoot, sourcePath);
+      const targetPath = pathx.posix(path.join(nodeModulesDir, targetName));
+      const resolvedSourcePath = pathx.posixResolve(projectRoot, sourcePath);
 
       // Verify source path exists
       try {
@@ -208,7 +208,7 @@ async function resolveAllReplaceDepEntries(
       try {
         const stat = await fs.promises.lstat(targetPath);
         if (stat.isSymbolicLink()) {
-          actualTargetPath = await fs.promises.realpath(targetPath);
+          actualTargetPath = pathx.posix(await fs.promises.realpath(targetPath));
         }
       } catch {
         // If targetPath doesn't exist, use as-is
@@ -263,7 +263,7 @@ export async function setupReplaceDeps(
 
   // Run postinstall scripts from replaced packages
   for (const { targetName, resolvedSourcePath, actualTargetPath } of entries) {
-    const sourcePkgJsonPath = path.join(resolvedSourcePath, "package.json");
+    const sourcePkgJsonPath = pathx.posix(path.join(resolvedSourcePath, "package.json"));
     try {
       const pkgJson = JSON.parse(await fs.promises.readFile(sourcePkgJsonPath, "utf-8"));
       const postinstall = pkgJson.scripts?.postinstall as string | undefined;
@@ -312,7 +312,7 @@ export async function watchReplaceDeps(
     watchedSources.add(entry.resolvedSourcePath);
 
     const excludedPaths = [...EXCLUDED_NAMES].map((name) =>
-      path.join(entry.resolvedSourcePath, name),
+      pathx.posix(path.join(entry.resolvedSourcePath, name)),
     );
 
     const watcher = await FsWatcher.watch([entry.resolvedSourcePath], { followSymlinks: false });
@@ -331,8 +331,8 @@ export async function watchReplaceDeps(
           if (e.resolvedSourcePath !== entry.resolvedSourcePath) continue;
 
           // Calculate relative path from source
-          const relativePath = path.relative(e.resolvedSourcePath, changedPath);
-          const destPath = path.join(e.actualTargetPath, relativePath);
+          const relativePath = pathx.posix(path.relative(e.resolvedSourcePath, changedPath));
+          const destPath = pathx.posix(path.join(e.actualTargetPath, relativePath));
 
           try {
             // Check if source exists
@@ -350,7 +350,7 @@ export async function watchReplaceDeps(
               if (stat.isDirectory()) {
                 await fsx.mkdir(destPath);
               } else {
-                await fsx.mkdir(path.dirname(destPath));
+                await fsx.mkdir(pathx.posix(path.dirname(destPath)));
                 await fsx.copy(changedPath, destPath, replaceDepsCopyFilter);
               }
             } else {

package/src/utils/sd-config.ts

@@ -1,7 +1,6 @@
-import path from "path";
 import { createJiti } from "jiti";
 import { SdError } from "@simplysm/core-common";
-import { fsx } from "@simplysm/core-node";
+import { fsx, pathx } from "@simplysm/core-node";
 import { consola } from "consola";
 import type { SdConfig, SdConfigParams } from "../sd-config.types";
 
@@ -13,7 +12,7 @@ const logger = consola.withTag("sd:cli:sd-config");
  * @throws if sd.config.ts is missing or format is incorrect
  */
 export async function loadSdConfig(params: SdConfigParams): Promise<SdConfig> {
-  const sdConfigPath = path.resolve(params.cwd, "sd.config.ts");
+  const sdConfigPath = pathx.posixResolve(params.cwd, "sd.config.ts");
   logger.debug(`sd.config.ts 로드 중: ${sdConfigPath}`);
 
   if (!(await fsx.exists(sdConfigPath))) {

package/src/utils/tsc-build.ts

@@ -4,6 +4,7 @@ import { err as errNs } from "@simplysm/core-common";
 import { consola } from "consola";
 
 const logger = consola.withTag("sd:cli:tsc-build");
+import { pathx } from "@simplysm/core-node";
 import {
   parseTsconfig,
   getPackageSourceFiles,
@@ -27,6 +28,8 @@ export interface TscPackageBuildOptions {
   parsedConfig?: ts.ParsedCommandLine;
   /** Typecheck environment. When set, adjusts compilerOptions via getCompilerOptionsForEnv(). */
   env?: TypecheckEnv;
+  /** Include tests/ files in typecheck-only mode. Defaults to false. */
+  includeTests?: boolean;
 }
 
 /**
@@ -49,7 +52,7 @@ export interface TscPackageBuildResult {
  * Run TypeScript incremental build for a package.
  *
  * - output.js || output.dts: emit mode (src files only, generates output files)
- * - neither: typecheck only (src + test files, no output)
+ * - neither: typecheck only (src files only by default, src + test files when includeTests=true)
  *
  * Uses tsBuildInfoFile for incremental compilation across runs.
  */
@@ -68,7 +71,7 @@ export function runTscPackageBuild(options: TscPackageBuildOptions): TscPackageB
 
     let rootFiles: string[];
 
-    if (needsEmit) {
+    if (needsEmit || !options.includeTests) {
       rootFiles = getPackageSourceFiles(pkgDir, parsedConfig);
     } else {
       rootFiles = getPackageFiles(pkgDir, parsedConfig);
@@ -79,7 +82,9 @@ export function runTscPackageBuild(options: TscPackageBuildOptions): TscPackageB
     const tsBuildInfoFile = path.join(
       pkgDir,
       ".cache",
-      needsEmit ? "build.tsbuildinfo" : `typecheck${envSuffix}.tsbuildinfo`,
+      needsEmit
+        ? `build${output.dts ? "" : "-no-dts"}${envSuffix}.tsbuildinfo`
+        : `typecheck${envSuffix}.tsbuildinfo`,
     );
 
     const compilerOptions: ts.CompilerOptions = {
@@ -148,7 +153,7 @@ export function runTscPackageBuild(options: TscPackageBuildOptions): TscPackageB
       const result = builderProgram.getSemanticDiagnosticsOfNextAffectedFile();
       if (result == null) break;
       if ("fileName" in result.affected) {
-        affectedFiles?.add(result.affected.fileName.replace(/\\/g, "/"));
+        affectedFiles?.add(pathx.posix(result.affected.fileName));
       } else {
         // ts.Program returned — global change, treat as full rebuild
         affectedFiles = undefined;

package/src/utils/typecheck-non-package.ts

@@ -1,6 +1,7 @@
 import path from "path";
 import ts from "typescript";
 import { consola } from "consola";
+import { pathx } from "@simplysm/core-node";
 import { parseTsconfig } from "./tsconfig";
 import { serializeDiagnostic, type SerializedDiagnostic } from "./typecheck-serialization";
 
@@ -28,15 +29,15 @@ export function typecheckNonPackageFiles(cwd: string): NonPackageTypecheckResult
   const packagesDir = path.join(cwd, "packages");
 
   const isNonPackageFile = (fileName: string): boolean => {
-    const normalized = path.resolve(fileName);
-    const normalizedPkgDir = path.resolve(packagesDir);
+    const normalized = pathx.posixResolve(fileName);
+    const normalizedPkgDir = pathx.posixResolve(packagesDir);
 
     // Files outside packages/ directory
-    if (!normalized.startsWith(normalizedPkgDir + path.sep)) return true;
+    if (!normalized.startsWith(normalizedPkgDir + "/")) return true;
 
     // Files directly in package root (e.g., packages/{pkg}/file.ts — depth 2)
-    const relative = path.relative(normalizedPkgDir, normalized);
-    return relative.split(path.sep).length === 2;
+    const relative = pathx.posix(path.relative(normalizedPkgDir, normalized));
+    return relative.split("/").length === 2;
   };
 
   const rootFiles = parsedConfig.fileNames.filter(isNonPackageFile);
@@ -54,14 +55,18 @@ export function typecheckNonPackageFiles(cwd: string): NonPackageTypecheckResult
     declarationMap: false,
   };
 
+  logger.debug("incremental 프로그램 생성 시작");
   const host = ts.createIncrementalCompilerHost(options);
   const program = ts.createIncrementalProgram({
     rootNames: rootFiles,
     options,
     host,
   });
+  logger.debug("incremental 프로그램 생성 완료");
 
+  logger.debug("emit 시작");
   program.emit();
+  logger.debug("emit 완료");
 
   const allDiagnostics = [
     ...program.getConfigFileParsingDiagnostics(),

package/src/utils/vite-config.ts

@@ -1,5 +1,6 @@
 import type { InlineConfig, PluginOption } from "vite";
 import path from "path";
+import { pathx } from "@simplysm/core-node";
 import tsconfigPaths from "vite-tsconfig-paths";
 import browserslistToEsbuild from "browserslist-to-esbuild";
 import { sdAngularPlugin } from "../angular/vite-angular-plugin.js";
@@ -227,7 +228,7 @@ export async function createClientViteConfig(
         if (!code.includes("import.meta")) return;
 
         // id(파일 경로)를 Vite 서빙 URL로 변환
-        const relative = path.relative(pkgDir, id).replace(/\\/g, "/");
+        const relative = pathx.posix(path.relative(pkgDir, id));
         const moduleUrl = id.startsWith("/") || id.startsWith("\0")
           ? id // 가상 모듈(/@vite/client 등)은 그대로 사용
           : base + relative;

package/src/utils/worker-events.ts

@@ -51,7 +51,7 @@ export interface BaseWorkerInfo<TEvents extends Record<string, unknown> = Record
 export interface WorkerEventHandlerOptions {
   resultKey: string;
   listrTitle: string;
-  resultType: "build" | "dts";
+  resultType: "build";
 }
 
 /**
@@ -77,6 +77,7 @@ export function registerWorkerEventHandlers(
   results: Map<string, BuildResult>,
   rebuildManager: RebuildManager,
 ): (result: BuildResult) => void {
+  workerEventsLogger.debug(`[${workerInfo.name}] 이벤트 핸들러 등록 (${opts.resultType})`);
   const completeTask = (result: BuildResult): void => {
     results.set(opts.resultKey, result);
     workerInfo.buildResolver?.();

package/src/utils/worker-utils.ts

@@ -1,13 +1,15 @@
 import consola, { type ConsolaInstance, LogLevels } from "consola";
+import { SdCliReporter } from "./SdCliReporter";
 
 /**
- * Apply debug log level in worker threads
+ * Apply sd-cli reporter and debug log level in worker threads
  *
  * Checks the SD_DEBUG environment variable (set by --debug flag in main process)
  * and applies debug log level to consola in the current worker thread.
  * Must be called at worker module top level.
  */
 export function applyDebugLevel(): void {
+  consola.options.reporters = [new SdCliReporter()];
   if (process.env["SD_DEBUG"] === "true") {
     consola.level = LogLevels.debug;
   }

package/src/vitest-plugin.ts

@@ -31,8 +31,13 @@ export function angularVitestPlugin(options: AngularVitestPluginOptions): Plugin
         (f) => f.includes("/src/") || f.includes(".fixture."),
       );
 
+      const angularCompilerOptions = configFile.config?.angularCompilerOptions as
+        | Record<string, unknown>
+        | undefined;
+
       const compilerOptions: ts.CompilerOptions = {
         ...parsedConfig.options,
+        ...(angularCompilerOptions as ts.CompilerOptions | undefined),
         noEmit: false,
         declaration: false,
         declarationMap: false,

package/src/workers/client.worker.ts

@@ -104,8 +104,10 @@ async function startWatch(info: ClientBuildInfo): Promise<ClientBuildResult> {
       pwa: info.pwa,
     });
 
+    logger.debug(`[${info.name}] Vite server 생성 시작`);
     viteServer = await createServer(viteConfig);
     await viteServer.listen();
+    logger.debug(`[${info.name}] Vite server listen 완료`);
 
     // 실제 포트 감지
     const address = viteServer.httpServer?.address();
@@ -139,11 +141,13 @@ async function startWatch(info: ClientBuildInfo): Promise<ClientBuildResult> {
  * dev server 중지. Vite server를 정리한다.
  */
 async function stopWatch(): Promise<void> {
+  logger.debug("Vite server 정리 시작");
   const serverToClose = viteServer;
   viteServer = undefined;
   if (serverToClose != null) {
     await serverToClose.close();
   }
+  logger.debug("Vite server 정리 완료");
 }
 
 /**

package/src/workers/library-build.worker.ts

@@ -1,5 +1,5 @@
-import path from "path";
-import { createWorker, FsWatcher } from "@simplysm/core-node";
+import type ts from "typescript";
+import { createWorker, FsWatcher, pathx } from "@simplysm/core-node";
 import { err as errNs } from "@simplysm/core-common";
 import { consola } from "consola";
 import type { SdBuildPackageConfig } from "../sd-config.types";
@@ -26,14 +26,12 @@ export interface LibraryBuildInfo {
 }
 
 export interface LibraryBuildResult {
-  js: { success: boolean; errors?: string[]; warnings?: string[] };
-  dts: { success: boolean; errors?: string[]; diagnostics: SerializedDiagnostic[] };
+  build: { success: boolean; errors?: string[]; warnings?: string[]; diagnostics: SerializedDiagnostic[] };
   lint?: LintWithProgramResult;
 }
 
 export interface CombinedBuildEvent {
-  js: { success: boolean; errors?: string[]; warnings?: string[] };
-  dts: { success: boolean; errors?: string[] };
+  build: { success: boolean; errors?: string[]; warnings?: string[] };
   lint?: LintWithProgramResult;
 }
 
@@ -54,6 +52,7 @@ let fsWatcher: FsWatcher | undefined;
 async function cleanup(): Promise<void> {
   const watcherToClose = fsWatcher;
   fsWatcher = undefined;
+  lastSourceFilePaths = undefined;
   await watcherToClose?.close();
 }
 
@@ -70,28 +69,27 @@ async function build(info: LibraryBuildInfo): Promise<LibraryBuildResult> {
     cwd: info.cwd,
     output: info.output,
     env: info.output.env,
+    includeTests: info.output.includeTests,
   });
   logger.debug(`[${info.name}] library worker build 완료 (success: ${tscResult.success})`);
 
   // Run lint if enabled and program is available
   let lint: LintWithProgramResult | undefined;
   if (info.output.lint === true && tscResult.program != null) {
+    logger.debug(`[${info.name}] lint 시작`);
     const lintRunner = new LintWithProgramRunner({
       cwd: info.cwd,
       pkgName: info.name,
     });
     lint = await lintRunner.lint({ program: tscResult.program });
+    logger.debug(`[${info.name}] lint 완료`);
   }
 
   return {
-    js: {
+    build: {
       success: tscResult.success,
       errors: tscResult.errors,
       warnings: undefined,
-    },
-    dts: {
-      success: tscResult.success,
-      errors: tscResult.errors,
       diagnostics: tscResult.diagnostics,
     },
     lint,
@@ -107,20 +105,36 @@ const guardStartWatch = createOnceGuard("startWatch");
 // Mutable state for watch mode
 let watchInfo: LibraryBuildInfo | undefined;
 let watchLintRunner: LintWithProgramRunner | undefined;
+let lastSourceFilePaths: Set<string> | undefined;
+
+function extractSourceFilePaths(program: ts.Program | undefined): Set<string> | undefined {
+  if (program == null) return undefined;
+  const paths = new Set<string>();
+  for (const sf of program.getSourceFiles()) {
+    paths.add(pathx.posix(sf.fileName));
+  }
+  return paths;
+}
 
 async function rebuildAll(): Promise<CombinedBuildEvent> {
   const info = watchInfo!;
+  logger.debug(`[${info.name}] rebuildAll 시작`);
 
   const tscResult = runTscPackageBuild({
     pkgDir: info.pkgDir,
     cwd: info.cwd,
     output: info.output,
     env: info.output.env,
+    includeTests: info.output.includeTests,
   });
 
+  // Update source file paths for dependency filtering
+  lastSourceFilePaths = extractSourceFilePaths(tscResult.program) ?? lastSourceFilePaths;
+
   // Run lint if enabled and program is available
   let lint: LintWithProgramResult | undefined;
   if (info.output.lint === true && tscResult.program != null) {
+    logger.debug(`[${info.name}] lint 시작`);
     if (watchLintRunner == null) {
       watchLintRunner = new LintWithProgramRunner({
         cwd: info.cwd,
@@ -131,11 +145,12 @@ async function rebuildAll(): Promise<CombinedBuildEvent> {
       program: tscResult.program,
       affectedFiles: tscResult.affectedFiles,
     });
+    logger.debug(`[${info.name}] lint 완료`);
   }
 
+  logger.debug(`[${info.name}] rebuildAll 완료`);
   return {
-    js: { success: tscResult.success, errors: tscResult.errors },
-    dts: { success: tscResult.success, errors: tscResult.errors },
+    build: { success: tscResult.success, errors: tscResult.errors },
     lint,
   };
 }
@@ -153,18 +168,33 @@ async function startWatch(info: LibraryBuildInfo): Promise<void> {
     const { workspaceDeps, replaceDeps } = collectDeps(info.pkgDir, info.cwd, info.replaceDeps);
 
     // Start FsWatcher — own src/ + workspace deps' src/ + replaceDeps dist/
+    logger.debug(`[${info.name}] FsWatcher 시작`);
     const watchPaths = [
-      path.join(info.pkgDir, "src", "**", "*.ts"),
-      ...workspaceDeps.map((d) => path.join(info.cwd, "packages", d, "src", "**", "*.ts")),
+      pathx.posixResolve(info.pkgDir, "src", "**", "*.ts"),
+      ...workspaceDeps.map((d) => pathx.posixResolve(info.cwd, "packages", d, "src", "**", "*.ts")),
       ...replaceDeps.flatMap((pkg) => [
-        path.join(info.cwd, "node_modules", ...pkg.split("/"), "dist", "**", "*.{js,mjs,cjs}"),
-        path.join(info.pkgDir, "node_modules", ...pkg.split("/"), "dist", "**", "*.{js,mjs,cjs}"),
+        pathx.posixResolve(info.cwd, "node_modules", ...pkg.split("/"), "dist", "**", "*.{js,mjs,cjs}"),
+        pathx.posixResolve(info.pkgDir, "node_modules", ...pkg.split("/"), "dist", "**", "*.{js,mjs,cjs}"),
       ]),
     ];
     fsWatcher = await FsWatcher.watch(watchPaths);
 
-    fsWatcher.onChange({ delay: 300 }, async () => {
+    fsWatcher.onChange({ delay: 300 }, async (changes) => {
       try {
+        const hasFileAddOrRemove = changes.some(
+          (c) => c.event === "add" || c.event === "unlink",
+        );
+
+        if (!hasFileAddOrRemove && lastSourceFilePaths != null) {
+          const hasRelevantChange = changes.some((c) =>
+            lastSourceFilePaths!.has(c.path),
+          );
+          if (!hasRelevantChange) {
+            logger.debug("변경된 파일이 빌드에 포함되지 않아 리빌드 건너뜀");
+            return;
+          }
+        }
+
         sender.send("buildStart", {});
         const result = await rebuildAll();
         sender.send("build", result);