@simplysm/sd-cli 14.0.44 → 14.0.46

package/tests/esbuild/esbuild-worker-plugin.spec.ts

@@ -0,0 +1,606 @@
+import { describe, it, expect } from "vitest";
+import esbuild from "esbuild";
+import path from "path";
+import fs from "fs";
+import os from "os";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const fixturesDir = path.join(__dirname, "fixtures", "worker-plugin");
+
+const { transformWorkerPatterns, createWorkerBundlePlugin, findWorkerPatterns } = await import(
+  "../../src/esbuild/esbuild-worker-plugin.js"
+);
+
+/**
+ * transformWorkerPatterns 테스트용 최소 PluginBuild mock 생성.
+ * 실제 esbuild 모듈을 사용하여 Worker 번들링이 동작한다.
+ */
+function createMockBuild(overrides?: Partial<esbuild.BuildOptions>): esbuild.PluginBuild {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "worker-unit-"));
+  return {
+    esbuild,
+    initialOptions: {
+      outdir: tmpDir,
+      write: false,
+      ...overrides,
+    },
+  } as unknown as esbuild.PluginBuild;
+}
+
+describe("transformWorkerPatterns — 패턴 감지", () => {
+  it("Worker 패턴이 없는 content에 대해 undefined를 반환한다", () => {
+    const result = transformWorkerPatterns(
+      'console.log("hello");',
+      "/test/entry.js",
+      createMockBuild(),
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  it("'Worker' 문자열이 있지만 new URL 패턴이 아니면 undefined를 반환한다", () => {
+    const result = transformWorkerPatterns(
+      'const w = new Worker("./worker.js");',
+      "/test/entry.js",
+      createMockBuild(),
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  it("import.meta.url이 아닌 URL 생성은 undefined를 반환한다", () => {
+    const result = transformWorkerPatterns(
+      'const w = new Worker(new URL("./worker.js", location.href));',
+      "/test/entry.js",
+      createMockBuild(),
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  it("주석 내 Worker 패턴은 무시한다", () => {
+    const result = transformWorkerPatterns(
+      `// new Worker(new URL("./worker.js", import.meta.url))
+const x = 1;`,
+      "/test/entry.js",
+      createMockBuild(),
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  it("문자열 리터럴 내 Worker 패턴은 무시한다", () => {
+    const result = transformWorkerPatterns(
+      `const s = "new Worker(new URL(\\"./worker.js\\", import.meta.url))";`,
+      "/test/entry.js",
+      createMockBuild(),
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  it("Worker + new URL + import.meta.url 패턴을 감지하여 치환한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+
+    const result = transformWorkerPatterns(
+      `const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).not.toContain("./worker.js");
+    expect(result!.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+    expect(result!.errors).toHaveLength(0);
+  });
+
+  it("SharedWorker + new URL + import.meta.url 패턴을 감지하여 치환한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+
+    const result = transformWorkerPatterns(
+      `const sw = new SharedWorker(new URL("./shared-worker.js", import.meta.url));`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).not.toContain("./shared-worker.js");
+    expect(result!.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+  });
+
+  it("복수 Worker 패턴을 모두 치환한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+
+    const result = transformWorkerPatterns(
+      [
+        `const w1 = new Worker(new URL("./worker.js", import.meta.url));`,
+        `const w2 = new Worker(new URL("./worker2.js", import.meta.url));`,
+      ].join("\n"),
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).not.toContain("./worker.js");
+    expect(result!.contents).not.toContain("./worker2.js");
+  });
+});
+
+describe("transformWorkerPatterns — type: module 처리", () => {
+  it("옵션 없는 Worker에 { type: 'module' }을 추가한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+
+    const result = transformWorkerPatterns(
+      `const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    // { type: "module" } 추가됨
+    expect(result!.contents).toMatch(/\{\s*type:\s*"module"\s*\}/);
+  });
+
+  it("기존 옵션이 있으면 그대로 유지한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+
+    const result = transformWorkerPatterns(
+      `const w = new Worker(new URL("./worker.js", import.meta.url), { type: "module" });`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).toContain('{ type: "module" }');
+  });
+});
+
+describe("transformWorkerPatterns — 에러 처리", () => {
+  it("Worker 빌드 에러를 errors에 포함하여 반환한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+
+    const result = transformWorkerPatterns(
+      `const w = new Worker(new URL("./worker-error.js", import.meta.url));`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.errors.length).toBeGreaterThan(0);
+  });
+});
+
+describe("transformWorkerPatterns — write 옵션", () => {
+  it("write: false일 때 workerOutputFiles를 반환한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+
+    const result = transformWorkerPatterns(
+      `const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      createMockBuild({ write: false }),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.workerOutputFiles).toBeDefined();
+    expect(result!.workerOutputFiles!.length).toBeGreaterThan(0);
+  });
+
+  it("write: true일 때 workerOutputFiles가 undefined이다", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "worker-write-"));
+
+    const result = transformWorkerPatterns(
+      `const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      createMockBuild({ write: true, outdir: tmpDir }),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.workerOutputFiles).toBeUndefined();
+
+    // 대신 디스크에 파일이 기록됨
+    const files = fs.readdirSync(tmpDir);
+    const workerFile = files.find((f) => /worker-[a-z0-9]+\.js$/i.test(f));
+    expect(workerFile).toBeDefined();
+  });
+});
+
+describe("transformWorkerPatterns — import.meta.resolve 패턴", () => {
+  it("import.meta.resolve 상대 경로 패턴을 감지하여 치환한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+
+    const result = transformWorkerPatterns(
+      `const p = import.meta.resolve("./node-worker.js");`,
+      entryPath,
+      createMockBuild({ platform: "node" }),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).not.toContain("./node-worker.js");
+    expect(result!.contents).toMatch(/new URL\("worker-[a-z0-9]+\.js", import\.meta\.url\)\.href/i);
+    expect(result!.errors).toHaveLength(0);
+  });
+
+  it("절대 모듈 경로의 import.meta.resolve는 무시한다", () => {
+    const result = transformWorkerPatterns(
+      `const p = import.meta.resolve("some-package");`,
+      "/test/entry.js",
+      createMockBuild({ platform: "node" }),
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  it("import.meta.resolve 패턴 없는 파일은 undefined를 반환한다", () => {
+    const result = transformWorkerPatterns(
+      `console.log("no resolve");`,
+      "/test/entry.js",
+      createMockBuild({ platform: "node" }),
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  it("브라우저 + Node.js Worker 패턴이 공존하면 모두 치환한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+
+    const result = transformWorkerPatterns(
+      [
+        `const w = new Worker(new URL("./worker.js", import.meta.url));`,
+        `const p = import.meta.resolve("./node-worker.js");`,
+      ].join("\n"),
+      entryPath,
+      createMockBuild({ platform: "node" }),
+    );
+
+    expect(result).toBeDefined();
+    // 브라우저 Worker 치환
+    expect(result!.contents).not.toContain('"./worker.js"');
+    // Node.js resolve 치환
+    expect(result!.contents).not.toContain("import.meta.resolve");
+    expect(result!.contents).toMatch(/new URL\("worker-[a-z0-9]+\.js", import\.meta\.url\)\.href/i);
+  });
+
+  it("import.meta.resolve Worker 빌드 에러를 errors에 포함한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+
+    const result = transformWorkerPatterns(
+      `const p = import.meta.resolve("./worker-error.js");`,
+      entryPath,
+      createMockBuild({ platform: "node" }),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.errors.length).toBeGreaterThan(0);
+  });
+
+  it("write: false일 때 workerOutputFiles를 반환한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+
+    const result = transformWorkerPatterns(
+      `const p = import.meta.resolve("./node-worker.js");`,
+      entryPath,
+      createMockBuild({ write: false, platform: "node" }),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.workerOutputFiles).toBeDefined();
+    expect(result!.workerOutputFiles!.length).toBeGreaterThan(0);
+  });
+});
+
+describe("createWorkerBundlePlugin — 플러그인 구조", () => {
+  it("esbuild Plugin 프로토콜을 따르는 객체를 반환한다", () => {
+    const plugin = createWorkerBundlePlugin();
+
+    expect(plugin.name).toBe("sd-worker-bundle");
+    expect(typeof plugin.setup).toBe("function");
+  });
+
+  it("setup에서 onLoad/onEnd 훅이 등록된다", async () => {
+    const plugin = createWorkerBundlePlugin();
+
+    let hasOnLoad = false;
+    let hasOnEnd = false;
+
+    const mockBuild = {
+      initialOptions: {},
+      onLoad(_opts: unknown, _cb: unknown) { hasOnLoad = true; },
+      onEnd(_cb: unknown) { hasOnEnd = true; },
+    } as unknown as esbuild.PluginBuild;
+
+    await plugin.setup(mockBuild);
+
+    expect(hasOnLoad).toBe(true);
+    expect(hasOnEnd).toBe(true);
+  });
+});
+
+describe("findWorkerPatterns — AST 기반 패턴 탐지", () => {
+  it("Worker + new URL + import.meta.url 패턴을 탐지한다", () => {
+    const matches = findWorkerPatterns(
+      `const w = new Worker(new URL("./worker.js", import.meta.url));`,
+    );
+
+    expect(matches).toHaveLength(1);
+    expect(matches[0].type).toBe("browser");
+    expect(matches[0].urlPath).toBe("./worker.js");
+    expect(matches[0].workerType).toBe("Worker");
+    expect(matches[0].existingOpts).toBeUndefined();
+  });
+
+  it("SharedWorker 패턴을 탐지한다", () => {
+    const matches = findWorkerPatterns(
+      `const sw = new SharedWorker(new URL("./sw.js", import.meta.url));`,
+    );
+
+    expect(matches).toHaveLength(1);
+    expect(matches[0].workerType).toBe("SharedWorker");
+    expect(matches[0].urlPath).toBe("./sw.js");
+  });
+
+  it("옵션 객체가 있는 Worker 패턴을 탐지하고 원본 텍스트를 보존한다", () => {
+    const content = `const w = new Worker(new URL("./w.js", import.meta.url), { type: "module" });`;
+    const matches = findWorkerPatterns(content);
+
+    expect(matches).toHaveLength(1);
+    expect(matches[0].existingOpts).toBe('{ type: "module" }');
+  });
+
+  it("import.meta.resolve 상대 경로 패턴을 탐지한다", () => {
+    const matches = findWorkerPatterns(
+      `const p = import.meta.resolve("./node-worker.js");`,
+    );
+
+    expect(matches).toHaveLength(1);
+    expect(matches[0].type).toBe("node");
+    expect(matches[0].urlPath).toBe("./node-worker.js");
+  });
+
+  it("import.meta.resolve 절대 모듈 경로는 무시한다", () => {
+    const matches = findWorkerPatterns(
+      `const p = import.meta.resolve("some-package");`,
+    );
+
+    expect(matches).toHaveLength(0);
+  });
+
+  it("new URL 없는 Worker는 무시한다", () => {
+    const matches = findWorkerPatterns(
+      `const w = new Worker("./worker.js");`,
+    );
+
+    expect(matches).toHaveLength(0);
+  });
+
+  it("import.meta.url이 아닌 URL 생성은 무시한다", () => {
+    const matches = findWorkerPatterns(
+      `const w = new Worker(new URL("./w.js", location.href));`,
+    );
+
+    expect(matches).toHaveLength(0);
+  });
+
+  it("복수 패턴을 모두 탐지한다", () => {
+    const matches = findWorkerPatterns(
+      [
+        `const w1 = new Worker(new URL("./w1.js", import.meta.url));`,
+        `const w2 = new Worker(new URL("./w2.js", import.meta.url));`,
+      ].join("\n"),
+    );
+
+    expect(matches).toHaveLength(2);
+    expect(matches[0].urlPath).toBe("./w1.js");
+    expect(matches[1].urlPath).toBe("./w2.js");
+  });
+
+  it("start/end 위치가 정확하다", () => {
+    const content = `const w = new Worker(new URL("./w.js", import.meta.url));`;
+    const matches = findWorkerPatterns(content);
+
+    expect(matches).toHaveLength(1);
+    const matched = content.slice(matches[0].start, matches[0].end);
+    expect(matched).toBe(`new Worker(new URL("./w.js", import.meta.url))`);
+  });
+
+  it("주석 내 Worker 패턴은 무시한다", () => {
+    const matches = findWorkerPatterns(
+      `// new Worker(new URL("./w.js", import.meta.url))
+const x = 1;`,
+    );
+
+    expect(matches).toHaveLength(0);
+  });
+
+  it("문자열 리터럴 내 Worker 패턴은 무시한다", () => {
+    const matches = findWorkerPatterns(
+      `const s = "new Worker(new URL(\\"./w.js\\", import.meta.url))";`,
+    );
+
+    expect(matches).toHaveLength(0);
+  });
+
+  it("블록 주석 내 Worker 패턴은 무시한다", () => {
+    const matches = findWorkerPatterns(
+      `/* new Worker(new URL("./w.js", import.meta.url)) */
+const x = 1;`,
+    );
+
+    expect(matches).toHaveLength(0);
+  });
+
+  it("주석 내 import.meta.resolve는 무시한다", () => {
+    const matches = findWorkerPatterns(
+      `// import.meta.resolve("./w.js")
+const x = 1;`,
+    );
+
+    expect(matches).toHaveLength(0);
+  });
+
+  it("파싱 불가능한 코드는 빈 배열을 반환한다", () => {
+    const matches = findWorkerPatterns(
+      `this is not valid javascript }{][`,
+    );
+
+    expect(matches).toHaveLength(0);
+  });
+});
+
+describe("transformWorkerPatterns — TypeScript 파일 처리", () => {
+  it("import type이 포함된 .ts 파일에서 Worker 패턴을 탐지하여 치환한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.ts");
+    const result = transformWorkerPatterns(
+      `import type { T } from "pkg";
+const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).not.toContain("./worker.js");
+    expect(result!.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+    expect(result!.errors).toHaveLength(0);
+  });
+
+  it("import type이 포함된 .ts 파일에서 import.meta.resolve 패턴을 탐지하여 치환한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.ts");
+    const result = transformWorkerPatterns(
+      `import type { T } from "pkg";
+const p = import.meta.resolve("./node-worker.js");`,
+      entryPath,
+      createMockBuild({ platform: "node" }),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).not.toContain("./node-worker.js");
+    expect(result!.contents).toMatch(
+      /new URL\("worker-[a-z0-9]+\.js", import\.meta\.url\)\.href/i,
+    );
+    expect(result!.errors).toHaveLength(0);
+  });
+
+  it("타입 어노테이션이 있는 변수 선언(const w: Worker = ...)에서 Worker를 탐지한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.ts");
+    const result = transformWorkerPatterns(
+      `const w: Worker = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+  });
+
+  it(".mts 확장자의 TS 파일도 변환 후 처리한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.mts");
+    const result = transformWorkerPatterns(
+      `import type { T } from "pkg";
+const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+  });
+
+  it(".cts 확장자의 TS 파일도 변환 후 처리한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.cts");
+    const result = transformWorkerPatterns(
+      `import type { T } from "pkg";
+const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+  });
+
+  it("TS 파일의 주석 내 Worker 패턴은 무시한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.ts");
+    const result = transformWorkerPatterns(
+      `import type { T } from "pkg";
+// new Worker(new URL("./worker.js", import.meta.url))
+const x: number = 1;`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  it("TS 파일의 문자열 리터럴 내 Worker 패턴은 무시한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.ts");
+    const result = transformWorkerPatterns(
+      `import type { T } from "pkg";
+const s: string = "new Worker(new URL(\\"./worker.js\\", import.meta.url))";`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  it("사전 필터를 통과하지 못하는 TS 파일(Worker 키워드 없음)은 undefined를 반환한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.ts");
+    const result = transformWorkerPatterns(
+      `import type { T } from "pkg";
+const x: number = 1;`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  it("TS 변환 실패(문법 오류) 시 errors에 에러를 포함하여 반환한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.ts");
+    const result = transformWorkerPatterns(
+      `const w = new Worker(new URL("./worker.js", import.meta.url)); const x: =`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.errors.length).toBeGreaterThan(0);
+  });
+});
+
+describe("createWorkerBundlePlugin — TS 파일 onLoad 반환", () => {
+  it("TS 파일에서 Worker 감지 시 loader로 'js'를 반환한다", async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "worker-onload-"));
+    const tsFile = path.join(tmpDir, "entry.ts");
+    fs.copyFileSync(
+      path.join(fixturesDir, "worker.js"),
+      path.join(tmpDir, "worker.js"),
+    );
+    fs.writeFileSync(
+      tsFile,
+      `import type { T } from "pkg";
+const w = new Worker(new URL("./worker.js", import.meta.url));`,
+    );
+
+    const plugin = createWorkerBundlePlugin();
+
+    let onLoadCallback: ((args: { path: string }) => Promise<any> | any) | null = null;
+    const mockBuild = {
+      esbuild,
+      initialOptions: { outdir: tmpDir, write: false },
+      onLoad: (_filter: unknown, cb: (args: { path: string }) => Promise<any> | any) => {
+        onLoadCallback = cb;
+      },
+      onEnd: () => { /* noop */ },
+    } as unknown as esbuild.PluginBuild;
+
+    await plugin.setup(mockBuild);
+    expect(onLoadCallback).not.toBeNull();
+
+    const result = await onLoadCallback!({ path: tsFile });
+    expect(result).toBeDefined();
+    expect(result.loader).toBe("js");
+    expect(result.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+  });
+});

package/tests/esbuild/esbuild-worker-plugin.verify.md

@@ -0,0 +1,7 @@
+# Worker 빌드 경고가 메인 빌드로 전파됨 — LLM 검증
+
+## 검증 항목
+
+- [x] `transformWorkerPatterns`에서 `workerResult.warnings`를 warnings 배열에 push: `esbuild-worker-plugin.ts:109` — `warnings.push(...workerResult.warnings)` 확인. esbuild.buildSync의 BuildResult.warnings가 그대로 전달됨.
+- [x] 반환 결과의 `warnings` 필드에 수집된 경고가 포함됨: `esbuild-worker-plugin.ts:172` — `warnings` 배열이 결과 객체에 포함됨.
+- [x] 플러그인의 onLoad에서 warnings를 esbuild에 전달: `esbuild-worker-plugin.ts:210` — `warnings: result.warnings.length > 0 ? result.warnings : undefined` — onLoad 결과에 warnings를 포함하여 esbuild가 빌드 경고로 처리.

package/tests/esbuild/fixtures/worker-plugin/node-worker.js

@@ -0,0 +1,2 @@
+const path = require("path");
+process.stdout.write("node-worker:" + path.resolve("."));

package/tests/esbuild/fixtures/worker-plugin/shared-worker.js

@@ -0,0 +1,6 @@
+self.onconnect = (e) => {
+  const port = e.ports[0];
+  port.onmessage = (ev) => {
+    port.postMessage(ev.data);
+  };
+};

package/tests/esbuild/fixtures/worker-plugin/worker-error.js

@@ -0,0 +1 @@
+this is not valid javascript }{][

package/tests/esbuild/fixtures/worker-plugin/worker.js

@@ -0,0 +1,3 @@
+self.onmessage = (e) => {
+  self.postMessage(e.data);
+};

package/tests/esbuild/fixtures/worker-plugin/worker2.js

@@ -0,0 +1,3 @@
+self.onmessage = (e) => {
+  self.postMessage("worker2:" + e.data);
+};

package/tests/workers/server-build-worker-plugin.verify.md

@@ -0,0 +1,9 @@
+# Feature 1.3 서버 빌드에 Worker 플러그인 적용 — LLM 검증
+
+## 검증 항목
+
+- [x] 프로덕션 빌드에 Worker 플러그인 포함: `server-build.worker.ts:169`에서 `plugins: [createWorkerBundlePlugin(), tscPlugin.plugin]`로 설정됨. Worker 플러그인이 tsc 플러그인보다 앞에 위치.
+- [x] Watch/dev 빌드에 Worker 플러그인 포함: `server-esbuild-context.ts:66-69`에서 `workerPlugin` 변수로 생성 후 tsc 유무에 따라 `[workerPlugin, tscPlugin.plugin]` 또는 `[workerPlugin]`으로 설정됨.
+- [x] Worker 패턴 없는 서버 코드 투명 통과: `esbuild-worker-plugin.ts:83-85`에서 `content.includes("Worker")`가 false면 즉시 `undefined` 반환. `esbuild-worker-plugin.ts:197`의 onLoad에서 `result == null`이면 `undefined` 반환하여 다음 핸들러에 위임.
+- [x] 기존 tsc 플러그인/external 처리 미변경: `createServerEsbuildOptions` 함수 미수정. tsc 플러그인 생성 로직 미변경. external 처리 미변경.
+- [x] import 경로에 `.js` 확장자 미사용: 두 파일 모두 `from "../esbuild/esbuild-worker-plugin"` (확장자 없음)