@simplysm/sd-cli 14.0.8 → 14.0.10

package/src/utils/ngtsc-build-core.ts

@@ -2,6 +2,7 @@ import path from "path";
 import fs from "fs";
 import ts from "typescript";
 import { err as errNs } from "@simplysm/core-common";
+import { pathx } from "@simplysm/core-node";
 import { consola } from "consola";
 
 const logger = consola.withTag("sd:cli:ngtsc-build");
@@ -12,6 +13,7 @@ import type { LintWithProgramResult } from "./lint-with-program";
 import {
   parseTsconfig,
   getPackageSourceFiles,
+  getPackageFiles,
   getCompilerOptionsForEnv,
   type TypecheckEnv,
 } from "./tsconfig";
@@ -34,8 +36,7 @@ export interface NgtscBuildInfo {
 }
 
 export interface NgtscBuildResult {
-  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;
 }
 
@@ -45,8 +46,7 @@ export interface NgtscBuildInternalResult extends NgtscBuildResult {
 }
 
 export interface NgtscCombinedBuildEvent {
-  js: { success: boolean; errors?: string[]; warnings?: string[] };
-  dts: { success: boolean; errors?: string[] };
+  build: { success: boolean; errors?: string[]; warnings?: string[] };
   lint?: LintWithProgramResult;
 }
 
@@ -192,6 +192,7 @@ export function writeEmitResults(
   pkgDir: string,
   scss?: SideEffectScssOptions,
 ): void {
+  logger.debug("emit 결과 파일 쓰기 시작");
   const rewritePath = createOutputPathRewriter(pkgDir);
   for (const { filename, contents, sourceFileName } of emitResults) {
     const rewrite = rewritePath(filename, contents);
@@ -241,6 +242,7 @@ export function writeEmitResults(
     fs.mkdirSync(path.dirname(newPath), { recursive: true });
     fs.writeFileSync(newPath, newContent, "utf-8");
   }
+  logger.debug("emit 결과 파일 쓰기 완료");
 }
 
 //#region Side-effect SCSS
@@ -256,6 +258,7 @@ export function compileSideEffectScss(
   scssErrors: string[],
   scssDependencies: Map<string, Set<string>>,
 ): void {
+  logger.debug(`side-effect SCSS 컴파일 시작 (${registry.size}개)`);
   for (const entry of registry.values()) {
     try {
       const result = compileScssFile(entry.scssAbsPath, loadPaths);
@@ -266,6 +269,7 @@ export function compileSideEffectScss(
       scssErrors.push(formatScssError(err, entry.scssAbsPath));
     }
   }
+  logger.debug("side-effect SCSS 컴파일 완료");
 }
 
 //#endregion
@@ -278,6 +282,7 @@ export function compileGlobalScss(
 ): string[] {
   const stylesPath = path.join(pkgDir, "scss", "styles.scss");
   if (!fs.existsSync(stylesPath)) return [];
+  logger.debug("global SCSS 컴파일 시작");
 
   const errors: string[] = [];
   try {
@@ -288,6 +293,7 @@ export function compileGlobalScss(
   } catch (err) {
     errors.push(`Global SCSS error: ${errNs.message(err)}`);
   }
+  logger.debug("global SCSS 컴파일 완료");
   return errors;
 }
 
@@ -302,7 +308,9 @@ export async function runNgtscBuild(info: NgtscBuildInfo): Promise<NgtscBuildInt
     logger.debug(`[${info.name}] ngtsc 빌드 시작 (env: ${info.env ?? "none"}, js: ${info.output.js}, dts: ${info.output.dts})`);
 
     const parsedConfig = parseTsconfig(info.pkgDir);
-    const sourceFiles = getPackageSourceFiles(info.pkgDir, parsedConfig);
+    const sourceFiles = info.output.includeTests === true
+      ? getPackageFiles(info.pkgDir, parsedConfig)
+      : getPackageSourceFiles(info.pkgDir, parsedConfig);
     logger.debug(`[${info.name}] rootNames: ${sourceFiles.length}개 파일`);
 
     const baseOptions =
@@ -311,12 +319,9 @@ export async function runNgtscBuild(info: NgtscBuildInfo): Promise<NgtscBuildInt
         : parsedConfig.options;
     const compilerOptions = buildCompilerOptions(baseOptions, info.pkgDir, info.output);
     const pkgSrcDir = path.join(info.pkgDir, "src");
-    const normalizedSrcDir = pkgSrcDir.replace(/\\/g, "/");
+    const normalizedSrcDir = pathx.posix(pkgSrcDir);
 
-    // Read angularCompilerOptions from root tsconfig
-    const rootTsconfigPath = path.join(info.cwd, "tsconfig.json");
-    const rootRawConfig = ts.readConfigFile(rootTsconfigPath, ts.sys.readFile);
-    const angularOptions = rootRawConfig.config?.angularCompilerOptions ?? {};
+    const angularOptions = (parsedConfig.raw?.angularCompilerOptions ?? {}) as Record<string, unknown>;
 
     // SCSS closure variables
     const scssErrors: string[] = [];
@@ -355,7 +360,7 @@ export async function runNgtscBuild(info: NgtscBuildInfo): Promise<NgtscBuildInt
     // Emit via AngularCompiler + output-path-rewriting
     const emitResults = compiler.emitAffectedFiles({
       sourceFilter: (fileName: string) =>
-        fileName.replace(/\\/g, "/").startsWith(normalizedSrcDir + "/"),
+        pathx.posix(fileName).startsWith(normalizedSrcDir + "/"),
     });
     writeEmitResults(emitResults, info.pkgDir, {
       loadPaths,
@@ -372,14 +377,10 @@ export async function runNgtscBuild(info: NgtscBuildInfo): Promise<NgtscBuildInt
     const buildSuccess = errorCount === 0 && scssErrors.length === 0 && globalScssErrors.length === 0;
 
     return {
-      js: {
+      build: {
         success: buildSuccess,
         errors: allErrors.length > 0 ? allErrors : undefined,
         warnings: undefined,
-      },
-      dts: {
-        success: buildSuccess,
-        errors: allErrors.length > 0 ? allErrors : undefined,
         diagnostics: serialized,
       },
       program: compiler.getTsProgram(),
@@ -392,8 +393,7 @@ export async function runNgtscBuild(info: NgtscBuildInfo): Promise<NgtscBuildInt
       logger.debug(`[${info.name}] 스택 트레이스:\n${stack}`);
     }
     return {
-      js: { success: false, errors: [message] },
-      dts: { success: false, errors: [message], diagnostics: [] },
+      build: { success: false, errors: [message], diagnostics: [] },
     };
   }
 }

package/src/utils/output-path-rewriter.ts

@@ -46,7 +46,7 @@ export function adjustMapSources(content: string, originalDir: string, newDir: s
     if (Array.isArray(map.sources)) {
       map.sources = map.sources.map((source) => {
         const absoluteSource = path.resolve(originalDir, source);
-        return path.relative(newDir, absoluteSource);
+        return pathx.posix(path.relative(newDir, absoluteSource));
       });
     }
     return JSON.stringify(map);
@@ -69,19 +69,19 @@ export function createOutputPathRewriter(
   pkgDir: string,
 ): (fileName: string, content: string) => [string, string] | null {
   const pkgName = path.basename(pkgDir);
-  const distDir = pathx.norm(path.join(pkgDir, "dist"));
-  const distPrefix = distDir + path.sep;
+  const distDir = pathx.posixResolve(pkgDir, "dist");
+  const distPrefix = distDir + "/";
   // Nested structure prefix for this package: dist/{pkgName}/src/
-  const ownNestedPrefix = pathx.norm(path.join(distDir, pkgName, "src")) + path.sep;
+  const ownNestedPrefix = pathx.posixResolve(distDir, pkgName, "src") + "/";
 
   return (fileName, content) => {
-    fileName = pathx.norm(fileName);
+    fileName = pathx.posixResolve(fileName);
 
     if (!fileName.startsWith(distPrefix)) return null;
 
     if (fileName.startsWith(ownNestedPrefix)) {
       // Rewrite nested path to flat: dist/{pkgName}/src/... → dist/...
-      const flatPath = path.join(distDir, fileName.slice(ownNestedPrefix.length));
+      const flatPath = pathx.posixResolve(distDir, fileName.slice(ownNestedPrefix.length));
       if (fileName.endsWith(".d.ts.map") || fileName.endsWith(".js.map")) {
         content = adjustMapSources(content, path.dirname(fileName), path.dirname(flatPath));
       }
@@ -90,7 +90,7 @@ export function createOutputPathRewriter(
 
     // Nested output from other packages (dist/{otherPkg}/src/...) → ignore
     const relFromDist = fileName.slice(distPrefix.length);
-    const segments = relFromDist.split(path.sep);
+    const segments = relFromDist.split("/");
     if (segments.length >= 3 && segments[1] === "src") {
       return null;
     }

package/src/utils/output-utils.ts

@@ -21,7 +21,7 @@ export function formatBuildMessages(name: string, label: string, messages: strin
 export function printErrors(results: Map<string, BuildResult>): void {
   for (const result of results.values()) {
     if (result.status === "error") {
-      const typeLabel = result.type === "dts" ? "dts" : result.type === "lint" ? "lint" : result.target;
+      const typeLabel = result.type === "lint" ? "lint" : result.target;
       if (result.message != null && result.message !== "") {
         consola.error(formatBuildMessages(result.name, typeLabel, [result.message]));
       } else {

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;
   }