@simplysm/sd-cli 14.0.16 → 14.0.17

package/src/workers/server-runtime.worker.ts

@@ -1,10 +1,10 @@
 import { createWorker } from "@simplysm/core-node";
-import { err as errNs } from "@simplysm/core-common";
+import { env, err as errNs } from "@simplysm/core-common";
 import { consola } from "consola";
 import proxy from "@fastify/http-proxy";
 import net from "net";
 import { pathToFileURL } from "url";
-import { registerCleanupHandlers, applyDebugLevel } from "../utils/worker-utils";
+import { registerCleanupHandlers, setupWorkerConsola } from "../utils/worker-utils";
 
 //#region Types
 
@@ -42,7 +42,7 @@ export interface ServerRuntimeWorkerEvents extends Record<string, unknown> {
 
 //#endregion
 
-applyDebugLevel();
+setupWorkerConsola();
 
 const logger = consola.withTag("sd:cli:server-runtime:worker");
 
@@ -122,7 +122,7 @@ async function start(info: ServerRuntimeStartInfo): Promise<void> {
     // main.js import 전에 환경변수를 process.env에 주입
     if (info.env != null) {
       for (const [key, value] of Object.entries(info.env)) {
-        process.env[key] = value;
+        env(key, value);
       }
     }
 

package/tests/angular/client-transform-stylesheet.spec.ts

@@ -3,6 +3,7 @@ import path from "path";
 import fs from "fs";
 import os from "os";
 import { createClientTransformStylesheet } from "../../src/angular/client-transform-stylesheet.js";
+import { compileScssFileAsync, compileScssStringAsync } from "../../src/utils/scss-compiler.js";
 
 const TMP_DIR = path.join(os.tmpdir(), "sd-cli-stylesheet-test");
 
@@ -151,3 +152,45 @@ describe("createClientTransformStylesheet", () => {
     expect(deps.size).toBeGreaterThan(0);
   });
 });
+
+// ─── scss-compiler async (low-level) ───
+
+describe("scss-compiler async", () => {
+  // Scenario: 외부 .scss 파일 변환
+  it("compiles external .scss file asynchronously", async () => {
+    ensureTmpDir();
+    const scssPath = path.join(TMP_DIR, "test.scss");
+    fs.writeFileSync(scssPath, "$color: red;\n.host { color: $color; }");
+
+    const result = await compileScssFileAsync(scssPath, []);
+
+    expect(result.css).toContain("color: red");
+    expect(result.css).not.toContain("$color");
+    expect(result.dependencies).toBeInstanceOf(Array);
+  });
+
+  // Scenario: 인라인 SCSS 문자열 변환
+  it("compiles inline SCSS string asynchronously", async () => {
+    ensureTmpDir();
+    const containingFile = path.join(TMP_DIR, "component.ts");
+
+    const result = await compileScssStringAsync(
+      "$size: 16px;\n.text { font-size: $size; }",
+      containingFile,
+      [],
+    );
+
+    expect(result.css).toContain("font-size: 16px");
+    expect(result.css).not.toContain("$size");
+    expect(result.dependencies).toBeInstanceOf(Array);
+  });
+
+  // Scenario: SCSS 컴파일 에러 시 에러
+  it("throws on invalid SCSS syntax", async () => {
+    ensureTmpDir();
+    const scssPath = path.join(TMP_DIR, "invalid.scss");
+    fs.writeFileSync(scssPath, ".host { @include nonexistent-mixin(); }");
+
+    await expect(compileScssFileAsync(scssPath, [])).rejects.toThrow();
+  });
+});

package/tests/angular/find-affected-by-scss.spec.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect } from "vitest";
+import { findAffectedByScss } from "../../src/angular/vite-angular-plugin.js";
+
+describe("findAffectedByScss", () => {
+  it("returns owner file when SCSS is in its dependency set", () => {
+    const deps = new Map<string, Set<string>>();
+    deps.set("/app/src/comp.ts", new Set(["/app/scss/_vars.scss"]));
+
+    const result = findAffectedByScss("/app/scss/_vars.scss", deps);
+    expect(result).toEqual(["/app/src/comp.ts"]);
+  });
+
+  it("returns multiple owners when multiple components depend on the same SCSS", () => {
+    const deps = new Map<string, Set<string>>();
+    deps.set("/app/src/comp-a.ts", new Set(["/app/scss/_vars.scss"]));
+    deps.set("/app/src/comp-b.ts", new Set(["/app/scss/_vars.scss", "/app/scss/_extra.scss"]));
+    deps.set("/app/src/comp-c.ts", new Set(["/app/scss/_other.scss"]));
+
+    const result = findAffectedByScss("/app/scss/_vars.scss", deps);
+    expect(result).toEqual(expect.arrayContaining(["/app/src/comp-a.ts", "/app/src/comp-b.ts"]));
+    expect(result).not.toContain("/app/src/comp-c.ts");
+  });
+
+  it("returns empty array when no component depends on the SCSS", () => {
+    const deps = new Map<string, Set<string>>();
+    deps.set("/app/src/comp.ts", new Set(["/app/scss/_vars.scss"]));
+
+    const result = findAffectedByScss("/app/scss/_unknown.scss", deps);
+    expect(result).toEqual([]);
+  });
+
+  it("returns empty array when scssDependencies is empty", () => {
+    const deps = new Map<string, Set<string>>();
+    const result = findAffectedByScss("/app/scss/_vars.scss", deps);
+    expect(result).toEqual([]);
+  });
+});

package/tests/angular/fixtures/basic-app/scss/_colors.scss

@@ -0,0 +1 @@
+$base: blue;

package/tests/angular/fixtures/basic-app/scss/_variables.scss

@@ -0,0 +1,3 @@
+@use 'colors' as c;
+
+$primary: c.$base;

package/tests/angular/fixtures/basic-app/src/styled.component.ts

@@ -0,0 +1,14 @@
+import { Component } from "@angular/core";
+
+@Component({
+  selector: "app-styled",
+  standalone: true,
+  template: `<p>styled</p>`,
+  styles: [`
+    @use 'variables' as vars;
+    :host {
+      color: vars.$primary;
+    }
+  `],
+})
+export class StyledComponent {}

package/tests/angular/linker-disk-cache.spec.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+const mockTransformFile = vi.fn(() => Promise.resolve("transformed-code"));
+
+vi.mock("@angular/build/private", () => ({
+  JavaScriptTransformer: class MockJSTransformer {
+    transformFile = mockTransformFile;
+    transformData = vi.fn(() => Promise.resolve(new TextEncoder().encode("transformed")));
+    close = vi.fn(() => Promise.resolve());
+  },
+}));
+
+const { sdAngularPlugin } = await import("../../src/angular/vite-angular-plugin.js");
+
+const TMP_DIR = path.join(os.tmpdir(), "sd-cli-linker-cache-test");
+const CACHE_DIR = path.join(TMP_DIR, "cache");
+
+type LoadHandler = (id: string) => Promise<string | null>;
+
+function getLoadHandler(plugin: ReturnType<typeof sdAngularPlugin>): LoadHandler {
+  const config = (plugin as any).config();
+  const rolldownPlugin = config.optimizeDeps.rolldownOptions.plugins[0] as {
+    load: (id: string) => Promise<string | null>;
+  };
+  return (id: string) => rolldownPlugin.load(id);
+}
+
+describe("Linker disk cache (optimizeDeps)", () => {
+  beforeEach(() => {
+    fs.mkdirSync(TMP_DIR, { recursive: true });
+    mockTransformFile.mockClear();
+    mockTransformFile.mockResolvedValue("transformed-code");
+  });
+
+  afterEach(() => {
+    fs.rmSync(TMP_DIR, { recursive: true, force: true });
+  });
+
+  // Acceptance: cache miss → transform + store, cache hit → load from disk
+  it("caches transformFile result on miss and returns cached on hit", async () => {
+    const jsFile = path.join(TMP_DIR, "module.js");
+    fs.writeFileSync(jsFile, "export const x = 1;");
+
+    const plugin = sdAngularPlugin({
+      tsconfig: path.join(TMP_DIR, "tsconfig.json"),
+      dev: true,
+      linkerCacheDir: CACHE_DIR,
+    });
+    const load = getLoadHandler(plugin);
+
+    // First call: cache miss
+    const result1 = await load(jsFile);
+    expect(mockTransformFile).toHaveBeenCalledOnce();
+    expect(result1).toBe("transformed-code");
+
+    // Cache file created
+    const cacheFiles = fs.readdirSync(CACHE_DIR);
+    expect(cacheFiles.length).toBe(1);
+    expect(cacheFiles[0]).toMatch(/^[a-f0-9]+\.js$/);
+
+    // Second call: cache hit
+    mockTransformFile.mockClear();
+    const result2 = await load(jsFile);
+    expect(mockTransformFile).not.toHaveBeenCalled();
+    expect(result2).toBe("transformed-code");
+  });
+
+  // Acceptance: file content change → cache miss
+  it("invalidates cache when file content changes", async () => {
+    const jsFile = path.join(TMP_DIR, "changing.js");
+    fs.writeFileSync(jsFile, "export const v = 1;");
+
+    const plugin = sdAngularPlugin({
+      tsconfig: path.join(TMP_DIR, "tsconfig.json"),
+      dev: true,
+      linkerCacheDir: CACHE_DIR,
+    });
+    const load = getLoadHandler(plugin);
+
+    await load(jsFile);
+    expect(mockTransformFile).toHaveBeenCalledOnce();
+
+    // Change content
+    fs.writeFileSync(jsFile, "export const v = 2;");
+    mockTransformFile.mockClear();
+    mockTransformFile.mockResolvedValue("transformed-v2");
+
+    const result = await load(jsFile);
+    expect(mockTransformFile).toHaveBeenCalledOnce();
+    expect(result).toBe("transformed-v2");
+  });
+
+  // Unit: corrupted cache file → graceful fallback
+  it("falls back to transform when cache file is corrupted", async () => {
+    const jsFile = path.join(TMP_DIR, "fallback.js");
+    fs.writeFileSync(jsFile, "export const y = 1;");
+
+    const plugin = sdAngularPlugin({
+      tsconfig: path.join(TMP_DIR, "tsconfig.json"),
+      dev: true,
+      linkerCacheDir: CACHE_DIR,
+    });
+    const load = getLoadHandler(plugin);
+
+    // First call to populate cache
+    await load(jsFile);
+
+    // Remove the cache file to simulate corruption/missing cache
+    const cacheFiles = fs.readdirSync(CACHE_DIR);
+    fs.rmSync(path.join(CACHE_DIR, cacheFiles[0]));
+
+    mockTransformFile.mockClear();
+    const result = await load(jsFile);
+    expect(mockTransformFile).toHaveBeenCalledOnce();
+    expect(result).toBe("transformed-code");
+  });
+
+  // Unit: Uint8Array result from transformFile is handled
+  it("handles Uint8Array result from transformFile", async () => {
+    const jsFile = path.join(TMP_DIR, "uint8.js");
+    fs.writeFileSync(jsFile, "export const z = 1;");
+
+    mockTransformFile.mockResolvedValue(new TextEncoder().encode("uint8-transformed") as unknown as string);
+
+    const plugin = sdAngularPlugin({
+      tsconfig: path.join(TMP_DIR, "tsconfig.json"),
+      dev: true,
+      linkerCacheDir: CACHE_DIR,
+    });
+    const load = getLoadHandler(plugin);
+
+    const result = await load(jsFile);
+    expect(result).toBe("uint8-transformed");
+
+    // Second call: cache hit should also return string
+    mockTransformFile.mockClear();
+    const result2 = await load(jsFile);
+    expect(mockTransformFile).not.toHaveBeenCalled();
+    expect(result2).toBe("uint8-transformed");
+  });
+
+  // Unit: non-.js file returns null (filter)
+  it("returns null for non-js files", async () => {
+    const plugin = sdAngularPlugin({
+      tsconfig: path.join(TMP_DIR, "tsconfig.json"),
+      dev: true,
+      linkerCacheDir: CACHE_DIR,
+    });
+    const load = getLoadHandler(plugin);
+
+    const result = await load(path.join(TMP_DIR, "data.json"));
+    expect(result).toBeNull();
+    expect(mockTransformFile).not.toHaveBeenCalled();
+  });
+});

package/tests/angular/scss-disk-cache.spec.ts

@@ -0,0 +1,162 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { createClientTransformStylesheet } from "../../src/angular/client-transform-stylesheet.js";
+
+const TMP_DIR = path.join(os.tmpdir(), "sd-cli-scss-cache-test");
+const CACHE_DIR = path.join(TMP_DIR, "scss-cache");
+
+function ensureTmpDir(): void {
+  fs.mkdirSync(TMP_DIR, { recursive: true });
+}
+
+describe("SCSS disk cache", () => {
+  beforeEach(() => {
+    ensureTmpDir();
+  });
+
+  afterEach(() => {
+    fs.rmSync(TMP_DIR, { recursive: true, force: true });
+  });
+
+  // Acceptance: cache miss → compile + store, cache hit → load from disk
+  it("caches SCSS compile result on miss and returns cached on hit", async () => {
+    const scssPath = path.join(TMP_DIR, "component.scss");
+    fs.writeFileSync(scssPath, "$color: blue;\n.host { color: $color; }");
+
+    const deps = new Map<string, Set<string>>();
+    const transform = createClientTransformStylesheet({
+      loadPaths: [],
+      scssErrors: [],
+      scssDependencies: deps,
+      cacheDir: CACHE_DIR,
+    });
+
+    // First call: compile (cache miss)
+    const result1 = await transform("", path.join(TMP_DIR, "component.ts"), scssPath);
+    expect(result1).toContain("color: blue");
+
+    // Cache file should exist
+    const cacheFiles = fs.readdirSync(CACHE_DIR);
+    expect(cacheFiles.length).toBe(1);
+
+    // Second call: cache hit (same file)
+    deps.clear();
+    const result2 = await transform("", path.join(TMP_DIR, "component.ts"), scssPath);
+    expect(result2).toBe(result1);
+  });
+
+  // Acceptance: dependency change → cache miss
+  it("invalidates cache when dependency file changes", async () => {
+    const partialPath = path.join(TMP_DIR, "_vars.scss");
+    fs.writeFileSync(partialPath, "$color: green;");
+    const scssPath = path.join(TMP_DIR, "with-dep.scss");
+    fs.writeFileSync(scssPath, '@use "vars";\n.host { color: vars.$color; }');
+
+    const deps = new Map<string, Set<string>>();
+    const transform = createClientTransformStylesheet({
+      loadPaths: [TMP_DIR],
+      scssErrors: [],
+      scssDependencies: deps,
+      cacheDir: CACHE_DIR,
+    });
+
+    // First call
+    const result1 = await transform("", path.join(TMP_DIR, "comp.ts"), scssPath);
+    expect(result1).toContain("color: green");
+
+    // Change dependency content
+    fs.writeFileSync(partialPath, "$color: red;");
+
+    const result2 = await transform("", path.join(TMP_DIR, "comp.ts"), scssPath);
+    expect(result2).toContain("color: red");
+    expect(result2).not.toContain("color: green");
+  });
+
+  // Acceptance: scssDependencies populated on cache hit
+  it("populates scssDependencies from cache on hit", async () => {
+    const partialPath = path.join(TMP_DIR, "_shared.scss");
+    fs.writeFileSync(partialPath, "$size: 14px;");
+    const scssPath = path.join(TMP_DIR, "deptest.scss");
+    fs.writeFileSync(scssPath, '@use "shared";\n.text { font-size: shared.$size; }');
+
+    const deps = new Map<string, Set<string>>();
+    const transform = createClientTransformStylesheet({
+      loadPaths: [TMP_DIR],
+      scssErrors: [],
+      scssDependencies: deps,
+      cacheDir: CACHE_DIR,
+    });
+
+    // First call: populate deps from compilation
+    await transform("", path.join(TMP_DIR, "comp.ts"), scssPath);
+    expect(deps.size).toBeGreaterThan(0);
+
+    // Clear deps and call again (cache hit)
+    deps.clear();
+    await transform("", path.join(TMP_DIR, "comp.ts"), scssPath);
+
+    // deps should be re-populated from cache
+    expect(deps.size).toBeGreaterThan(0);
+    const depSet = deps.get(scssPath);
+    expect(depSet).toBeDefined();
+    expect(depSet!.size).toBeGreaterThan(0);
+  });
+
+  // Unit: inline SCSS is NOT cached
+  it("does not cache inline SCSS", async () => {
+    const deps = new Map<string, Set<string>>();
+    const transform = createClientTransformStylesheet({
+      loadPaths: [],
+      scssErrors: [],
+      scssDependencies: deps,
+      cacheDir: CACHE_DIR,
+    });
+
+    await transform(
+      "$size: 14px;\n.text { font-size: $size; }",
+      path.join(TMP_DIR, "component.ts"),
+    );
+
+    // No cache files should be created for inline SCSS
+    expect(fs.existsSync(CACHE_DIR)).toBe(false);
+  });
+
+  // Unit: file content change → cache miss
+  it("invalidates cache when SCSS file content changes", async () => {
+    const scssPath = path.join(TMP_DIR, "changing.scss");
+    fs.writeFileSync(scssPath, ".host { color: blue; }");
+
+    const transform = createClientTransformStylesheet({
+      loadPaths: [],
+      scssErrors: [],
+      scssDependencies: new Map(),
+      cacheDir: CACHE_DIR,
+    });
+
+    const result1 = await transform("", path.join(TMP_DIR, "comp.ts"), scssPath);
+    expect(result1).toContain("color: blue");
+
+    fs.writeFileSync(scssPath, ".host { color: red; }");
+
+    const result2 = await transform("", path.join(TMP_DIR, "comp.ts"), scssPath);
+    expect(result2).toContain("color: red");
+  });
+
+  // Unit: no cacheDir → no caching (backward compatible)
+  it("works without cacheDir (no caching)", async () => {
+    const scssPath = path.join(TMP_DIR, "nodir.scss");
+    fs.writeFileSync(scssPath, ".host { color: navy; }");
+
+    const transform = createClientTransformStylesheet({
+      loadPaths: [],
+      scssErrors: [],
+      scssDependencies: new Map(),
+    });
+
+    const result = await transform("", path.join(TMP_DIR, "comp.ts"), scssPath);
+    expect(result).toContain("color: navy");
+    expect(fs.existsSync(CACHE_DIR)).toBe(false);
+  });
+});

package/tests/angular/vite-angular-plugin-hmr-fallback.spec.ts

@@ -28,7 +28,7 @@ describe("sdAngularPlugin CSS HMR compatibility", () => {
       .join(FIXTURE_DIR, "node_modules/@scope/lib/dist/style.css")
       .replace(/\\/g, "/");
 
-    const hmrResult = await (plugin as any).handleHotUpdate?.({
+    const hmrResult = await (plugin as any).hotUpdate?.({
       file: cssFilePath,
       modules: [{ file: cssFilePath, id: cssFilePath }],
       server: { watcher: { emit: vi.fn() } },
@@ -68,7 +68,7 @@ describe("sdAngularPlugin CSS HMR compatibility", () => {
       .join(FIXTURE_DIR, "src/app.component.ts")
       .replace(/\\/g, "/");
 
-    await (plugin as any).handleHotUpdate?.({
+    await (plugin as any).hotUpdate?.({
       file: tsFilePath,
       modules: [{ file: tsFilePath, id: tsFilePath }],
       server: { watcher: { emit: vi.fn() } },
@@ -88,7 +88,7 @@ describe("sdAngularPlugin CSS HMR compatibility", () => {
       .join(FIXTURE_DIR, "node_modules/@scope/lib/dist/style.css")
       .replace(/\\/g, "/");
 
-    await (plugin as any).handleHotUpdate?.({
+    await (plugin as any).hotUpdate?.({
       file: cssFilePath,
       modules: [{ file: cssFilePath, id: cssFilePath }],
       server: { watcher: { emit: vi.fn() } },
@@ -121,7 +121,7 @@ describe("sdAngularPlugin CSS HMR compatibility", () => {
     ];
 
     for (const cssPath of cssVariants) {
-      const result = await (plugin as any).handleHotUpdate?.({
+      const result = await (plugin as any).hotUpdate?.({
         file: cssPath,
         modules: [{ file: cssPath, id: cssPath }],
         server: { watcher: { emit: vi.fn() } },
@@ -159,7 +159,7 @@ describe("sdAngularPlugin CSS HMR compatibility", () => {
       .join(FIXTURE_DIR, "src/styles.scss")
       .replace(/\\/g, "/");
 
-    const result = await (plugin as any).handleHotUpdate?.({
+    const result = await (plugin as any).hotUpdate?.({
       file: scssFilePath,
       modules: [{ file: scssFilePath, id: scssFilePath }],
       server: { watcher: { emit: vi.fn() } },
@@ -209,8 +209,8 @@ describe("sdAngularPlugin HMR fallback", () => {
       .join(FIXTURE_DIR, "src/app.component.ts")
       .replace(/\\/g, "/");
 
-    // handleHotUpdate 호출
-    const hmrResult = await (plugin as any).handleHotUpdate?.({
+    // hotUpdate 호출
+    const hmrResult = await (plugin as any).hotUpdate?.({
       file: appComponentPath,
       modules: [{ file: appComponentPath, id: appComponentPath }],
       server: { watcher: { emit: vi.fn() } },
@@ -218,7 +218,7 @@ describe("sdAngularPlugin HMR fallback", () => {
       read: () => Promise.resolve(""),
     });
 
-    // handleHotUpdate는 항상 affected modules 배열을 반환해야 한다
+    // hotUpdate는 항상 affected modules 배열을 반환해야 한다
     // (templateUpdates가 undefined이든 아니든)
     expect(Array.isArray(hmrResult)).toBe(true);
 
@@ -249,8 +249,8 @@ describe("sdAngularPlugin HMR fallback", () => {
     await (plugin as any).buildEnd?.call({});
   });
 
-  // Unit: prod 모드(dev: false)에서는 handleHotUpdate가 void 반환 (HMR 비활성)
-  it("returns undefined from handleHotUpdate in prod mode", async () => {
+  // Unit: prod 모드(dev: false)에서는 hotUpdate가 void 반환 (HMR 비활성)
+  it("returns undefined from hotUpdate in prod mode", async () => {
     const plugin = sdAngularPlugin({
       tsconfig: TSCONFIG_PATH,
       dev: false,
@@ -262,7 +262,7 @@ describe("sdAngularPlugin HMR fallback", () => {
       .join(FIXTURE_DIR, "src/app.component.ts")
       .replace(/\\/g, "/");
 
-    const hmrResult = await (plugin as any).handleHotUpdate?.({
+    const hmrResult = await (plugin as any).hotUpdate?.({
       file: appComponentPath,
       modules: [{ file: appComponentPath }],
       server: { watcher: { emit: vi.fn() } },
@@ -276,7 +276,7 @@ describe("sdAngularPlugin HMR fallback", () => {
     await (plugin as any).buildEnd?.call({});
   });
 
-  // Acceptance: 수정 파일 33개 이상일 때도 handleHotUpdate가 정상 동작
+  // Acceptance: 수정 파일 33개 이상일 때도 hotUpdate가 정상 동작
   // (Angular 컴파일러 내부에서 HMR 분석을 생략하고 templateUpdates=undefined 반환)
   it("handles update with many modified files gracefully (HMR skipped by compiler)", async () => {
     const plugin = sdAngularPlugin({
@@ -290,11 +290,11 @@ describe("sdAngularPlugin HMR fallback", () => {
       .join(FIXTURE_DIR, "src/app.component.ts")
       .replace(/\\/g, "/");
 
-    // handleHotUpdate는 단일 파일에 대해 호출됨 (Vite 설계)
+    // hotUpdate는 단일 파일에 대해 호출됨 (Vite 설계)
     // 33개 이상 수정 파일 제한은 Angular 컴파일러 내부에서 처리
     // AngularFacade.update()에서 modifiedFiles가 SourceFileCache.modifiedFiles로 전달되므로
     // 실제 33개 이상 파일 변경은 SourceFileCache를 통해 추적됨
-    const hmrResult = await (plugin as any).handleHotUpdate?.({
+    const hmrResult = await (plugin as any).hotUpdate?.({
       file: appComponentPath,
       modules: [{ file: appComponentPath }],
       server: { watcher: { emit: vi.fn() } },
@@ -302,7 +302,7 @@ describe("sdAngularPlugin HMR fallback", () => {
       read: () => Promise.resolve(""),
     });
 
-    // handleHotUpdate가 에러 없이 동작해야 한다
+    // hotUpdate가 에러 없이 동작해야 한다
     expect(Array.isArray(hmrResult)).toBe(true);
 
     await (plugin as any).buildEnd?.call({});

package/tests/angular/vite-angular-plugin-hmr.spec.ts

@@ -131,8 +131,8 @@ describe("sdAngularPlugin HMR + component-middleware", () => {
     await (plugin as any).buildEnd?.call({});
   });
 
-  // Acceptance: handleHotUpdate에서 templateUpdates를 수집하고 middleware에서 서빙
-  it("collects templateUpdates from handleHotUpdate and serves via middleware", async () => {
+  // Acceptance: hotUpdate에서 templateUpdates를 수집하고 middleware에서 서빙
+  it("collects templateUpdates from hotUpdate and serves via middleware", async () => {
     const plugin = sdAngularPlugin({ tsconfig: TSCONFIG_PATH, dev: true });
 
     await (plugin as any).buildStart?.call({});
@@ -151,12 +151,12 @@ describe("sdAngularPlugin HMR + component-middleware", () => {
     };
     (plugin as any).configureServer?.(mockServer);
 
-    // handleHotUpdate 호출 (인라인 템플릿 변경)
+    // hotUpdate 호출 (인라인 템플릿 변경)
     const appComponentPath = path
       .join(FIXTURE_DIR, "src/app.component.ts")
       .replace(/\\/g, "/");
 
-    await (plugin as any).handleHotUpdate?.({
+    await (plugin as any).hotUpdate?.({
       file: appComponentPath,
       modules: [{ file: appComponentPath, id: appComponentPath }],
       server: { watcher: { emit: vi.fn() } },
@@ -174,7 +174,7 @@ describe("sdAngularPlugin HMR + component-middleware", () => {
   });
 
   // Acceptance: rebuild 시작 시 이전 templateUpdates 정리
-  it("clears templateUpdates at the start of handleHotUpdate", async () => {
+  it("clears templateUpdates at the start of hotUpdate", async () => {
     const plugin = sdAngularPlugin({ tsconfig: TSCONFIG_PATH, dev: true });
     await (plugin as any).buildStart?.call({});
 
@@ -195,8 +195,8 @@ describe("sdAngularPlugin HMR + component-middleware", () => {
       .join(FIXTURE_DIR, "src/app.component.ts")
       .replace(/\\/g, "/");
 
-    // 첫 번째 handleHotUpdate
-    await (plugin as any).handleHotUpdate?.({
+    // 첫 번째 hotUpdate
+    await (plugin as any).hotUpdate?.({
       file: appComponentPath,
       modules: [{ file: appComponentPath }],
       server: { watcher: { emit: vi.fn() } },
@@ -204,8 +204,8 @@ describe("sdAngularPlugin HMR + component-middleware", () => {
       read: () => Promise.resolve(""),
     });
 
-    // 두 번째 handleHotUpdate — 이전 templateUpdates가 정리되어야 한다
-    await (plugin as any).handleHotUpdate?.({
+    // 두 번째 hotUpdate — 이전 templateUpdates가 정리되어야 한다
+    await (plugin as any).hotUpdate?.({
       file: appComponentPath,
       modules: [{ file: appComponentPath }],
       server: { watcher: { emit: vi.fn() } },

package/tests/angular/vite-angular-plugin-lint.spec.ts

@@ -145,7 +145,7 @@ describe("vite-angular-plugin lint integration (Slice 5)", () => {
     });
   });
 
-  describe("Scenario: lint runs in handleHotUpdate", () => {
+  describe("Scenario: lint runs in hotUpdate", () => {
     it("runs lint after incremental compilation and passes result to onBuild", async () => {
       const onBuildResults: any[] = [];
 
@@ -167,9 +167,9 @@ describe("vite-angular-plugin lint integration (Slice 5)", () => {
         formattedOutput: "lint errors found",
       });
 
-      // Call handleHotUpdate
-      const handleHotUpdate = (plugin as any).handleHotUpdate;
-      await handleHotUpdate.call({}, {
+      // Call hotUpdate
+      const hotUpdate = (plugin as any).hotUpdate;
+      await hotUpdate.call({}, {
         file: "/workspace/packages/client/src/app.ts",
         modules: [],
         server: {},