@simplysm/sd-cli 14.0.37 → 14.0.39

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-service-dispatcher.acc.spec.ts

@@ -155,6 +155,76 @@ describe("HMR 디스패처 통합", () => {
     });
   });
 
+  describe("Scenario: 파일 크기 동일하지만 내용 변경 → 변경 감지", () => {
+    it("CSS 내용이 변경되었지만 크기가 동일한 경우 css-update를 전송한다", async () => {
+      // 임시 dist 디렉토리에 CSS 파일 생성
+      const distDir = path.join(tmpDir, "dist-hash-test");
+      fs.mkdirSync(distDir, { recursive: true });
+      fs.writeFileSync(path.join(distDir, "main.css"), "body { color: red; }");
+      fs.writeFileSync(path.join(distDir, "main.js"), "console.log('hello');");
+
+      // outDir을 전달하는 HMR 서비스 생성
+      hmrService.close();
+      await new Promise<void>((resolve, reject) => {
+        httpServer.close((err) => {
+          if (err != null) reject(err);
+          else resolve();
+        });
+      });
+
+      httpServer = http.createServer((_req, res) => { res.writeHead(404); res.end(); });
+      hmrService = createHmrService({
+        httpServer,
+        basePath: "/app/",
+        templateUpdates,
+        outDir: distDir,
+      });
+      port = await new Promise<number>((resolve, reject) => {
+        httpServer.listen(0, "127.0.0.1", () => {
+          const addr = httpServer.address();
+          if (typeof addr === "object" && addr != null) resolve(addr.port);
+          else reject(new Error("포트 감지 실패"));
+        });
+        httpServer.on("error", reject);
+      });
+
+      const cssContent = "body { color: red; }";
+      const metafile1: esbuild.Metafile = {
+        inputs: {},
+        outputs: {
+          "main.js": { bytes: 22, inputs: {}, imports: [], exports: [] },
+          "main.css": { bytes: cssContent.length, inputs: {}, imports: [], exports: [] },
+        },
+      };
+
+      // 첫 빌드 (baseline)
+      hmrService.onBuildEnd(metafile1);
+      await new Promise((r) => setTimeout(r, 150));
+
+      // CSS 내용 변경 (같은 크기)
+      const newCssContent = "body { color: blu; }"; // 같은 길이
+      fs.writeFileSync(path.join(distDir, "main.css"), newCssContent);
+
+      const ws = await connectWs();
+      const msgPromise = waitForMessage(ws);
+
+      const metafile2: esbuild.Metafile = {
+        inputs: {},
+        outputs: {
+          "main.js": { bytes: 22, inputs: {}, imports: [], exports: [] },
+          "main.css": { bytes: newCssContent.length, inputs: {}, imports: [], exports: [] },
+        },
+      };
+      hmrService.onBuildEnd(metafile2);
+
+      const msg = await msgPromise;
+      expect(msg["type"]).toBe("css-update");
+
+      ws.close();
+      fs.rmSync(distDir, { recursive: true, force: true });
+    });
+  });
+
   describe("Scenario: CSS-only 변경 → css-update 메시지", () => {
     it("JS 출력은 동일하고 CSS만 변경되면 css-update를 전송한다", async () => {
       // 초기 빌드

package/tests/workers/client-worker-initial-build-error.verify.md

@@ -0,0 +1,8 @@
+# 초기 빌드 에러 보고 — LLM 검증
+
+## 검증 항목
+
+- [x] client.worker.ts onEnd에서 초기 빌드 시 errors 필드가 포함되는지: `client.worker.ts:285-291` — `initialBuildResolve`에 `errors: result.errors.map((e) => e.text)` 포함 확인
+- [x] EsbuildClientEngine.startWatch에서 반환값의 success 확인 후 에러 로깅하는지: `EsbuildClientEngine.ts:135-137` — `result != null && !result.success` 조건으로 `logger.error` 호출 확인. 테스트 실행 시 `[my-client] 초기 빌드 실패: Module not found: @angular/core; Syntax error in app.ts` 출력 확인
+- [x] esbuild-client-config.ts에서 dev 모드 logLevel이 "warning"인지: `esbuild-client-config.ts:169` — `logLevel: isDev ? "warning" : "silent"` 확인. `isDev = options.mode === "dev"` (line 52)
+- [x] esbuild-client-config.ts에서 build 모드 logLevel이 "silent"인지: 동일 라인 — 삼항 연산자의 false 분기가 `"silent"` 확인

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`에 코드 변경 없음: 확인 — 파일 미수정