@simplysm/sd-cli 14.0.30 → 14.0.32

package/tests/workers/server-esbuild-context.spec.ts

@@ -0,0 +1,198 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+
+//#region Mocks
+
+const mockRebuild = vi.fn();
+const mockDispose = vi.fn();
+
+vi.mock("esbuild", () => ({
+  default: {
+    context: vi.fn(() =>
+      Promise.resolve({ rebuild: mockRebuild, dispose: mockDispose }),
+    ),
+  },
+}));
+
+vi.mock("../../src/esbuild/esbuild-config", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../../src/esbuild/esbuild-config")>();
+  return {
+    ...actual,
+    writeChangedOutputFiles: vi.fn(() => Promise.resolve()),
+  };
+});
+
+//#endregion
+
+const esbuild = (await import("esbuild")).default;
+const { writeChangedOutputFiles } = await import("../../src/esbuild/esbuild-config");
+const { createContext, rebuild, recreateContext, dispose, getMetafile, hasContext } =
+  await import("../../src/workers/server-esbuild-context");
+
+const baseOptions = {
+  pkgDir: "/workspace/packages/my-server",
+  entryPoints: ["/workspace/packages/my-server/src/main.ts"],
+  external: ["express"],
+};
+
+describe("createContext", () => {
+  afterEach(async () => {
+    mockRebuild.mockReset();
+    mockDispose.mockReset();
+    vi.mocked(esbuild.context).mockClear();
+    vi.mocked(writeChangedOutputFiles).mockClear();
+    await dispose();
+  });
+
+  it("calls esbuild.context with metafile:true and write:false", async () => {
+    await createContext(baseOptions);
+
+    expect(esbuild.context).toHaveBeenCalledWith(
+      expect.objectContaining({
+        metafile: true,
+        write: false,
+        external: ["express"],
+      }),
+    );
+    expect(hasContext()).toBe(true);
+  });
+
+  it("passes dev:true options for sourcemap and no minification", async () => {
+    await createContext(baseOptions);
+
+    expect(esbuild.context).toHaveBeenCalledWith(
+      expect.objectContaining({
+        minify: false,
+        sourcemap: "linked",
+      }),
+    );
+  });
+});
+
+describe("rebuild", () => {
+  afterEach(async () => {
+    mockRebuild.mockReset();
+    mockDispose.mockReset();
+    vi.mocked(esbuild.context).mockClear();
+    vi.mocked(writeChangedOutputFiles).mockClear();
+    await dispose();
+  });
+
+  it("returns null when no context exists", async () => {
+    const result = await rebuild();
+    expect(result).toBeNull();
+  });
+
+  it("returns success result and updates metafile", async () => {
+    const mockMetafile = { inputs: { "src/main.ts": {} }, outputs: {} };
+    mockRebuild.mockResolvedValue({
+      errors: [],
+      warnings: [],
+      outputFiles: [{ path: "/dist/main.js", text: "export {}" }],
+      metafile: mockMetafile,
+    });
+
+    await createContext(baseOptions);
+    const result = await rebuild();
+
+    expect(result).toEqual({
+      success: true,
+      errors: undefined,
+      warnings: undefined,
+    });
+    expect(getMetafile()).toBe(mockMetafile);
+    expect(writeChangedOutputFiles).toHaveBeenCalledWith([
+      { path: "/dist/main.js", text: "export {}" },
+    ]);
+  });
+
+  it("returns error result on esbuild errors", async () => {
+    mockRebuild.mockResolvedValue({
+      errors: [{ text: "syntax error" }],
+      warnings: [{ text: "deprecation warning" }],
+      outputFiles: [],
+      metafile: undefined,
+    });
+
+    await createContext(baseOptions);
+    const result = await rebuild();
+
+    expect(result).toEqual({
+      success: false,
+      errors: ["syntax error"],
+      warnings: ["deprecation warning"],
+    });
+  });
+});
+
+describe("recreateContext", () => {
+  afterEach(async () => {
+    mockRebuild.mockReset();
+    mockDispose.mockReset();
+    vi.mocked(esbuild.context).mockClear();
+    vi.mocked(writeChangedOutputFiles).mockClear();
+    await dispose();
+  });
+
+  it("disposes old context and creates new one", async () => {
+    await createContext(baseOptions);
+    const newOptions = { ...baseOptions, entryPoints: ["/src/new.ts"] };
+
+    const disposeCountBefore = mockDispose.mock.calls.length;
+    await recreateContext(newOptions);
+
+    // recreateContext 중 old context가 dispose됨
+    expect(mockDispose.mock.calls.length - disposeCountBefore).toBe(1);
+    expect(esbuild.context).toHaveBeenCalledTimes(2);
+    expect(hasContext()).toBe(true);
+  });
+
+  it("clears metafile during recreation", async () => {
+    mockRebuild.mockResolvedValue({
+      errors: [],
+      warnings: [],
+      outputFiles: [],
+      metafile: { inputs: {}, outputs: {} },
+    });
+
+    await createContext(baseOptions);
+    await rebuild(); // set metafile
+    expect(getMetafile()).toBeDefined();
+
+    await recreateContext(baseOptions);
+
+    // metafile cleared (new context hasn't been rebuilt yet)
+    expect(getMetafile()).toBeUndefined();
+  });
+});
+
+describe("dispose", () => {
+  afterEach(() => {
+    mockRebuild.mockReset();
+    mockDispose.mockReset();
+    vi.mocked(esbuild.context).mockClear();
+    vi.mocked(writeChangedOutputFiles).mockClear();
+  });
+
+  it("is safe to call when no context exists", async () => {
+    await expect(dispose()).resolves.not.toThrow();
+    expect(hasContext()).toBe(false);
+  });
+
+  it("disposes context and clears all state", async () => {
+    mockRebuild.mockResolvedValue({
+      errors: [],
+      warnings: [],
+      outputFiles: [],
+      metafile: { inputs: {}, outputs: {} },
+    });
+
+    await createContext(baseOptions);
+    await rebuild();
+
+    await dispose();
+
+    expect(mockDispose).toHaveBeenCalledOnce();
+    expect(hasContext()).toBe(false);
+    expect(getMetafile()).toBeUndefined();
+  });
+});

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

@@ -1,3 +1,4 @@
+/* eslint-disable no-restricted-properties -- 테스트 환경변수 조작 필요 */
 import { describe, it, expect, vi, beforeEach, afterEach, beforeAll, afterAll } from "vitest";
 import fs from "fs";
 import path from "path";
@@ -16,7 +17,7 @@ vi.mock("@simplysm/core-node", () => ({
   }),
 }));
 
-vi.mock("../../src/utils/worker-utils", () => ({
+vi.mock("../../src/runtime/worker-utils", () => ({
   registerCleanupHandlers: vi.fn(),
   setupWorkerConsola: vi.fn(),
 }));
@@ -95,7 +96,7 @@ describe("server-runtime.worker cleanup", () => {
     await workerFns["start"]({ mainJsPath: mockMainJsPath });
 
     // Get the cleanup function registered via registerCleanupHandlers
-    const { registerCleanupHandlers } = await import("../../src/utils/worker-utils");
+    const { registerCleanupHandlers } = await import("../../src/runtime/worker-utils");
     const firstCall = vi.mocked(registerCleanupHandlers).mock.calls[0];
     expect(firstCall).toBeDefined();
     const cleanupFn = firstCall[0];
@@ -283,7 +284,7 @@ describe("server-runtime.worker start", () => {
     const portFile = path.join(mockMainDir, ".dev-port");
     expect(fs.existsSync(portFile)).toBe(true);
 
-    const { registerCleanupHandlers } = await import("../../src/utils/worker-utils");
+    const { registerCleanupHandlers } = await import("../../src/runtime/worker-utils");
     const cleanupFn = vi.mocked(registerCleanupHandlers).mock.calls[0][0];
     await cleanupFn();
 

package/tests/workers/server-watch-manager.acc.spec.ts

@@ -0,0 +1,162 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import type { ConsolaInstance } from "consola";
+
+//#region Mocks
+
+const mockWatcherOnChange = vi.fn();
+const mockWatcherClose = vi.fn();
+
+vi.mock("@simplysm/core-node", () => ({
+  FsWatcher: {
+    watch: vi.fn(() =>
+      Promise.resolve({ onChange: mockWatcherOnChange, close: mockWatcherClose }),
+    ),
+  },
+  pathx: {
+    posix: vi.fn((p: string) => p.replace(/\\/g, "/")),
+    posixResolve: vi.fn((...args: string[]) => {
+      // Simple path join for testing
+      return args.join("/").replace(/\/+/g, "/");
+    }),
+  },
+}));
+
+vi.mock("fs", () => ({
+  default: {
+    realpathSync: vi.fn((p: string) => p),
+  },
+}));
+
+vi.mock("../../src/workers/server-esbuild-context", () => ({
+  hasContext: vi.fn(() => true),
+  getMetafile: vi.fn(() => undefined),
+  recreateContext: vi.fn(() => Promise.resolve()),
+}));
+
+vi.mock("../../src/workers/build-change-filter", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../../src/workers/build-change-filter")>();
+  return actual;
+});
+
+vi.mock("../../src/utils/tsconfig", () => ({
+  parseTsconfig: vi.fn(() => ({
+    options: { target: 1, module: 99 },
+    fileNames: ["/workspace/packages/my-server/src/main.ts"],
+    errors: [],
+  })),
+  getPackageSourceFiles: vi.fn(() => ["/workspace/packages/my-server/src/main.ts"]),
+}));
+
+vi.mock("../../src/deps/server-externals/server-production-files", () => ({
+  collectAllExternals: vi.fn(() => []),
+}));
+
+//#endregion
+
+const { FsWatcher } = await import("@simplysm/core-node");
+const esbuildCtx = await import("../../src/workers/server-esbuild-context");
+const { collectAllExternals } = await import("../../src/deps/server-externals/server-production-files");
+const { startServerWatchLoop } = await import("../../src/workers/server-watch-manager");
+
+const mockLogger = { debug: vi.fn(), warn: vi.fn() } as unknown as ConsolaInstance;
+
+function createConfig(overrides?: Partial<Parameters<typeof startServerWatchLoop>[0]>) {
+  return {
+    info: {
+      name: "my-server",
+      cwd: "/workspace",
+      pkgDir: "/workspace/packages/my-server",
+      output: { js: true, dts: false },
+      externals: undefined as string[] | undefined,
+    },
+    watchPaths: ["/workspace/packages/my-server/src/**/*"],
+    logger: mockLogger,
+    initialExternals: [],
+    onBuildStart: vi.fn(),
+    onBuild: vi.fn(),
+    onError: vi.fn(),
+    rebuild: vi.fn(() =>
+      Promise.resolve({
+        build: { success: true },
+        mainJsPath: "/workspace/packages/my-server/dist/main.js",
+      }),
+    ),
+    ...overrides,
+  };
+}
+
+describe("startServerWatchLoop", () => {
+  beforeEach(() => {
+    mockWatcherOnChange.mockClear();
+    mockWatcherClose.mockClear();
+    vi.mocked(FsWatcher.watch).mockClear();
+    vi.mocked(esbuildCtx.hasContext).mockReturnValue(true);
+    vi.mocked(esbuildCtx.getMetafile).mockReturnValue(undefined);
+    vi.mocked(esbuildCtx.recreateContext).mockResolvedValue();
+    vi.mocked(collectAllExternals).mockReturnValue([]);
+    (mockLogger.debug as unknown as ReturnType<typeof vi.fn>).mockClear();
+  });
+
+  // Acceptance: 파일 추가 시 context 재생성 + 리빌드
+  it("recreates esbuild context and triggers rebuild on file add", async () => {
+    const config = createConfig();
+    await startServerWatchLoop(config);
+
+    // onChange 핸들러 추출
+    const onChangeHandler = mockWatcherOnChange.mock.calls[0][1] as (
+      changes: Array<{ event: string; path: string }>,
+    ) => Promise<void>;
+
+    await onChangeHandler([
+      { event: "add", path: "/workspace/packages/my-server/src/new.ts" },
+    ]);
+
+    expect(config.onBuildStart).toHaveBeenCalledOnce();
+    expect(esbuildCtx.recreateContext).toHaveBeenCalled();
+    expect(config.rebuild).toHaveBeenCalledOnce();
+    expect(config.onBuild).toHaveBeenCalledOnce();
+  });
+
+  // Acceptance: metafile 기반 필터링으로 불필요한 리빌드 건너뜀
+  it("skips rebuild when changed file is not in metafile.inputs", async () => {
+    vi.mocked(esbuildCtx.getMetafile).mockReturnValue({
+      inputs: { "packages/my-server/src/main.ts": {} as any },
+      outputs: {},
+    });
+
+    const config = createConfig();
+    await startServerWatchLoop(config);
+
+    const onChangeHandler = mockWatcherOnChange.mock.calls[0][1] as (
+      changes: Array<{ event: string; path: string }>,
+    ) => Promise<void>;
+
+    await onChangeHandler([
+      { event: "change", path: "/workspace/packages/my-server/src/unrelated.ts" },
+    ]);
+
+    expect(config.onBuildStart).not.toHaveBeenCalled();
+    expect(config.rebuild).not.toHaveBeenCalled();
+  });
+
+  // Acceptance: onChange 에러 시 onError 콜백 호출
+  it("calls onError when onChange handler throws", async () => {
+    const config = createConfig({
+      rebuild: vi.fn().mockRejectedValue(new Error("rebuild failed")),
+    });
+
+    vi.mocked(esbuildCtx.hasContext).mockReturnValue(false);
+
+    await startServerWatchLoop(config);
+
+    const onChangeHandler = mockWatcherOnChange.mock.calls[0][1] as (
+      changes: Array<{ event: string; path: string }>,
+    ) => Promise<void>;
+
+    await onChangeHandler([
+      { event: "change", path: "/workspace/packages/my-server/src/main.ts" },
+    ]);
+
+    expect(config.onError).toHaveBeenCalledWith("rebuild failed");
+  });
+});

package/tests/workers/server-watch-manager.spec.ts

@@ -0,0 +1,199 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import type { ConsolaInstance } from "consola";
+
+//#region Mocks
+
+const mockWatcherOnChange = vi.fn();
+const mockWatcherClose = vi.fn();
+
+vi.mock("@simplysm/core-node", () => ({
+  FsWatcher: {
+    watch: vi.fn(() =>
+      Promise.resolve({ onChange: mockWatcherOnChange, close: mockWatcherClose }),
+    ),
+  },
+  pathx: {
+    posix: vi.fn((p: string) => p.replace(/\\/g, "/")),
+    posixResolve: vi.fn((...args: string[]) => args.join("/").replace(/\/+/g, "/")),
+  },
+}));
+
+vi.mock("fs", () => ({
+  default: {
+    realpathSync: vi.fn((p: string) => p),
+  },
+}));
+
+vi.mock("../../src/workers/server-esbuild-context", () => ({
+  hasContext: vi.fn(() => true),
+  getMetafile: vi.fn(() => undefined),
+  recreateContext: vi.fn(() => Promise.resolve()),
+}));
+
+vi.mock("../../src/workers/build-change-filter", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../../src/workers/build-change-filter")>();
+  return actual;
+});
+
+vi.mock("../../src/utils/tsconfig", () => ({
+  parseTsconfig: vi.fn(() => ({
+    options: {},
+    fileNames: ["/workspace/packages/my-server/src/main.ts"],
+    errors: [],
+  })),
+  getPackageSourceFiles: vi.fn(() => ["/workspace/packages/my-server/src/main.ts"]),
+}));
+
+vi.mock("../../src/deps/server-externals/server-production-files", () => ({
+  collectAllExternals: vi.fn(() => []),
+}));
+
+//#endregion
+
+const { FsWatcher } = await import("@simplysm/core-node");
+const esbuildCtx = await import("../../src/workers/server-esbuild-context");
+const { collectAllExternals } = await import("../../src/deps/server-externals/server-production-files");
+const { startServerWatchLoop } = await import("../../src/workers/server-watch-manager");
+
+const mockLogger = { debug: vi.fn(), warn: vi.fn() } as unknown as ConsolaInstance;
+
+function createConfig(overrides?: Record<string, unknown>) {
+  return {
+    info: {
+      name: "my-server",
+      cwd: "/workspace",
+      pkgDir: "/workspace/packages/my-server",
+      output: { js: true, dts: false },
+      externals: undefined as string[] | undefined,
+    },
+    watchPaths: ["/workspace/packages/my-server/src/**/*"],
+    logger: mockLogger,
+    initialExternals: [],
+    onBuildStart: vi.fn(),
+    onBuild: vi.fn(),
+    onError: vi.fn(),
+    rebuild: vi.fn(() =>
+      Promise.resolve({
+        build: { success: true },
+        mainJsPath: "/workspace/packages/my-server/dist/main.js",
+      }),
+    ),
+    ...overrides,
+  };
+}
+
+describe("startServerWatchLoop", () => {
+  beforeEach(() => {
+    mockWatcherOnChange.mockClear();
+    vi.mocked(FsWatcher.watch).mockClear();
+    vi.mocked(esbuildCtx.hasContext).mockReset().mockReturnValue(true);
+    vi.mocked(esbuildCtx.getMetafile).mockReset().mockReturnValue(undefined);
+    vi.mocked(esbuildCtx.recreateContext).mockReset().mockResolvedValue();
+    vi.mocked(collectAllExternals).mockReset().mockReturnValue([]);
+    (mockLogger.debug as unknown as ReturnType<typeof vi.fn>).mockClear();
+  });
+
+  it("creates FsWatcher and registers onChange with 300ms delay", async () => {
+    const config = createConfig();
+    await startServerWatchLoop(config);
+
+    expect(FsWatcher.watch).toHaveBeenCalledWith(config.watchPaths);
+    expect(mockWatcherOnChange).toHaveBeenCalledWith(
+      { delay: 300 },
+      expect.any(Function),
+    );
+  });
+
+  it("returns FsWatcher instance", async () => {
+    const config = createConfig();
+    const watcher = await startServerWatchLoop(config);
+
+    expect(watcher).toBeDefined();
+    expect(watcher.onChange).toBeDefined();
+  });
+
+  describe("onChange: file add/remove", () => {
+    it("recreates context when output.js is true", async () => {
+      const config = createConfig();
+      await startServerWatchLoop(config);
+
+      const handler = mockWatcherOnChange.mock.calls[0][1] as Function;
+      await handler([{ event: "add", path: "/workspace/packages/my-server/src/new.ts" }]);
+
+      expect(esbuildCtx.recreateContext).toHaveBeenCalled();
+    });
+
+    it("skips context recreation when output.js is false", async () => {
+      const config = createConfig({
+        info: {
+          name: "my-server",
+          cwd: "/workspace",
+          pkgDir: "/workspace/packages/my-server",
+          output: { js: false, dts: true },
+        },
+      });
+      await startServerWatchLoop(config);
+
+      const handler = mockWatcherOnChange.mock.calls[0][1] as Function;
+      await handler([{ event: "add", path: "/workspace/packages/my-server/src/new.ts" }]);
+
+      expect(esbuildCtx.recreateContext).not.toHaveBeenCalled();
+      expect(config.rebuild).toHaveBeenCalled();
+    });
+
+    it("re-collects externals when package.json changed", async () => {
+      const config = createConfig();
+      await startServerWatchLoop(config);
+
+      const handler = mockWatcherOnChange.mock.calls[0][1] as Function;
+      await handler([
+        { event: "add", path: "/workspace/packages/my-server/package.json" },
+      ]);
+
+      expect(collectAllExternals).toHaveBeenCalled();
+    });
+  });
+
+  describe("onChange: file change (metafile filtering)", () => {
+    it("rebuilds unconditionally when no context exists", async () => {
+      vi.mocked(esbuildCtx.hasContext).mockReturnValue(false);
+      const config = createConfig();
+      await startServerWatchLoop(config);
+
+      const handler = mockWatcherOnChange.mock.calls[0][1] as Function;
+      await handler([{ event: "change", path: "/workspace/packages/my-server/src/main.ts" }]);
+
+      expect(config.onBuildStart).toHaveBeenCalled();
+      expect(config.rebuild).toHaveBeenCalled();
+    });
+
+    it("rebuilds unconditionally when metafile is not available", async () => {
+      vi.mocked(esbuildCtx.getMetafile).mockReturnValue(undefined);
+      const config = createConfig();
+      await startServerWatchLoop(config);
+
+      const handler = mockWatcherOnChange.mock.calls[0][1] as Function;
+      await handler([{ event: "change", path: "/workspace/packages/my-server/src/main.ts" }]);
+
+      expect(config.rebuild).toHaveBeenCalled();
+    });
+
+    it("rebuilds when changed file is in metafile.inputs", async () => {
+      vi.mocked(esbuildCtx.getMetafile).mockReturnValue({
+        inputs: { "packages/my-server/src/main.ts": {} as any },
+        outputs: {},
+      });
+      const config = createConfig();
+      await startServerWatchLoop(config);
+
+      const handler = mockWatcherOnChange.mock.calls[0][1] as Function;
+      // pathx.posixResolve("/workspace", "packages/my-server/src/main.ts")
+      // → "/workspace/packages/my-server/src/main.ts"
+      await handler([
+        { event: "change", path: "/workspace/packages/my-server/src/main.ts" },
+      ]);
+
+      expect(config.rebuild).toHaveBeenCalled();
+    });
+  });
+});

package/tests/workers/shared-worker-lifecycle.acc.spec.ts

@@ -0,0 +1,27 @@
+import { describe, it, expect, vi } from "vitest";
+
+// setupConsola는 consola 글로벌 상태를 변경하므로 모킹
+vi.mock("@simplysm/core-node", () => ({
+  setupConsola: vi.fn(),
+}));
+
+const { setupWorkerLifecycle } = await import("../../src/workers/shared-worker-lifecycle");
+
+describe("setupWorkerLifecycle", () => {
+  // Scenario: setupWorkerLifecycle 함수가 4개 초기화 단계를 통합한다
+  it("returns tagged logger and working guardStartWatch from single call", () => {
+    const cleanup = vi.fn();
+    const { logger, guardStartWatch } = setupWorkerLifecycle("test-worker", cleanup);
+
+    // logger가 유효한 ConsolaInstance인지 확인
+    expect(typeof logger.debug).toBe("function");
+    expect(typeof logger.warn).toBe("function");
+    expect(typeof logger.error).toBe("function");
+
+    // guardStartWatch: 첫 호출은 성공
+    expect(() => guardStartWatch()).not.toThrow();
+
+    // guardStartWatch: 두 번째 호출은 에러
+    expect(() => guardStartWatch()).toThrow("startWatch can only be called once per Worker");
+  });
+});

package/tests/workers/shared-worker-lifecycle.spec.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { consola } from "consola";
+
+// setupConsola는 consola 글로벌 상태를 변경하므로 모킹
+vi.mock("@simplysm/core-node", () => ({
+  setupConsola: vi.fn(),
+}));
+
+const { setupWorkerLifecycle } = await import("../../src/workers/shared-worker-lifecycle");
+
+beforeEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("setupWorkerLifecycle logger tag", () => {
+  // Scenario: 각 워커별 고유 태그가 생성된다
+  it("creates logger with 'sd:cli:{workerName}:worker' tag pattern", () => {
+    const withTagSpy = vi.spyOn(consola, "withTag");
+
+    setupWorkerLifecycle("server-build", vi.fn());
+
+    expect(withTagSpy).toHaveBeenCalledWith("sd:cli:server-build:worker");
+  });
+
+  it("uses different tag for different worker names", () => {
+    const withTagSpy = vi.spyOn(consola, "withTag");
+
+    setupWorkerLifecycle("client", vi.fn());
+
+    expect(withTagSpy).toHaveBeenCalledWith("sd:cli:client:worker");
+  });
+});
+
+describe("setupWorkerLifecycle guardStartWatch", () => {
+  it("returns independent guard per call", () => {
+    const result1 = setupWorkerLifecycle("worker-a", vi.fn());
+    const result2 = setupWorkerLifecycle("worker-b", vi.fn());
+
+    // 각 guard는 독립적이어야 함
+    expect(() => result1.guardStartWatch()).not.toThrow();
+    expect(() => result2.guardStartWatch()).not.toThrow();
+
+    // 각각 두 번째 호출은 에러
+    expect(() => result1.guardStartWatch()).toThrow();
+    expect(() => result2.guardStartWatch()).toThrow();
+  });
+});

package/dist/angular/vite-postcss-inline-plugin.d.ts

@@ -1,18 +0,0 @@
-import type { Plugin } from "vite";
-/** sdPostCssInlinePlugin 옵션 */
-export interface SdPostCssInlinePluginOptions {
-    /** PostCSS 플러그인 배열 */
-    postCssPlugins: unknown[];
-}
-/**
- * JS 파일 내 Angular @Component 인라인 스타일에 PostCSS를 적용하는 Vite 플러그인.
- *
- * TS AST로 @Component decorator의 `styles` 배열에서 CSS 문자열을 추출하고,
- * PostCSS를 적용한 후 교체한다.
- */
-export declare function sdPostCssInlinePlugin(options: SdPostCssInlinePluginOptions): Plugin;
-/**
- * JS 코드에서 Angular @Component의 styles CSS를 추출하고 PostCSS를 적용한다.
- */
-export declare function processPostCssInline(jsContent: string, filePath: string, postCssPlugins: unknown[]): Promise<string>;
-//# sourceMappingURL=vite-postcss-inline-plugin.d.ts.map

package/dist/angular/vite-postcss-inline-plugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vite-postcss-inline-plugin.d.ts","sourceRoot":"","sources":["../../src/angular/vite-postcss-inline-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAInC,+BAA+B;AAC/B,MAAM,WAAW,4BAA4B;IAC3C,sBAAsB;IACtB,cAAc,EAAE,OAAO,EAAE,CAAC;CAC3B;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,4BAA4B,GAAG,MAAM,CAqBnF;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,OAAO,EAAE,GACxB,OAAO,CAAC,MAAM,CAAC,CA4FjB"}