@simplysm/sd-cli 14.0.64 → 14.0.65

package/tests/utils/esbuild-client-config.acc.spec.ts

@@ -1,8 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import path from "path";
 
-// --- Mocks ---
-
+// 외부 npm + Node 표준 모듈은 ESM namespace immutable이라 vi.mock 유지
 const mockContext = {
   rebuild: vi.fn(),
   watch: vi.fn(),
@@ -15,18 +14,6 @@ vi.mock("esbuild", () => ({
   },
 }));
 
-const mockAngularPlugin = { name: "sd-angular-compiler" };
-
-vi.mock("../../src/esbuild/esbuild-angular-compiler-plugin", () => ({
-  createAngularCompilerPlugin: vi.fn(() => mockAngularPlugin),
-}));
-
-const mockTransformStylesheet = vi.fn();
-
-vi.mock("../../src/angular/client-transform-stylesheet", () => ({
-  createClientTransformStylesheet: vi.fn(() => mockTransformStylesheet),
-}));
-
 vi.mock("browserslist-to-esbuild", () => ({
   default: vi.fn(() => ["chrome61"]),
 }));
@@ -44,7 +31,14 @@ vi.mock("module", async (importOriginal) => {
   };
 });
 
-// --- Imports (after mocks) ---
+import * as angularPluginMod from "../../src/esbuild/esbuild-angular-compiler-plugin";
+import * as transformStylesheetMod from "../../src/angular/client-transform-stylesheet";
+
+const mockAngularPlugin = { name: "sd-angular-compiler" };
+const mockTransformStylesheet = vi.fn();
+
+vi.spyOn(angularPluginMod, "createAngularCompilerPlugin").mockReturnValue(mockAngularPlugin as any);
+vi.spyOn(transformStylesheetMod, "createClientTransformStylesheet").mockReturnValue(mockTransformStylesheet as any);
 
 const { createClientEsbuildContext, ClientSourceFileCache } = await import(
   "../../src/esbuild/esbuild-client-config"

package/tests/utils/esbuild-client-config.spec.ts

@@ -2,8 +2,7 @@ import { describe, it, expect, vi, beforeEach } from "vitest";
 import path from "path";
 import type esbuildTypes from "esbuild";
 
-// --- Mocks ---
-
+// 외부 npm + Node 표준 모듈은 ESM namespace immutable이라 vi.mock 유지
 const mockContext = {
   rebuild: vi.fn(),
   watch: vi.fn(),
@@ -16,18 +15,6 @@ vi.mock("esbuild", () => ({
   },
 }));
 
-const mockAngularPlugin = { name: "sd-angular-compiler" };
-
-vi.mock("../../src/esbuild/esbuild-angular-compiler-plugin", () => ({
-  createAngularCompilerPlugin: vi.fn(() => mockAngularPlugin),
-}));
-
-const mockTransformStylesheet = vi.fn();
-
-vi.mock("../../src/angular/client-transform-stylesheet", () => ({
-  createClientTransformStylesheet: vi.fn(() => mockTransformStylesheet),
-}));
-
 vi.mock("browserslist-to-esbuild", () => ({
   default: vi.fn(() => ["chrome61"]),
 }));
@@ -45,18 +32,19 @@ vi.mock("module", async (importOriginal) => {
   };
 });
 
-// --- Imports (after mocks) ---
+import * as angularPluginMod from "../../src/esbuild/esbuild-angular-compiler-plugin";
+import * as transformStylesheetMod from "../../src/angular/client-transform-stylesheet";
+
+const mockAngularPlugin = { name: "sd-angular-compiler" };
+const mockTransformStylesheet = vi.fn();
+
+vi.spyOn(angularPluginMod, "createAngularCompilerPlugin").mockReturnValue(mockAngularPlugin as any);
+vi.spyOn(transformStylesheetMod, "createClientTransformStylesheet").mockReturnValue(mockTransformStylesheet as any);
 
-const { createClientEsbuildContext, ClientSourceFileCache } = await import(
-  "../../src/esbuild/esbuild-client-config"
-);
+import { createClientEsbuildContext, ClientSourceFileCache } from "../../src/esbuild/esbuild-client-config";
+import { createAngularCompilerPlugin } from "../../src/esbuild/esbuild-angular-compiler-plugin";
+import { createClientTransformStylesheet } from "../../src/angular/client-transform-stylesheet";
 const esbuild = (await import("esbuild")).default;
-const { createAngularCompilerPlugin } = await import(
-  "../../src/esbuild/esbuild-angular-compiler-plugin"
-);
-const { createClientTransformStylesheet } = await import(
-  "../../src/angular/client-transform-stylesheet"
-);
 const browserslistToEsbuild = (await import("browserslist-to-esbuild")).default;
 
 // --- Helpers ---

package/tests/utils/esbuild-config.spec.ts

@@ -1,18 +1,13 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
 import path from "path";
+import fs from "fs/promises";
+import os from "os";
 
-vi.mock("fs/promises", () => ({
-  default: {
-    readFile: vi.fn(),
-    writeFile: vi.fn(),
-    mkdir: vi.fn(),
-  },
-}));
-
-const { createServerEsbuildOptions, createEnvBanner, writeChangedOutputFiles } =
-  await import("../../src/esbuild/esbuild-config");
-
-const { default: mockFs } = await import("fs/promises");
+import {
+  createServerEsbuildOptions,
+  createEnvBanner,
+  writeChangedOutputFiles,
+} from "../../src/esbuild/esbuild-config";
 
 describe("createServerEsbuildOptions", () => {
   const baseOptions = {
@@ -121,93 +116,107 @@ describe("createEnvBanner", () => {
 });
 
 describe("writeChangedOutputFiles", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.mocked(mockFs.mkdir).mockResolvedValue(undefined);
-    vi.mocked(mockFs.writeFile).mockResolvedValue();
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "sd-esbuild-config-"));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
   });
 
   it("adds .js extension to relative import paths in .js files", async () => {
-    vi.mocked(mockFs.readFile).mockRejectedValue(new Error("not found"));
+    const distDir = path.join(tmpDir, "dist");
+    const filePath = path.join(distDir, "foo.js");
 
     await writeChangedOutputFiles([
       {
-        path: "/pkg/dist/foo.js",
+        path: filePath,
         text: 'import { bar } from "./bar";\nexport { baz } from "../utils/baz";',
       },
     ] as any);
 
-    expect(mockFs.writeFile).toHaveBeenCalledWith(
-      "/pkg/dist/foo.js",
+    const written = await fs.readFile(filePath, "utf8");
+    expect(written).toBe(
       'import { bar } from "./bar.js";\nexport { baz } from "../utils/baz.js";',
     );
   });
 
   it("preserves imports that already have extensions", async () => {
-    vi.mocked(mockFs.readFile).mockRejectedValue(new Error("not found"));
+    const filePath = path.join(tmpDir, "dist", "foo.js");
 
     await writeChangedOutputFiles([
       {
-        path: "/pkg/dist/foo.js",
+        path: filePath,
         text: 'import data from "./data.json";\nimport styles from "./styles.css";\nimport mod from "./native.node";',
       },
     ] as any);
 
-    expect(mockFs.writeFile).toHaveBeenCalledWith(
-      "/pkg/dist/foo.js",
+    const written = await fs.readFile(filePath, "utf8");
+    expect(written).toBe(
       'import data from "./data.json";\nimport styles from "./styles.css";\nimport mod from "./native.node";',
     );
   });
 
   it("skips writing when transformed content matches existing file", async () => {
-    vi.mocked(mockFs.readFile).mockResolvedValue('import { bar } from "./bar.js";');
+    const filePath = path.join(tmpDir, "dist", "foo.js");
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const existing = 'import { bar } from "./bar.js";';
+    await fs.writeFile(filePath, existing);
+    const statBefore = await fs.stat(filePath);
 
+    await new Promise((r) => setTimeout(r, 10));
     await writeChangedOutputFiles([
       {
-        path: "/pkg/dist/foo.js",
+        path: filePath,
         text: 'import { bar } from "./bar";',
       },
     ] as any);
 
-    expect(mockFs.writeFile).not.toHaveBeenCalled();
+    const statAfter = await fs.stat(filePath);
+    expect(statAfter.mtimeMs).toBe(statBefore.mtimeMs);
+    const written = await fs.readFile(filePath, "utf8");
+    expect(written).toBe(existing);
   });
 
   it("writes file when content changed", async () => {
-    vi.mocked(mockFs.readFile).mockResolvedValue('import { old } from "./old.js";');
+    const filePath = path.join(tmpDir, "dist", "foo.js");
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, 'import { old } from "./old.js";');
 
     await writeChangedOutputFiles([
       {
-        path: "/pkg/dist/foo.js",
+        path: filePath,
         text: 'import { bar } from "./bar";',
       },
     ] as any);
 
-    expect(mockFs.writeFile).toHaveBeenCalled();
+    const written = await fs.readFile(filePath, "utf8");
+    expect(written).toBe('import { bar } from "./bar.js";');
   });
 
   it("writes new file when existing file does not exist", async () => {
-    vi.mocked(mockFs.readFile).mockRejectedValue(new Error("ENOENT"));
+    const filePath = path.join(tmpDir, "dist", "foo.js");
 
     await writeChangedOutputFiles([
-      {
-        path: "/pkg/dist/foo.js",
-        text: 'const x = 1;',
-      },
+      { path: filePath, text: "const x = 1;" },
     ] as any);
 
-    expect(mockFs.mkdir).toHaveBeenCalledWith(path.dirname("/pkg/dist/foo.js"), { recursive: true });
-    expect(mockFs.writeFile).toHaveBeenCalledWith("/pkg/dist/foo.js", "const x = 1;");
+    const written = await fs.readFile(filePath, "utf8");
+    expect(written).toBe("const x = 1;");
   });
 
   it("does not transform non-.js files", async () => {
-    vi.mocked(mockFs.readFile).mockRejectedValue(new Error("not found"));
-
+    const filePath = path.join(tmpDir, "dist", "foo.js.map");
     const mapContent = '{"version":3,"sources":["./bar"]}';
+
     await writeChangedOutputFiles([
-      { path: "/pkg/dist/foo.js.map", text: mapContent },
+      { path: filePath, text: mapContent },
     ] as any);
 
-    expect(mockFs.writeFile).toHaveBeenCalledWith("/pkg/dist/foo.js.map", mapContent);
+    const written = await fs.readFile(filePath, "utf8");
+    expect(written).toBe(mapContent);
   });
 });
 

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

@@ -1,10 +1,8 @@
 /* eslint-disable no-restricted-properties -- 테스트 환경변수 조작 필요 */
 import { describe, it, expect, vi, beforeEach } from "vitest";
 
-// Hoisted mock references — available inside vi.mock factories
+// eslint, jiti는 외부 npm 패키지로 ESM namespace immutable — vi.mock 유지
 const mocks = vi.hoisted(() => ({
-  fsxExists: vi.fn<(path: string) => Promise<boolean>>(),
-  fsxGlob: vi.fn<(...args: unknown[]) => Promise<string[]>>(),
   lintFiles: vi.fn<() => Promise<Array<{ errorCount: number; warningCount: number }>>>(),
   loadFormatter: vi.fn(),
   outputFixes: vi.fn(),
@@ -12,14 +10,6 @@ const mocks = vi.hoisted(() => ({
   eslintCtor: vi.fn(),
 }));
 
-vi.mock("@simplysm/core-node", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("@simplysm/core-node")>();
-  return {
-    ...actual,
-    fsx: { exists: mocks.fsxExists, glob: mocks.fsxGlob },
-  };
-});
-
 vi.mock("eslint", () => ({
   ESLint: class MockESLint {
     constructor(options: unknown) { mocks.eslintCtor(options); }
@@ -33,7 +23,11 @@ vi.mock("jiti", () => ({
   createJiti: vi.fn(() => ({ import: mocks.jitiImport })),
 }));
 
-const { loadIgnorePatterns, executeLint } = await import("../../src/lint/lint-core");
+import { fsx } from "@simplysm/core-node";
+import { loadIgnorePatterns, executeLint } from "../../src/lint/lint-core";
+
+const fsxExists = vi.spyOn(fsx, "exists");
+const fsxGlob = vi.spyOn(fsx, "glob");
 
 //#region loadIgnorePatterns
 
@@ -41,7 +35,7 @@ describe("loadIgnorePatterns", () => {
   beforeEach(() => vi.clearAllMocks());
 
   it("extracts globalIgnores patterns from eslint config", async () => {
-    mocks.fsxExists.mockImplementation((p) =>
+    fsxExists.mockImplementation((p) =>
       Promise.resolve(typeof p === "string" && p.endsWith("eslint.config.ts")),
     );
     mocks.jitiImport.mockResolvedValue({
@@ -57,7 +51,7 @@ describe("loadIgnorePatterns", () => {
   });
 
   it("ignores config objects that have files key", async () => {
-    mocks.fsxExists.mockImplementation((p) =>
+    fsxExists.mockImplementation((p) =>
       Promise.resolve(typeof p === "string" && p.endsWith("eslint.config.ts")),
     );
     mocks.jitiImport.mockResolvedValue({
@@ -69,7 +63,7 @@ describe("loadIgnorePatterns", () => {
   });
 
   it("throws when no eslint config file found", async () => {
-    mocks.fsxExists.mockResolvedValue(false);
+    fsxExists.mockResolvedValue(false);
 
     await expect(loadIgnorePatterns("/project")).rejects.toThrow(
       "ESLint 설정 파일",
@@ -85,11 +79,11 @@ describe("executeLint", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     // Default: eslint config exists with no ignores
-    mocks.fsxExists.mockImplementation((p) =>
+    fsxExists.mockImplementation((p) =>
       Promise.resolve(typeof p === "string" && p.endsWith("eslint.config.ts")),
     );
     mocks.jitiImport.mockResolvedValue({ default: [] });
-    mocks.fsxGlob.mockResolvedValue(["/project/src/a.ts", "/project/src/b.ts"]);
+    fsxGlob.mockResolvedValue(["/project/src/a.ts", "/project/src/b.ts"]);
     mocks.lintFiles.mockResolvedValue([{ errorCount: 0, warningCount: 0 }]);
     mocks.loadFormatter.mockResolvedValue({
       format: vi.fn().mockResolvedValue(""),
@@ -106,7 +100,7 @@ describe("executeLint", () => {
 
   it("filters files by targets via pathx.filterByTargets", async () => {
     const cwd = process.cwd().replace(/\\/g, "/");
-    mocks.fsxGlob.mockResolvedValue([
+    fsxGlob.mockResolvedValue([
       `${cwd}/packages/core-common/src/a.ts`,
       `${cwd}/packages/other/src/b.ts`,
     ]);
@@ -162,7 +156,7 @@ describe("executeLint", () => {
   });
 
   it("returns success when no files to lint", async () => {
-    mocks.fsxGlob.mockResolvedValue([]);
+    fsxGlob.mockResolvedValue([]);
 
     const result = await executeLint({ targets: [], fix: false, timing: false });
 

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

@@ -1,29 +1,22 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
+import { Worker } from "@simplysm/core-node";
 
-//#region Mocks
-
-const mocks = vi.hoisted(() => ({
-  workerCreate: vi.fn(),
+const mocks = {
+  workerCreate: vi.spyOn(Worker, "create"),
   lintFn: vi.fn(),
   terminateFn: vi.fn(async () => {}),
-}));
-
-vi.mock("@simplysm/core-node", () => ({
-  Worker: {
-    create: mocks.workerCreate,
-  },
-}));
+};
 
-const { runLintInWorker } = await import("../../src/lint/lint-utils");
-
-//#endregion
+import { runLintInWorker } from "../../src/lint/lint-utils";
 
 beforeEach(() => {
   vi.clearAllMocks();
   mocks.workerCreate.mockReturnValue({
     lint: mocks.lintFn,
     terminate: mocks.terminateFn,
-  });
+    on: vi.fn(),
+    off: vi.fn(),
+  } as never);
 });
 
 describe("runLintInWorker", () => {

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

@@ -1,7 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
+import { consola } from "consola";
 
-// --- Mock ESLint ---
-
+// eslint은 외부 npm으로 ESM namespace immutable — vi.mock 유지
 const { mockLintFiles, mockLoadFormatter, MockESLintClass } = vi.hoisted(() => {
   const lintFilesFn = vi.fn();
   const loadFormatterFn = vi.fn();
@@ -18,10 +18,6 @@ vi.mock("eslint", () => ({
   ESLint: MockESLintClass,
 }));
 
-// --- Spy consola ---
-
-import { consola } from "consola";
-
 const mockLintLogger = {
   debug: vi.fn(),
   info: vi.fn(),
@@ -31,7 +27,7 @@ const mockLintLogger = {
 
 vi.spyOn(consola, "withTag").mockReturnValue(mockLintLogger as any);
 
-const { LintWithProgramRunner } = await import("../../src/lint/lint-with-program");
+import { LintWithProgramRunner } from "../../src/lint/lint-with-program";
 
 // --- Helpers ---
 

package/tests/utils/ngtsc-build-core.spec.ts

@@ -1,104 +1,8 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import ts from "typescript";
+import { describe, it, expect } from "vitest";
 
-// --- Mock: AngularCompiler를 사용하는지 검증 ---
-
-const mockInitialize = vi.fn().mockResolvedValue({ affectedFiles: new Set() });
-const mockCollectDiagnostics = vi.fn().mockReturnValue([]);
-const mockEmitAffectedFiles = vi.fn().mockReturnValue([]);
-const mockGetTsProgram = vi.fn().mockReturnValue({
-  getSourceFiles: () => [],
-});
-
-const angularCompilerConstructorSpy = vi.fn();
-
-vi.mock("../../src/angular/angular-compiler", () => {
-  class AngularCompiler {
-    constructor(options: unknown) {
-      angularCompilerConstructorSpy(options);
-    }
-    initialize = mockInitialize;
-    *collectDiagnostics() {
-      yield* mockCollectDiagnostics();
-    }
-    *emitAffectedFiles() {
-      yield* mockEmitAffectedFiles();
-    }
-    getTsProgram = mockGetTsProgram;
-  }
-
-  class AngularSourceFileCache extends Map<string, ts.SourceFile> {
-    readonly modifiedFiles = new Set<string>();
-    invalidate(_files: Iterable<string>): void {
-      // no-op
-    }
-  }
-
-  return {
-    AngularCompiler,
-    AngularSourceFileCache,
-    augmentHostWithCaching: vi.fn(),
-  };
-});
-
-vi.mock("../../src/utils/tsconfig", () => ({
-  parseTsconfig: vi.fn().mockReturnValue({
-    options: {
-      target: ts.ScriptTarget.ESNext,
-      module: ts.ModuleKind.ESNext,
-      moduleResolution: ts.ModuleResolutionKind.Bundler,
-      strict: false,
-      skipLibCheck: true,
-    },
-    fileNames: ["/workspace/packages/test-pkg/src/main.ts"],
-  }),
-  getPackageSourceFiles: vi
-    .fn()
-    .mockReturnValue(["/workspace/packages/test-pkg/src/main.ts"]),
-  getCompilerOptionsForEnv: vi.fn().mockImplementation((opts: ts.CompilerOptions) => opts),
-}));
-
-const ngtscProgramSpy = vi.fn();
-vi.mock("../../src/angular/angular-build", () => {
-  class NgtscProgram {
-    constructor(...args: unknown[]) {
-      ngtscProgramSpy(...args);
-    }
-    compiler = {
-      analyzeAsync: vi.fn().mockResolvedValue(undefined),
-      getDiagnosticsForFile: vi.fn().mockReturnValue([]),
-      getOptionDiagnostics: vi.fn().mockReturnValue([]),
-      getResourceDependencies: vi.fn().mockReturnValue([]),
-      ignoreForDiagnostics: new Set(),
-      ignoreForEmit: new Set(),
-      incrementalCompilation: {
-        safeToSkipEmit: vi.fn().mockReturnValue(false),
-        recordSuccessfulEmit: vi.fn(),
-      },
-      prepareEmit: vi.fn().mockReturnValue({ transformers: { before: [], after: [] } }),
-    };
-    getTsProgram() {
-      return { getSourceFiles: () => [] } as unknown as ts.Program;
-    }
-  }
-  return {
-    NgtscProgram,
-    OptimizeFor: { WholeProgram: 0, SingleFile: 1 },
-  };
-});
-
-const {
-  createLibraryTransformStylesheet,
-} = await import("../../src/angular/ngtsc-build-core");
-
-
-// ─── createLibraryTransformStylesheet ───
+import { createLibraryTransformStylesheet } from "../../src/angular/ngtsc-build-core";
 
 describe("createLibraryTransformStylesheet", () => {
-  beforeEach(() => {
-    vi.restoreAllMocks();
-  });
-
   it("외부 .scss 파일이면 compileScssFile로 CSS를 반환하고 의존성을 기록한다", async () => {
     const loadPaths = ["/pkg/scss", "/cwd/node_modules"];
     const scssErrors: string[] = [];
@@ -185,4 +89,3 @@ describe("createLibraryTransformStylesheet", () => {
     expect(scssDependencies.has("/project/src/app.component.ts")).toBe(true);
   });
 });
-

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

@@ -1,28 +1,15 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import type { SdConfig } from "../../src/sd-config.types";
 
-//#region Mocks
+import * as sdConfigMod from "../../src/utils/sd-config";
+import * as packageUtilsMod from "../../src/utils/package-utils";
 
-const mocks = vi.hoisted(() => ({
-  loadSdConfig: vi.fn(),
-  validateTargets: vi.fn(),
-}));
+const mocks = {
+  loadSdConfig: vi.spyOn(sdConfigMod, "loadSdConfig"),
+  validateTargets: vi.spyOn(packageUtilsMod, "validateTargets"),
+};
 
-vi.mock("../../src/utils/sd-config", () => ({
-  loadSdConfig: mocks.loadSdConfig,
-}));
-
-vi.mock("../../src/utils/package-utils", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("../../src/utils/package-utils")>();
-  return {
-    ...actual,
-    validateTargets: mocks.validateTargets,
-  };
-});
-
-const { loadAndValidateConfig } = await import("../../src/utils/orchestrator-utils");
-
-//#endregion
+import { loadAndValidateConfig } from "../../src/utils/orchestrator-utils";
 
 beforeEach(() => {
   vi.clearAllMocks();

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

@@ -4,21 +4,15 @@ import type { BuildResult } from "../../src/runtime/ResultCollector";
 import type { PartialMessage } from "esbuild";
 
 // output-utils.ts가 모듈 로드 시 consola.withTag("sd:cli:output")로 로거를 생성하므로,
-// withTag가 consola 자체를 반환하도록 하여 기존 스파이가 태그 로거 호출을 캡처하게 한다.
-vi.mock("consola", async (importOriginal) => {
-  const mod = await importOriginal<typeof import("consola")>();
-  const orig = mod.consola;
-  vi.spyOn(orig, "withTag").mockReturnValue(orig);
-  return { consola: orig };
-});
-
-const { formatBuildMessages, formatEsbuildMessages, printDiagnostics, printServers } =
-  await import("../../src/utils/output-utils");
-
+// 동적 import 전에 spy 등록하여 withTag가 consola 자체를 반환하게 한다
+vi.spyOn(consola, "withTag").mockReturnValue(consola);
 vi.spyOn(consola, "error").mockImplementation(() => {});
 vi.spyOn(consola, "warn").mockImplementation(() => {});
 vi.spyOn(consola, "info").mockImplementation(() => {});
 
+const { formatBuildMessages, formatEsbuildMessages, printDiagnostics, printServers } =
+  await import("../../src/utils/output-utils");
+
 describe("formatBuildMessages", () => {
   it("formats name, label, and messages into indented lines", () => {
     const result = formatBuildMessages("core", "node", ["error in file.ts"]);

package/tests/utils/sd-config.spec.ts

@@ -1,25 +1,17 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
+import { fsx } from "@simplysm/core-node";
 
-const mockExists = vi.fn();
+const mockExists = vi.spyOn(fsx, "exists");
 const mockJitiImport = vi.fn();
 
-vi.mock("@simplysm/core-node", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("@simplysm/core-node")>();
-  return {
-    ...actual,
-    fsx: {
-      exists: (...args: unknown[]) => mockExists(...args),
-    },
-  };
-});
-
+// jiti는 외부 npm으로 ESM namespace immutable이라 vi.mock 유지
 vi.mock("jiti", () => ({
   createJiti: () => ({
     import: (...args: unknown[]) => mockJitiImport(...args),
   }),
 }));
 
-const { loadSdConfig } = await import("../../src/utils/sd-config");
+import { loadSdConfig } from "../../src/utils/sd-config";
 
 describe("loadSdConfig", () => {
   const baseParams = { cwd: "/project", dev: true, opt: [] as string[] };