@simplysm/sd-cli 14.0.43 → 14.0.45

package/src/deps/server-externals/server-production-files.ts

@@ -1,6 +1,7 @@
 import type { ServerBuildInfo } from "../../workers/server-build.worker";
 import path from "path";
 import fs from "fs";
+import YAML from "yaml";
 import { cpx } from "@simplysm/core-node";
 import { consola } from "consola";
 import { collectAllDependencyExternals } from "../../esbuild/esbuild-config";
@@ -8,21 +9,29 @@ import { collectAllDependencyExternals } from "../../esbuild/esbuild-config";
 const logger = consola.withTag("sd:cli:server-production-files");
 
 /**
- * 세 가지 소스에서 외부 모듈을 수집하고 병합한다.
- * collectAllDependencyExternals를 통한 단일 패스 의존성 트리 순회를 사용한다.
+ * 외부 모듈을 두 용도로 분리하여 수집한다.
+ * - bundleExternals: esbuild external — 번들에서 제외할 패키지
+ * - prodDependencies: dist/package.json dependencies — 런타임에 실제 설치되어야 하는 패키지
+ *
+ * 미설치 optional peer는 번들 제외만 필요할 뿐 런타임에 쓰이지 않으므로 prodDependencies에 포함하지 않는다.
  */
-export function collectAllExternals(pkgDir: string, manualExternals?: string[]): string[] {
+export function collectAllExternals(
+  pkgDir: string,
+  manualExternals?: string[],
+): { bundleExternals: string[]; prodDependencies: string[] } {
   logger.debug("의존성 트리 스캔 중...");
   const { optionalPeerDeps, nativeModules } = collectAllDependencyExternals(pkgDir);
 
   const manual = manualExternals ?? [];
-  return [...new Set([...optionalPeerDeps, ...nativeModules, ...manual])];
+  return {
+    bundleExternals: [...new Set([...optionalPeerDeps, ...nativeModules, ...manual])],
+    prodDependencies: [...new Set([...nativeModules, ...manual])],
+  };
 }
 
 /**
  * pnpm-lock.yaml의 packages 섹션을 파싱하여 name→version 맵을 생성한다.
- * Lockfile v9 형식: `packages:` 섹션의 `'name@version':` 키를 파싱한다.
- * YAML 파서 의존성을 피하기 위해 단순 라인 기반 파싱을 사용한다.
+ * 키 형태: "name@version" · "@scope/name@version" · "name@version(peer@ver)..."
  */
 export function parseLockfileVersions(cwd: string): Map<string, string> {
   const lockfilePath = path.join(cwd, "pnpm-lock.yaml");
@@ -31,30 +40,19 @@ export function parseLockfileVersions(cwd: string): Map<string, string> {
   }
 
   const content = fs.readFileSync(lockfilePath, "utf-8");
+  const parsed = YAML.parse(content) as { packages?: Record<string, unknown> };
   const map = new Map<string, string>();
 
-  // "packages:" 섹션을 찾고 "'@scope/name@1.2.3':" 또는 "'name@1.2.3':" 형태의 항목을 파싱
-  const lines = content.split("\n");
-  let inPackages = false;
-  for (const line of lines) {
-    if (line === "packages:") {
-      inPackages = true;
-      continue;
-    }
-    if (inPackages && line.length > 0 && !line.startsWith(" ") && !line.startsWith("'")) {
-      break; // 다음 최상위 섹션
-    }
-    if (!inPackages) continue;
-
-    // "'@scope/name@version':" 또는 "'name@version':" 매칭
-    const match = /^\s{2}'(.+)@(\d[^']*)':\s*$/.exec(line);
-    if (match != null) {
-      const name = match[1];
-      const version = match[2];
-      // 첫 번째 항목 유지 (lockfile은 각 버전을 한 번만 기록)
-      if (!map.has(name)) {
-        map.set(name, version);
-      }
+  for (const key of Object.keys(parsed.packages ?? {})) {
+    // 첫 번째 @숫자 기준으로 name / version 분리 (scope 패키지의 선두 @ 보존)
+    const m = /^(.+?)@(\d.+)$/.exec(key);
+    if (m == null) continue;
+    const name = m[1];
+    // peerDep suffix "(peer@ver)..." 제거
+    const parenIdx = m[2].indexOf("(");
+    const version = parenIdx === -1 ? m[2] : m[2].substring(0, parenIdx);
+    if (!map.has(name)) {
+      map.set(name, version);
     }
   }
 

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-postcss-plugin.ts

@@ -88,16 +88,19 @@ export function createPostcssPlugin(options: CreatePostcssPluginOptions): esbuil
 
             if (replacements.length === 0) continue;
 
-            // PostCSS 적용 및 역순 교체
-            let modified = code;
-            // 끝에서 시작 방향으로 교체하여 offset 유지
-            const sorted = replacements.sort((a, b) => b.start - a.start);
+            // PostCSS 적용 — 정방향 청크 배열 + join
+            const sorted = replacements.sort((a, b) => a.start - b.start);
+            const chunks: string[] = [];
+            let cursor = 0;
 
             for (const rep of sorted) {
+              chunks.push(code.slice(cursor, rep.start));
               const processed = await processor.process(rep.text, { from: file });
-              const escaped = JSON.stringify(processed.css);
-              modified = modified.slice(0, rep.start) + escaped + modified.slice(rep.end);
+              chunks.push(JSON.stringify(processed.css));
+              cursor = rep.end;
             }
+            chunks.push(code.slice(cursor));
+            const modified = chunks.join("");
 
             await fs.promises.writeFile(file, modified);
           } catch (e: unknown) {

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;
+      });
+    },
+  };
+}