@simplysm/sd-cli 14.0.43 → 14.0.44

package/tests/angular/ngtsc-build-core.acc.spec.ts

@@ -0,0 +1,210 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import path from "path";
+import type { SideEffectScssEntry, SideEffectScssOptions } from "../../src/angular/ngtsc-build-core";
+
+// Mock fs — filesystem I/O (OS 의존)
+vi.mock("fs", () => ({
+  default: {
+    mkdirSync: vi.fn(),
+    writeFileSync: vi.fn(),
+    existsSync: vi.fn(() => false),
+  },
+}));
+
+// Mock scss-compiler — dart-sass 외부 의존성
+const mockCompileScssFile = vi.fn<(filePath: string, loadPaths: string[]) => { css: string; dependencies: string[] }>()
+  .mockReturnValue({ css: "/* compiled */", dependencies: [] });
+
+vi.mock("../../src/angular/scss-compiler", () => ({
+  compileScssFile: (filePath: string, loadPaths: string[]) => mockCompileScssFile(filePath, loadPaths),
+  compileScssString: vi.fn(() => ({ css: "", dependencies: [] })),
+}));
+
+const { writeEmitResults, compileSideEffectScss } = await import("../../src/angular/ngtsc-build-core");
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockCompileScssFile.mockReturnValue({ css: "/* compiled */", dependencies: [] as string[] });
+});
+
+describe("writeEmitResults — registryReverseIndex", () => {
+  // 테스트용 경로 헬퍼
+  const pkgDir = path.resolve("/test-pkg");
+  const srcFile = path.resolve(pkgDir, "src", "comp.ts");
+  const distDir = path.resolve(pkgDir, "dist");
+
+  function makeEmitResult(jsContent: string, sourceFileName?: string) {
+    // createOutputPathRewriter는 dist/ 하위 파일만 처리하므로 dist/ 경로로 생성
+    return {
+      filename: path.resolve(distDir, "comp.js"),
+      contents: jsContent,
+      sourceFileName,
+    };
+  }
+
+  // Acceptance: registryReverseIndex가 제공되면 O(1) 삭제를 수행한다
+  it("deletes registry entries using reverseIndex and cleans up reverseIndex", () => {
+    const oldScssPath = path.resolve(pkgDir, "src", "old.scss");
+    const registry = new Map<string, SideEffectScssEntry>([
+      [oldScssPath, { scssAbsPath: oldScssPath, cssAbsPath: "/out/old.css", sourceFileName: srcFile }],
+    ]);
+    const registryReverseIndex = new Map<string, Set<string>>([
+      [srcFile, new Set([oldScssPath])],
+    ]);
+    const scss: SideEffectScssOptions = {
+      loadPaths: [],
+      scssErrors: [],
+      scssDependencies: new Map(),
+      registry,
+      registryReverseIndex,
+    };
+
+    // SCSS import 없는 JS → 삭제만 발생, 등록 없음
+    writeEmitResults([makeEmitResult("export class Comp {}", srcFile)], pkgDir, scss);
+
+    expect(registry.has(oldScssPath)).toBe(false);
+    expect(registryReverseIndex.has(srcFile)).toBe(false);
+  });
+
+  // Acceptance: 삭제 후 새 SCSS import가 있으면 등록하고 reverseIndex도 갱신
+  it("registers new entries and updates reverseIndex after deletion", () => {
+    const oldScssPath = path.resolve(pkgDir, "src", "old.scss");
+    const registry = new Map<string, SideEffectScssEntry>([
+      [oldScssPath, { scssAbsPath: oldScssPath, cssAbsPath: "/out/old.css", sourceFileName: srcFile }],
+    ]);
+    const registryReverseIndex = new Map<string, Set<string>>([
+      [srcFile, new Set([oldScssPath])],
+    ]);
+    const scss: SideEffectScssOptions = {
+      loadPaths: [],
+      scssErrors: [],
+      scssDependencies: new Map(),
+      registry,
+      registryReverseIndex,
+    };
+
+    // JS with SCSS import → 삭제 + 등록
+    const jsContent = 'import "./button.scss";\nexport class Comp {}';
+    writeEmitResults([makeEmitResult(jsContent, srcFile)], pkgDir, scss);
+
+    // old.scss 삭제됨
+    expect(registry.has(oldScssPath)).toBe(false);
+    // button.scss가 등록됨 (scssAbsPath = path.resolve(srcDir, "./button.scss"))
+    const expectedScssPath = path.resolve(pkgDir, "src", "button.scss");
+    expect(registry.has(expectedScssPath)).toBe(true);
+    // reverseIndex에 새 항목 반영
+    expect(registryReverseIndex.get(srcFile)).toEqual(new Set([expectedScssPath]));
+  });
+
+  // Acceptance: reverseIndex에 없는 sourceFileName이면 삭제 없음
+  it("does not delete when sourceFileName is not in reverseIndex", () => {
+    const otherScssPath = path.resolve(pkgDir, "src", "other.scss");
+    const otherSrcFile = path.resolve(pkgDir, "src", "other.ts");
+    const registry = new Map<string, SideEffectScssEntry>([
+      [otherScssPath, { scssAbsPath: otherScssPath, cssAbsPath: "/out/other.css", sourceFileName: otherSrcFile }],
+    ]);
+    const registryReverseIndex = new Map<string, Set<string>>([
+      [otherSrcFile, new Set([otherScssPath])],
+    ]);
+    const scss: SideEffectScssOptions = {
+      loadPaths: [],
+      scssErrors: [],
+      scssDependencies: new Map(),
+      registry,
+      registryReverseIndex,
+    };
+
+    // srcFile (comp.ts)에 대한 emit → other.ts의 항목은 건드리지 않음
+    writeEmitResults([makeEmitResult("export class Comp {}", srcFile)], pkgDir, scss);
+
+    expect(registry.has(otherScssPath)).toBe(true);
+    expect(registryReverseIndex.has(otherSrcFile)).toBe(true);
+  });
+});
+
+describe("compileSideEffectScss — incremental compilation", () => {
+  function makeEntry(scssAbsPath: string, sourceFileName: string): SideEffectScssEntry {
+    return {
+      scssAbsPath,
+      cssAbsPath: scssAbsPath.replace(/\.scss$/, ".css"),
+      sourceFileName,
+    };
+  }
+
+  // Acceptance: changedScssFiles 미제공 시 전체 재컴파일
+  it("compiles all entries when changedScssFiles is not provided", () => {
+    const registry = new Map<string, SideEffectScssEntry>([
+      ["/src/button.scss", makeEntry("/src/button.scss", "/src/comp.ts")],
+      ["/src/dialog.scss", makeEntry("/src/dialog.scss", "/src/comp.ts")],
+      ["/src/card.scss", makeEntry("/src/card.scss", "/src/other.ts")],
+    ]);
+
+    compileSideEffectScss(registry, [], [], new Map());
+
+    expect(mockCompileScssFile).toHaveBeenCalledTimes(3);
+  });
+
+  // Acceptance: 변경된 SCSS 파일만 재컴파일 (직접 히트)
+  it("only compiles entries whose scssAbsPath is in changedScssFiles", () => {
+    const registry = new Map<string, SideEffectScssEntry>([
+      ["/src/button.scss", makeEntry("/src/button.scss", "/src/comp.ts")],
+      ["/src/dialog.scss", makeEntry("/src/dialog.scss", "/src/other.ts")],
+    ]);
+    const changedScssFiles = new Set(["/src/button.scss"]);
+    const sideEffectScssDeps = new Map<string, Set<string>>();
+
+    compileSideEffectScss(registry, [], [], new Map(), changedScssFiles, sideEffectScssDeps);
+
+    expect(mockCompileScssFile).toHaveBeenCalledTimes(1);
+    expect(mockCompileScssFile).toHaveBeenCalledWith("/src/button.scss", []);
+  });
+
+  // Acceptance: 의존성이 변경된 SCSS도 재컴파일
+  it("recompiles entries whose dependency is in changedScssFiles", () => {
+    const registry = new Map<string, SideEffectScssEntry>([
+      ["/src/button.scss", makeEntry("/src/button.scss", "/src/comp.ts")],
+    ]);
+    const changedScssFiles = new Set(["/src/shared.scss"]);
+    // button.scss의 이전 컴파일에서 shared.scss가 의존성이었음
+    const sideEffectScssDeps = new Map<string, Set<string>>([
+      ["/src/button.scss", new Set(["/src/shared.scss"])],
+    ]);
+
+    compileSideEffectScss(registry, [], [], new Map(), changedScssFiles, sideEffectScssDeps);
+
+    expect(mockCompileScssFile).toHaveBeenCalledTimes(1);
+    expect(mockCompileScssFile).toHaveBeenCalledWith("/src/button.scss", []);
+  });
+
+  // Acceptance: 영향받지 않는 항목은 건너뜀
+  it("skips entries not affected by changedScssFiles", () => {
+    const registry = new Map<string, SideEffectScssEntry>([
+      ["/src/button.scss", makeEntry("/src/button.scss", "/src/comp.ts")],
+      ["/src/dialog.scss", makeEntry("/src/dialog.scss", "/src/other.ts")],
+    ]);
+    const changedScssFiles = new Set(["/src/shared.scss"]);
+    const sideEffectScssDeps = new Map<string, Set<string>>([
+      ["/src/button.scss", new Set(["/src/shared.scss"])],
+      ["/src/dialog.scss", new Set(["/src/theme.scss"])],
+    ]);
+
+    compileSideEffectScss(registry, [], [], new Map(), changedScssFiles, sideEffectScssDeps);
+
+    // button.scss만 재컴파일 (shared.scss가 의존성), dialog.scss는 건너뜀
+    expect(mockCompileScssFile).toHaveBeenCalledTimes(1);
+    expect(mockCompileScssFile).toHaveBeenCalledWith("/src/button.scss", []);
+  });
+
+  // Unit: 컴파일 후 sideEffectScssDeps가 갱신됨
+  it("updates sideEffectScssDeps after compilation", () => {
+    const registry = new Map<string, SideEffectScssEntry>([
+      ["/src/button.scss", makeEntry("/src/button.scss", "/src/comp.ts")],
+    ]);
+    mockCompileScssFile.mockReturnValue({ css: "/* ok */", dependencies: ["/src/new-dep.scss"] });
+    const sideEffectScssDeps = new Map<string, Set<string>>();
+
+    compileSideEffectScss(registry, [], [], new Map(), undefined, sideEffectScssDeps);
+
+    expect(sideEffectScssDeps.get("/src/button.scss")).toEqual(new Set(["/src/new-dep.scss"]));
+  });
+});

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

@@ -0,0 +1,52 @@
+import { describe, it, expect } from "vitest";
+import { buildReverseDeps } from "../../src/angular/ngtsc-build-core";
+
+describe("buildReverseDeps", () => {
+  // Acceptance: 정방향 맵에서 역방향 인덱스를 구축한다
+  it("builds reverse index from forward deps with multiple owners sharing a dep", () => {
+    const forward = new Map<string, ReadonlySet<string>>([
+      ["comp.ts", new Set(["shared.scss", "theme.scss"])],
+      ["dialog.ts", new Set(["shared.scss"])],
+    ]);
+
+    const reverse = buildReverseDeps(forward);
+
+    expect(reverse.get("shared.scss")).toEqual(new Set(["comp.ts", "dialog.ts"]));
+    expect(reverse.get("theme.scss")).toEqual(new Set(["comp.ts"]));
+    expect(reverse.size).toBe(2);
+  });
+
+  // Acceptance: 빈 맵이면 역방향 맵도 비어있다
+  it("returns empty map for empty input", () => {
+    const reverse = buildReverseDeps(new Map());
+
+    expect(reverse.size).toBe(0);
+  });
+
+  // Unit: 하나의 소유자가 여러 의존성을 가진 경우
+  it("maps each dep to its single owner", () => {
+    const forward = new Map<string, ReadonlySet<string>>([
+      ["comp.ts", new Set(["a.scss", "b.scss", "c.scss"])],
+    ]);
+
+    const reverse = buildReverseDeps(forward);
+
+    expect(reverse.size).toBe(3);
+    expect(reverse.get("a.scss")).toEqual(new Set(["comp.ts"]));
+    expect(reverse.get("b.scss")).toEqual(new Set(["comp.ts"]));
+    expect(reverse.get("c.scss")).toEqual(new Set(["comp.ts"]));
+  });
+
+  // Unit: 의존성이 빈 Set인 소유자는 역방향 맵에 영향 없음
+  it("ignores owners with empty dep sets", () => {
+    const forward = new Map<string, ReadonlySet<string>>([
+      ["comp.ts", new Set<string>()],
+      ["dialog.ts", new Set(["shared.scss"])],
+    ]);
+
+    const reverse = buildReverseDeps(forward);
+
+    expect(reverse.size).toBe(1);
+    expect(reverse.get("shared.scss")).toEqual(new Set(["dialog.ts"]));
+  });
+});

package/tests/commands/version-upgrade.acc.spec.ts

@@ -0,0 +1,210 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { upgradeVersion, computePublishLevels } from "../../src/commands/publish/version-upgrade";
+
+function createTempDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "sd-cli-version-upgrade-"));
+}
+
+function writeJson(filePath: string, data: unknown): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+
+function readJson<T>(filePath: string): T {
+  return JSON.parse(fs.readFileSync(filePath, "utf-8")) as T;
+}
+
+describe("upgradeVersion", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = createTempDir();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("복수 패키지의 package.json을 병렬 업데이트한다", async () => {
+    // Given: allPkgPaths에 5개 패키지 경로가 있다
+    writeJson(path.join(tmpDir, "package.json"), {
+      name: "@simplysm/root",
+      version: "14.0.0",
+    });
+
+    const pkgNames = ["pkg-a", "pkg-b", "pkg-c", "pkg-d", "pkg-e"];
+    const allPkgPaths = pkgNames.map((name) => {
+      const pkgDir = path.join(tmpDir, "packages", name);
+      writeJson(path.join(pkgDir, "package.json"), {
+        name: `@simplysm/${name}`,
+        version: "14.0.0",
+      });
+      return pkgDir;
+    });
+
+    // sd-cli/templates 디렉토리 생성 (glob 대상이 없도록)
+    fs.mkdirSync(path.join(tmpDir, "packages", "sd-cli", "templates"), {
+      recursive: true,
+    });
+
+    // When
+    const result = await upgradeVersion(tmpDir, allPkgPaths, false);
+
+    // Then: 5개 패키지의 package.json이 모두 newVersion으로 업데이트된다
+    expect(result.version).toBe("14.0.1");
+    for (const pkgDir of allPkgPaths) {
+      const pkg = readJson<{ version: string }>(path.join(pkgDir, "package.json"));
+      expect(pkg.version).toBe("14.0.1");
+    }
+
+    // And: changedFiles에 5개 패키지 경로가 모두 포함된다
+    for (const pkgDir of allPkgPaths) {
+      expect(result.changedFiles).toContain(path.resolve(pkgDir, "package.json"));
+    }
+  });
+
+  it("패키지가 없으면 루트 package.json만 changedFiles에 포함된다", async () => {
+    // Given: allPkgPaths가 빈 배열이다
+    writeJson(path.join(tmpDir, "package.json"), {
+      name: "@simplysm/root",
+      version: "14.0.0",
+    });
+    fs.mkdirSync(path.join(tmpDir, "packages", "sd-cli", "templates"), {
+      recursive: true,
+    });
+
+    // When
+    const result = await upgradeVersion(tmpDir, [], false);
+
+    // Then: 루트 package.json만 changedFiles에 포함된다
+    expect(result.changedFiles).toHaveLength(1);
+    expect(result.changedFiles[0]).toBe(path.resolve(tmpDir, "package.json"));
+  });
+
+  it("복수 템플릿 파일을 병렬 업데이트한다", async () => {
+    // Given: 템플릿 3개 중 2개에 @simplysm 버전이 포함되어 있다
+    writeJson(path.join(tmpDir, "package.json"), {
+      name: "@simplysm/root",
+      version: "14.0.0",
+    });
+
+    const templatesDir = path.join(tmpDir, "packages", "sd-cli", "templates");
+    fs.mkdirSync(templatesDir, { recursive: true });
+
+    // 템플릿 1: @simplysm 버전 포함
+    fs.writeFileSync(
+      path.join(templatesDir, "a.hbs"),
+      `"@simplysm/core-common": "~14.0.0"`,
+      "utf-8",
+    );
+    // 템플릿 2: @simplysm 버전 포함
+    fs.writeFileSync(
+      path.join(templatesDir, "b.hbs"),
+      `"@simplysm/angular": "~14.0.0"`,
+      "utf-8",
+    );
+    // 템플릿 3: @simplysm 버전 미포함
+    fs.writeFileSync(path.join(templatesDir, "c.hbs"), `no version here`, "utf-8");
+
+    // When
+    const result = await upgradeVersion(tmpDir, [], false);
+
+    // Then: 2개 파일만 수정되고 changedFiles에 추가된다
+    const templateChanges = result.changedFiles.filter((f) => f.endsWith(".hbs"));
+    expect(templateChanges).toHaveLength(2);
+
+    // 수정된 파일들의 내용 확인
+    expect(fs.readFileSync(path.join(templatesDir, "a.hbs"), "utf-8")).toContain("~14.0.1");
+    expect(fs.readFileSync(path.join(templatesDir, "b.hbs"), "utf-8")).toContain("~14.0.1");
+    // 수정되지 않은 파일
+    expect(fs.readFileSync(path.join(templatesDir, "c.hbs"), "utf-8")).toBe("no version here");
+  });
+
+  it("템플릿이 없으면 템플릿 관련 쓰기 없이 완료된다", async () => {
+    // Given: glob 결과가 빈 배열이다 (templates 디렉토리에 .hbs 파일 없음)
+    writeJson(path.join(tmpDir, "package.json"), {
+      name: "@simplysm/root",
+      version: "14.0.0",
+    });
+    fs.mkdirSync(path.join(tmpDir, "packages", "sd-cli", "templates"), {
+      recursive: true,
+    });
+
+    // When
+    const result = await upgradeVersion(tmpDir, [], false);
+
+    // Then
+    const templateChanges = result.changedFiles.filter((f) => f.endsWith(".hbs"));
+    expect(templateChanges).toHaveLength(0);
+  });
+
+  it("changedFiles[0]이 프로젝트 루트 package.json 경로이다", async () => {
+    // Given: allPkgPaths에 3개 패키지가 있다
+    writeJson(path.join(tmpDir, "package.json"), {
+      name: "@simplysm/root",
+      version: "14.0.0",
+    });
+
+    const allPkgPaths = ["pkg-a", "pkg-b", "pkg-c"].map((name) => {
+      const pkgDir = path.join(tmpDir, "packages", name);
+      writeJson(path.join(pkgDir, "package.json"), {
+        name: `@simplysm/${name}`,
+        version: "14.0.0",
+      });
+      return pkgDir;
+    });
+
+    fs.mkdirSync(path.join(tmpDir, "packages", "sd-cli", "templates"), {
+      recursive: true,
+    });
+
+    // When
+    const result = await upgradeVersion(tmpDir, allPkgPaths, false);
+
+    // Then: changedFiles[0]이 프로젝트 루트 package.json 경로이다
+    expect(result.changedFiles[0]).toBe(path.resolve(tmpDir, "package.json"));
+  });
+});
+
+describe("computePublishLevels", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = createTempDir();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("의존 관계가 있는 패키지들의 레벨을 올바르게 계산한다", async () => {
+    // Given: A(의존 없음), B(A 의존), C(B 의존)
+    const pkgs = [
+      { name: "pkg-a", deps: {} },
+      { name: "pkg-b", deps: { "@simplysm/pkg-a": "~14.0.0" } },
+      { name: "pkg-c", deps: { "@simplysm/pkg-b": "~14.0.0" } },
+    ];
+
+    const publishPkgs = pkgs.map((p) => {
+      const pkgDir = path.join(tmpDir, "packages", p.name);
+      writeJson(path.join(pkgDir, "package.json"), {
+        name: `@simplysm/${p.name}`,
+        version: "14.0.0",
+        dependencies: p.deps,
+      });
+      return { name: p.name, path: pkgDir };
+    });
+
+    // When
+    const levels = await computePublishLevels(publishPkgs);
+
+    // Then: 레벨은 [[A], [B], [C]]
+    expect(levels).toHaveLength(3);
+    expect(levels[0].map((p) => p.name)).toEqual(["pkg-a"]);
+    expect(levels[1].map((p) => p.name)).toEqual(["pkg-b"]);
+    expect(levels[2].map((p) => p.name)).toEqual(["pkg-c"]);
+  });
+});

package/tests/commands/version-upgrade.spec.ts

@@ -0,0 +1,148 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { upgradeVersion, computePublishLevels } from "../../src/commands/publish/version-upgrade";
+
+function createTempDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "sd-cli-vu-unit-"));
+}
+
+function writeJson(filePath: string, data: unknown): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+
+function readJson<T>(filePath: string): T {
+  return JSON.parse(fs.readFileSync(filePath, "utf-8")) as T;
+}
+
+describe("upgradeVersion — unit", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = createTempDir();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("prerelease 버전은 prerelease로 증가한다", async () => {
+    writeJson(path.join(tmpDir, "package.json"), {
+      name: "@simplysm/root",
+      version: "14.0.0-beta.3",
+    });
+    fs.mkdirSync(path.join(tmpDir, "packages", "sd-cli", "templates"), {
+      recursive: true,
+    });
+
+    const result = await upgradeVersion(tmpDir, [], false);
+    expect(result.version).toBe("14.0.0-beta.4");
+  });
+
+  it("dryRun이면 파일을 수정하지 않고 새 버전만 반환한다", async () => {
+    writeJson(path.join(tmpDir, "package.json"), {
+      name: "@simplysm/root",
+      version: "14.0.0",
+    });
+
+    const pkgDir = path.join(tmpDir, "packages", "pkg-a");
+    writeJson(path.join(pkgDir, "package.json"), {
+      name: "@simplysm/pkg-a",
+      version: "14.0.0",
+    });
+
+    const result = await upgradeVersion(tmpDir, [pkgDir], true);
+    expect(result.version).toBe("14.0.1");
+    expect(result.changedFiles).toHaveLength(0);
+
+    // 파일이 수정되지 않았는지 확인
+    const rootPkg = readJson<{ version: string }>(path.join(tmpDir, "package.json"));
+    expect(rootPkg.version).toBe("14.0.0");
+  });
+
+  it("템플릿 파일에서 @simplysm 버전이 없으면 수정하지 않는다", async () => {
+    writeJson(path.join(tmpDir, "package.json"), {
+      name: "@simplysm/root",
+      version: "14.0.0",
+    });
+
+    const templatesDir = path.join(tmpDir, "packages", "sd-cli", "templates");
+    fs.mkdirSync(templatesDir, { recursive: true });
+    fs.writeFileSync(path.join(templatesDir, "no-version.hbs"), "plain template content", "utf-8");
+
+    const result = await upgradeVersion(tmpDir, [], false);
+    const templateChanges = result.changedFiles.filter((f) => f.endsWith(".hbs"));
+    expect(templateChanges).toHaveLength(0);
+
+    // 파일이 수정되지 않았는지 확인
+    expect(fs.readFileSync(path.join(templatesDir, "no-version.hbs"), "utf-8")).toBe(
+      "plain template content",
+    );
+  });
+});
+
+describe("computePublishLevels — unit", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = createTempDir();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("의존성 없는 패키지들은 모두 Level 0이다", async () => {
+    const publishPkgs = ["pkg-a", "pkg-b", "pkg-c"].map((name) => {
+      const pkgDir = path.join(tmpDir, "packages", name);
+      writeJson(path.join(pkgDir, "package.json"), {
+        name: `@simplysm/${name}`,
+        version: "14.0.0",
+        dependencies: {},
+      });
+      return { name, path: pkgDir };
+    });
+
+    const levels = await computePublishLevels(publishPkgs);
+    expect(levels).toHaveLength(1);
+    expect(levels[0].map((p) => p.name).sort()).toEqual(["pkg-a", "pkg-b", "pkg-c"]);
+  });
+
+  it("외부 의존성(@simplysm/ 아닌)은 레벨 계산에 영향 없다", async () => {
+    const pkgDir = path.join(tmpDir, "packages", "pkg-a");
+    writeJson(path.join(pkgDir, "package.json"), {
+      name: "@simplysm/pkg-a",
+      version: "14.0.0",
+      dependencies: { lodash: "^4.0.0", express: "^5.0.0" },
+    });
+
+    const levels = await computePublishLevels([{ name: "pkg-a", path: pkgDir }]);
+    expect(levels).toHaveLength(1);
+    expect(levels[0][0].name).toBe("pkg-a");
+  });
+
+  it("peerDependencies와 optionalDependencies도 레벨에 반영된다", async () => {
+    const pkgADir = path.join(tmpDir, "packages", "pkg-a");
+    writeJson(path.join(pkgADir, "package.json"), {
+      name: "@simplysm/pkg-a",
+      version: "14.0.0",
+    });
+
+    const pkgBDir = path.join(tmpDir, "packages", "pkg-b");
+    writeJson(path.join(pkgBDir, "package.json"), {
+      name: "@simplysm/pkg-b",
+      version: "14.0.0",
+      peerDependencies: { "@simplysm/pkg-a": "~14.0.0" },
+    });
+
+    const levels = await computePublishLevels([
+      { name: "pkg-a", path: pkgADir },
+      { name: "pkg-b", path: pkgBDir },
+    ]);
+    expect(levels).toHaveLength(2);
+    expect(levels[0][0].name).toBe("pkg-a");
+    expect(levels[1][0].name).toBe("pkg-b");
+  });
+});

package/tests/deps/replace-deps/replace-deps-perf.verify.md

@@ -0,0 +1,15 @@
+# replace-deps 성능 최적화 — LLM 검증
+
+## 검증 항목
+
+### Slice 1: Set 중복 검사 + glob 병렬화
+
+- [x] `resolveAllReplaceDepEntries`에서 `entries.some()` 대신 `Set<string>` 사용 확인: `replace-deps-resolve.ts:143`에 `seenTargetPaths = new Set<string>()` 선언, `:205`에서 `seenTargetPaths.has(actualTargetPath)` + `seenTargetPaths.add(actualTargetPath)` 사용. 기존 `entries.some()` 제거됨.
+- [x] glob 병렬화 확인: `replace-deps-resolve.ts:167-171`에서 `Promise.all(Object.keys(replaceDeps).map(...))` 사용. 기존 순차 `for` 루프 제거됨. `:172-174`에서 `flatMap`으로 결과를 합침.
+- [x] `seenTargetPaths`가 while 루프 바깥에 선언되어 재귀 탐색 전체에 걸쳐 중복 방지가 유지됨 확인.
+
+### Slice 2: watch onChange entries 사전 필터링
+
+- [x] `watchReplaceDeps`에서 사전 필터링 확인: `replace-deps.ts:240-242`에 `sourceEntries = entries.filter(e => e.resolvedSourcePath === entry.resolvedSourcePath)` 선언. watcher 생성 전에 필터링되어 클로저에 캡처됨.
+- [x] onChange 내부에서 `sourceEntries`만 순회 확인: `replace-deps.ts:252`에서 `for (const e of sourceEntries)` 사용. 기존 `for (const e of entries)` + `if (e.resolvedSourcePath !== entry.resolvedSourcePath) continue;` 패턴이 제거됨.
+- [x] `entries` 배열은 `resolveAllReplaceDepEntries` 호출 후 불변이므로, 필터링 결과가 watcher 생명주기 동안 유효함 확인 (`replace-deps.ts:202`에서 `entries` 할당 후 수정 없음).