@simplysm/sd-cli 14.0.42 → 14.0.43

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

@@ -1,12 +1,13 @@
+import path from "path";
 import type ts from "typescript";
 import { createWorker, FsWatcher, pathx } from "@simplysm/core-node";
 import { err as errNs } from "@simplysm/core-common";
-import type { SdBuildPackageConfig } from "../sd-config.types";
 import type { BuildOutput } from "../engines/types";
 import type { SerializedDiagnostic } from "../typecheck/typecheck-serialization";
 import type { LintWithProgramResult } from "../lint/lint-with-program";
-import { runTscPackageBuild } from "../utils/tsc-build";
-import { LintWithProgramRunner } from "../lint/lint-with-program";
+import { SdTsCompiler } from "../ts-compiler/SdTsCompiler";
+import type { ISdTsCompilerResult } from "../ts-compiler/sd-ts-compiler-result";
+import { writeEmitResults, compileSideEffectScss } from "../angular/ngtsc-build-core";
 import { setupWorkerLifecycle } from "./shared-worker-lifecycle";
 import { buildWatchPaths } from "./build-watch-paths";
 import { hasFileAddOrRemove, shouldSkipRebuild } from "./build-change-filter";
@@ -15,7 +16,6 @@ import { hasFileAddOrRemove, shouldSkipRebuild } from "./build-change-filter";
 
 export interface LibraryBuildInfo {
   name: string;
-  config: SdBuildPackageConfig;
   cwd: string;
   pkgDir: string;
   output: BuildOutput;
@@ -44,12 +44,15 @@ export interface LibraryBuildWorkerEvents extends Record<string, unknown> {
 //#region Resource Management
 
 let fsWatcher: FsWatcher | undefined;
+let compiler: SdTsCompiler | undefined;
+let combinedScssDeps = new Map<string, Set<string>>();
 
 async function cleanup(): Promise<void> {
   const watcherToClose = fsWatcher;
   fsWatcher = undefined;
+  compiler = undefined;
   lastSourceFilePaths = undefined;
-  lastBuilderProgram = undefined;
+  combinedScssDeps = new Map();
   await watcherToClose?.close();
 }
 
@@ -61,36 +64,71 @@ const { logger, guardStartWatch } = setupWorkerLifecycle("library-build", cleanu
 
 async function build(info: LibraryBuildInfo): Promise<LibraryBuildResult> {
   logger.debug(`[${info.name}] library worker build 시작 (pkgDir: ${info.pkgDir})`);
-  const tscResult = runTscPackageBuild({
-    pkgDir: info.pkgDir,
-    cwd: info.cwd,
-    output: info.output,
-    env: info.output.env,
-    includeTests: info.output.includeTests,
-  });
-  logger.debug(`[${info.name}] library worker build 완료 (success: ${tscResult.success})`);
 
-  // lint 실행 (활성화 + program 사용 가능 시)
-  let lint: LintWithProgramResult | undefined;
-  if (info.output.lint === true && tscResult.program != null) {
-    logger.debug(`[${info.name}] lint 시작`);
-    const lintRunner = new LintWithProgramRunner({
+  try {
+    compiler = new SdTsCompiler({
+      pkgDir: info.pkgDir,
       cwd: info.cwd,
-      pkgName: info.name,
+      output: { js: info.output.js, dts: info.output.dts },
+      includeTests: info.output.includeTests,
+      env: info.output.env,
+      lint: info.output.lint,
+      globalScss: info.output.globalScss,
     });
-    lint = await lintRunner.lint({ program: tscResult.program });
-    logger.debug(`[${info.name}] lint 완료`);
-  }
+    const result = await compiler.compileAsync();
+    const isAngular = info.output.globalScss === true;
+
+    // Angular: emit 결과 디스크 쓰기 + side-effect SCSS 처리
+    const sideEffectScssErrors: string[] = [];
+    if (result.emitResults != null) {
+      const normalizedSrcDir = pathx.posix(path.join(info.pkgDir, "src"));
+      const filteredEmitResults = result.emitResults.filter((r) =>
+        pathx.posix(r.sourceFileName).startsWith(normalizedSrcDir + "/"),
+      );
+
+      if (isAngular) {
+        const loadPaths = [path.join(info.pkgDir, "scss"), path.join(info.cwd, "node_modules")];
+        writeEmitResults(filteredEmitResults, info.pkgDir, {
+          loadPaths,
+          scssErrors: sideEffectScssErrors,
+          scssDependencies: combinedScssDeps,
+          registry: compiler.sideEffectScssRegistry,
+        });
+        // 초기 빌드: 등록된 side-effect SCSS 전체 컴파일
+        compileSideEffectScss(
+          compiler.sideEffectScssRegistry,
+          loadPaths,
+          sideEffectScssErrors,
+          combinedScssDeps,
+        );
+      } else {
+        writeEmitResults(filteredEmitResults, info.pkgDir);
+      }
+    }
 
-  return {
-    build: {
-      success: tscResult.success,
-      errors: tscResult.errors,
-      warnings: undefined,
-      diagnostics: tscResult.diagnostics,
-    },
-    lint,
-  };
+    // 에러 통합 (ts errors + scss errors + side-effect scss errors)
+    const allErrors = [...(result.errors ?? []), ...result.scssErrors, ...sideEffectScssErrors];
+
+    logger.debug(`[${info.name}] library worker build 완료 (success: ${result.errorCount === 0})`);
+    return {
+      build: {
+        success:
+          result.errorCount === 0 &&
+          result.scssErrors.length === 0 &&
+          sideEffectScssErrors.length === 0,
+        errors: allErrors.length > 0 ? allErrors : undefined,
+        warnings: undefined,
+        diagnostics: result.diagnostics,
+      },
+      lint: result.lint,
+    };
+  } catch (err) {
+    const message = errNs.message(err);
+    logger.debug(`[${info.name}] library worker build 예외 발생: ${message}`);
+    return {
+      build: { success: false, errors: [message], diagnostics: [] },
+    };
+  }
 }
 
 //#endregion
@@ -98,10 +136,7 @@ async function build(info: LibraryBuildInfo): Promise<LibraryBuildResult> {
 //#region startWatch (watch mode)
 
 // watch 모드용 가변 상태
-let watchInfo: LibraryBuildInfo | undefined;
-let watchLintRunner: LintWithProgramRunner | undefined;
 let lastSourceFilePaths: Set<string> | undefined;
-let lastBuilderProgram: ts.EmitAndSemanticDiagnosticsBuilderProgram | undefined;
 
 function extractSourceFilePaths(program: ts.Program | undefined): Set<string> | undefined {
   if (program == null) return undefined;
@@ -112,61 +147,108 @@ function extractSourceFilePaths(program: ts.Program | undefined): Set<string> |
   return paths;
 }
 
-async function rebuildAll(): Promise<CombinedBuildEvent> {
-  const info = watchInfo!;
-  logger.debug(`[${info.name}] rebuildAll 시작`);
+/** compile-time SCSS 의존성으로 combinedScssDeps를 갱신한다 */
+function updateCombinedScssDeps(result: ISdTsCompilerResult): void {
+  combinedScssDeps = new Map();
+  for (const [file, deps] of result.scssDependencies) {
+    combinedScssDeps.set(file, new Set(deps));
+  }
+}
 
-  const tscResult = runTscPackageBuild({
-    pkgDir: info.pkgDir,
-    cwd: info.cwd,
-    output: info.output,
-    env: info.output.env,
-    includeTests: info.output.includeTests,
-    oldBuilderProgram: lastBuilderProgram,
-  });
-  lastBuilderProgram = tscResult.builderProgram ?? lastBuilderProgram;
-
-  // 의존성 필터링을 위한 소스 파일 경로 업데이트
-  lastSourceFilePaths = extractSourceFilePaths(tscResult.program) ?? lastSourceFilePaths;
-
-  // lint 실행 (활성화 + program 사용 가능 시)
-  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,
-        pkgName: info.name,
-      });
+/**
+ * SdTsCompiler 결과를 CombinedBuildEvent로 변환한다.
+ * Angular일 경우 emit 디스크 쓰기 + side-effect SCSS 처리를 포함한다.
+ */
+function buildWatchEvent(
+  info: LibraryBuildInfo,
+  result: ISdTsCompilerResult,
+  hasScssChanges: boolean,
+): CombinedBuildEvent {
+  const isAngular = info.output.globalScss === true;
+
+  if (isAngular && result.emitResults != null) {
+    const normalizedSrcDir = pathx.posix(path.join(info.pkgDir, "src"));
+    const loadPaths = [path.join(info.pkgDir, "scss"), path.join(info.cwd, "node_modules")];
+    const sideEffectScssErrors: string[] = [];
+
+    // emit 결과 디스크 쓰기 (side-effect SCSS 등록 포함)
+    writeEmitResults(
+      result.emitResults.filter((r) =>
+        pathx.posix(r.sourceFileName).startsWith(normalizedSrcDir + "/"),
+      ),
+      info.pkgDir,
+      {
+        loadPaths,
+        scssErrors: sideEffectScssErrors,
+        scssDependencies: combinedScssDeps,
+        registry: compiler!.sideEffectScssRegistry,
+      },
+    );
+
+    // SCSS 변경 시 side-effect SCSS 재컴파일
+    if (hasScssChanges) {
+      compileSideEffectScss(
+        compiler!.sideEffectScssRegistry,
+        loadPaths,
+        sideEffectScssErrors,
+        combinedScssDeps,
+      );
     }
-    lint = await watchLintRunner.lint({
-      program: tscResult.program,
-      affectedFiles: tscResult.affectedFiles,
-    });
-    logger.debug(`[${info.name}] lint 완료`);
+
+    // 모든 에러 통합
+    const allErrors = [...(result.errors ?? []), ...result.scssErrors, ...sideEffectScssErrors];
+    return {
+      build: {
+        success:
+          result.errorCount === 0 &&
+          result.scssErrors.length === 0 &&
+          sideEffectScssErrors.length === 0,
+        errors: allErrors.length > 0 ? allErrors : undefined,
+      },
+      lint: result.lint,
+    };
   }
 
-  logger.debug(`[${info.name}] rebuildAll 완료`);
+  // Non-Angular 경로
   return {
-    build: { success: tscResult.success, errors: tscResult.errors },
-    lint,
+    build: {
+      success: result.errorCount === 0,
+      errors: result.errors,
+    },
+    lint: result.lint,
   };
 }
 
 async function startWatch(info: LibraryBuildInfo): Promise<void> {
   guardStartWatch();
-  watchInfo = info;
+  const isAngular = info.output.globalScss === true;
+
+  compiler = new SdTsCompiler({
+    pkgDir: info.pkgDir,
+    cwd: info.cwd,
+    output: { js: info.output.js, dts: info.output.dts },
+    includeTests: info.output.includeTests,
+    env: info.output.env,
+    lint: info.output.lint,
+    globalScss: info.output.globalScss,
+  });
 
   try {
     // 초기 빌드
-    const initialResult = await rebuildAll();
-    sender.send("build", initialResult);
+    const initialResult = await compiler.compileAsync();
+    lastSourceFilePaths = extractSourceFilePaths(initialResult.program) ?? lastSourceFilePaths;
+    if (isAngular) {
+      updateCombinedScssDeps(initialResult);
+    }
+    const initialEvent = buildWatchEvent(info, initialResult, isAngular);
+    sender.send("build", initialEvent);
 
     // workspace 의존성 경로 + replaceDeps 수집
     const { watchPaths } = buildWatchPaths({
       pkgDir: info.pkgDir,
       cwd: info.cwd,
-      srcGlobs: ["*.ts"],
+      srcGlobs: isAngular ? ["*.{ts,scss,css}"] : ["*.ts"],
+      extraDirs: isAngular ? [{ dir: "scss", globs: ["*.{scss,css}"] }] : undefined,
       replaceDeps: info.replaceDeps,
     });
 
@@ -174,15 +256,45 @@ async function startWatch(info: LibraryBuildInfo): Promise<void> {
     logger.debug(`[${info.name}] FsWatcher 시작`);
     fsWatcher = await FsWatcher.watch(watchPaths);
 
-    fsWatcher.onChange({ delay: 300 }, async (changes) => {
+    fsWatcher.onChange({ delay: 300 }, async (changedFiles) => {
       try {
-        if (shouldSkipRebuild(changes.map((c) => c.path), hasFileAddOrRemove(changes), lastSourceFilePaths, logger)) {
+        const addOrRemove = hasFileAddOrRemove(changedFiles);
+
+        // 변경된 파일 수집
+        const modifiedFiles = new Set<string>();
+        for (const f of changedFiles) {
+          modifiedFiles.add(f.path);
+
+          // Angular: SCSS 역방향 의존성 탐색
+          if (isAngular && (f.path.endsWith(".scss") || f.path.endsWith(".css"))) {
+            const normalizedPath = pathx.posix(f.path);
+            for (const [ownerFile, deps] of combinedScssDeps) {
+              if (deps.has(normalizedPath)) {
+                modifiedFiles.add(ownerFile);
+              }
+            }
+          }
+        }
+
+        // 의존성 필터: 관련 변경이 없으면 리빌드 건너뜀
+        if (shouldSkipRebuild(modifiedFiles, addOrRemove, lastSourceFilePaths, logger)) {
           return;
         }
 
         sender.send("buildStart", {});
-        const result = await rebuildAll();
-        sender.send("build", result);
+
+        const result = await compiler!.compileAsync(modifiedFiles);
+        lastSourceFilePaths = extractSourceFilePaths(result.program) ?? lastSourceFilePaths;
+        if (isAngular) {
+          updateCombinedScssDeps(result);
+        }
+
+        const hasScssChanges = changedFiles.some(
+          (f) => f.path.endsWith(".scss") || f.path.endsWith(".css"),
+        );
+
+        const event = buildWatchEvent(info, result, hasScssChanges);
+        sender.send("build", event);
       } catch (err) {
         sender.send("error", { message: errNs.message(err) });
       }

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

@@ -1,9 +1,9 @@
-import type ts from "typescript";
 import path from "path";
 import fs from "fs";
 import esbuild from "esbuild";
 import { createWorker, FsWatcher, pathx } from "@simplysm/core-node";
 import { err as errNs } from "@simplysm/core-common";
+import { formatEsbuildMessages } from "../utils/output-utils";
 import type { BuildOutput } from "../engines/types";
 import type { SerializedDiagnostic } from "../typecheck/typecheck-serialization";
 import type { LintWithProgramResult } from "../lint/lint-with-program";
@@ -16,9 +16,8 @@ import {
   writeChangedOutputFiles,
 } from "../esbuild/esbuild-config";
 import { collectAllExternals, generateProductionFiles } from "../deps/server-externals/server-production-files";
-import { runTscPackageBuild } from "../utils/tsc-build";
+import { SdTsCompiler } from "../ts-compiler/SdTsCompiler";
 import { createTscPlugin } from "../esbuild/esbuild-tsc-plugin";
-import { LintWithProgramRunner } from "../lint/lint-with-program";
 import { setupWorkerLifecycle } from "./shared-worker-lifecycle";
 import { buildWatchPaths } from "./build-watch-paths";
 import { copyPublicFiles, watchPublicFiles } from "../utils/copy-public";
@@ -146,7 +145,7 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
     let jsResult: { success: boolean; errors?: string[]; warnings?: string[] };
     let tscErrors: string[];
     let tscDiagnostics: SerializedDiagnostic[];
-    let tscProgram: ts.Program | undefined;
+    let lint: LintWithProgramResult | undefined;
 
     if (info.output.js) {
       // js=true: tsc 플러그인 통합 — 단일 esbuild.build() 호출
@@ -156,6 +155,7 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
         output: { dts: info.output.dts },
         env: info.output.env,
         includeTests: info.output.includeTests,
+        lint: info.output.lint,
       });
 
       const esbuildOptions = createServerEsbuildOptions({
@@ -170,8 +170,8 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
           if (result.outputFiles) {
             await writeChangedOutputFiles(result.outputFiles);
           }
-          const errors = result.errors.map((e) => e.text);
-          const warnings = result.warnings.map((w) => w.text);
+          const errors = formatEsbuildMessages(result.errors, "error");
+          const warnings = formatEsbuildMessages(result.warnings, "warning");
           return {
             success: result.errors.length === 0,
             errors: errors.length > 0 ? errors : undefined,
@@ -186,34 +186,23 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
 
       tscErrors = tscPlugin.getErrors() ?? [];
       tscDiagnostics = tscPlugin.getDiagnostics();
-      tscProgram = tscPlugin.getProgram();
+      lint = tscPlugin.getLintResult();
     } else {
-      // js=false: runTscPackageBuild 직접 호출 (플러그인 경유 불가)
-      const tscResult = runTscPackageBuild({
+      // js=false: SdTsCompiler 직접 호출 (플러그인 경유 불가)
+      const compiler = new SdTsCompiler({
         pkgDir: info.pkgDir,
         cwd: info.cwd,
         output: { js: false, dts: info.output.dts },
-        parsedConfig,
         env: info.output.env,
         includeTests: info.output.includeTests,
+        lint: info.output.lint,
       });
+      const tscResult = await compiler.compileAsync();
 
       jsResult = { success: true, errors: undefined, warnings: undefined };
       tscErrors = tscResult.errors ?? [];
       tscDiagnostics = tscResult.diagnostics;
-      tscProgram = tscResult.program;
-    }
-
-    // lint 실행 (활성화 + program 사용 가능 시)
-    let lint: LintWithProgramResult | undefined;
-    if (info.output.lint === true && tscProgram != null) {
-      logger.debug(`[${info.name}] lint 시작`);
-      const lintRunner = new LintWithProgramRunner({
-        cwd: info.cwd,
-        pkgName: info.name,
-      });
-      lint = await lintRunner.lint({ program: tscProgram });
-      logger.debug(`[${info.name}] lint 완료`);
+      lint = tscResult.lint;
     }
 
     // JS 출력이 요청된 경우에만 프로덕션 아티팩트 생성
@@ -261,65 +250,45 @@ async function startWatch(info: ServerWatchInfo): Promise<void> {
   logger.debug(`[${info.name}] server worker startWatch 시작`);
 
   // watch 모드 로컬 상태 (클로저로 관리)
-  let lastBuilderProgram: ts.EmitAndSemanticDiagnosticsBuilderProgram | undefined;
-  let watchLintRunner: LintWithProgramRunner | undefined;
+  // js=false 경로에서 SdTsCompiler 인스턴스를 유지하여 증분 빌드를 지원한다
+  let watchCompiler: SdTsCompiler | undefined;
 
   /**
    * esbuild + tsc 리빌드 (watch 모드)
    * js=true: esbuildCtx.rebuild() 단일 호출 (tsc 플러그인 자동 트리거)
-   * js=false: runTscPackageBuild 직접 호출
+   * js=false: SdTsCompiler.compileAsync() 직접 호출
    */
   async function rebuildAll(): Promise<ServerCombinedBuildEvent> {
     logger.debug(`[${info.name}] rebuildAll 시작`);
     const mainJsPath = pathx.posixResolve(info.pkgDir, "dist", "main.js");
 
     let jsResult: { success: boolean; errors?: string[]; warnings?: string[] };
-    let tscProgram: ts.Program | undefined;
-    let tscAffectedFiles: ReadonlySet<string> | undefined;
     let tscErrors: string[];
+    let lint: LintWithProgramResult | undefined;
 
     if (info.output.js) {
       // js=true: esbuildCtx.rebuild() 단일 호출 (tsc 에러 자동 병합)
       const rebuildResult = await esbuildCtx.rebuild();
       jsResult = rebuildResult ?? { success: true, errors: undefined, warnings: undefined };
-      tscProgram = esbuildCtx.getTscProgram();
-      tscAffectedFiles = esbuildCtx.getTscAffectedFiles();
       tscErrors = [];
+      lint = esbuildCtx.getTscLintResult();
     } else {
-      // js=false: runTscPackageBuild 직접 호출
-      const parsedConfig = parseTsconfig(info.pkgDir);
-      const tscResult = runTscPackageBuild({
-        pkgDir: info.pkgDir,
-        cwd: info.cwd,
-        output: { js: false, dts: info.output.dts },
-        parsedConfig,
-        env: info.output.env,
-        includeTests: info.output.includeTests,
-        oldBuilderProgram: lastBuilderProgram,
-      });
-      lastBuilderProgram = tscResult.builderProgram ?? lastBuilderProgram;
-
-      jsResult = { success: true, errors: undefined, warnings: undefined };
-      tscProgram = tscResult.program;
-      tscAffectedFiles = tscResult.affectedFiles;
-      tscErrors = tscResult.errors ?? [];
-    }
-
-    // lint 실행 (활성화 + program 사용 가능 시)
-    let lint: LintWithProgramResult | undefined;
-    if (info.output.lint === true && tscProgram != null) {
-      logger.debug(`[${info.name}] lint 시작`);
-      if (watchLintRunner == null) {
-        watchLintRunner = new LintWithProgramRunner({
+      // js=false: SdTsCompiler 직접 호출
+      if (watchCompiler == null) {
+        watchCompiler = new SdTsCompiler({
+          pkgDir: info.pkgDir,
           cwd: info.cwd,
-          pkgName: info.name,
+          output: { js: false, dts: info.output.dts },
+          env: info.output.env,
+          includeTests: info.output.includeTests,
+          lint: info.output.lint,
         });
       }
-      lint = await watchLintRunner.lint({
-        program: tscProgram,
-        affectedFiles: tscAffectedFiles,
-      });
-      logger.debug(`[${info.name}] lint 완료`);
+      const tscResult = await watchCompiler.compileAsync();
+
+      jsResult = { success: true, errors: undefined, warnings: undefined };
+      tscErrors = tscResult.errors ?? [];
+      lint = tscResult.lint;
     }
 
     const allErrors = [...(jsResult.errors ?? []), ...tscErrors];
@@ -355,6 +324,7 @@ async function startWatch(info: ServerWatchInfo): Promise<void> {
           output: { dts: info.output.dts },
           env: info.output.env,
           includeTests: info.output.includeTests,
+          lint: info.output.lint,
         },
       });
     }

package/src/workers/server-esbuild-context.ts

@@ -1,6 +1,7 @@
 import type ts from "typescript";
 import esbuild from "esbuild";
 import { err as errNs } from "@simplysm/core-common";
+import { formatEsbuildMessages } from "../utils/output-utils";
 import {
   createServerEsbuildOptions,
   writeChangedOutputFiles,
@@ -8,6 +9,7 @@ import {
 import { createTscPlugin, type TscPluginResult } from "../esbuild/esbuild-tsc-plugin";
 import type { TypecheckEnv } from "../utils/tsconfig";
 import type { SerializedDiagnostic } from "../typecheck/typecheck-serialization";
+import type { LintWithProgramResult } from "../lint/lint-with-program";
 
 /**
  * esbuild watch context 생성 옵션
@@ -23,6 +25,7 @@ export interface EsbuildContextOptions {
     output: { dts: boolean };
     env?: TypecheckEnv;
     includeTests?: boolean;
+    lint?: boolean;
   };
 }
 
@@ -47,6 +50,7 @@ export async function createContext(options: EsbuildContextOptions): Promise<voi
       output: options.tsc.output,
       env: options.tsc.env,
       includeTests: options.tsc.includeTests,
+      lint: options.tsc.lint,
     });
   }
 
@@ -98,10 +102,10 @@ export async function rebuild(): Promise<{
     await writeChangedOutputFiles(result.outputFiles);
   }
 
-  const esbuildErrors = result.errors.map((e) => e.text);
+  const esbuildErrors = formatEsbuildMessages(result.errors, "error");
   const tscErrors = tscPlugin?.getErrors() ?? [];
   const allErrors = [...esbuildErrors, ...tscErrors];
-  const warnings = result.warnings.map((w) => w.text);
+  const warnings = formatEsbuildMessages(result.warnings, "warning");
 
   return {
     success: allErrors.length === 0,
@@ -188,3 +192,11 @@ export function getTscAffectedFiles(): ReadonlySet<string> | undefined {
 export function getTscDiagnostics(): SerializedDiagnostic[] {
   return tscPlugin?.getDiagnostics() ?? [];
 }
+
+/**
+ * tsc 플러그인의 lint 결과를 반환한다.
+ * 플러그인이 없거나 lint가 비활성이면 undefined를 반환한다.
+ */
+export function getTscLintResult(): LintWithProgramResult | undefined {
+  return tscPlugin?.getLintResult();
+}

package/tests/angular/fixtures/packages/basic-app/dist/styles.css

@@ -0,0 +1,3 @@
+body {
+  color: blue;
+}

package/tests/angular/fixtures/packages/basic-app/scss/styles.scss

@@ -0,0 +1,5 @@
+@use 'variables' as vars;
+
+body {
+  color: vars.$primary;
+}

package/tests/angular/vite-angular-plugin-sdtscompiler.verify.md

@@ -0,0 +1,13 @@
+# vite-angular-plugin SdTsCompiler 전환 — LLM 검증
+
+## 검증 항목
+
+- [x] AngularBuildPipeline import 제거: `vite-angular-plugin.ts:6` — `SdTsCompiler` import으로 교체, `AngularBuildPipeline` 미사용
+- [x] SdTsCompiler 인스턴스 생성: `:69-81` — `new SdTsCompiler({ pkgDir, cwd, output: { js: true, dts: false }, sourceFileCache, compilerOptionsTransformer })` 올바르게 구성
+- [x] compileAsync 호출: `:90` — `sdTsCompiler.compileAsync(modifiedFiles)` 호출, modifiedFiles는 pendingWatchChanges에서 수집
+- [x] emitResults → emittedFilesBySource 매핑: `:93-95` — `pathx.posix(sourceFileName)` 키로 저장
+- [x] transform 훅: `:107-124` — `emittedFilesBySource.get(normalizedId)` 조회, 인라인 소스맵 분리 유지
+- [x] buildEnd에서 sdTsCompiler 참조 해제: `:127` — `sdTsCompiler = undefined`
+- [x] watch 모드 증분 빌드: `:61-66` — pendingWatchChanges를 modifiedFiles로 전달, compileAsync에서 증분 처리
+- [x] 이미 초기화됐고 변경 없으면 건너뜀: `:84-87` — `emittedFilesBySource.size > 0 && modifiedFiles == null` 조건
+- [x] 기존 테스트 회귀: vite-angular-plugin.spec.ts 6개, vite-angular-plugin-vitest.spec.ts + legacy-watch.spec.ts 5개 모두 통과