@simplysm/sd-cli 14.0.7 → 14.0.9

package/src/utils/angular-compiler.ts

@@ -2,6 +2,7 @@ import path from "path";
 import { createHash } from "crypto";
 import ts from "typescript";
 import { consola } from "consola";
+import { pathx } from "@simplysm/core-node";
 import { NgtscProgram, OptimizeFor } from "./angular-build";
 import { collectHmrCandidates } from "./hmr-candidates.js";
 
@@ -67,7 +68,7 @@ export class AngularSourceFileCache extends Map<string, ts.SourceFile> {
 
   invalidate(files: Iterable<string>): void {
     for (const file of files) {
-      const normalized = file.replace(/\\/g, "/");
+      const normalized = pathx.posix(file);
       this.delete(normalized);
       this.modifiedFiles.add(normalized);
     }
@@ -312,7 +313,7 @@ export class AngularCompiler {
         }
         const sf = node.getSourceFile();
         let relativePath = path.relative(host.getCurrentDirectory(), sf.fileName);
-        relativePath = relativePath.replace(/\\/g, "/");
+        relativePath = pathx.posix(relativePath);
 
         const updateId = encodeURIComponent(
           `${host.getCanonicalFileName(relativePath)}@${node.name?.text}`,
@@ -352,6 +353,7 @@ export class AngularCompiler {
     angularCompiler: NgCompiler,
     sourceFileCache?: AngularSourceFileCache,
   ): Set<ts.SourceFile> {
+    logger.debug("affected 파일 탐색 시작");
     const affectedFiles = new Set<ts.SourceFile>();
 
     while (true) {
@@ -393,7 +395,7 @@ export class AngularCompiler {
       // modifiedFiles의 경로를 정규화한 Set 생성 (Windows backslash 대응)
       const normalizedModifiedFiles = new Set<string>();
       for (const f of sourceFileCache.modifiedFiles) {
-        normalizedModifiedFiles.add(f.replace(/\\/g, "/"));
+        normalizedModifiedFiles.add(pathx.posix(f));
       }
 
       for (const sourceFile of builderProgram.getSourceFiles()) {
@@ -402,7 +404,7 @@ export class AngularCompiler {
         }
         const resourceDependencies = angularCompiler.getResourceDependencies(sourceFile);
         for (const resourceDep of resourceDependencies) {
-          if (normalizedModifiedFiles.has(resourceDep.replace(/\\/g, "/"))) {
+          if (normalizedModifiedFiles.has(pathx.posix(resourceDep))) {
             this._diagnosticCache.delete(sourceFile);
             affectedFiles.add(sourceFile);
             break;
@@ -411,6 +413,7 @@ export class AngularCompiler {
       }
     }
 
+    logger.debug(`affected 파일 탐색 완료 (${affectedFiles.size}개)`);
     return affectedFiles;
   }
 
@@ -420,6 +423,7 @@ export class AngularCompiler {
     affectedFiles: ReadonlySet<ts.SourceFile>;
     templateUpdates?: Map<string, string>;
   }> {
+    logger.debug("증분 업데이트 시작");
     const sourceFileCache = this._options.sourceFileCache;
     if (sourceFileCache == null) {
       throw new Error("sourceFileCache가 없으면 incremental rebuild를 수행할 수 없습니다");
@@ -432,6 +436,7 @@ export class AngularCompiler {
     if (this._ngtscProgram == null || this._builderProgram == null) {
       throw new Error("initialize()를 먼저 호출해야 합니다");
     }
+    logger.debug("emitAffectedFiles 시작");
 
     const compilerOptions = this._builderProgram.getCompilerOptions();
 
@@ -519,6 +524,7 @@ export class AngularCompiler {
     }
 
     // 7. sourceFilter 적용 후 yield
+    logger.debug(`emitAffectedFiles 완료 (${emitResults.length}개 파일)`);
     for (const result of emitResults) {
       if (options?.sourceFilter != null && !options.sourceFilter(result.sourceFileName)) {
         continue;
@@ -531,6 +537,7 @@ export class AngularCompiler {
     if (this._ngtscProgram == null || this._builderProgram == null) {
       throw new Error("initialize()를 먼저 호출해야 합니다");
     }
+    logger.debug("진단 수집 시작");
 
     const angularCompiler = this._ngtscProgram.compiler;
     const builderProgram = this._builderProgram;

package/src/utils/build-env.ts

@@ -1,11 +1,12 @@
 import path from "path";
 import fs from "fs/promises";
+import { pathx } from "@simplysm/core-node";
 
 /**
  * Get version from root package.json
  */
 export async function getVersion(cwd: string): Promise<string> {
-  const pkgJsonPath = path.join(cwd, "package.json");
+  const pkgJsonPath = pathx.posix(path.join(cwd, "package.json"));
   const pkgJsonContent = await fs.readFile(pkgJsonPath, "utf-8");
   const pkgJson = JSON.parse(pkgJsonContent) as { version?: string };
   return pkgJson.version ?? "0.0.0";

package/src/utils/copy-public.ts

@@ -13,18 +13,18 @@ import {
  * @param includeDev Whether to include public-dev/ (true only in dev mode)
  */
 export async function copyPublicFiles(pkgDir: string, includeDev: boolean): Promise<void> {
-  const distDir = path.join(pkgDir, "dist");
+  const distDir = pathx.posix(path.join(pkgDir, "dist"));
   await fsx.mkdir(distDir);
 
   // Copy public/
-  const publicDir = path.join(pkgDir, "public");
+  const publicDir = pathx.posix(path.join(pkgDir, "public"));
   if (await fsx.exists(publicDir)) {
     const files = await fsx.glob("**/*", { cwd: publicDir, absolute: true });
     await Promise.all(
       files.map(async (file) => {
-        const relativePath = path.relative(publicDir, file);
-        const distPath = path.join(distDir, relativePath);
-        await fsx.mkdir(path.dirname(distPath));
+        const relativePath = pathx.posix(path.relative(publicDir, file));
+        const distPath = pathx.posix(path.join(distDir, relativePath));
+        await fsx.mkdir(pathx.posix(path.dirname(distPath)));
         await fsx.copy(file, distPath);
       }),
     );
@@ -32,14 +32,14 @@ export async function copyPublicFiles(pkgDir: string, includeDev: boolean): Prom
 
   // Copy public-dev/ (overlay: overwrites public/)
   if (includeDev) {
-    const publicDevDir = path.join(pkgDir, "public-dev");
+    const publicDevDir = pathx.posix(path.join(pkgDir, "public-dev"));
     if (await fsx.exists(publicDevDir)) {
       const files = await fsx.glob("**/*", { cwd: publicDevDir, absolute: true });
       await Promise.all(
         files.map(async (file) => {
-          const relativePath = path.relative(publicDevDir, file);
-          const distPath = path.join(distDir, relativePath);
-          await fsx.mkdir(path.dirname(distPath));
+          const relativePath = pathx.posix(path.relative(publicDevDir, file));
+          const distPath = pathx.posix(path.join(distDir, relativePath));
+          await fsx.mkdir(pathx.posix(path.dirname(distPath)));
           await fsx.copy(file, distPath);
         }),
       );
@@ -59,9 +59,9 @@ export async function watchPublicFiles(
   pkgDir: string,
   includeDev: boolean,
 ): Promise<FsWatcher | undefined> {
-  const distDir = path.join(pkgDir, "dist");
-  const publicDir = path.join(pkgDir, "public");
-  const publicDevDir = path.join(pkgDir, "public-dev");
+  const distDir = pathx.posix(path.join(pkgDir, "dist"));
+  const publicDir = pathx.posix(path.join(pkgDir, "public"));
+  const publicDevDir = pathx.posix(path.join(pkgDir, "public-dev"));
 
   // Initial copy
   await copyPublicFiles(pkgDir, includeDev);
@@ -69,10 +69,10 @@ export async function watchPublicFiles(
   // Collect watch target paths
   const watchPaths: string[] = [];
   if (await fsx.exists(publicDir)) {
-    watchPaths.push(path.join(publicDir, "**/*"));
+    watchPaths.push(pathx.posix(path.join(publicDir, "**/*")));
   }
   if (includeDev && (await fsx.exists(publicDevDir))) {
-    watchPaths.push(path.join(publicDevDir, "**/*"));
+    watchPaths.push(pathx.posix(path.join(publicDevDir, "**/*")));
   }
 
   if (watchPaths.length === 0) {
@@ -91,22 +91,22 @@ export async function watchPublicFiles(
         sourceDir = publicDir;
       }
 
-      const relPath = path.relative(sourceDir, filePath);
-      const distPath = path.join(distDir, relPath);
+      const relPath = pathx.posix(path.relative(sourceDir, filePath));
+      const distPath = pathx.posix(path.join(distDir, relPath));
 
       if (event === "unlink") {
         // If deleted from public, don't delete if same file exists in public-dev
         if (sourceDir === publicDir && includeDev) {
-          const devOverride = path.join(publicDevDir, relPath);
+          const devOverride = pathx.posix(path.join(publicDevDir, relPath));
           if (await fsx.exists(devOverride)) {
             continue;
           }
         }
         // If deleted from public-dev, restore from public if it exists (fallback restore)
         if (sourceDir === publicDevDir && includeDev) {
-          const publicFallback = path.join(publicDir, relPath);
+          const publicFallback = pathx.posix(path.join(publicDir, relPath));
           if (await fsx.exists(publicFallback)) {
-            await fsx.mkdir(path.dirname(distPath));
+            await fsx.mkdir(pathx.posix(path.dirname(distPath)));
             await fsx.copy(publicFallback, distPath);
             continue;
           }
@@ -115,12 +115,12 @@ export async function watchPublicFiles(
       } else if (event === "add" || event === "change") {
         // If changed in public, skip if same file exists in public-dev (overlay takes priority)
         if (sourceDir === publicDir && includeDev) {
-          const devOverride = path.join(publicDevDir, relPath);
+          const devOverride = pathx.posix(path.join(publicDevDir, relPath));
           if (await fsx.exists(devOverride)) {
             continue;
           }
         }
-        await fsx.mkdir(path.dirname(distPath));
+        await fsx.mkdir(pathx.posix(path.dirname(distPath)));
         await fsx.copy(filePath, distPath);
       }
     }

package/src/utils/copy-src.ts

@@ -1,5 +1,5 @@
 import path from "path";
-import { fsx, FsWatcher } from "@simplysm/core-node";
+import { fsx, pathx, FsWatcher } from "@simplysm/core-node";
 
 /**
  * Copy files matching glob patterns from src/ to dist/
@@ -9,16 +9,16 @@ import { fsx, FsWatcher } from "@simplysm/core-node";
  * @param patterns Array of glob patterns (relative to src/)
  */
 export async function copySrcFiles(pkgDir: string, patterns: string[]): Promise<void> {
-  const srcDir = path.join(pkgDir, "src");
-  const distDir = path.join(pkgDir, "dist");
+  const srcDir = pathx.posix(path.join(pkgDir, "src"));
+  const distDir = pathx.posix(path.join(pkgDir, "dist"));
 
   for (const pattern of patterns) {
     const files = await fsx.glob(pattern, { cwd: srcDir, absolute: true });
     await Promise.all(
       files.map(async (file) => {
-        const relativePath = path.relative(srcDir, file);
-        const distPath = path.join(distDir, relativePath);
-        await fsx.mkdir(path.dirname(distPath));
+        const relativePath = pathx.posix(path.relative(srcDir, file));
+        const distPath = pathx.posix(path.join(distDir, relativePath));
+        await fsx.mkdir(pathx.posix(path.dirname(distPath)));
         await fsx.copy(file, distPath);
       }),
     );
@@ -34,25 +34,25 @@ export async function copySrcFiles(pkgDir: string, patterns: string[]): Promise<
  * @returns FsWatcher instance (call close() on shutdown)
  */
 export async function watchCopySrcFiles(pkgDir: string, patterns: string[]): Promise<FsWatcher> {
-  const srcDir = path.join(pkgDir, "src");
-  const distDir = path.join(pkgDir, "dist");
+  const srcDir = pathx.posix(path.join(pkgDir, "src"));
+  const distDir = pathx.posix(path.join(pkgDir, "dist"));
 
   // Initial copy
   await copySrcFiles(pkgDir, patterns);
 
   // Start watch
-  const watchPaths = patterns.map((p) => path.join(srcDir, p));
+  const watchPaths = patterns.map((p) => pathx.posix(path.join(srcDir, p)));
   const watcher = await FsWatcher.watch(watchPaths);
 
   watcher.onChange({ delay: 300 }, async (changes) => {
     for (const { event, path: filePath } of changes) {
-      const relPath = path.relative(srcDir, filePath);
-      const distPath = path.join(distDir, relPath);
+      const relPath = pathx.posix(path.relative(srcDir, filePath));
+      const distPath = pathx.posix(path.join(distDir, relPath));
 
       if (event === "unlink") {
         await fsx.rm(distPath);
       } else if (event === "add" || event === "change") {
-        await fsx.mkdir(path.dirname(distPath));
+        await fsx.mkdir(pathx.posix(path.dirname(distPath)));
         await fsx.copy(filePath, distPath);
       }
     }

package/src/utils/diagnostic-utils.ts

@@ -1,4 +1,5 @@
 import ts from "typescript";
+import { pathx } from "@simplysm/core-node";
 
 /**
  * 워크스페이스 스코프 진단 필터.
@@ -8,8 +9,8 @@ import ts from "typescript";
 export function isWorkspaceDiagnostic(diagnostic: ts.Diagnostic, cwd: string): boolean {
   if (diagnostic.file == null) return true;
 
-  const normalized = diagnostic.file.fileName.replace(/\\/g, "/");
-  const normalizedCwd = cwd.replace(/\\/g, "/").replace(/\/$/, "");
+  const normalized = pathx.posix(diagnostic.file.fileName);
+  const normalizedCwd = pathx.posix(cwd).replace(/\/$/, "");
   return normalized.startsWith(normalizedCwd + "/") && !normalized.includes("/node_modules/");
 }
 

package/src/utils/esbuild-config.ts

@@ -15,6 +15,7 @@ const logger = consola.withTag("sd:cli:esbuild-config");
  * - Skip writing if content matches existing file to preserve timestamps
  */
 export async function writeChangedOutputFiles(outputFiles: esbuild.OutputFile[]): Promise<boolean> {
+  logger.debug(`변경된 출력 파일 쓰기 시작 (${outputFiles.length}개)`);
   let hasChanges = false;
   await Promise.all(
     outputFiles.map(async (file) => {
@@ -40,6 +41,7 @@ export async function writeChangedOutputFiles(outputFiles: esbuild.OutputFile[])
       await fs.writeFile(file.path, finalText);
     }),
   );
+  logger.debug(`변경된 출력 파일 쓰기 완료 (변경: ${String(hasChanges)})`);
   return hasChanges;
 }
 

package/src/utils/lint-with-program.ts

@@ -1,6 +1,7 @@
 import path from "path";
 import type ts from "typescript";
 import { ESLint } from "eslint";
+import { pathx } from "@simplysm/core-node";
 import { consola } from "consola";
 
 const logger = consola.withTag("sd:cli:lint-with-program");
@@ -58,11 +59,12 @@ export class LintWithProgramRunner {
    * Includes all workspace source files (cwd scope), excludes .d.ts, node_modules, and Angular shims.
    */
   private _extractFiles(program: ts.Program): string[] {
-    const normalizedCwd = this._cwd.replace(/\\/g, "/");
+    logger.debug(`[${this._pkgName}] 린트 대상 파일 추출 시작`);
+    const normalizedCwd = pathx.posix(this._cwd);
     const files: string[] = [];
 
     for (const sf of program.getSourceFiles()) {
-      const fileName = sf.fileName.replace(/\\/g, "/");
+      const fileName = pathx.posix(sf.fileName);
 
       // Must be within workspace root
       if (!fileName.startsWith(normalizedCwd + "/")) {
@@ -87,6 +89,7 @@ export class LintWithProgramRunner {
       files.push(sf.fileName);
     }
 
+    logger.debug(`[${this._pkgName}] 린트 대상 파일 추출 완료 (${files.length}개)`);
     return files;
   }
 
@@ -103,7 +106,7 @@ export class LintWithProgramRunner {
 
     // When affectedFiles is provided, intersect with extracted files
     if (affectedFiles != null) {
-      files = files.filter((f) => affectedFiles.has(f.replace(/\\/g, "/")));
+      files = files.filter((f) => affectedFiles.has(pathx.posix(f)));
     }
 
     if (files.length === 0) {
@@ -127,6 +130,7 @@ export class LintWithProgramRunner {
 
     // Create new ESLint instance when cache policy changes or on first call
     if (this._eslint == null || this._lastUseCache !== useCache) {
+      logger.debug(`[${this._pkgName}] ESLint 인스턴스 생성 (cache: ${String(useCache)})`);
       // ESLint Flat Config serializes languageOptions via languageOptionsToJSON(),
       // which recurses into parserOptions and throws on ts.Program methods.
       // Adding toJSON() to parserOptions returns a serializable representation

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 {