@simplysm/sd-cli 14.0.30 → 14.0.32

package/tests/utils/hmr-service-dispatcher.acc.spec.ts

@@ -0,0 +1,217 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } from "vitest";
+import fs from "node:fs";
+import path from "path";
+import os from "node:os";
+import http from "node:http";
+import WebSocket from "ws";
+import type esbuild from "esbuild";
+import { createHmrService, type HmrService } from "../../src/dev-server/hmr-service";
+
+describe("HMR 디스패처 통합", () => {
+  let tmpDir: string;
+  let httpServer: http.Server;
+  let hmrService: HmrService;
+  let templateUpdates: Map<string, string>;
+  let port: number;
+
+  beforeAll(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "hmr-dispatcher-acc-"));
+  });
+
+  afterAll(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  beforeEach(async () => {
+    templateUpdates = new Map<string, string>();
+    httpServer = http.createServer((req, res) => {
+      if (!hmrService.handleRequest(req, res)) {
+        res.writeHead(404);
+        res.end();
+      }
+    });
+    hmrService = createHmrService({
+      httpServer,
+      basePath: "/app/",
+      templateUpdates,
+    });
+    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);
+    });
+  });
+
+  afterEach(async () => {
+    hmrService.close();
+    await new Promise<void>((resolve, reject) => {
+      httpServer.close((err) => {
+        if (err != null) reject(err);
+        else resolve();
+      });
+    });
+  });
+
+  function connectWs(): Promise<WebSocket> {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(`ws://127.0.0.1:${port}`);
+      ws.on("open", () => resolve(ws));
+      ws.on("error", reject);
+    });
+  }
+
+  function waitForMessage(ws: WebSocket): Promise<Record<string, unknown>> {
+    return new Promise((resolve) => {
+      ws.on("message", (data) => {
+        resolve(JSON.parse(data.toString()) as Record<string, unknown>);
+      });
+    });
+  }
+
+  describe("Scenario: template 변경 → component-update 메시지", () => {
+    it("templateUpdates에 entry가 있으면 component-update 메시지를 전송한다", async () => {
+      const ws = await connectWs();
+      const msgPromise = waitForMessage(ws);
+
+      // templateUpdates 채우기 (createCompilerPlugin이 빌드 중 채움)
+      const componentId = encodeURIComponent("src/app/app.component.ts@AppComponent");
+      templateUpdates.set(componentId, "export function update() {}");
+
+      // onBuildEnd 호출 (esbuild onEnd에서 호출됨)
+      const fakeMetafile: esbuild.Metafile = {
+        inputs: {},
+        outputs: {
+          "dist/main.js": {
+            bytes: 1000,
+            inputs: {},
+            imports: [],
+            exports: [],
+            entryPoint: "src/main.ts",
+          },
+        },
+      };
+      hmrService.onBuildEnd(fakeMetafile);
+
+      // 100ms 디바운스 + 여유
+      const msg = await msgPromise;
+      expect(msg["type"]).toBe("component-update");
+      expect(msg["ids"]).toEqual([componentId]);
+      expect(msg["timestamp"]).toBeTypeOf("number");
+
+      ws.close();
+    });
+  });
+
+  describe("Scenario: TS 로직 변경 → full-reload 메시지", () => {
+    it("templateUpdates가 비어있고 JS 출력이 변경되면 full-reload를 전송한다", async () => {
+      const ws = await connectWs();
+      const msgPromise = waitForMessage(ws);
+
+      // 초기 metafile 설정 (이전 빌드)
+      const prevMetafile: esbuild.Metafile = {
+        inputs: {},
+        outputs: {
+          "dist/main.js": {
+            bytes: 1000,
+            inputs: {},
+            imports: [],
+            exports: [],
+            entryPoint: "src/main.ts",
+          },
+        },
+      };
+      hmrService.onBuildEnd(prevMetafile);
+
+      // 첫 번째 메시지 소비 (초기 빌드)
+      await msgPromise;
+
+      // 두 번째 빌드: JS 크기 변경
+      const ws2 = await connectWs();
+      const msgPromise2 = waitForMessage(ws2);
+
+      templateUpdates.clear();
+      const newMetafile: esbuild.Metafile = {
+        inputs: {},
+        outputs: {
+          "dist/main.js": {
+            bytes: 2000, // 변경됨
+            inputs: {},
+            imports: [],
+            exports: [],
+            entryPoint: "src/main.ts",
+          },
+        },
+      };
+      hmrService.onBuildEnd(newMetafile);
+
+      const msg2 = await msgPromise2;
+      expect(msg2["type"]).toBe("full-reload");
+
+      ws.close();
+      ws2.close();
+    });
+  });
+
+  describe("Scenario: CSS-only 변경 → css-update 메시지", () => {
+    it("JS 출력은 동일하고 CSS만 변경되면 css-update를 전송한다", async () => {
+      // 초기 빌드
+      const prevMetafile: esbuild.Metafile = {
+        inputs: {},
+        outputs: {
+          "dist/main.js": {
+            bytes: 1000,
+            inputs: {},
+            imports: [],
+            exports: [],
+            entryPoint: "src/main.ts",
+          },
+          "dist/main.css": {
+            bytes: 500,
+            inputs: {},
+            imports: [],
+            exports: [],
+          },
+        },
+      };
+      hmrService.onBuildEnd(prevMetafile);
+
+      // 첫 번째 빌드의 100ms 디바운스 완료 대기
+      await new Promise((r) => setTimeout(r, 150));
+
+      // 두 번째 빌드: CSS만 변경
+      const ws = await connectWs();
+      const msgPromise = waitForMessage(ws);
+
+      templateUpdates.clear();
+      const newMetafile: esbuild.Metafile = {
+        inputs: {},
+        outputs: {
+          "dist/main.js": {
+            bytes: 1000, // 동일
+            inputs: {},
+            imports: [],
+            exports: [],
+            entryPoint: "src/main.ts",
+          },
+          "dist/main.css": {
+            bytes: 800, // 변경됨
+            inputs: {},
+            imports: [],
+            exports: [],
+          },
+        },
+      };
+      hmrService.onBuildEnd(newMetafile);
+
+      const msg = await msgPromise;
+      expect(msg["type"]).toBe("css-update");
+      expect(msg["files"]).toContain("main.css");
+      expect(msg["timestamp"]).toBeTypeOf("number");
+
+      ws.close();
+    });
+  });
+});

package/tests/utils/hmr-service-dispatcher.spec.ts

@@ -0,0 +1,143 @@
+import { describe, it, expect, afterEach } from "vitest";
+import http from "node:http";
+import WebSocket from "ws";
+import type esbuild from "esbuild";
+import { createHmrService, type HmrService } from "../../src/dev-server/hmr-service";
+
+describe("HmrService 디스패처 단위 테스트", () => {
+  let httpServer: http.Server;
+  let hmrService: HmrService;
+  let templateUpdates: Map<string, string>;
+  let port: number;
+
+  function setup(): Promise<number> {
+    templateUpdates = new Map<string, string>();
+    httpServer = http.createServer((_req, res) => {
+      res.writeHead(404);
+      res.end();
+    });
+    hmrService = createHmrService({
+      httpServer,
+      basePath: "/app/",
+      templateUpdates,
+    });
+    return new Promise<number>((resolve, reject) => {
+      httpServer.listen(0, "127.0.0.1", () => {
+        const addr = httpServer.address();
+        if (typeof addr === "object" && addr != null) {
+          port = addr.port;
+          resolve(addr.port);
+        } else {
+          reject(new Error("포트 감지 실패"));
+        }
+      });
+      httpServer.on("error", reject);
+    });
+  }
+
+  afterEach(async () => {
+    hmrService.close();
+    await new Promise<void>((resolve, reject) => {
+      httpServer.close((err) => {
+        if (err != null) reject(err);
+        else resolve();
+      });
+    });
+  });
+
+  function connectWs(): Promise<WebSocket> {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(`ws://127.0.0.1:${port}`);
+      ws.on("open", () => resolve(ws));
+      ws.on("error", reject);
+    });
+  }
+
+  function waitForMessage(ws: WebSocket): Promise<Record<string, unknown>> {
+    return new Promise((resolve) => {
+      ws.once("message", (data) => {
+        resolve(JSON.parse(data.toString()) as Record<string, unknown>);
+      });
+    });
+  }
+
+  function makeMetafile(outputs: Record<string, { bytes: number; entryPoint?: string }>): esbuild.Metafile {
+    const result: esbuild.Metafile = { inputs: {}, outputs: {} };
+    for (const [key, value] of Object.entries(outputs)) {
+      result.outputs[key] = {
+        bytes: value.bytes,
+        inputs: {},
+        imports: [],
+        exports: [],
+        ...(value.entryPoint != null ? { entryPoint: value.entryPoint } : {}),
+      };
+    }
+    return result;
+  }
+
+  describe("onBuildEnd 디바운싱", () => {
+    it("100ms 내에 여러 호출이 오면 마지막 metafile로 한 번만 디스패치한다", async () => {
+      await setup();
+      const ws = await connectWs();
+      const messages: Record<string, unknown>[] = [];
+      ws.on("message", (data) => {
+        messages.push(JSON.parse(data.toString()) as Record<string, unknown>);
+      });
+
+      // 빠른 연속 호출
+      hmrService.onBuildEnd(makeMetafile({ "dist/main.js": { bytes: 100 } }));
+      hmrService.onBuildEnd(makeMetafile({ "dist/main.js": { bytes: 200 } }));
+      hmrService.onBuildEnd(makeMetafile({ "dist/main.js": { bytes: 300 } }));
+
+      // 150ms 대기 (디바운스 + 여유)
+      await new Promise((r) => setTimeout(r, 150));
+
+      expect(messages).toHaveLength(1);
+      expect(messages[0]["type"]).toBe("full-reload"); // 첫 빌드이므로 full-reload
+
+      ws.close();
+    });
+  });
+
+  describe("변경 없는 리빌드", () => {
+    it("출력이 동일하면 full-reload를 전송한다", async () => {
+      await setup();
+      const metafile = makeMetafile({ "dist/main.js": { bytes: 1000 } });
+
+      // 첫 빌드
+      hmrService.onBuildEnd(metafile);
+      await new Promise((r) => setTimeout(r, 150));
+
+      // 두 번째 빌드 (동일)
+      const ws = await connectWs();
+      const msgPromise = waitForMessage(ws);
+
+      templateUpdates.clear();
+      hmrService.onBuildEnd(metafile);
+
+      const msg = await msgPromise;
+      expect(msg["type"]).toBe("full-reload");
+
+      ws.close();
+    });
+  });
+
+  describe("component-update에 여러 컴포넌트 ID", () => {
+    it("templateUpdates에 여러 entry가 있으면 모든 ID를 전송한다", async () => {
+      await setup();
+      const ws = await connectWs();
+      const msgPromise = waitForMessage(ws);
+
+      templateUpdates.set("id1", "code1");
+      templateUpdates.set("id2", "code2");
+
+      hmrService.onBuildEnd(makeMetafile({ "dist/main.js": { bytes: 1000 } }));
+
+      const msg = await msgPromise;
+      expect(msg["type"]).toBe("component-update");
+      expect(msg["ids"]).toEqual(["id1", "id2"]);
+
+      ws.close();
+    });
+  });
+});

package/tests/utils/hmr-service.acc.spec.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } from "vitest";
+import fs from "node:fs";
+import path from "path";
+import os from "node:os";
+import WebSocket from "ws";
+import { createDevHttpServer, type DevHttpServer } from "../../src/dev-server/dev-http-server";
+import { createHmrService, type HmrService } from "../../src/dev-server/hmr-service";
+
+describe("HMR Service 통합", () => {
+  let tmpDir: string;
+  let distDir: string;
+  let server: DevHttpServer | undefined;
+  let hmrService: HmrService | undefined;
+  let port: number;
+
+  beforeAll(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "hmr-service-acc-"));
+    distDir = path.join(tmpDir, "dist");
+  });
+
+  afterAll(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  beforeEach(() => {
+    fs.mkdirSync(distDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    hmrService?.close();
+    if (server?.port != null) {
+      await server.close();
+    }
+    fs.rmSync(distDir, { recursive: true, force: true });
+  });
+
+  async function setupServerWithHmr(
+    templateUpdates?: Map<string, string>,
+  ): Promise<void> {
+    const updates = templateUpdates ?? new Map<string, string>();
+
+    // dev-http-server 먼저 생성 (httpServer 인스턴스 필요)
+    server = createDevHttpServer({
+      distDir,
+      basePath: "/app/",
+      port: 0,
+      onRequest: (req, res) => hmrService!.handleRequest(req, res),
+    });
+
+    // hmrService 생성 (httpServer에 WebSocket 연결)
+    hmrService = createHmrService({
+      httpServer: server.httpServer,
+      basePath: "/app/",
+      templateUpdates: updates,
+    });
+
+    port = await server.listen();
+  }
+
+  function connectWs(): Promise<WebSocket> {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(`ws://127.0.0.1:${port}`);
+      ws.on("open", () => resolve(ws));
+      ws.on("error", reject);
+    });
+  }
+
+  describe("Scenario: WebSocket 연결 + /@ng/component 통합", () => {
+    it("WebSocket으로 연결하고 /@ng/component 엔드포인트에서 templateUpdates 조회가 가능하다", async () => {
+      const templateUpdates = new Map<string, string>();
+      templateUpdates.set(
+        "src/app/app.component.ts@AppComponent",
+        'export function AppComponent_UpdateMetadata() {}',
+      );
+
+      await setupServerWithHmr(templateUpdates);
+
+      // WebSocket 연결 확인
+      const ws = await connectWs();
+      expect(ws.readyState).toBe(WebSocket.OPEN);
+
+      // /@ng/component 엔드포인트 확인
+      const res = await fetch(
+        `http://127.0.0.1:${port}/app/@ng/component?c=${encodeURIComponent("src/app/app.component.ts@AppComponent")}`,
+      );
+      expect(res.status).toBe(200);
+      expect(res.headers.get("content-type")).toBe("text/javascript");
+      expect(res.headers.get("cache-control")).toBe("no-cache");
+      const body = await res.text();
+      expect(body).toBe('export function AppComponent_UpdateMetadata() {}');
+
+      ws.close();
+    });
+  });
+
+  describe("Scenario: 다중 클라이언트 브로드캐스트", () => {
+    it("3개의 WebSocket 클라이언트에 동시에 메시지를 전송한다", async () => {
+      await setupServerWithHmr();
+
+      const clients = await Promise.all([connectWs(), connectWs(), connectWs()]);
+      const messages: string[] = [];
+
+      const messagePromises = clients.map(
+        (ws) =>
+          new Promise<string>((resolve) => {
+            ws.on("message", (data) => {
+              const msg = data.toString();
+              messages.push(msg);
+              resolve(msg);
+            });
+          }),
+      );
+
+      // 브로드캐스트
+      hmrService!.broadcast({ type: "full-reload" });
+
+      await Promise.all(messagePromises);
+      expect(messages).toHaveLength(3);
+      for (const msg of messages) {
+        expect(JSON.parse(msg)).toEqual({ type: "full-reload" });
+      }
+
+      for (const ws of clients) ws.close();
+    });
+  });
+
+  describe("Scenario: 없는 componentId 요청", () => {
+    it("존재하지 않는 componentId 요청 시 200 + 빈 본문을 반환한다", async () => {
+      await setupServerWithHmr();
+
+      const res = await fetch(
+        `http://127.0.0.1:${port}/app/@ng/component?c=nonexistent`,
+      );
+      expect(res.status).toBe(200);
+      const body = await res.text();
+      expect(body).toBe("");
+    });
+  });
+});

package/tests/utils/hmr-service.spec.ts

@@ -0,0 +1,131 @@
+import { describe, it, expect, afterEach } from "vitest";
+import http from "node:http";
+import WebSocket from "ws";
+import { createHmrService, type HmrService } from "../../src/dev-server/hmr-service";
+
+describe("createHmrService", () => {
+  let httpServer: http.Server;
+  let hmrService: HmrService;
+  let port: number;
+
+  function setup(templateUpdates?: Map<string, string>): Promise<number> {
+    const updates = templateUpdates ?? new Map<string, string>();
+    httpServer = http.createServer((req, res) => {
+      if (!hmrService.handleRequest(req, res)) {
+        res.writeHead(404);
+        res.end("Not Found");
+      }
+    });
+    hmrService = createHmrService({
+      httpServer,
+      basePath: "/app/",
+      templateUpdates: updates,
+    });
+    return new Promise<number>((resolve, reject) => {
+      httpServer.listen(0, "127.0.0.1", () => {
+        const addr = httpServer.address();
+        if (typeof addr === "object" && addr != null) {
+          port = addr.port;
+          resolve(addr.port);
+        } else {
+          reject(new Error("포트 감지 실패"));
+        }
+      });
+      httpServer.on("error", reject);
+    });
+  }
+
+  afterEach(async () => {
+    hmrService.close();
+    await new Promise<void>((resolve, reject) => {
+      httpServer.close((err) => {
+        if (err != null) reject(err);
+        else resolve();
+      });
+    });
+  });
+
+  function connectWs(): Promise<WebSocket> {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(`ws://127.0.0.1:${port}`);
+      ws.on("open", () => resolve(ws));
+      ws.on("error", reject);
+    });
+  }
+
+  describe("broadcast", () => {
+    it("연결된 클라이언트가 없으면 에러 없이 실행된다", async () => {
+      await setup();
+      expect(() => hmrService.broadcast({ type: "full-reload" })).not.toThrow();
+    });
+
+    it("닫힌 클라이언트는 메시지를 수신하지 않는다", async () => {
+      await setup();
+      const ws = await connectWs();
+      ws.close();
+      // close 완료 대기
+      await new Promise<void>((resolve) => ws.on("close", resolve));
+
+      expect(() => hmrService.broadcast({ type: "full-reload" })).not.toThrow();
+    });
+  });
+
+  describe("handleRequest", () => {
+    it("/@ng/component 경로가 아닌 요청은 false를 반환한다", async () => {
+      await setup();
+      const res = await fetch(`http://127.0.0.1:${port}/app/main.js`);
+      expect(res.status).toBe(404); // handleRequest가 false → 404 반환
+    });
+
+    it("basePath 없는 /@ng/component 요청은 false를 반환한다", async () => {
+      await setup();
+      const res = await fetch(`http://127.0.0.1:${port}/@ng/component?c=test`);
+      expect(res.status).toBe(404);
+    });
+
+    it("c 파라미터가 없으면 빈 문자열로 조회한다", async () => {
+      const updates = new Map<string, string>();
+      updates.set("", "empty-id-content");
+      await setup(updates);
+
+      const res = await fetch(`http://127.0.0.1:${port}/app/@ng/component`);
+      expect(res.status).toBe(200);
+      // c 파라미터 없음 → componentId = "" → encodeURIComponent("") = "" → "empty-id-content"
+      const body = await res.text();
+      expect(body).toBe("empty-id-content");
+    });
+
+    it("componentId로 templateUpdates를 직접 조회한다 (인코딩 없이)", async () => {
+      const updates = new Map<string, string>();
+      const rawId = "src/components/my-comp.ts@MyComp";
+      updates.set(rawId, "raw-key-content");
+      await setup(updates);
+
+      const res = await fetch(
+        `http://127.0.0.1:${port}/app/@ng/component?c=${encodeURIComponent(rawId)}`,
+      );
+      expect(res.status).toBe(200);
+      const body = await res.text();
+      expect(body).toBe("raw-key-content");
+    });
+  });
+
+  describe("인터페이스 계약", () => {
+    it("반환 객체에 onBuildStart가 없다", async () => {
+      await setup();
+      expect(hmrService).not.toHaveProperty("onBuildStart");
+    });
+  });
+
+  describe("close", () => {
+    it("close 후 WebSocket 연결이 종료된다", async () => {
+      await setup();
+      const ws = await connectWs();
+      const closePromise = new Promise<void>((resolve) => ws.on("close", resolve));
+
+      hmrService.close();
+      await closePromise;
+      expect(ws.readyState).toBe(WebSocket.CLOSED);
+    });
+  });
+});

package/tests/utils/hmr-service.verify.md

@@ -0,0 +1,17 @@
+# HMR Service — LLM 검증
+
+## 검증 항목
+
+- [x] ws 의존성이 sd-cli package.json dependencies에 추가되었는가: `"ws": "^8.20.0"` 확인 (package.json:51)
+- [x] @types/ws가 sd-cli package.json devDependencies에 추가되었는가: `"@types/ws": "^8.18.1"` 확인 (package.json:57)
+- [x] dev-http-server.ts의 onRequest 훅 타입 시그니처가 올바른가: `onRequest?: (req: http.IncomingMessage, res: http.ServerResponse) => boolean` — Node.js 표준 타입 사용, boolean 반환으로 처리 완료 여부 표시
+- [x] hmr-service.ts의 handleRequest가 angularComponentMiddleware와 동일한 encodeURIComponent 패턴을 사용하는가: `templateUpdates.get(encodeURIComponent(componentId))` (hmr-service.ts:65) — vite-angular-plugin.ts:553과 동일 패턴
+- [x] WebSocketServer가 httpServer의 upgrade 이벤트를 통해 연결되는가: `new WebSocketServer({ server: httpServer })` (hmr-service.ts:27) — ws 라이브러리가 httpServer의 upgrade 이벤트를 자동 처리
+
+## Slice 2 검증 항목
+
+- [x] import.meta.hot 폴리필이 esbuild banner로 주입되는가: `esbuild-client-config.ts`에서 `templateUpdates != null && legacyModule !== true` 조건으로 banner 생성. `import.meta.hot.on()`, `import.meta.hot.off()`, `globalThis.__hmr_dispatch()` 제공.
+- [x] legacyModule일 때 폴리필이 주입되지 않는가: `options.legacyModule !== true` 조건으로 legacyModule에서 banner 미생성.
+- [x] ngHmrMode 가드가 있어 prod에서 실행되지 않는가: banner 코드가 `if(typeof ngHmrMode!=="undefined"&&ngHmrMode)` 가드로 래핑. prod에서 `ngHmrMode="false"`로 정의되므로 실행 안됨.
+- [x] sd-hmr-reset 플러그인이 onStart에서 templateUpdates.clear()를 호출하는가: `esbuild-client-config.ts`에 `sd-hmr-reset` 플러그인 추가. `build.onStart(() => { options.templateUpdates!.clear(); })` 확인.
+- [x] sd-hmr-reset이 angularPlugin보다 먼저 등록되는가: plugins 배열에서 `sd-hmr-reset`이 첫 번째 위치 (angularPlugin, scssPlugin보다 앞). createCompilerPlugin이 templateUpdates에 쓰기 전에 clear됨.

package/tests/utils/lint-core.spec.ts

@@ -1,3 +1,4 @@
+/* eslint-disable no-restricted-properties -- 테스트 환경변수 조작 필요 */
 import { describe, it, expect, vi, beforeEach } from "vitest";
 
 // Hoisted mock references — available inside vi.mock factories
@@ -32,7 +33,7 @@ vi.mock("jiti", () => ({
   createJiti: vi.fn(() => ({ import: mocks.jitiImport })),
 }));
 
-const { loadIgnorePatterns, executeLint } = await import("../../src/utils/lint-core");
+const { loadIgnorePatterns, executeLint } = await import("../../src/lint/lint-core");
 
 //#region loadIgnorePatterns
 

package/tests/utils/lint-utils.spec.ts

@@ -14,7 +14,7 @@ vi.mock("@simplysm/core-node", () => ({
   },
 }));
 
-const { runLintInWorker } = await import("../../src/utils/lint-utils");
+const { runLintInWorker } = await import("../../src/lint/lint-utils");
 
 //#endregion
 

package/tests/utils/lint-with-program.spec.ts

@@ -31,7 +31,7 @@ const mockLintLogger = {
 
 vi.spyOn(consola, "withTag").mockReturnValue(mockLintLogger as any);
 
-const { LintWithProgramRunner } = await import("../../src/utils/lint-with-program");
+const { LintWithProgramRunner } = await import("../../src/lint/lint-with-program");
 
 // --- Helpers ---