@simplysm/sd-cli 14.0.38 → 14.0.40

package/src/workers/client.worker.ts

@@ -1,6 +1,6 @@
 import path from "path";
 import fs from "node:fs";
-import { createWorker } from "@simplysm/core-node";
+import { createWorker, FsWatcher } from "@simplysm/core-node";
 import { err as errNs } from "@simplysm/core-common";
 import { setupWorkerLifecycle } from "./shared-worker-lifecycle.js";
 import {
@@ -14,7 +14,6 @@ import { createHmrService, type HmrService } from "../dev-server/hmr-service.js"
 import { createHmrPostTransform } from "../dev-server/hmr-client-script.js";
 import { copyPublicFiles, watchPublicFiles } from "../utils/copy-public.js";
 import type { SdBrowserSupportConfig, SdPwaConfig } from "../sd-config.types.js";
-import type { FsWatcher } from "@simplysm/core-node";
 import type esbuild from "esbuild";
 
 //#region Types
@@ -63,6 +62,7 @@ let esbuildResult: ClientEsbuildResult | undefined;
 let devServer: DevHttpServer | undefined;
 let hmrService: HmrService | undefined;
 let publicWatcher: FsWatcher | undefined;
+let indexHtmlWatcher: FsWatcher | undefined;
 
 const { logger, guardStartWatch } = setupWorkerLifecycle("client", async () => {
   await stopWatch();
@@ -118,7 +118,6 @@ async function build(info: ClientBuildInfo): Promise<ClientBuildResult> {
       polyfills,
       legacyModule,
       postcssPlugins,
-      postcssConfigPath: info.pkgDir,
       templateUpdates,
     });
 
@@ -211,8 +210,29 @@ async function startWatch(info: ClientBuildInfo): Promise<ClientBuildResult> {
     const polyfills = fs.existsSync(polyfillsPath) ? ["src/polyfills.ts"] : undefined;
     const entryNames = ["main", ...(polyfills != null ? ["polyfills"] : [])];
 
-    // 4. templateUpdates Map + esbuild context 생성
+    // 4. templateUpdates Map
     const templateUpdates = new Map<string, string>();
+
+    // 5. HTTP dev server 생성 + 시작 (포트 확정 — HMR 스크립트에 포트 주입 필요)
+    const httpDevServer = createDevHttpServer({
+      distDir: outdir,
+      basePath,
+      port: info.port ?? 0,
+      onRequest: (req, res) => hmrService?.handleRequest(req, res) ?? false,
+    });
+    devServer = httpDevServer;
+    const actualPort = await httpDevServer.listen();
+
+    // 6. HMR WebSocket 서비스 생성
+    hmrService = createHmrService({
+      httpServer: httpDevServer.httpServer,
+      basePath,
+      templateUpdates,
+      outDir: outdir,
+    });
+
+    // 7. esbuild context 생성
+    let lastMetafile: esbuild.Metafile | undefined;
     let initialBuildResolve: ((result: ClientBuildResult) => void) | undefined;
     let isInitialBuild = true;
 
@@ -226,25 +246,61 @@ async function startWatch(info: ClientBuildInfo): Promise<ClientBuildResult> {
       polyfills,
       legacyModule,
       postcssPlugins,
-      postcssConfigPath: info.pkgDir,
       templateUpdates: legacyModule ? undefined : templateUpdates,
       plugins: [
         {
           name: "sd-build-start",
           setup(pluginBuild: esbuild.PluginBuild) {
+            const prevMtimes = new Map<string, number>();
+
             pluginBuild.onStart(() => {
+              // sourceFileCache 무효화: 변경된 파일의 loadResultCache + TypeScript 소스 캐시 모두 제거
+              if (esbuildResult != null) {
+                const { loadResultCache } = esbuildResult.sourceFileCache;
+                const changedFiles = new Set<string>();
+                for (const file of loadResultCache.watchFiles) {
+                  try {
+                    const mtime = fs.statSync(file).mtimeMs;
+                    const prev = prevMtimes.get(file);
+                    if (prev != null && prev !== mtime) {
+                      changedFiles.add(file);
+                    }
+                  } catch {
+                    if (prevMtimes.has(file)) {
+                      changedFiles.add(file);
+                    }
+                  }
+                }
+                if (changedFiles.size > 0) {
+                  esbuildResult.sourceFileCache.invalidate(changedFiles);
+                }
+              }
+
               if (!isInitialBuild) {
                 sender.send("buildStart", {});
               }
             });
+
+            pluginBuild.onEnd(() => {
+              if (esbuildResult == null) return;
+              prevMtimes.clear();
+              for (const file of esbuildResult.sourceFileCache.loadResultCache.watchFiles) {
+                try {
+                  prevMtimes.set(file, fs.statSync(file).mtimeMs);
+                } catch {
+                  // 삭제된 파일
+                }
+              }
+            });
           },
         },
       ],
       onEnd: async (result: esbuild.BuildResult) => {
         try {
-          // index.html 재생성
+          // index.html 재생성 (lastMetafile 보관 — index.html 단독 변경 시 재생성용)
           if (result.metafile != null) {
-            const hmrPostTransform = createHmrPostTransform(basePath);
+            lastMetafile = result.metafile;
+            const hmrPostTransform = createHmrPostTransform(basePath, actualPort);
             const indexPath = path.join(info.pkgDir, "src", "index.html");
             const indexResult = await generateIndexHtml({
               indexPath,
@@ -301,37 +357,42 @@ async function startWatch(info: ClientBuildInfo): Promise<ClientBuildResult> {
       },
     });
 
-    // 5. HTTP dev server 생성
-    const httpDevServer = createDevHttpServer({
-      distDir: outdir,
-      basePath,
-      port: info.port ?? 0,
-      onRequest: (req, res) => hmrService?.handleRequest(req, res) ?? false,
-    });
-    devServer = httpDevServer;
-
-    // 6. HMR WebSocket 서비스 생성
-    hmrService = createHmrService({
-      httpServer: httpDevServer.httpServer,
-      basePath,
-      templateUpdates,
-      outDir: outdir,
-    });
-
-    // 7. esbuild watch 시작 + 초기 빌드 대기
+    // 8. esbuild watch 시작 + 초기 빌드 대기
     await esbuildResult.context.watch();
 
     const initialResult = await new Promise<ClientBuildResult>((resolve) => {
       initialBuildResolve = resolve;
     });
 
-    // 8. HTTP 서버 시작
-    const actualPort = await httpDevServer.listen();
+    // 9. src/index.html 감시 (esbuild watch는 HTML을 감시하지 않음)
+    const indexHtmlSrcPath = path.join(info.pkgDir, "src", "index.html");
+    indexHtmlWatcher = await FsWatcher.watch([indexHtmlSrcPath]);
+    indexHtmlWatcher.onChange({ delay: 300 }, async () => {
+      if (lastMetafile == null) return;
+      try {
+        sender.send("buildStart", {});
+        const hmrPostTransform = createHmrPostTransform(basePath, actualPort);
+        const indexResult = await generateIndexHtml({
+          indexPath: indexHtmlSrcPath,
+          metafile: lastMetafile,
+          outdir,
+          baseHref: basePath,
+          mode: "dev",
+          entryNames,
+          postTransform: hmrPostTransform,
+        });
+        fs.writeFileSync(path.join(outdir, "index.html"), indexResult.content);
+        hmrService?.broadcast({ type: "full-reload" });
+        sender.send("build", { success: true });
+      } catch (err) {
+        sender.send("error", { message: errNs.message(err) });
+      }
+    });
 
-    // 9. serverReady 이벤트 전송
+    // 10. serverReady 이벤트 전송
     sender.send("serverReady", { port: actualPort });
 
-    // 10. .config.json + .dev-port 기록
+    // 11. .config.json + .dev-port 기록
     writeConfigJson(outdir, info.configs);
     fs.writeFileSync(path.join(outdir, ".dev-port"), String(actualPort));
 
@@ -373,6 +434,12 @@ async function stopWatch(): Promise<void> {
     publicWatcher = undefined;
   }
 
+  // 5. index.html 감시 종료
+  if (indexHtmlWatcher != null) {
+    await indexHtmlWatcher.close();
+    indexHtmlWatcher = undefined;
+  }
+
   logger.debug("esbuild watch 정리 완료");
 }
 

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

@@ -17,6 +17,7 @@ import {
 } from "../esbuild/esbuild-config";
 import { collectAllExternals, generateProductionFiles } from "../deps/server-externals/server-production-files";
 import { runTscPackageBuild } from "../utils/tsc-build";
+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";
@@ -106,7 +107,6 @@ let srcWatcher: FsWatcher | undefined;
 
 async function cleanup(): Promise<void> {
   await esbuildCtx.dispose();
-  lastBuilderProgram = undefined;
 
   const watcherToClose = publicWatcher;
   publicWatcher = undefined;
@@ -143,16 +143,30 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
     // 외부 모듈 수집
     const external = collectAllExternals(info.pkgDir, info.externals);
 
-    // esbuild (비동기) ‖ tsc (동기) 병렬 실행
-    const esbuildOptions = createServerEsbuildOptions({
-      pkgDir: info.pkgDir,
-      entryPoints,
-      env: info.env,
-      external,
-    });
+    let jsResult: { success: boolean; errors?: string[]; warnings?: string[] };
+    let tscErrors: string[];
+    let tscDiagnostics: SerializedDiagnostic[];
+    let tscProgram: ts.Program | undefined;
+
+    if (info.output.js) {
+      // js=true: tsc 플러그인 통합 — 단일 esbuild.build() 호출
+      const tscPlugin = createTscPlugin({
+        pkgDir: info.pkgDir,
+        cwd: info.cwd,
+        output: { dts: info.output.dts },
+        env: info.output.env,
+        includeTests: info.output.includeTests,
+      });
 
-    const esbuildPromise = info.output.js
-      ? esbuild.build(esbuildOptions).then(async (result) => {
+      const esbuildOptions = createServerEsbuildOptions({
+        pkgDir: info.pkgDir,
+        entryPoints,
+        env: info.env,
+        external,
+      });
+
+      jsResult = await esbuild.build({ ...esbuildOptions, plugins: [tscPlugin.plugin] })
+        .then(async (result) => {
           if (result.outputFiles) {
             await writeChangedOutputFiles(result.outputFiles);
           }
@@ -163,36 +177,42 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
             errors: errors.length > 0 ? errors : undefined,
             warnings: warnings.length > 0 ? warnings : undefined,
           };
-        }).catch((err) => ({
+        })
+        .catch((err) => ({
           success: false,
           errors: [errNs.message(err)],
           warnings: undefined,
-        }))
-      : null;
-
-    // tsc 타입체크 (항상 실행, emit은 output.dts로 제어)
-    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,
-    });
+        }));
+
+      tscErrors = tscPlugin.getErrors() ?? [];
+      tscDiagnostics = tscPlugin.getDiagnostics();
+      tscProgram = tscPlugin.getProgram();
+    } else {
+      // js=false: runTscPackageBuild 직접 호출 (플러그인 경유 불가)
+      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,
+      });
 
-    const jsResult = esbuildPromise
-      ? await esbuildPromise
-      : { success: true, errors: undefined, warnings: undefined };
+      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 && tscResult.program != null) {
+    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: tscResult.program });
+      lint = await lintRunner.lint({ program: tscProgram });
       logger.debug(`[${info.name}] lint 완료`);
     }
 
@@ -206,14 +226,15 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
       generateProductionFiles(info, external);
     }
 
-    const allErrors = [...(jsResult.errors ?? []), ...(tscResult.errors ?? [])];
-    logger.debug(`[${info.name}] server worker build 완료 (js: ${jsResult.success}, tsc: ${tscResult.success})`);
+    const allErrors = [...(jsResult.errors ?? []), ...tscErrors];
+    const tscSuccess = tscErrors.length === 0;
+    logger.debug(`[${info.name}] server worker build 완료 (js: ${jsResult.success}, tsc: ${tscSuccess})`);
     return {
       build: {
-        success: jsResult.success && tscResult.success,
+        success: jsResult.success && tscSuccess,
         errors: allErrors.length > 0 ? allErrors : undefined,
         warnings: jsResult.warnings,
-        diagnostics: tscResult.diagnostics,
+        diagnostics: tscDiagnostics,
       },
       lint,
       mainJsPath,
@@ -232,76 +253,88 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
   }
 }
 
-// watch 모드용 가변 상태
-let watchInfo: ServerWatchInfo | undefined;
-let watchLintRunner: LintWithProgramRunner | undefined;
-let lastBuilderProgram: ts.EmitAndSemanticDiagnosticsBuilderProgram | undefined;
-
 /**
- * esbuild + tsc 병렬 리빌드 (watch 모드)
+ * watch 모드 시작
  */
-async function rebuildAll(): Promise<ServerCombinedBuildEvent> {
-  const info = watchInfo!;
-  logger.debug(`[${info.name}] rebuildAll 시작`);
-  const mainJsPath = pathx.posixResolve(info.pkgDir, "dist", "main.js");
-  const parsedConfig = parseTsconfig(info.pkgDir);
-
-  // esbuild 리빌드 (비동기)
-  const esbuildPromise = info.output.js ? esbuildCtx.rebuild() : null;
-
-  // tsc 리빌드 (동기, 증분)
-  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;
-
-  // 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({
+async function startWatch(info: ServerWatchInfo): Promise<void> {
+  guardStartWatch();
+  logger.debug(`[${info.name}] server worker startWatch 시작`);
+
+  // watch 모드 로컬 상태 (클로저로 관리)
+  let lastBuilderProgram: ts.EmitAndSemanticDiagnosticsBuilderProgram | undefined;
+  let watchLintRunner: LintWithProgramRunner | undefined;
+
+  /**
+   * esbuild + tsc 리빌드 (watch 모드)
+   * js=true: esbuildCtx.rebuild() 단일 호출 (tsc 플러그인 자동 트리거)
+   * js=false: runTscPackageBuild 직접 호출
+   */
+  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[];
+
+    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 = [];
+    } else {
+      // js=false: runTscPackageBuild 직접 호출
+      const parsedConfig = parseTsconfig(info.pkgDir);
+      const tscResult = runTscPackageBuild({
+        pkgDir: info.pkgDir,
         cwd: info.cwd,
-        pkgName: info.name,
+        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 = await watchLintRunner.lint({
-      program: tscResult.program,
-      affectedFiles: tscResult.affectedFiles,
-    });
-    logger.debug(`[${info.name}] lint 완료`);
-  }
 
-  const jsResult = esbuildPromise != null
-    ? (await esbuildPromise) ?? { success: true, errors: undefined, warnings: undefined }
-    : { success: true, errors: undefined, warnings: undefined };
-
-  const allErrors = [...(jsResult.errors ?? []), ...(tscResult.errors ?? [])];
-  logger.debug(`[${info.name}] rebuildAll 완료`);
-  return {
-    build: {
-      success: jsResult.success && tscResult.success,
-      errors: allErrors.length > 0 ? allErrors : undefined,
-      warnings: jsResult.warnings,
-    },
-    lint,
-    mainJsPath,
-  };
-}
+    // lint 실행 (활성화 + program 사용 가능 시)
+    let lint: LintWithProgramResult | undefined;
+    if (info.output.lint === true && tscProgram != null) {
+      logger.debug(`[${info.name}] lint 시작`);
+      if (watchLintRunner == null) {
+        watchLintRunner = new LintWithProgramRunner({
+          cwd: info.cwd,
+          pkgName: info.name,
+        });
+      }
+      lint = await watchLintRunner.lint({
+        program: tscProgram,
+        affectedFiles: tscAffectedFiles,
+      });
+      logger.debug(`[${info.name}] lint 완료`);
+    }
 
-/**
- * watch 모드 시작
- */
-async function startWatch(info: ServerWatchInfo): Promise<void> {
-  guardStartWatch();
-  watchInfo = info;
-  logger.debug(`[${info.name}] server worker startWatch 시작`);
+    const allErrors = [...(jsResult.errors ?? []), ...tscErrors];
+    const allSuccess = jsResult.success && tscErrors.length === 0;
+    logger.debug(`[${info.name}] rebuildAll 완료`);
+    return {
+      build: {
+        success: allSuccess,
+        errors: allErrors.length > 0 ? allErrors : undefined,
+        warnings: jsResult.warnings,
+      },
+      lint,
+      mainJsPath,
+    };
+  }
 
   try {
     const parsedConfig = parseTsconfig(info.pkgDir);
@@ -310,17 +343,23 @@ async function startWatch(info: ServerWatchInfo): Promise<void> {
     // 외부 모듈 수집 (watch 모드용 — watch manager가 자체 캐시를 유지)
     const cachedExternal = collectAllExternals(info.pkgDir, info.externals);
 
-    // esbuild 컨텍스트 생성 (JS 출력 필요 시)
+    // esbuild 컨텍스트 생성 (JS 출력 필요 시, tsc 플러그인 포함)
     if (info.output.js) {
       await esbuildCtx.createContext({
         pkgDir: info.pkgDir,
         entryPoints,
         env: info.env,
         external: cachedExternal,
+        tsc: {
+          cwd: info.cwd,
+          output: { dts: info.output.dts },
+          env: info.output.env,
+          includeTests: info.output.includeTests,
+        },
       });
     }
 
-    // 초기 빌드: esbuild + tsc 병렬
+    // 초기 빌드
     sender.send("buildStart", {});
     const initialResult = await rebuildAll();
 

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

@@ -1,8 +1,13 @@
+import type ts from "typescript";
 import esbuild from "esbuild";
+import { err as errNs } from "@simplysm/core-common";
 import {
   createServerEsbuildOptions,
   writeChangedOutputFiles,
 } from "../esbuild/esbuild-config";
+import { createTscPlugin, type TscPluginResult } from "../esbuild/esbuild-tsc-plugin";
+import type { TypecheckEnv } from "../utils/tsconfig";
+import type { SerializedDiagnostic } from "../typecheck/typecheck-serialization";
 
 /**
  * esbuild watch context 생성 옵션
@@ -12,6 +17,13 @@ export interface EsbuildContextOptions {
   entryPoints: string[];
   env?: Record<string, string>;
   external: string[];
+  /** tsc 플러그인 옵션. 제공 시 createTscPlugin으로 플러그인을 생성하여 esbuild context에 포함한다. */
+  tsc?: {
+    cwd: string;
+    output: { dts: boolean };
+    env?: TypecheckEnv;
+    includeTests?: boolean;
+  };
 }
 
 /** esbuild watch context (모듈 스코프 상태) */
@@ -20,11 +32,24 @@ let context: esbuild.BuildContext | undefined;
 /** 마지막 빌드의 metafile (변경 필터링용) */
 let lastMetafile: esbuild.Metafile | undefined;
 
+/** tsc 플러그인 인스턴스 (모듈 스코프 상태) */
+let tscPlugin: TscPluginResult | undefined;
+
 /**
  * esbuild watch context를 생성한다.
  * dev 모드 전용 (metafile:true, write:false).
  */
 export async function createContext(options: EsbuildContextOptions): Promise<void> {
+  if (options.tsc != null) {
+    tscPlugin = createTscPlugin({
+      pkgDir: options.pkgDir,
+      cwd: options.tsc.cwd,
+      output: options.tsc.output,
+      env: options.tsc.env,
+      includeTests: options.tsc.includeTests,
+    });
+  }
+
   const baseOptions = createServerEsbuildOptions({
     pkgDir: options.pkgDir,
     entryPoints: options.entryPoints,
@@ -35,6 +60,7 @@ export async function createContext(options: EsbuildContextOptions): Promise<voi
 
   context = await esbuild.context({
     ...baseOptions,
+    plugins: tscPlugin != null ? [tscPlugin.plugin] : [],
     metafile: true,
     write: false,
   });
@@ -51,7 +77,18 @@ export async function rebuild(): Promise<{
 } | null> {
   if (context == null) return null;
 
-  const result = await context.rebuild();
+  let result: esbuild.BuildResult;
+  try {
+    result = await context.rebuild();
+  } catch (err) {
+    const tscErrors = tscPlugin?.getErrors() ?? [];
+    const allErrors = [errNs.message(err), ...tscErrors];
+    return {
+      success: false,
+      errors: allErrors.length > 0 ? allErrors : undefined,
+      warnings: undefined,
+    };
+  }
 
   if (result.metafile != null) {
     lastMetafile = result.metafile;
@@ -61,12 +98,14 @@ export async function rebuild(): Promise<{
     await writeChangedOutputFiles(result.outputFiles);
   }
 
-  const errors = result.errors.map((e) => e.text);
+  const esbuildErrors = result.errors.map((e) => e.text);
+  const tscErrors = tscPlugin?.getErrors() ?? [];
+  const allErrors = [...esbuildErrors, ...tscErrors];
   const warnings = result.warnings.map((w) => w.text);
 
   return {
-    success: result.errors.length === 0,
-    errors: errors.length > 0 ? errors : undefined,
+    success: allErrors.length === 0,
+    errors: allErrors.length > 0 ? allErrors : undefined,
     warnings: warnings.length > 0 ? warnings : undefined,
   };
 }
@@ -85,6 +124,10 @@ export async function recreateContext(options: EsbuildContextOptions): Promise<v
   context = undefined;
   lastMetafile = undefined;
 
+  if (tscPlugin != null) {
+    tscPlugin.resetBuilderProgram();
+  }
+
   try {
     await createContext(options);
   } finally {
@@ -101,6 +144,7 @@ export async function dispose(): Promise<void> {
   const contextToDispose = context;
   context = undefined;
   lastMetafile = undefined;
+  tscPlugin = undefined;
 
   if (contextToDispose != null) {
     await contextToDispose.dispose();
@@ -120,3 +164,27 @@ export function getMetafile(): esbuild.Metafile | undefined {
 export function hasContext(): boolean {
   return context != null;
 }
+
+/**
+ * tsc 플러그인의 ts.Program을 반환한다.
+ * 플러그인이 없으면 undefined를 반환한다.
+ */
+export function getTscProgram(): ts.Program | undefined {
+  return tscPlugin?.getProgram();
+}
+
+/**
+ * tsc 플러그인의 affected files를 반환한다.
+ * 플러그인이 없으면 undefined를 반환한다.
+ */
+export function getTscAffectedFiles(): ReadonlySet<string> | undefined {
+  return tscPlugin?.getAffectedFiles();
+}
+
+/**
+ * tsc 플러그인의 diagnostics를 반환한다.
+ * 플러그인이 없으면 빈 배열을 반환한다.
+ */
+export function getTscDiagnostics(): SerializedDiagnostic[] {
+  return tscPlugin?.getDiagnostics() ?? [];
+}

package/tests/angular/client-transform-stylesheet.spec.ts

@@ -118,7 +118,7 @@ describe("createClientTransformStylesheet", () => {
     const deps = new Map<string, Set<string>>();
     const transform = createClientTransformStylesheet({
       loadPaths: [],
-      postCssPlugins: [testPlugin],
+      postcssPlugins: [testPlugin],
       scssErrors: errors,
       scssDependencies: deps,
     });