@simplysm/sd-cli 13.0.99 → 14.0.1

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

@@ -0,0 +1,43 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { applyDebugLevel, createOnceGuard } from "../../src/utils/worker-utils";
+import consola, { LogLevels } from "consola";
+
+describe("applyDebugLevel", () => {
+  const originalLevel = consola.level;
+  const originalEnv = process.env["SD_DEBUG"];
+
+  afterEach(() => {
+    consola.level = originalLevel;
+    if (originalEnv === undefined) {
+      delete process.env["SD_DEBUG"];
+    } else {
+      process.env["SD_DEBUG"] = originalEnv;
+    }
+  });
+
+  it("sets consola level to debug when SD_DEBUG is 'true'", () => {
+    process.env["SD_DEBUG"] = "true";
+    applyDebugLevel();
+    expect(consola.level).toBe(LogLevels.debug);
+  });
+
+  it("does not change level when SD_DEBUG is not set", () => {
+    delete process.env["SD_DEBUG"];
+    const before = consola.level;
+    applyDebugLevel();
+    expect(consola.level).toBe(before);
+  });
+});
+
+describe("createOnceGuard", () => {
+  it("allows first call", () => {
+    const guard = createOnceGuard("startWatch");
+    expect(() => guard()).not.toThrow();
+  });
+
+  it("throws on second call", () => {
+    const guard = createOnceGuard("startWatch");
+    guard();
+    expect(() => guard()).toThrow("startWatch can only be called once per Worker");
+  });
+});

package/tests/vitest-plugin-cwd.spec.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect, beforeAll } from "vitest";
+import type { Plugin } from "vite";
+import { resolve } from "node:path";
+
+const workspaceRoot = resolve(import.meta.dirname, "../../..");
+const angularTsconfig = resolve(workspaceRoot, "packages/angular/tsconfig.json");
+
+async function callTransform(
+  plugin: Plugin,
+  code: string,
+  id: string,
+): Promise<{ code: string; map?: unknown } | undefined> {
+  if (typeof plugin.transform !== "function") return undefined;
+  const result = await (plugin.transform as (code: string, id: string) => Promise<unknown>).call(
+    {},
+    code,
+    id,
+  );
+  return result as { code: string; map?: unknown } | undefined;
+}
+
+// Scenario 3: cwd 옵션으로 워크스페이스 루트를 지정한다
+describe("angularVitestPlugin with explicit cwd", () => {
+  let plugin: Plugin;
+
+  beforeAll(async () => {
+    const { angularVitestPlugin } = await import("../src/vitest-plugin");
+    plugin = angularVitestPlugin({ tsconfig: angularTsconfig, cwd: workspaceRoot });
+    if (typeof plugin.buildStart === "function") {
+      await (plugin.buildStart as () => Promise<void>).call({});
+    }
+  }, 30_000);
+
+  it("compiles Angular source successfully with explicit cwd", async () => {
+    const filePath = resolve(
+      workspaceRoot,
+      "packages/angular/src/core/providers/sd-theme-provider.ts",
+    );
+    const result = await callTransform(plugin, "", filePath);
+
+    expect(result).toBeDefined();
+    expect(result!.code).toContain("ɵprov");
+  });
+});
+
+// Scenario 4: cwd 미지정 시 tsconfig 기준 상위 2단계를 사용한다
+describe("angularVitestPlugin without cwd (fallback)", () => {
+  let plugin: Plugin;
+
+  beforeAll(async () => {
+    const { angularVitestPlugin } = await import("../src/vitest-plugin");
+    plugin = angularVitestPlugin({ tsconfig: angularTsconfig });
+    if (typeof plugin.buildStart === "function") {
+      await (plugin.buildStart as () => Promise<void>).call({});
+    }
+  }, 30_000);
+
+  it("compiles Angular source successfully with default cwd", async () => {
+    const filePath = resolve(
+      workspaceRoot,
+      "packages/angular/src/core/providers/sd-theme-provider.ts",
+    );
+    const result = await callTransform(plugin, "", filePath);
+
+    expect(result).toBeDefined();
+    expect(result!.code).toContain("ɵprov");
+  });
+});

package/tests/vitest-plugin.spec.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect, beforeAll } from "vitest";
+import type { Plugin } from "vite";
+import { resolve } from "node:path";
+
+const workspaceRoot = resolve(import.meta.dirname, "../../..");
+const angularTsconfig = resolve(workspaceRoot, "packages/angular/tsconfig.json");
+
+async function callTransform(
+  plugin: Plugin,
+  code: string,
+  id: string,
+): Promise<{ code: string; map?: unknown } | undefined> {
+  if (typeof plugin.transform !== "function") return undefined;
+  const result = await (plugin.transform as (code: string, id: string) => Promise<unknown>).call(
+    {},
+    code,
+    id,
+  );
+  return result as { code: string; map?: unknown } | undefined;
+}
+
+describe("angularVitestPlugin", () => {
+  let plugin: Plugin;
+
+  beforeAll(async () => {
+    const { angularVitestPlugin } = await import("../src/vitest-plugin");
+    plugin = angularVitestPlugin({ tsconfig: angularTsconfig });
+    if (typeof plugin.buildStart === "function") {
+      await (plugin.buildStart as () => Promise<void>).call({});
+    }
+  }, 30_000);
+
+  // Unit: non-Angular 파일 필터링
+  it("returns undefined for node_modules path", async () => {
+    const result = await callTransform(
+      plugin,
+      "",
+      resolve(workspaceRoot, "node_modules/@angular/core/index.ts"),
+    );
+    expect(result).toBeUndefined();
+  });
+
+  it("returns undefined for non-.ts file", async () => {
+    const result = await callTransform(plugin, "", resolve(workspaceRoot, "vitest.config.js"));
+    expect(result).toBeUndefined();
+  });
+
+  it("returns undefined for test file not in compilation scope", async () => {
+    const result = await callTransform(
+      plugin,
+      "",
+      resolve(workspaceRoot, "packages/angular/tests/testbed-setup.spec.ts"),
+    );
+    expect(result).toBeUndefined();
+  });
+
+  // Unit: @Directive 변환
+  it("compiles @Directive source and serves ɵdir runtime code", async () => {
+    const filePath = resolve(
+      workspaceRoot,
+      "packages/angular/src/core/directives/sd-events.directive.ts",
+    );
+    const result = await callTransform(plugin, "", filePath);
+
+    expect(result).toBeDefined();
+    expect(result!.code).toContain("ɵdir");
+  });
+
+  // Unit: 소스맵 포함 (inline)
+  it("includes inline sourcemap in compiled output", async () => {
+    const filePath = resolve(
+      workspaceRoot,
+      "packages/angular/src/core/providers/sd-theme-provider.ts",
+    );
+    const result = await callTransform(plugin, "", filePath);
+
+    expect(result).toBeDefined();
+    expect(result!.code).toContain("//# sourceMappingURL=data:application/json;base64,");
+  });
+
+  // Acceptance: Scenario "vitest-plugin이 동일한 SCSS 컴파일 모듈을 사용한다"
+  // buildStart succeeds with SCSS-enabled transformResource, proving scss-compiler is wired up.
+  // The angular package currently has no components with SCSS styles, so this verifies
+  // the integration path without exercising actual SCSS content.
+  it("initializes with SCSS-enabled transformResource without errors", () => {
+    // buildStart already called in beforeAll — if transformResource had an error, it would throw
+    expect(plugin).toBeDefined();
+    expect(plugin.name).toBe("angular-vitest");
+  });
+
+  // Acceptance: 플러그인 초기화 + @Injectable AOT 컴파일 + 인메모리 서빙
+  it("compiles @Injectable source and serves ɵprov runtime code via transform", async () => {
+    const filePath = resolve(
+      workspaceRoot,
+      "packages/angular/src/core/providers/sd-theme-provider.ts",
+    );
+    const result = await callTransform(plugin, "", filePath);
+
+    expect(result).toBeDefined();
+    expect(result!.code).toContain("ɵprov");
+    expect(result!.code).not.toContain("@Injectable");
+  });
+});

package/tests/workers/library-build-worker.spec.ts

@@ -0,0 +1,258 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+//#region Mocks
+
+let workerFns: Record<string, (...args: any[]) => any>;
+let mockSend: ReturnType<typeof vi.fn>;
+
+// FsWatcher mock
+const mockOnChange = vi.fn();
+const mockWatcherClose = vi.fn();
+
+// tsc build mock
+const mockRunTscPackageBuild = vi.fn(() => ({
+  success: true,
+  errors: undefined,
+  diagnostics: [],
+  errorCount: 0,
+  warningCount: 0,
+}));
+
+vi.mock("@simplysm/core-node", () => ({
+  createWorker: vi.fn((fns: Record<string, Function>) => {
+    workerFns = fns as any;
+    mockSend = vi.fn();
+    return { send: mockSend };
+  }),
+  FsWatcher: {
+    watch: vi.fn(() => Promise.resolve({
+      onChange: mockOnChange,
+      close: mockWatcherClose,
+    })),
+  },
+}));
+
+vi.mock("@simplysm/core-common", () => ({
+  err: { message: (e: any) => e?.message ?? String(e) },
+}));
+
+vi.mock("consola", () => ({
+  consola: {
+    withTag: vi.fn(() => ({
+      debug: vi.fn(),
+      warn: vi.fn(),
+    })),
+  },
+}));
+
+vi.mock("../../src/utils/tsc-build", () => ({
+  runTscPackageBuild: mockRunTscPackageBuild,
+}));
+
+vi.mock("../../src/utils/worker-utils", () => ({
+  applyDebugLevel: vi.fn(),
+  registerCleanupHandlers: vi.fn(),
+  createOnceGuard: vi.fn(() => vi.fn()),
+}));
+
+const mockCollectDeps = vi.fn((_pkgDir: string, _cwd: string) => ({ workspaceDeps: [] as string[], replaceDeps: [] as string[] }));
+vi.mock("../../src/utils/package-utils", () => ({
+  collectDeps: (...args: [string, string]) => mockCollectDeps(...args),
+}));
+
+//#endregion
+
+// Force fresh module import for each test
+beforeEach(async () => {
+  vi.clearAllMocks();
+  mockRunTscPackageBuild.mockReturnValue({
+    success: true,
+    errors: undefined,
+    diagnostics: [],
+    errorCount: 0,
+    warningCount: 0,
+  });
+  mockCollectDeps.mockReturnValue({ workspaceDeps: [], replaceDeps: [] });
+  // Re-import to get fresh workerFns
+  vi.resetModules();
+  await import("../../src/workers/library-build.worker");
+});
+
+const buildInfo = {
+  name: "test-pkg",
+  config: { target: "node" as const },
+  cwd: "/",
+  pkgDir: "/pkg",
+  output: { js: true, dts: true },
+};
+
+describe("library-build.worker build()", () => {
+  // Acceptance: tsc builds JS + DTS in single process
+  it("runs tsc with output flags and returns combined result", () => {
+    const result = workerFns["build"]({ ...buildInfo, output: { js: true, dts: true } });
+
+    expect(result.js.success).toBe(true);
+    expect(result.dts.success).toBe(true);
+    expect(mockRunTscPackageBuild).toHaveBeenCalledWith(
+      expect.objectContaining({ output: { js: true, dts: true } }),
+    );
+  });
+
+  // Acceptance: DTS only build
+  it("passes dts-only output to tsc", () => {
+    const result = workerFns["build"]({ ...buildInfo, output: { js: false, dts: true } });
+
+    expect(result.js.success).toBe(true);
+    expect(result.dts.success).toBe(true);
+    expect(mockRunTscPackageBuild).toHaveBeenCalledWith(
+      expect.objectContaining({ output: { js: false, dts: true } }),
+    );
+  });
+
+  // Acceptance: Typecheck only
+  it("runs typecheck only when both false", () => {
+    const result = workerFns["build"]({ ...buildInfo, output: { js: false, dts: false } });
+
+    expect(result.dts.success).toBe(true);
+    expect(mockRunTscPackageBuild).toHaveBeenCalledWith(
+      expect.objectContaining({ output: { js: false, dts: false } }),
+    );
+  });
+
+  // Unit: tsc failure reflects in both js and dts results
+  it("reports failure in both js and dts when tsc fails", () => {
+    mockRunTscPackageBuild.mockReturnValueOnce({
+      success: false,
+      errors: ["TS2345: type error"] as any,
+      diagnostics: [{ code: 2345, category: 1 }] as any,
+      errorCount: 1,
+      warningCount: 0,
+    });
+
+    const result = workerFns["build"]({ ...buildInfo, output: { js: true, dts: true } });
+
+    expect(result.js.success).toBe(false);
+    expect(result.js.errors).toContain("TS2345: type error");
+    expect(result.dts.success).toBe(false);
+    expect(result.dts.diagnostics).toHaveLength(1);
+  });
+
+  // Unit: build is synchronous (no esbuild async)
+  it("returns result synchronously (not a Promise)", () => {
+    const result = workerFns["build"]({ ...buildInfo });
+    // If it were async, result would be a Promise
+    expect(result).not.toBeInstanceOf(Promise);
+    expect(result.js.success).toBe(true);
+  });
+});
+
+describe("library-build.worker startWatch()", () => {
+  // Acceptance: Initial build completes before returning
+  it("completes initial build and sends build event", async () => {
+    await workerFns["startWatch"]({ ...buildInfo, output: { js: true, dts: true } });
+
+    expect(mockSend).toHaveBeenCalledWith("build", expect.objectContaining({
+      js: expect.objectContaining({ success: true }),
+      dts: expect.objectContaining({ success: true }),
+    }));
+  });
+
+  // Acceptance: FsWatcher is set up
+  it("starts FsWatcher after initial build", async () => {
+    await workerFns["startWatch"]({ ...buildInfo, output: { js: true, dts: true } });
+
+    const { FsWatcher } = await import("@simplysm/core-node");
+    expect(FsWatcher.watch).toHaveBeenCalledWith([
+      expect.stringContaining("*.{ts,tsx}"),
+    ]);
+    expect(mockOnChange).toHaveBeenCalledWith(
+      expect.objectContaining({ delay: 300 }),
+      expect.any(Function),
+    );
+  });
+
+  // Acceptance: File change triggers rebuild with buildStart event
+  it("sends buildStart and build events on file change", async () => {
+    await workerFns["startWatch"]({ ...buildInfo, output: { js: true, dts: true } });
+
+    const onChangeCallback = mockOnChange.mock.calls[0][1];
+    mockSend.mockClear();
+
+    await onChangeCallback();
+
+    expect(mockSend).toHaveBeenCalledWith("buildStart", {});
+    expect(mockSend).toHaveBeenCalledWith("build", expect.objectContaining({
+      js: expect.objectContaining({ success: true }),
+      dts: expect.objectContaining({ success: true }),
+    }));
+  });
+
+  // Unit: No esbuild context management needed
+  it("does not require esbuild for watch mode", async () => {
+    await workerFns["startWatch"]({ ...buildInfo, output: { js: true, dts: true } });
+
+    // tsc is called for rebuild
+    expect(mockRunTscPackageBuild).toHaveBeenCalledWith(
+      expect.objectContaining({ output: { js: true, dts: true } }),
+    );
+  });
+
+  // Unit: error event on exception
+  it("sends error event on rebuild exception", async () => {
+    await workerFns["startWatch"]({ ...buildInfo, output: { js: true, dts: true } });
+
+    mockRunTscPackageBuild.mockImplementationOnce(() => { throw new Error("tsc crash"); });
+    const onChangeCallback = mockOnChange.mock.calls[0][1];
+    mockSend.mockClear();
+
+    await onChangeCallback();
+
+    expect(mockSend).toHaveBeenCalledWith("error", { message: "tsc crash" });
+  });
+
+  // Acceptance: Watches workspace dependency source directories
+  it("includes workspace dependency src/ in watch paths", async () => {
+    mockCollectDeps.mockReturnValue({ workspaceDeps: ["core-common", "core-node"], replaceDeps: [] });
+
+    await workerFns["startWatch"]({ ...buildInfo, output: { js: true, dts: true } });
+
+    const { FsWatcher } = await import("@simplysm/core-node");
+    const watchPaths = vi.mocked(FsWatcher.watch).mock.calls[0][0];
+
+    // Own src/ + 2 workspace deps' src/
+    expect(watchPaths).toHaveLength(3);
+    expect(watchPaths).toEqual(expect.arrayContaining([
+      expect.stringContaining("core-common"),
+      expect.stringContaining("core-node"),
+    ]));
+  });
+
+  // Unit: collectDeps is called with correct arguments
+  it("calls collectDeps with pkgDir and cwd", async () => {
+    await workerFns["startWatch"]({ ...buildInfo, output: { js: true, dts: true } });
+
+    expect(mockCollectDeps).toHaveBeenCalledWith("/pkg", "/");
+  });
+
+  // Unit: no extra paths when no workspace deps
+  it("watches only own src/ when no workspace deps", async () => {
+    mockCollectDeps.mockReturnValue({ workspaceDeps: [], replaceDeps: [] });
+
+    await workerFns["startWatch"]({ ...buildInfo, output: { js: true, dts: true } });
+
+    const { FsWatcher } = await import("@simplysm/core-node");
+    const watchPaths = vi.mocked(FsWatcher.watch).mock.calls[0][0];
+
+    expect(watchPaths).toHaveLength(1);
+    expect(watchPaths[0]).toContain("pkg");
+  });
+});
+
+describe("library-build.worker stopWatch()", () => {
+  it("cleans up FsWatcher", async () => {
+    await workerFns["startWatch"]({ ...buildInfo, output: { js: true, dts: true } });
+    await workerFns["stopWatch"]();
+
+    expect(mockWatcherClose).toHaveBeenCalled();
+  });
+});

package/tests/workers/ngtsc-build-worker.spec.ts

@@ -0,0 +1,187 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { resolve } from "node:path";
+import fs from "node:fs";
+import { runNgtscBuild, compileGlobalScss } from "../../src/utils/ngtsc-build-core";
+
+const workspaceRoot = resolve(import.meta.dirname, "../../../..");
+const angularPkgDir = resolve(workspaceRoot, "packages/angular");
+const distDir = resolve(angularPkgDir, "dist");
+
+describe("ngtsc-build-core: NgtscProgram AOT compilation", () => {
+  beforeAll(() => {
+    // Clean dist before tests
+    if (fs.existsSync(distDir)) {
+      fs.rmSync(distDir, { recursive: true, force: true });
+    }
+  });
+
+  afterAll(() => {
+    // Clean up dist after tests
+    if (fs.existsSync(distDir)) {
+      fs.rmSync(distDir, { recursive: true, force: true });
+    }
+  });
+
+  // Acceptance: Scenario "@Injectable 데코레이터가 런타임 코드로 변환된다"
+  it("transforms @Injectable decorator to runtime ɵprov factory", async () => {
+    const result = await runNgtscBuild({
+      name: "angular",
+      cwd: workspaceRoot,
+      pkgDir: angularPkgDir,
+      output: { js: true, dts: false },
+    });
+
+    // Debug: print errors if build failed
+    if (!result.js.success) {
+      console.error("JS errors:", result.js.errors);
+      console.error("DTS errors:", result.dts.errors);
+    }
+
+    expect(result.js.success).toBe(true);
+
+    // Find the provider file output
+    const providerJsPath = resolve(distDir, "core", "providers", "sd-theme-provider.js");
+    expect(fs.existsSync(providerJsPath)).toBe(true);
+
+    const content = fs.readFileSync(providerJsPath, "utf-8");
+    // ɵprov is the Angular injectable factory
+    expect(content).toContain("ɵprov");
+    // Original @Injectable decorator should be removed
+    expect(content).not.toContain("@Injectable");
+  }, 60_000);
+
+  // Acceptance: Scenario "@Directive 데코레이터가 런타임 코드로 변환된다"
+  it("transforms @Directive decorator to runtime ɵdir definition", () => {
+    // dist already populated from prior test, check directive
+    const directiveJsPath = resolve(distDir, "core", "directives", "sd-events.directive.js");
+    expect(fs.existsSync(directiveJsPath)).toBe(true);
+
+    const content = fs.readFileSync(directiveJsPath, "utf-8");
+    expect(content).toContain("ɵdir");
+  }, 60_000);
+
+  // Acceptance: Scenario ".d.ts 파일이 Angular 메타데이터를 포함하여 출력된다"
+  it("outputs .d.ts files with Angular type metadata", async () => {
+    // Clean dist and run with dts: true
+    if (fs.existsSync(distDir)) {
+      fs.rmSync(distDir, { recursive: true, force: true });
+    }
+
+    const result = await runNgtscBuild({
+      name: "angular",
+      cwd: workspaceRoot,
+      pkgDir: angularPkgDir,
+      output: { js: true, dts: true },
+    });
+
+    expect(result.dts.success).toBe(true);
+
+    const providerDtsPath = resolve(distDir, "core", "providers", "sd-theme-provider.d.ts");
+    expect(fs.existsSync(providerDtsPath)).toBe(true);
+
+    const content = fs.readFileSync(providerDtsPath, "utf-8");
+    // Angular .d.ts includes ɵ metadata fields
+    expect(content).toMatch(/ɵ(prov|fac)/);
+  }, 60_000);
+
+  // Acceptance: Scenario "run()으로 one-time 빌드를 수행한다"
+  it("produces both JS and .d.ts when output is {js: true, dts: true}", () => {
+    // dist already populated from prior test
+    const jsExists = fs.existsSync(resolve(distDir, "core", "providers", "sd-theme-provider.js"));
+    const dtsExists = fs.existsSync(resolve(distDir, "core", "providers", "sd-theme-provider.d.ts"));
+
+    expect(jsExists).toBe(true);
+    expect(dtsExists).toBe(true);
+  }, 60_000);
+
+  // Acceptance: Scenario "run()에서 dts: false면 .d.ts를 생략한다"
+  it("omits .d.ts when output is {js: true, dts: false}", async () => {
+    if (fs.existsSync(distDir)) {
+      fs.rmSync(distDir, { recursive: true, force: true });
+    }
+
+    const result = await runNgtscBuild({
+      name: "angular",
+      cwd: workspaceRoot,
+      pkgDir: angularPkgDir,
+      output: { js: true, dts: false },
+    });
+
+    expect(result.js.success).toBe(true);
+
+    const jsExists = fs.existsSync(resolve(distDir, "core", "providers", "sd-theme-provider.js"));
+    expect(jsExists).toBe(true);
+
+    // Should NOT have .d.ts files
+    const dtsExists = fs.existsSync(resolve(distDir, "core", "providers", "sd-theme-provider.d.ts"));
+    expect(dtsExists).toBe(false);
+  }, 60_000);
+
+  // Acceptance: Scenario "TypeScript + Angular diagnostics를 통합 수집한다"
+  it("collects diagnostics from both TypeScript and Angular compiler", async () => {
+    if (fs.existsSync(distDir)) {
+      fs.rmSync(distDir, { recursive: true, force: true });
+    }
+
+    const result = await runNgtscBuild({
+      name: "angular",
+      cwd: workspaceRoot,
+      pkgDir: angularPkgDir,
+      output: { js: true, dts: true },
+    });
+
+    // Angular package should compile cleanly
+    expect(result.dts.diagnostics).toBeDefined();
+    expect(Array.isArray(result.dts.diagnostics)).toBe(true);
+  }, 60_000);
+
+  // Acceptance: Scenario "타입 에러가 있어도 빌드 결과를 반환한다"
+  // This tests error handling by verifying the result structure is always returned
+  it("returns complete result structure even when build succeeds", async () => {
+    const result = await runNgtscBuild({
+      name: "angular",
+      cwd: workspaceRoot,
+      pkgDir: angularPkgDir,
+      output: { js: true, dts: true },
+    });
+
+    // Verify result structure completeness
+    expect(result.js).toHaveProperty("success");
+    expect(result.dts).toHaveProperty("success");
+    expect(result.dts).toHaveProperty("diagnostics");
+    expect(Array.isArray(result.dts.diagnostics)).toBe(true);
+  }, 60_000);
+
+  // Acceptance: Scenario "scss/styles.scss가 CSS로 컴파일되어 dist에 출력된다"
+  it("compiles scss/styles.scss to dist/styles.css", async () => {
+    if (fs.existsSync(distDir)) {
+      fs.rmSync(distDir, { recursive: true, force: true });
+    }
+
+    const result = await runNgtscBuild({
+      name: "angular",
+      cwd: workspaceRoot,
+      pkgDir: angularPkgDir,
+      output: { js: true, dts: false },
+    });
+
+    expect(result.dts.success).toBe(true);
+
+    const stylesCssPath = resolve(distDir, "styles.css");
+    expect(fs.existsSync(stylesCssPath)).toBe(true);
+
+    const content = fs.readFileSync(stylesCssPath, "utf-8");
+    expect(content.length).toBeGreaterThan(0);
+  }, 60_000);
+
+  // Acceptance: Scenario "scss/styles.scss가 없으면 전역 스타일 컴파일을 건너뛴다"
+  it("skips global SCSS when scss/styles.scss does not exist", () => {
+    const nonExistentPkgDir = resolve(import.meta.dirname, "__nonexistent_pkg__");
+
+    const errors = compileGlobalScss(nonExistentPkgDir, []);
+
+    // No errors and no dist/styles.css created
+    expect(errors).toEqual([]);
+    expect(fs.existsSync(resolve(nonExistentPkgDir, "dist", "styles.css"))).toBe(false);
+  });
+});