@simplysm/sd-cli 14.0.42 → 14.0.44

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, buildReverseDeps } 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,21 @@ 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>>();
+let reverseScssDeps = new Map<string, Set<string>>();
+let registryReverseIndex = new Map<string, Set<string>>();
+let sideEffectScssDeps = new Map<string, Set<string>>();
 
 async function cleanup(): Promise<void> {
   const watcherToClose = fsWatcher;
   fsWatcher = undefined;
+  compiler = undefined;
   lastSourceFilePaths = undefined;
-  lastBuilderProgram = undefined;
+  combinedScssDeps = new Map();
+  reverseScssDeps = new Map();
+  registryReverseIndex = new Map();
+  sideEffectScssDeps = new Map();
   await watcherToClose?.close();
 }
 
@@ -61,36 +70,75 @@ 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,
+          registryReverseIndex,
+          sideEffectScssDeps,
+        });
+        // 초기 빌드: 등록된 side-effect SCSS 전체 컴파일 (changedScssFiles 미전달)
+        compileSideEffectScss(
+          compiler.sideEffectScssRegistry,
+          loadPaths,
+          sideEffectScssErrors,
+          combinedScssDeps,
+          undefined,
+          sideEffectScssDeps,
+        );
+      } 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 +146,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 +157,122 @@ 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와 reverseScssDeps를 갱신한다 */
+function updateCombinedScssDeps(result: ISdTsCompilerResult): void {
+  combinedScssDeps = new Map();
+  for (const [file, deps] of result.scssDependencies) {
+    combinedScssDeps.set(file, new Set(deps));
+  }
+  rebuildReverseScssDeps();
+}
 
-  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,
-      });
+/** combinedScssDeps에서 역방향 인덱스를 재구축한다 */
+function rebuildReverseScssDeps(): void {
+  reverseScssDeps = buildReverseDeps(combinedScssDeps);
+}
+
+/**
+ * SdTsCompiler 결과를 CombinedBuildEvent로 변환한다.
+ * Angular일 경우 emit 디스크 쓰기 + side-effect SCSS 처리를 포함한다.
+ */
+function buildWatchEvent(
+  info: LibraryBuildInfo,
+  result: ISdTsCompilerResult,
+  changedScssFiles?: ReadonlySet<string>,
+): 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,
+        registryReverseIndex,
+        sideEffectScssDeps,
+      },
+    );
+
+    // side-effect SCSS 재컴파일
+    // changedScssFiles 미제공 = 초기 빌드 → 전체 컴파일
+    // changedScssFiles 제공 + size > 0 → 증분 컴파일
+    if (changedScssFiles == null || changedScssFiles.size > 0) {
+      compileSideEffectScss(
+        compiler!.sideEffectScssRegistry,
+        loadPaths,
+        sideEffectScssErrors,
+        combinedScssDeps,
+        changedScssFiles,
+        sideEffectScssDeps,
+      );
+      // side-effect SCSS 의존성이 combinedScssDeps에 추가되었으므로 역방향 인덱스 재구축
+      rebuildReverseScssDeps();
     }
-    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);
+    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 +280,48 @@ 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 역방향 의존성 탐색 (O(1) 조회)
+          if (isAngular && (f.path.endsWith(".scss") || f.path.endsWith(".css"))) {
+            const normalizedPath = pathx.posix(f.path);
+            const owners = reverseScssDeps.get(normalizedPath);
+            if (owners != null) {
+              for (const owner of owners) {
+                modifiedFiles.add(owner);
+              }
+            }
+          }
+        }
+
+        // 의존성 필터: 관련 변경이 없으면 리빌드 건너뜀
+        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 changedScssFiles = new Set(
+          changedFiles
+            .filter((f) => f.path.endsWith(".scss") || f.path.endsWith(".css"))
+            .map((f) => pathx.posix(f.path)),
+        );
+
+        const event = buildWatchEvent(info, result, changedScssFiles);
+        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;
+}