@simplysm/sd-cli 14.0.38 → 14.0.40

package/tests/utils/esbuild-postcss-plugin.spec.ts

@@ -0,0 +1,290 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import postcss from "postcss";
+import type esbuild from "esbuild";
+import { createPostcssPlugin } from "../../src/esbuild/esbuild-postcss-plugin";
+
+// --- Helpers ---
+
+function markerPlugin(): postcss.Plugin {
+  return {
+    postcssPlugin: "test-marker",
+    Once(root) {
+      root.prepend(new postcss.Comment({ text: "marker" }));
+    },
+  };
+}
+
+function captureOnEnd(
+  plugin: esbuild.Plugin,
+): (result: esbuild.BuildResult) => Promise<void> | void {
+  let cb!: (result: esbuild.BuildResult) => Promise<void> | void;
+  void plugin.setup({
+    onEnd(fn: (result: esbuild.BuildResult) => Promise<void> | void) {
+      cb = fn;
+    },
+  } as unknown as esbuild.PluginBuild);
+  return cb;
+}
+
+function buildResult(
+  outputs: Record<string, unknown>,
+): esbuild.BuildResult {
+  return {
+    errors: [] as esbuild.Message[],
+    warnings: [] as esbuild.Message[],
+    metafile: { inputs: {}, outputs } as esbuild.Metafile,
+    outputFiles: [],
+    mangleCache: {},
+  };
+}
+
+// --- Tests ---
+
+describe("createPostcssPlugin — 플러그인 구조", () => {
+  it("플러그인 이름이 sd-postcss이다", () => {
+    const plugin = createPostcssPlugin({ plugins: [markerPlugin()] });
+    expect(plugin.name).toBe("sd-postcss");
+  });
+
+  it("onEnd 콜백이 등록된다", () => {
+    const plugin = createPostcssPlugin({ plugins: [markerPlugin()] });
+    let registered = false;
+    void plugin.setup({
+      onEnd() {
+        registered = true;
+      },
+    } as unknown as esbuild.PluginBuild);
+    expect(registered).toBe(true);
+  });
+});
+
+describe("createPostcssPlugin — metafile 가드", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "postcss-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("metafile이 null이면 아무 처리도 하지 않는다", async () => {
+    const cssFile = path.join(tmpDir, "main.css");
+    const original = ".host { display: flex; }";
+    fs.writeFileSync(cssFile, original);
+
+    const plugin = createPostcssPlugin({ plugins: [markerPlugin()] });
+    const onEnd = captureOnEnd(plugin);
+
+    await onEnd({
+      errors: [],
+      warnings: [],
+      metafile: undefined,
+      outputFiles: [],
+      mangleCache: {},
+    } as unknown as esbuild.BuildResult);
+
+    expect(fs.readFileSync(cssFile, "utf-8")).toBe(original);
+  });
+});
+
+describe("createPostcssPlugin — .css 파일 처리", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "postcss-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("여러 .css 파일이 있으면 모두 처리된다", async () => {
+    const css1 = path.join(tmpDir, "a.css");
+    const css2 = path.join(tmpDir, "b.css");
+    fs.writeFileSync(css1, ".a { color: red; }");
+    fs.writeFileSync(css2, ".b { color: blue; }");
+
+    const plugin = createPostcssPlugin({ plugins: [markerPlugin()] });
+    const onEnd = captureOnEnd(plugin);
+
+    await onEnd(
+      buildResult({
+        [css1]: { bytes: 10, inputs: {}, imports: [], exports: [] },
+        [css2]: { bytes: 10, inputs: {}, imports: [], exports: [] },
+      }),
+    );
+
+    expect(fs.readFileSync(css1, "utf-8")).toContain("/* marker */");
+    expect(fs.readFileSync(css2, "utf-8")).toContain("/* marker */");
+  });
+
+  it("outputs에 .css 파일이 없으면 파일을 읽지 않는다", async () => {
+    const plugin = createPostcssPlugin({ plugins: [markerPlugin()] });
+    const onEnd = captureOnEnd(plugin);
+
+    // .js와 .map만 있는 outputs — 에러 없이 정상 완료
+    await onEnd(
+      buildResult({
+        "dist/main.js": { bytes: 10, inputs: {}, imports: [], exports: [] },
+        "dist/main.js.map": { bytes: 10, inputs: {}, imports: [], exports: [] },
+      }),
+    );
+
+    // 에러 없이 완료되면 성공
+  });
+
+  it("PostCSS 에러 메시지에 파일 경로가 포함된다", async () => {
+    const cssFile = path.join(tmpDir, "err.css");
+    fs.writeFileSync(cssFile, ".host { color: red; }");
+
+    const throwing: postcss.Plugin = {
+      postcssPlugin: "throw-with-detail",
+      Once() {
+        throw new Error("detailed-error-message");
+      },
+    };
+
+    const plugin = createPostcssPlugin({ plugins: [throwing] });
+    const onEnd = captureOnEnd(plugin);
+
+    const result = buildResult({
+      [cssFile]: { bytes: 10, inputs: {}, imports: [], exports: [] },
+    });
+    await onEnd(result);
+
+    expect(result.errors[0].text).toContain(cssFile);
+    expect(result.errors[0].text).toContain("detailed-error-message");
+  });
+});
+
+describe("createPostcssPlugin — .js 파일 사전 필터링", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "postcss-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("styles 문자열이 없는 .js 파일은 원본이 유지된다", async () => {
+    const jsFile = path.join(tmpDir, "chunk.js");
+    const original = 'export const x = "no relevant content";';
+    fs.writeFileSync(jsFile, original);
+
+    const plugin = createPostcssPlugin({ plugins: [markerPlugin()] });
+    const onEnd = captureOnEnd(plugin);
+
+    await onEnd(
+      buildResult({
+        [jsFile]: { bytes: 50, inputs: {}, imports: [], exports: [] },
+      }),
+    );
+
+    expect(fs.readFileSync(jsFile, "utf-8")).toBe(original);
+  });
+});
+
+describe("createPostcssPlugin — .js AST 기반 styles 추출", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "postcss-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("styles 배열에 Identifier(변수 참조)만 있으면 파일이 수정되지 않는다", async () => {
+    const jsFile = path.join(tmpDir, "varref.js");
+    const code = [
+      'import * as i0 from "@angular/core";',
+      "const _c0 = [];",
+      "class MyComp {}",
+      "MyComp.ɵcmp = i0.ɵɵdefineComponent({",
+      "  styles: _c0",
+      "});",
+    ].join("\n");
+    fs.writeFileSync(jsFile, code);
+
+    const plugin = createPostcssPlugin({ plugins: [markerPlugin()] });
+    const onEnd = captureOnEnd(plugin);
+
+    await onEnd(
+      buildResult({
+        [jsFile]: { bytes: 200, inputs: {}, imports: [], exports: [] },
+      }),
+    );
+
+    expect(fs.readFileSync(jsFile, "utf-8")).toBe(code);
+  });
+
+  it("styles 배열에 문자열과 변수 참조가 혼재하면 문자열만 처리된다", async () => {
+    const jsFile = path.join(tmpDir, "mixed.js");
+    const code = [
+      'import * as i0 from "@angular/core";',
+      "const _c0 = '.external { margin: 0 }';",
+      "class MyComp {}",
+      "MyComp.ɵcmp = i0.ɵɵdefineComponent({",
+      '  styles: [_c0, ".inline { color: red; }"]',
+      "});",
+    ].join("\n");
+    fs.writeFileSync(jsFile, code);
+
+    const plugin = createPostcssPlugin({ plugins: [markerPlugin()] });
+    const onEnd = captureOnEnd(plugin);
+
+    await onEnd(
+      buildResult({
+        [jsFile]: { bytes: 200, inputs: {}, imports: [], exports: [] },
+      }),
+    );
+
+    const output = fs.readFileSync(jsFile, "utf-8");
+    // 문자열 리터럴만 처리됨 (마커 1개)
+    const markerCount = (output.match(/\/\* marker \*\//g) ?? []).length;
+    expect(markerCount).toBe(1);
+    // 변수 참조는 원본 유지
+    expect(output).toContain("_c0");
+  });
+
+  it(".js PostCSS 실패 시에도 다른 .css 파일은 정상 처리된다", async () => {
+    const jsFile = path.join(tmpDir, "fail.js");
+    const cssFile = path.join(tmpDir, "ok.css");
+    const jsCode = [
+      'import * as i0 from "@angular/core";',
+      "class MyComp {}",
+      "MyComp.ɵcmp = i0.ɵɵdefineComponent({",
+      '  styles: [".host { display: flex; }"]',
+      "});",
+    ].join("\n");
+    fs.writeFileSync(jsFile, jsCode);
+    fs.writeFileSync(cssFile, ".ok { color: green; }");
+
+    const throwing: postcss.Plugin = {
+      postcssPlugin: "test-throwing",
+      Once() {
+        throw new Error("js-postcss-error");
+      },
+    };
+
+    const plugin = createPostcssPlugin({ plugins: [throwing] });
+    const onEnd = captureOnEnd(plugin);
+
+    const result = buildResult({
+      [cssFile]: { bytes: 20, inputs: {}, imports: [], exports: [] },
+      [jsFile]: { bytes: 200, inputs: {}, imports: [], exports: [] },
+    });
+    await onEnd(result);
+
+    // 에러가 보고됨
+    expect(result.errors.length).toBeGreaterThanOrEqual(1);
+  });
+});

package/tests/utils/esbuild-scss-plugin.acc.spec.ts

@@ -109,3 +109,4 @@ describe("createScssPlugin — Acceptance", () => {
     }
   });
 });
+

package/tests/utils/hmr-client-script.acc.spec.ts

@@ -5,7 +5,7 @@ import { getHmrClientScript, createHmrPostTransform } from "../../src/dev-server
 describe("HMR 클라이언트 스크립트 통합", () => {
   describe("Scenario: HMR 클라이언트 문법 호환성", () => {
     it("Chrome 61 비호환 문법을 사용하지 않는다", () => {
-      const script = getHmrClientScript("/app/");
+      const script = getHmrClientScript("/app/", 4200);
 
       // optional chaining (?.) 미사용
       expect(script).not.toMatch(/\?\./);
@@ -16,13 +16,13 @@ describe("HMR 클라이언트 스크립트 통합", () => {
     });
 
     it("WebSocket 연결 코드를 포함한다", () => {
-      const script = getHmrClientScript("/app/");
+      const script = getHmrClientScript("/app/", 4200);
       expect(script).toContain("WebSocket");
       expect(script).toContain("ws://");
     });
 
     it("component-update, css-update, full-reload 메시지 핸들러를 포함한다", () => {
-      const script = getHmrClientScript("/app/");
+      const script = getHmrClientScript("/app/", 4200);
       expect(script).toContain("component-update");
       expect(script).toContain("css-update");
       expect(script).toContain("full-reload");
@@ -31,7 +31,7 @@ describe("HMR 클라이언트 스크립트 통합", () => {
     });
 
     it("자동 재연결 로직을 포함한다", () => {
-      const script = getHmrClientScript("/app/");
+      const script = getHmrClientScript("/app/", 4200);
       expect(script).toContain("setTimeout");
       expect(script).toContain("connect");
     });
@@ -77,7 +77,7 @@ describe("HMR 클라이언트 스크립트 통합", () => {
     }
 
     it("css-update 시 msg.files와 매칭되는 link만 cache-busting 적용", () => {
-      const script = getHmrClientScript("/app/");
+      const script = getHmrClientScript("/app/", 4200);
       const { sandbox, triggerMessage, mainLink, vendorLink } = createScriptEnv();
 
       runInNewContext(script, sandbox);
@@ -89,7 +89,7 @@ describe("HMR 클라이언트 스크립트 통합", () => {
     });
 
     it("css-update 시 files에 여러 파일이 있으면 매칭되는 모든 link를 업데이트", () => {
-      const script = getHmrClientScript("/app/");
+      const script = getHmrClientScript("/app/", 4200);
       const { sandbox, triggerMessage, mainLink, vendorLink } = createScriptEnv();
 
       runInNewContext(script, sandbox);
@@ -107,7 +107,7 @@ describe("HMR 클라이언트 스크립트 통합", () => {
 
   describe("Scenario: 스크립트 주입", () => {
     it("postTransform이 </body> 직전에 script 태그를 삽입한다", async () => {
-      const transform = createHmrPostTransform("/app/");
+      const transform = createHmrPostTransform("/app/", 4200);
       const html = "<html><body><div>content</div></body></html>";
       const result = await transform(html);
 
@@ -117,7 +117,7 @@ describe("HMR 클라이언트 스크립트 통합", () => {
     });
 
     it("</body>가 없는 HTML에서도 스크립트를 추가한다", async () => {
-      const transform = createHmrPostTransform("/app/");
+      const transform = createHmrPostTransform("/app/", 4200);
       const html = "<html><body><div>content</div>";
       const result = await transform(html);
 

package/tests/utils/hmr-client-script.spec.ts

@@ -3,19 +3,19 @@ import { getHmrClientScript, createHmrPostTransform } from "../../src/dev-server
 
 describe("getHmrClientScript", () => {
   it("유효한 JavaScript를 생성한다", () => {
-    const script = getHmrClientScript("/app/");
+    const script = getHmrClientScript("/app/", 4200);
     // new Function으로 구문 오류 확인
     expect(() => new Function(script)).not.toThrow();
   });
 
   it("IIFE로 감싸져 있다", () => {
-    const script = getHmrClientScript("/app/");
+    const script = getHmrClientScript("/app/", 4200);
     expect(script.trimStart()).toMatch(/^\(function\(\)/);
     expect(script.trimEnd()).toMatch(/\}\)\(\);$/);
   });
 
   it("const/let 대신 var를 사용한다", () => {
-    const script = getHmrClientScript("/app/");
+    const script = getHmrClientScript("/app/", 4200);
     // var 사용 확인
     expect(script).toContain("var ws");
     // const/let 미사용 확인
@@ -26,7 +26,7 @@ describe("getHmrClientScript", () => {
 
 describe("createHmrPostTransform", () => {
   it("여러 </body> 태그가 있으면 마지막 것 앞에 주입한다", async () => {
-    const transform = createHmrPostTransform("/app/");
+    const transform = createHmrPostTransform("/app/", 4200);
     const html = "<body>first</body><body>second</body>";
     const result = await transform(html);
 
@@ -37,7 +37,7 @@ describe("createHmrPostTransform", () => {
   });
 
   it("빈 HTML에도 스크립트를 추가한다", async () => {
-    const transform = createHmrPostTransform("/");
+    const transform = createHmrPostTransform("/", 4200);
     const result = await transform("");
     expect(result).toContain("<script>");
   });

package/tests/workers/server-build-lint.spec.ts

@@ -32,6 +32,20 @@ vi.mock("../../src/utils/tsc-build", () => ({
   runTscPackageBuild: vi.fn(() => mockTscResult),
 }));
 
+// tsc plugin mock (build() js=true path)
+const mockTscPlugin = {
+  plugin: { name: "sd-tsc", setup: vi.fn() },
+  getProgram: vi.fn(),
+  getAffectedFiles: vi.fn(),
+  getDiagnostics: vi.fn((): unknown[] => []),
+  getErrors: vi.fn((): string[] | undefined => undefined),
+  resetBuilderProgram: vi.fn(),
+};
+
+vi.mock("../../src/esbuild/esbuild-tsc-plugin", () => ({
+  createTscPlugin: vi.fn(() => mockTscPlugin),
+}));
+
 vi.mock("../../src/utils/tsconfig", () => ({
   parseTsconfig: vi.fn(() => ({ options: {}, fileNames: [] })),
   getPackageSourceFiles: vi.fn(() => []),
@@ -107,6 +121,13 @@ beforeEach(() => {
     formattedOutput: "",
   });
   mockTscResult.program = { getSourceFiles: () => [] } as any;
+
+  // Reset tsc plugin mock
+  mockTscPlugin.getProgram.mockReset();
+  mockTscPlugin.getAffectedFiles.mockReset();
+  mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+  mockTscPlugin.getErrors.mockReset().mockReturnValue(undefined);
+  mockTscPlugin.resetBuilderProgram.mockReset();
 });
 
 describe("server-build.worker lint integration (Slice 3)", () => {
@@ -129,6 +150,28 @@ describe("server-build.worker lint integration (Slice 3)", () => {
     });
   });
 
+  describe("Scenario: build js=true runs lint using tscPlugin.getProgram()", () => {
+    it("returns lint result using plugin program when js=true and lint enabled", async () => {
+      const fakeProgram = { getSourceFiles: () => [] };
+      mockTscPlugin.getProgram.mockReturnValue(fakeProgram);
+
+      const result = await workerMethods["build"]({
+        name: "my-server",
+        cwd: "/workspace",
+        pkgDir: "/workspace/packages/my-server",
+        output: { js: true, dts: false, lint: true },
+      });
+
+      expect(result).toHaveProperty("lint");
+      expect(result.lint).toEqual({
+        success: true,
+        errorCount: 0,
+        warningCount: 0,
+        formattedOutput: "",
+      });
+    });
+  });
+
   describe("Scenario: lint disabled", () => {
     it("does not run lint when output.lint is not set", async () => {
       const result = await workerMethods["build"]({

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

@@ -0,0 +1,14 @@
+# server-build.worker.ts 리팩토링 — LLM 검증
+
+## 검증 항목
+
+- [x] rebuildAll()이 startWatch() 내부 클로저로 정의: `server-build.worker.ts:272` — startWatch (`:259`) 내부에 `async function rebuildAll()` 정의 확인
+- [x] lastBuilderProgram이 startWatch 로컬 변수: `server-build.worker.ts:264` — `let lastBuilderProgram` startWatch 함수 스코프 내 정의 확인
+- [x] watchLintRunner가 startWatch 로컬 변수: `server-build.worker.ts:265` — `let watchLintRunner` startWatch 함수 스코프 내 정의 확인
+- [x] watchInfo 모듈 스코프 변수 제거: 모듈 스코프에 `watchInfo` 선언 없음 확인, startWatch의 `info` 파라미터를 직접 사용
+- [x] cleanup()에서 lastBuilderProgram 참조 제거: `server-build.worker.ts:108-123` — cleanup 함수에 lastBuilderProgram 참조 없음 확인
+- [x] startWatch에서 createContext에 tsc 옵션 전달: `server-build.worker.ts:348-359` — `tsc: { cwd, output: { dts }, env, includeTests }` 옵션 포함 확인
+- [x] build() js=true에서 createTscPlugin 로컬 생성: `server-build.worker.ts:153-159` — build 함수 내 `const tscPlugin = createTscPlugin({...})` 확인
+- [x] build() js=false에서 runTscPackageBuild 직접 호출: `server-build.worker.ts:192-199` — `runTscPackageBuild({...})` 직접 호출 확인
+- [x] 외부 인터페이스(ServerBuildInfo/WatchInfo/Result/WorkerEvents) 변경 없음: 타입 정의 `:33-96` 변경 없음 확인
+- [x] runTscPackageBuild import 유지: `server-build.worker.ts:19` — import 존재 확인 (js=false fallback용)

package/tests/workers/server-build-worker.spec.ts

@@ -29,8 +29,8 @@ let mockMetafileInputs: Record<string, unknown> = {};
 // tsc build mock
 const mockRunTscPackageBuild = vi.fn(() => ({
   success: true,
-  errors: undefined,
-  diagnostics: [],
+  errors: undefined as string[] | undefined,
+  diagnostics: [] as unknown[],
   errorCount: 0,
   warningCount: 0,
 }));
@@ -116,6 +116,20 @@ vi.mock("../../src/utils/tsc-build", () => ({
   runTscPackageBuild: mockRunTscPackageBuild,
 }));
 
+// tsc plugin mock (build() js=true path uses createTscPlugin)
+const mockTscPlugin = {
+  plugin: { name: "sd-tsc", setup: vi.fn() },
+  getProgram: vi.fn(),
+  getAffectedFiles: vi.fn(),
+  getDiagnostics: vi.fn((): unknown[] => []),
+  getErrors: vi.fn((): string[] | undefined => undefined),
+  resetBuilderProgram: vi.fn(),
+};
+
+vi.mock("../../src/esbuild/esbuild-tsc-plugin", () => ({
+  createTscPlugin: vi.fn(() => mockTscPlugin),
+}));
+
 vi.mock("../../src/workers/shared-worker-lifecycle", () => {
   let guardCalled = false;
   resetGuard = () => { guardCalled = false; };
@@ -175,7 +189,14 @@ describe("server-build.worker build()", () => {
       diagnostics: [],
       errorCount: 0,
       warningCount: 0,
-      });
+    });
+
+    // Reset tsc plugin mock (used for js=true path)
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset().mockReturnValue(undefined);
+    mockTscPlugin.resetBuilderProgram.mockReset();
 
     // Reset lockfile content and cache
     mockLockfileContent = "";
@@ -212,21 +233,65 @@ describe("server-build.worker build()", () => {
     expect(result.mainJsPath).toBe(path.resolve(baseBuildInfo.pkgDir, "dist", "main.js").replace(/\\/g, "/"));
   });
 
-  // Acceptance: type error detected
+  // Acceptance: type error detected via tsc plugin (js=true)
   it("reports typecheck error in build field", async () => {
+    mockTscPlugin.getErrors.mockReturnValue(["TS2345: type error"]);
+    mockTscPlugin.getDiagnostics.mockReturnValue([{ code: 2345, category: 1 }]);
+
+    const result = await workerFns["build"](baseBuildInfo);
+
+    expect(result.build.success).toBe(false);
+    expect(result.build.errors).toContain("TS2345: type error");
+    expect(result.build.diagnostics).toHaveLength(1);
+  });
+
+  // Acceptance: esbuild + tsc both error — merged
+  it("merges esbuild and tsc errors when both fail", async () => {
+    vi.mocked(esbuild.build).mockResolvedValueOnce({
+      errors: [{ text: "esbuild syntax error" }],
+      warnings: [],
+      outputFiles: [],
+    } as any);
+    mockTscPlugin.getErrors.mockReturnValue(["TS2322: type mismatch"]);
+
+    const result = await workerFns["build"](baseBuildInfo);
+
+    expect(result.build.success).toBe(false);
+    expect(result.build.errors).toContain("esbuild syntax error");
+    expect(result.build.errors).toContain("TS2322: type mismatch");
+  });
+
+  // Acceptance: diagnostics from tsc plugin (js=true)
+  it("includes diagnostics from tsc plugin in build result", async () => {
+    mockTscPlugin.getDiagnostics.mockReturnValue([
+      { code: 2322, category: 1, messageText: "Type mismatch" },
+    ]);
+
+    const result = await workerFns["build"](baseBuildInfo);
+
+    expect(result.build.diagnostics).toHaveLength(1);
+    expect(result.build.diagnostics[0]).toEqual(
+      expect.objectContaining({ code: 2322 }),
+    );
+  });
+
+  // Acceptance: js=false uses runTscPackageBuild directly
+  it("uses runTscPackageBuild directly when output.js=false", async () => {
     mockRunTscPackageBuild.mockReturnValueOnce({
       success: false,
-      errors: ["TS2345: type error"] as any,
+      errors: ["TS2345: type error"],
       diagnostics: [{ code: 2345, category: 1 }] as any,
       errorCount: 1,
       warningCount: 0,
-      });
+    });
 
-    const result = await workerFns["build"](baseBuildInfo);
+    const result = await workerFns["build"]({
+      ...baseBuildInfo,
+      output: { js: false, dts: true },
+    });
 
     expect(result.build.success).toBe(false);
     expect(result.build.errors).toContain("TS2345: type error");
-    expect(result.build.diagnostics).toHaveLength(1);
   });
 
   // Acceptance: esbuild error detected
@@ -466,7 +531,14 @@ describe("server-build.worker startWatch()", () => {
       diagnostics: [],
       errorCount: 0,
       warningCount: 0,
-      });
+    });
+
+    // Reset tsc plugin mock (used for watch mode rebuild)
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset().mockReturnValue(undefined);
+    mockTscPlugin.resetBuilderProgram.mockReset();
 
     mockReadFileSync.mockImplementation((filePath: string) => {
       if (String(filePath).endsWith("package.json")) {
@@ -567,6 +639,47 @@ describe("server-build.worker startWatch()", () => {
     const buildCalls = mockSend.mock.calls.filter((c) => c[0] === "build");
     expect(buildCalls.length).toBeGreaterThanOrEqual(1);
   });
+
+  // Acceptance: rebuildAll js=true — single esbuildCtx.rebuild() call, tsc not called directly
+  it("uses esbuildCtx.rebuild() without direct tsc call in watch mode rebuild", async () => {
+    mockMetafileInputs = { "packages/my-server/src/main.ts": {} };
+
+    await workerFns["startWatch"](watchInfo);
+
+    const onChangeHandler = mockOnChange.mock.calls[0][1] as (
+      changes: Array<{ event: string; path: string }>,
+    ) => Promise<void>;
+
+    mockRebuild.mockClear();
+    mockRunTscPackageBuild.mockClear();
+    mockSend.mockClear();
+
+    const absPath = path.resolve("/workspace", "packages/my-server/src/main.ts").replace(/\\/g, "/");
+    await onChangeHandler([{ event: "change", path: absPath }]);
+
+    // esbuild rebuild should have been called (tsc triggered by plugin inside)
+    expect(mockRebuild).toHaveBeenCalled();
+    // runTscPackageBuild should NOT be called directly for js=true
+    expect(mockRunTscPackageBuild).not.toHaveBeenCalled();
+    // Build event should be sent
+    expect(mockSend).toHaveBeenCalledWith("build", expect.objectContaining({
+      build: expect.objectContaining({ success: true }),
+    }));
+  });
+
+  // Acceptance: startWatch passes tsc options to createContext
+  it("passes tsc options to esbuildCtx.createContext", async () => {
+    await workerFns["startWatch"]({
+      ...watchInfo,
+      output: { js: true, dts: true, env: "node" as any, includeTests: true },
+    });
+
+    expect(esbuild.context).toHaveBeenCalledWith(
+      expect.objectContaining({
+        plugins: [mockTscPlugin.plugin],
+      }),
+    );
+  });
 });
 
 describe("server-build.worker stopWatch()", () => {

package/tests/workers/server-esbuild-context-tsc.verify.md

@@ -0,0 +1,7 @@
+# server-esbuild-context tsc 통합 — LLM 검증
+
+## 검증 항목
+
+- [x] `EsbuildContextOptions.tsc`가 optional이므로 `server-watch-manager.ts:66-71`의 기존 `recreateContext()` 호출이 타입 에러 없이 동작: 확인 — `tsc` 미전달 시 기존 플러그인 재사용 로직 정상
+- [x] `server-watch-manager.spec.ts` 8개 테스트 전부 통과: 확인 — 회귀 없음
+- [x] `server-watch-manager.ts`에 코드 변경 없음: 확인 — 파일 미수정