@simplysm/sd-cli 14.0.44 → 14.0.45

package/src/esbuild/esbuild-angular-compiler-plugin.ts

@@ -5,15 +5,15 @@ import ts from "typescript";
 import type esbuild from "esbuild";
 import { consola } from "consola";
 import { JavaScriptTransformer, Cache as AngularCache } from "@angular/build/private";
-import type { AngularSourceFileCache } from "../angular/angular-compiler.js";
-import type { SerializedDiagnostic } from "../typecheck/typecheck-serialization.js";
-import { SdTsCompiler } from "../ts-compiler/SdTsCompiler.js";
-import type { ISdTsCompilerResult } from "../ts-compiler/sd-ts-compiler-result.js";
-import { FileReferenceTracker } from "./file-reference-tracker.js";
-import { LmdbCacheStore } from "./lmdb-cache-store.js";
-import { createCachedLoad, type LoadResultCache } from "./load-result-cache.js";
-import { collectHmrCandidates, HMR_MODIFIED_FILE_LIMIT } from "../angular/hmr-candidates.js";
-import { createWorkerTransformer } from "../angular/web-worker-transformer.js";
+import type { AngularSourceFileCache } from "../angular/angular-compiler";
+import type { SerializedDiagnostic } from "../typecheck/typecheck-serialization";
+import { SdTsCompiler } from "../ts-compiler/SdTsCompiler";
+import type { ISdTsCompilerResult } from "../ts-compiler/sd-ts-compiler-result";
+import { FileReferenceTracker } from "./file-reference-tracker";
+import { LmdbCacheStore } from "./lmdb-cache-store";
+import { createCachedLoad, type LoadResultCache } from "./load-result-cache";
+import { collectHmrCandidates, HMR_MODIFIED_FILE_LIMIT } from "../angular/hmr-candidates";
+import { transformWorkerPatterns } from "./esbuild-worker-plugin";
 
 const logger = consola.withTag("sd:cli:angular-plugin");
 
@@ -48,12 +48,6 @@ export interface AngularCompilerPluginOptions {
   stylesheetErrors?: string[];
 }
 
-interface AdditionalResult {
-  outputFiles?: esbuild.OutputFile[];
-  metafile?: esbuild.Metafile;
-  errors?: esbuild.PartialMessage[];
-}
-
 //#endregion
 
 //#region compilerOptions 변환
@@ -158,46 +152,6 @@ export function convertSerializedDiagnosticToEsbuild(
 
 //#endregion
 
-//#region bundleWebWorker
-
-/**
- * Worker 파일을 esbuild.buildSync()로 별도 ESM 번들로 빌드한다.
- * TypeScript transformer 내에서 동기적으로 호출되므로 sync API를 사용한다.
- */
-export function bundleWebWorker(
-  build: esbuild.PluginBuild,
-  sourcemap: boolean,
-  workerFile: string,
-): esbuild.BuildResult {
-  try {
-    return build.esbuild.buildSync({
-      ...build.initialOptions,
-      platform: "browser",
-      write: false,
-      bundle: true,
-      metafile: true,
-      format: "esm",
-      entryNames: "worker-[hash]",
-      entryPoints: [workerFile],
-      sourcemap,
-      supported: undefined,
-      plugins: undefined,
-    });
-  } catch (error) {
-    if (
-      error != null &&
-      typeof error === "object" &&
-      "errors" in error &&
-      "warnings" in error
-    ) {
-      return error as esbuild.BuildResult;
-    }
-    throw error;
-  }
-}
-
-//#endregion
-
 //#region onLoad 헬퍼
 
 const POTENTIAL_METADATA_REGEX =
@@ -288,7 +242,12 @@ export function createAngularCompilerPlugin(
       // ── 내부 상태 ──
       const typeScriptFileCache: Map<string, string | Uint8Array> =
         pluginOptions.typeScriptFileCache ?? new Map();
-      const additionalResults = new Map<string, AdditionalResult>();
+      // containingFile별 Worker 번들 결과. 증분 빌드에서 변경된 파일만 선택적으로
+      // 제거하여, 변경되지 않은 Worker metafile/outputFiles가 유지되도록 함.
+      const workerResultsByContainingFile = new Map<
+        string,
+        { outputFiles?: esbuild.OutputFile[]; metafile?: esbuild.Metafile }
+      >();
       const referencedFileTracker = new FileReferenceTracker();
       let sdTsCompiler: SdTsCompiler | undefined;
       let lastResult: ISdTsCompilerResult | undefined;
@@ -308,58 +267,6 @@ export function createAngularCompilerPlugin(
         return sideEffects;
       }
 
-      // ── 서브함수: WebWorker 프로세서 생성 ──
-      function createWebWorkerProcessor(
-        errors: esbuild.PartialMessage[],
-        warnings: esbuild.PartialMessage[],
-      ): (workerFile: string, containingFile: string) => string {
-        return (workerFile: string, containingFile: string): string => {
-          const fullWorkerPath = path.join(path.dirname(containingFile), workerFile);
-          const workerResult = bundleWebWorker(build, pluginOptions.sourcemap, fullWorkerPath);
-
-          warnings.push(...workerResult.warnings);
-
-          if (workerResult.errors.length > 0) {
-            errors.push(...workerResult.errors);
-            // 에러 파일 경로 추적 (rebuild 허용)
-            referencedFileTracker.add(
-              containingFile,
-              workerResult.errors
-                .map((e) => e.location?.file)
-                .filter((f): f is string => f != null)
-                .map((f) => path.join(cwd, f)),
-            );
-            additionalResults.set(fullWorkerPath, { errors: workerResult.errors });
-            return workerFile;
-          }
-
-          additionalResults.set(fullWorkerPath, {
-            outputFiles: workerResult.outputFiles,
-            metafile: workerResult.metafile,
-          });
-
-          // metafile.inputs → FileReferenceTracker
-          if (workerResult.metafile != null) {
-            referencedFileTracker.add(
-              containingFile,
-              Object.keys(workerResult.metafile.inputs).map((input) => path.join(cwd, input)),
-            );
-          }
-
-          // worker-[HASH].js 파일 찾기
-          const workerCodeFile = workerResult.outputFiles?.find((file) =>
-            /^worker-[A-Z0-9]{8}\.[cm]?js$/.test(path.basename(file.path)),
-          );
-          if (workerCodeFile == null) {
-            errors.push({ text: `Web Worker bundled code file not found: ${fullWorkerPath}`, location: null });
-            return workerFile;
-          }
-          const outdir = build.initialOptions.outdir ?? "";
-          const workerCodePath = path.relative(outdir, workerCodeFile.path);
-          return workerCodePath.replaceAll("\\", "/");
-        };
-      }
-
       // ── onStart ──
       build.onStart(async () => {
         const result: esbuild.OnStartResult = {};
@@ -402,9 +309,10 @@ export function createAngularCompilerPlugin(
               sourceFileCache.modifiedFiles,
             );
 
-            // stale additionalResults 제거
+            // 변경된 파일의 Worker 결과만 선택적 제거 (변경되지 않은 파일의
+            // Worker metafile은 유지되어 onEnd에서 재병합됨)
             for (const file of expandedModifiedFiles) {
-              additionalResults.delete(file);
+              workerResultsByContainingFile.delete(file);
             }
           }
 
@@ -424,19 +332,39 @@ export function createAngularCompilerPlugin(
             });
           }
 
-          // ── processWebWorker + workerTransformer ──
-          const processWebWorker = createWebWorkerProcessor(errors, warnings);
-          const workerTransformer = createWorkerTransformer(processWebWorker);
-
           // ── compileAsync ──
           const compileResult = await sdTsCompiler.compileAsync(
             isIncremental ? expandedModifiedFiles : undefined,
-            { additionalTransformers: { before: [workerTransformer] } },
           );
 
-          // ── emitResults → typeScriptFileCache ──
+          // ── emitResults → typeScriptFileCache (Worker 패턴 처리 포함) ──
           for (const { contents, sourceFileName } of compileResult.emitResults ?? []) {
-            typeScriptFileCache.set(path.normalize(sourceFileName), contents);
+            const normalized = path.normalize(sourceFileName);
+            const workerResult = transformWorkerPatterns(contents, normalized, build);
+            if (workerResult != null) {
+              typeScriptFileCache.set(normalized, workerResult.contents);
+              errors.push(...workerResult.errors);
+              warnings.push(...workerResult.warnings);
+              if (workerResult.workerMetafile != null) {
+                referencedFileTracker.add(
+                  normalized,
+                  Object.keys(workerResult.workerMetafile.inputs).map((input) =>
+                    path.join(cwd, input),
+                  ),
+                );
+              }
+              if (
+                workerResult.workerMetafile != null ||
+                workerResult.workerOutputFiles != null
+              ) {
+                workerResultsByContainingFile.set(normalized, {
+                  outputFiles: workerResult.workerOutputFiles,
+                  metafile: workerResult.workerMetafile,
+                });
+              }
+            } else {
+              typeScriptFileCache.set(normalized, contents);
+            }
           }
 
           // ── onLoad 플래그 결정 (첫 빌드에서만) ──
@@ -612,6 +540,37 @@ export function createAngularCompilerPlugin(
             false, // skipLinker
             sideEffects,
           );
+
+          // Worker 패턴 처리 (D2)
+          const textContents = new TextDecoder().decode(contents);
+          const workerResult = transformWorkerPatterns(textContents, request, build);
+          if (workerResult != null) {
+            if (workerResult.workerMetafile != null) {
+              referencedFileTracker.add(
+                request,
+                Object.keys(workerResult.workerMetafile.inputs).map((input) =>
+                  path.join(cwd, input),
+                ),
+              );
+            }
+            if (
+              workerResult.workerMetafile != null ||
+              workerResult.workerOutputFiles != null
+            ) {
+              workerResultsByContainingFile.set(request, {
+                outputFiles: workerResult.workerOutputFiles,
+                metafile: workerResult.workerMetafile,
+              });
+            }
+            return {
+              contents: workerResult.contents,
+              loader: "js" as const,
+              resolveDir: path.dirname(request),
+              errors: workerResult.errors.length > 0 ? workerResult.errors : undefined,
+              warnings: workerResult.warnings.length > 0 ? workerResult.warnings : undefined,
+            };
+          }
+
           return {
             contents,
             loader: "js" as const,
@@ -622,13 +581,13 @@ export function createAngularCompilerPlugin(
 
       // ── onEnd ──
       build.onEnd((result: esbuild.BuildResult) => {
-        for (const { outputFiles, metafile } of additionalResults.values()) {
-          if (outputFiles != null && outputFiles.length > 0) {
-            result.outputFiles?.push(...outputFiles);
+        for (const wr of workerResultsByContainingFile.values()) {
+          if (wr.outputFiles != null && wr.outputFiles.length > 0) {
+            result.outputFiles?.push(...wr.outputFiles);
           }
-          if (result.metafile != null && metafile != null) {
-            Object.assign(result.metafile.inputs, metafile.inputs);
-            Object.assign(result.metafile.outputs, metafile.outputs);
+          if (result.metafile != null && wr.metafile != null) {
+            Object.assign(result.metafile.inputs, wr.metafile.inputs);
+            Object.assign(result.metafile.outputs, wr.metafile.outputs);
           }
         }
       });

package/src/esbuild/esbuild-worker-plugin.ts

@@ -0,0 +1,266 @@
+import path from "path";
+import fs from "fs";
+import type esbuild from "esbuild";
+
+/**
+ * Worker/SharedWorker + new URL + import.meta.url 패턴을 감지하는 정규식.
+ *
+ * 캡처 그룹:
+ * - Group 1: `Worker` 또는 `SharedWorker`
+ * - Group 2: URL 경로 (예: `"./worker.ts"`)
+ * - Group 3: 옵션 객체 (예: `{ type: "module" }`) — 없으면 undefined
+ */
+const WORKER_PATTERN =
+  /\bnew\s+(Worker|SharedWorker)\s*\(\s*new\s+URL\s*\(\s*["']([^"']+)["']\s*,\s*import\.meta\.url\s*\)\s*(?:,\s*(\{[^}]*\}))?\s*\)/g;
+
+/**
+ * Node.js import.meta.resolve 패턴을 감지하는 정규식.
+ * 상대 경로(./ 또는 ../)만 감지 — 절대 모듈 경로("some-package")는 무시.
+ *
+ * 캡처 그룹:
+ * - Group 1: 상대 경로 (예: `"../workers/service-protocol.worker"`)
+ */
+const NODE_WORKER_PATTERN =
+  /\bimport\.meta\.resolve\s*\(\s*["'](\.\.?\/[^"']+)["']\s*\)/g;
+
+/**
+ * Worker 번들 빌드 결과를 포함하는 transform 결과.
+ */
+export interface TransformWorkerResult {
+  contents: string;
+  errors: esbuild.PartialMessage[];
+  warnings: esbuild.PartialMessage[];
+  /** write: false일 때 Worker 번들의 outputFiles (onEnd에서 병합용) */
+  workerOutputFiles?: esbuild.OutputFile[];
+  /** Worker 번들의 metafile (onEnd에서 병합용) */
+  workerMetafile?: esbuild.Metafile;
+}
+
+/**
+ * Worker 파일을 esbuild.buildSync()로 별도 ESM 번들로 빌드한다.
+ * esbuild-angular-compiler-plugin.ts의 bundleWebWorker를 기반으로 작성.
+ */
+function bundleWorker(
+  build: esbuild.PluginBuild,
+  workerFile: string,
+  platform: esbuild.Platform,
+): esbuild.BuildResult {
+  const sourcemap =
+    build.initialOptions.sourcemap != null &&
+    build.initialOptions.sourcemap !== false;
+  const write = build.initialOptions.write !== false;
+
+  try {
+    return build.esbuild.buildSync({
+      ...build.initialOptions,
+      platform,
+      write,
+      bundle: true,
+      metafile: true,
+      format: "esm",
+      entryNames: "worker-[hash]",
+      entryPoints: [workerFile],
+      sourcemap,
+      // 메인 빌드에서 상속하지 않는 옵션
+      external: undefined,
+      supported: undefined,
+      plugins: undefined,
+      outbase: undefined,
+      inject: undefined,
+    });
+  } catch (error) {
+    if (
+      error != null &&
+      typeof error === "object" &&
+      "errors" in error &&
+      "warnings" in error
+    ) {
+      return error as esbuild.BuildResult;
+    }
+    throw error;
+  }
+}
+
+/**
+ * 파일 내용에서 Worker/SharedWorker 패턴을 감지하여 Worker 파일을 번들링하고
+ * URL 경로를 번들된 파일 경로로 치환한다.
+ *
+ * Angular 플러그인 등 외부에서 직접 호출할 수 있도록 export한다 (D2).
+ *
+ * @returns 변환 결과. 패턴이 없으면 undefined.
+ */
+export function transformWorkerPatterns(
+  content: string,
+  filePath: string,
+  build: esbuild.PluginBuild,
+): TransformWorkerResult | undefined {
+  // 빠른 사전 필터
+  const hasBrowserWorker = content.includes("Worker") && WORKER_PATTERN.test(content);
+  if (hasBrowserWorker) WORKER_PATTERN.lastIndex = 0;
+
+  const hasNodeWorker =
+    content.includes("import.meta.resolve") && NODE_WORKER_PATTERN.test(content);
+  if (hasNodeWorker) NODE_WORKER_PATTERN.lastIndex = 0;
+
+  if (!hasBrowserWorker && !hasNodeWorker) {
+    return undefined;
+  }
+
+  const errors: esbuild.PartialMessage[] = [];
+  const warnings: esbuild.PartialMessage[] = [];
+  const allOutputFiles: esbuild.OutputFile[] = [];
+  let mergedMetafile: esbuild.Metafile | undefined;
+
+  const write = build.initialOptions.write !== false;
+  const outdir = build.initialOptions.outdir ?? "";
+  const containingDir = path.dirname(filePath);
+
+  /**
+   * Worker 번들을 빌드하고, 결과에서 출력 파일 경로를 찾아 반환한다.
+   * 에러/경고/outputFiles/metafile을 외부 변수에 수집한다.
+   */
+  function processWorkerBundle(
+    fullWorkerPath: string,
+    platform: esbuild.Platform,
+  ): string | undefined {
+    const workerResult = bundleWorker(build, fullWorkerPath, platform);
+
+    warnings.push(...workerResult.warnings);
+
+    if (workerResult.errors.length > 0) {
+      errors.push(...workerResult.errors);
+      return undefined;
+    }
+
+    if (!write && workerResult.outputFiles != null) {
+      allOutputFiles.push(...workerResult.outputFiles);
+    }
+
+    if (workerResult.metafile != null) {
+      if (mergedMetafile == null) {
+        mergedMetafile = { inputs: {}, outputs: {} };
+      }
+      Object.assign(mergedMetafile.inputs, workerResult.metafile.inputs);
+      Object.assign(mergedMetafile.outputs, workerResult.metafile.outputs);
+    }
+
+    const workerCodeFile =
+      workerResult.outputFiles?.find((file) =>
+        /^worker-[a-z0-9]+\.[cm]?js$/i.test(path.basename(file.path)),
+      ) ??
+      (workerResult.metafile != null
+        ? (() => {
+            const outputKey = Object.keys(workerResult.metafile.outputs).find(
+              (key) => /worker-[a-z0-9]+\.[cm]?js$/i.test(path.basename(key)),
+            );
+            return outputKey != null ? { path: path.resolve(outputKey) } : undefined;
+          })()
+        : undefined);
+
+    if (workerCodeFile == null) {
+      errors.push({
+        text: `Worker 번들 출력 파일을 찾을 수 없습니다: ${fullWorkerPath}`,
+        location: null,
+      });
+      return undefined;
+    }
+
+    // outdir 루트 기준 상대 경로. bundleWorker에서 outbase: undefined를 설정하여
+    // Worker 파일이 항상 outdir 루트에 출력됨을 보장한다.
+    return path.relative(outdir, workerCodeFile.path).replaceAll("\\", "/");
+  }
+
+  let transformed = content;
+
+  // 1. 브라우저 Worker 패턴 처리 (new Worker(new URL("path", import.meta.url)))
+  if (hasBrowserWorker) {
+    transformed = transformed.replace(
+      WORKER_PATTERN,
+      (match, workerType: string, urlPath: string, existingOpts?: string) => {
+        const fullWorkerPath = path.resolve(containingDir, urlPath);
+        const workerCodePath = processWorkerBundle(fullWorkerPath, "browser");
+        if (workerCodePath == null) return match;
+
+        const optsStr = existingOpts != null ? existingOpts : '{ type: "module" }';
+        return `new ${workerType}(new URL("${workerCodePath}", import.meta.url), ${optsStr})`;
+      },
+    );
+  }
+
+  // 2. Node.js import.meta.resolve 패턴 처리
+  if (hasNodeWorker) {
+    transformed = transformed.replace(
+      NODE_WORKER_PATTERN,
+      (match, resolvePath: string) => {
+        const fullWorkerPath = path.resolve(containingDir, resolvePath);
+        const workerCodePath = processWorkerBundle(
+          fullWorkerPath,
+          build.initialOptions.platform ?? "browser",
+        );
+        if (workerCodePath == null) return match;
+
+        return `new URL("${workerCodePath}", import.meta.url).href`;
+      },
+    );
+  }
+
+  return {
+    contents: transformed,
+    errors,
+    warnings,
+    workerOutputFiles: allOutputFiles.length > 0 ? allOutputFiles : undefined,
+    workerMetafile: mergedMetafile,
+  };
+}
+
+/**
+ * esbuild Worker 번들링 플러그인을 생성한다.
+ *
+ * onLoad에서 .js/.ts 파일의 Worker/SharedWorker 패턴을 감지하여
+ * Worker 파일을 별도 ESM 번들로 빌드하고, URL 경로를 번들된 파일로 치환한다.
+ */
+export function createWorkerBundlePlugin(): esbuild.Plugin {
+  return {
+    name: "sd-worker-bundle",
+    setup(build) {
+      const pendingWorkerResults: Array<{
+        outputFiles?: esbuild.OutputFile[];
+        metafile?: esbuild.Metafile;
+      }> = [];
+
+      build.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, (args) => {
+        const content = fs.readFileSync(args.path, "utf-8");
+        const result = transformWorkerPatterns(content, args.path, build);
+        if (result == null) return undefined;
+
+        // write: false일 때 Worker outputFiles를 모아뒀다가 onEnd에서 병합
+        if (result.workerOutputFiles != null || result.workerMetafile != null) {
+          pendingWorkerResults.push({
+            outputFiles: result.workerOutputFiles,
+            metafile: result.workerMetafile,
+          });
+        }
+
+        return {
+          contents: result.contents,
+          loader: /\.[cm]?tsx?$/.test(args.path) ? ("ts" as const) : ("js" as const),
+          errors: result.errors.length > 0 ? result.errors : undefined,
+          warnings: result.warnings.length > 0 ? result.warnings : undefined,
+        };
+      });
+
+      build.onEnd((result) => {
+        for (const wr of pendingWorkerResults) {
+          if (wr.outputFiles != null && wr.outputFiles.length > 0) {
+            result.outputFiles?.push(...wr.outputFiles);
+          }
+          if (result.metafile != null && wr.metafile != null) {
+            Object.assign(result.metafile.inputs, wr.metafile.inputs);
+            Object.assign(result.metafile.outputs, wr.metafile.outputs);
+          }
+        }
+        pendingWorkerResults.length = 0;
+      });
+    },
+  };
+}

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

@@ -18,6 +18,7 @@ import {
 import { collectAllExternals, generateProductionFiles } from "../deps/server-externals/server-production-files";
 import { SdTsCompiler } from "../ts-compiler/SdTsCompiler";
 import { createTscPlugin } from "../esbuild/esbuild-tsc-plugin";
+import { createWorkerBundlePlugin } from "../esbuild/esbuild-worker-plugin";
 import { setupWorkerLifecycle } from "./shared-worker-lifecycle";
 import { buildWatchPaths } from "./build-watch-paths";
 import { copyPublicFiles, watchPublicFiles } from "../utils/copy-public";
@@ -140,7 +141,7 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
     const entryPoints = getPackageSourceFiles(info.pkgDir, parsedConfig);
 
     // 외부 모듈 수집
-    const external = collectAllExternals(info.pkgDir, info.externals);
+    const { bundleExternals, prodDependencies } = collectAllExternals(info.pkgDir, info.externals);
 
     let jsResult: { success: boolean; errors?: string[]; warnings?: string[] };
     let tscErrors: string[];
@@ -162,10 +163,10 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
         pkgDir: info.pkgDir,
         entryPoints,
         env: info.env,
-        external,
+        external: bundleExternals,
       });
 
-      jsResult = await esbuild.build({ ...esbuildOptions, plugins: [tscPlugin.plugin] })
+      jsResult = await esbuild.build({ ...esbuildOptions, plugins: [createWorkerBundlePlugin(), tscPlugin.plugin] })
         .then(async (result) => {
           if (result.outputFiles) {
             await writeChangedOutputFiles(result.outputFiles);
@@ -212,7 +213,7 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
 
       await copyPublicFiles(info.pkgDir, false);
 
-      generateProductionFiles(info, external);
+      generateProductionFiles(info, prodDependencies);
     }
 
     const allErrors = [...(jsResult.errors ?? []), ...tscErrors];
@@ -310,7 +311,7 @@ async function startWatch(info: ServerWatchInfo): Promise<void> {
     const entryPoints = getPackageSourceFiles(info.pkgDir, parsedConfig);
 
     // 외부 모듈 수집 (watch 모드용 — watch manager가 자체 캐시를 유지)
-    const cachedExternal = collectAllExternals(info.pkgDir, info.externals);
+    const { bundleExternals: cachedExternal } = collectAllExternals(info.pkgDir, info.externals);
 
     // esbuild 컨텍스트 생성 (JS 출력 필요 시, tsc 플러그인 포함)
     if (info.output.js) {

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

@@ -10,6 +10,7 @@ import { createTscPlugin, type TscPluginResult } from "../esbuild/esbuild-tsc-pl
 import type { TypecheckEnv } from "../utils/tsconfig";
 import type { SerializedDiagnostic } from "../typecheck/typecheck-serialization";
 import type { LintWithProgramResult } from "../lint/lint-with-program";
+import { createWorkerBundlePlugin } from "../esbuild/esbuild-worker-plugin";
 
 /**
  * esbuild watch context 생성 옵션
@@ -62,9 +63,10 @@ export async function createContext(options: EsbuildContextOptions): Promise<voi
     dev: true,
   });
 
+  const workerPlugin = createWorkerBundlePlugin();
   context = await esbuild.context({
     ...baseOptions,
-    plugins: tscPlugin != null ? [tscPlugin.plugin] : [],
+    plugins: tscPlugin != null ? [workerPlugin, tscPlugin.plugin] : [workerPlugin],
     metafile: true,
     write: false,
   });

package/src/workers/server-watch-manager.ts

@@ -59,7 +59,7 @@ export async function startServerWatchLoop(config: ServerWatchLoopConfig): Promi
           c.path.endsWith("package.json"),
         );
         if (hasPackageJsonChange) {
-          cachedExternal = collectAllExternals(info.pkgDir, info.externals);
+          cachedExternal = collectAllExternals(info.pkgDir, info.externals).bundleExternals;
         }
 
         if (info.output.js) {