@simplysm/sd-cli 14.0.38 → 14.0.39

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

@@ -0,0 +1,299 @@
+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 ---
+
+/** PostCSS 플러그인: CSS 앞에 마커 주석을 추가한다 */
+function markerPlugin(): postcss.Plugin {
+  return {
+    postcssPlugin: "test-marker",
+    Once(root) {
+      root.prepend(new postcss.Comment({ text: "marker" }));
+    },
+  };
+}
+
+/** PostCSS 플러그인: 항상 예외를 발생시킨다 */
+function throwingPlugin(): postcss.Plugin {
+  return {
+    postcssPlugin: "test-throwing",
+    Once() {
+      throw new Error("postcss-boom");
+    },
+  };
+}
+
+/** esbuild 플러그인에서 onEnd 콜백을 캡처한다 */
+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;
+}
+
+/** 최소한의 esbuild BuildResult를 생성한다 */
+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 — Acceptance", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "postcss-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  // Scenario: .css 파일에 PostCSS 적용
+  it(".css 파일의 내용이 PostCSS 플러그인으로 변환되어 덮어쓰기된다", async () => {
+    const cssFile = path.join(tmpDir, "main.css");
+    fs.writeFileSync(cssFile, ".host { display: flex; }");
+
+    const plugin = createPostcssPlugin({ plugins: [markerPlugin()] });
+    const onEnd = captureOnEnd(plugin);
+
+    await onEnd(
+      buildResult({
+        [cssFile]: { bytes: 100, inputs: {}, imports: [], exports: [] },
+      }),
+    );
+
+    const output = fs.readFileSync(cssFile, "utf-8");
+    expect(output).toContain("/* marker */");
+    expect(output).toContain("display: flex");
+  });
+
+  // Scenario: .css 확장자가 아닌 파일은 CSS 전체 처리 대상에서 제외
+  it(".js 파일은 CSS 전체 적용 로직에서 처리되지 않아 원본이 유지된다", async () => {
+    const jsFile = path.join(tmpDir, "main.js");
+    const original = 'console.log("hello");';
+    fs.writeFileSync(jsFile, original);
+
+    const plugin = createPostcssPlugin({ plugins: [markerPlugin()] });
+    const onEnd = captureOnEnd(plugin);
+
+    await onEnd(
+      buildResult({
+        [jsFile]: { bytes: 100, inputs: {}, imports: [], exports: [] },
+      }),
+    );
+
+    expect(fs.readFileSync(jsFile, "utf-8")).toBe(original);
+  });
+
+  // Scenario: 빈 PostCSS 플러그인 배열로 생성 시 파일 처리 없음
+  it("빈 플러그인 배열이면 .css 파일을 읽지도 수정하지도 않는다", async () => {
+    const cssFile = path.join(tmpDir, "main.css");
+    const original = ".host { display: flex; }";
+    fs.writeFileSync(cssFile, original);
+
+    const plugin = createPostcssPlugin({ plugins: [] });
+    const onEnd = captureOnEnd(plugin);
+
+    await onEnd(
+      buildResult({
+        [cssFile]: { bytes: 100, inputs: {}, imports: [], exports: [] },
+      }),
+    );
+
+    expect(fs.readFileSync(cssFile, "utf-8")).toBe(original);
+  });
+
+  // Scenario: .css 파일 PostCSS 적용 실패 시 esbuild error 추가
+  it("PostCSS 실패 시 result.errors에 파일 경로와 에러 메시지가 추가된다", async () => {
+    const cssFile = path.join(tmpDir, "broken.css");
+    fs.writeFileSync(cssFile, ".host { display: flex; }");
+
+    const plugin = createPostcssPlugin({ plugins: [throwingPlugin()] });
+    const onEnd = captureOnEnd(plugin);
+
+    const result = buildResult({
+      [cssFile]: { bytes: 100, inputs: {}, imports: [], exports: [] },
+    });
+    await onEnd(result);
+
+    expect(result.errors).toHaveLength(1);
+    expect(result.errors[0].text).toContain("postcss-boom");
+    expect(result.errors[0].text).toContain(cssFile);
+  });
+
+  // --- Slice 2: .js 파일 AST 기반 inline CSS ---
+
+  // Scenario: ɵɵdefineComponent 내 단일 styles 문자열에 PostCSS 적용
+  it("ɵɵdefineComponent 내 styles 문자열에 PostCSS가 적용되어 내용이 변환된다", async () => {
+    const jsFile = path.join(tmpDir, "main.js");
+    const code = [
+      'import * as i0 from "@angular/core";',
+      "class MyComp {}",
+      "MyComp.ɵcmp = i0.ɵɵdefineComponent({",
+      '  styles: [".host { display: flex; }"]',
+      "});",
+    ].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");
+    expect(output).toContain("/* marker */");
+    expect(output).toContain("display: flex");
+    // 원본 JS 구조가 유지되어야 한다
+    expect(output).toContain("ɵɵdefineComponent");
+  });
+
+  // Scenario: ɵɵdefineComponent 내 복수 styles 문자열에 각각 PostCSS 적용
+  it("복수 styles 문자열에 각각 독립적으로 PostCSS가 적용된다", async () => {
+    const jsFile = path.join(tmpDir, "multi.js");
+    const code = [
+      'import * as i0 from "@angular/core";',
+      "class MyComp {}",
+      "MyComp.ɵcmp = i0.ɵɵdefineComponent({",
+      '  styles: [".a { color: red; }", ".b { color: blue; }"]',
+      "});",
+    ].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");
+    // 마커가 각 문자열에 독립적으로 적용됨 → 2회 등장
+    const markerCount = (output.match(/\/\* marker \*\//g) ?? []).length;
+    expect(markerCount).toBe(2);
+  });
+
+  // Scenario: styles 배열이 비어 있으면 파일 수정 안 함
+  it("styles 배열이 비어 있으면 .js 파일이 수정되지 않는다", async () => {
+    const jsFile = path.join(tmpDir, "empty.js");
+    const code = [
+      'import * as i0 from "@angular/core";',
+      "class MyComp {}",
+      "MyComp.ɵcmp = i0.ɵɵdefineComponent({",
+      "  styles: []",
+      "});",
+    ].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);
+  });
+
+  // Scenario: ɵɵdefineComponent 외부의 styles 속성은 무시
+  it("ɵɵdefineComponent 외부의 styles 속성은 처리되지 않는다", async () => {
+    const jsFile = path.join(tmpDir, "outside.js");
+    const code = [
+      'const config = { styles: [".host { display: flex; }"] };',
+      "export default config;",
+    ].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);
+  });
+
+  // Scenario: 한 .js 파일 내 여러 ɵɵdefineComponent의 styles 모두 처리
+  it("한 파일 내 여러 ɵɵdefineComponent의 styles 모두에 PostCSS가 적용된다", async () => {
+    const jsFile = path.join(tmpDir, "bundle.js");
+    const code = [
+      'import * as i0 from "@angular/core";',
+      "class CompA {}",
+      "CompA.ɵcmp = i0.ɵɵdefineComponent({",
+      '  styles: [".a { color: red; }"]',
+      "});",
+      "class CompB {}",
+      "CompB.ɵcmp = i0.ɵɵdefineComponent({",
+      '  styles: [".b { color: blue; }"]',
+      "});",
+    ].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");
+    const markerCount = (output.match(/\/\* marker \*\//g) ?? []).length;
+    expect(markerCount).toBe(2);
+    expect(output).toContain("color: red");
+    expect(output).toContain("color: blue");
+  });
+
+  // Scenario: .js 파일 inline CSS PostCSS 적용 실패 시 esbuild error 추가
+  it(".js inline CSS PostCSS 실패 시 result.errors에 에러가 추가된다", async () => {
+    const jsFile = path.join(tmpDir, "fail.js");
+    const code = [
+      'import * as i0 from "@angular/core";',
+      "class MyComp {}",
+      "MyComp.ɵcmp = i0.ɵɵdefineComponent({",
+      '  styles: [".host { display: flex; }"]',
+      "});",
+    ].join("\n");
+    fs.writeFileSync(jsFile, code);
+
+    const plugin = createPostcssPlugin({ plugins: [throwingPlugin()] });
+    const onEnd = captureOnEnd(plugin);
+
+    const result = buildResult({
+      [jsFile]: { bytes: 200, inputs: {}, imports: [], exports: [] },
+    });
+    await onEnd(result);
+
+    expect(result.errors.length).toBeGreaterThanOrEqual(1);
+    expect(result.errors[0].text).toContain("postcss-boom");
+    expect(result.errors[0].text).toContain(jsFile);
+  });
+});

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/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용)