@simplysm/sd-cli 14.0.43 → 14.0.45

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` 할당 후 수정 없음).

package/tests/deps/replace-deps/replace-deps-resolve.acc.spec.ts

@@ -0,0 +1,124 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { pathx } from "@simplysm/core-node";
+import { resolveAllReplaceDepEntries } from "../../../src/deps/replace-deps/replace-deps-resolve";
+import { consola } from "consola";
+
+describe("resolveAllReplaceDepEntries", () => {
+  let tmpDir: string;
+  let projectRoot: string;
+  const logger = consola.withTag("test");
+
+  beforeEach(async () => {
+    tmpDir = pathx.posix(await fs.promises.mkdtemp(path.join(os.tmpdir(), "sd-resolve-deps-")));
+    projectRoot = pathx.posix(path.join(tmpDir, "project"));
+    await fs.promises.mkdir(projectRoot, { recursive: true });
+    await fs.promises.writeFile(
+      pathx.posix(path.join(projectRoot, "pnpm-workspace.yaml")),
+      "packages:\n",
+    );
+  });
+
+  afterEach(async () => {
+    await fs.promises.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  /**
+   * node_modules에 패키지 디렉토리를 생성하는 헬퍼
+   */
+  async function createNodeModulesPkg(
+    nodeModulesDir: string,
+    pkgName: string,
+  ): Promise<string> {
+    const pkgDir = pathx.posix(path.join(nodeModulesDir, pkgName));
+    await fs.promises.mkdir(pkgDir, { recursive: true });
+    await fs.promises.writeFile(
+      pathx.posix(path.join(pkgDir, "package.json")),
+      JSON.stringify({ name: pkgName }),
+    );
+    return pkgDir;
+  }
+
+  /**
+   * 소스 패키지를 생성하는 헬퍼
+   */
+  async function createSourcePkg(name: string): Promise<string> {
+    const sourcePath = pathx.posix(path.join(tmpDir, name));
+    await fs.promises.mkdir(sourcePath, { recursive: true });
+    await fs.promises.writeFile(
+      pathx.posix(path.join(sourcePath, "package.json")),
+      JSON.stringify({ name, files: ["dist"] }),
+    );
+    await fs.promises.mkdir(pathx.posix(path.join(sourcePath, "dist")), { recursive: true });
+    await fs.promises.writeFile(
+      pathx.posix(path.join(sourcePath, "dist", "index.js")),
+      "module.exports = {};",
+    );
+    return sourcePath;
+  }
+
+  it("동일 actualTargetPath를 가진 항목은 중복 등록되지 않는다", async () => {
+    // Given: 루트 node_modules와 workspace pkg의 node_modules에 동일 패키지가 존재하고
+    //        둘 다 같은 실제 경로(symlink 해석 후)를 가리킨다
+    const sourcePath = await createSourcePkg("@test/pkg");
+    const nodeModulesDir = pathx.posix(path.join(projectRoot, "node_modules"));
+    await createNodeModulesPkg(nodeModulesDir, "@test/pkg");
+
+    // workspace 패키지 설정 (pnpm-workspace.yaml에 추가)
+    const workspacePkgDir = pathx.posix(path.join(projectRoot, "packages", "my-app"));
+    await fs.promises.mkdir(workspacePkgDir, { recursive: true });
+    await fs.promises.writeFile(
+      pathx.posix(path.join(projectRoot, "pnpm-workspace.yaml")),
+      "packages:\n  - packages/*\n",
+    );
+
+    // workspace 패키지의 node_modules에도 동일 패키지 생성
+    const wsPkgNodeModules = pathx.posix(path.join(workspacePkgDir, "node_modules"));
+    await createNodeModulesPkg(wsPkgNodeModules, "@test/pkg");
+
+    // When
+    const entries = await resolveAllReplaceDepEntries(
+      projectRoot,
+      { "@test/pkg": sourcePath },
+      logger,
+    );
+
+    // Then: actualTargetPath가 다르므로 2개가 반환되어야 한다
+    //       (symlink가 아닌 실제 디렉토리이므로 actualTargetPath가 각각 다름)
+    //       중복 방지 로직은 동일 actualTargetPath일 때만 작동한다
+    const actualTargetPaths = entries.map((e) => e.actualTargetPath);
+    const uniqueActualTargetPaths = new Set(actualTargetPaths);
+    expect(actualTargetPaths.length).toBe(uniqueActualTargetPaths.size);
+  });
+
+  it("여러 replaceDeps 패턴이 올바르게 매칭되어 결과를 반환한다", async () => {
+    // Given: 2개의 다른 패턴과 각각의 소스 패키지
+    const sourceA = await createSourcePkg("@test/pkg-a");
+    const sourceB = await createSourcePkg("@other/lib");
+    const nodeModulesDir = pathx.posix(path.join(projectRoot, "node_modules"));
+    await createNodeModulesPkg(nodeModulesDir, "@test/pkg-a");
+    await createNodeModulesPkg(nodeModulesDir, "@other/lib");
+
+    // When: 2개 패턴으로 호출 (glob이 병렬 실행되어야 함)
+    const entries = await resolveAllReplaceDepEntries(
+      projectRoot,
+      {
+        "@test/pkg-a": sourceA,
+        "@other/lib": sourceB,
+      },
+      logger,
+    );
+
+    // Then: 두 패턴 모두 매칭되어 2개 entries 반환
+    expect(entries).toHaveLength(2);
+    const targetNames = entries.map((e) => e.targetName).sort();
+    expect(targetNames).toEqual(["@other/lib", "@test/pkg-a"]);
+  });
+
+  it("빈 replaceDeps 설정이면 빈 배열을 반환한다", async () => {
+    const entries = await resolveAllReplaceDepEntries(projectRoot, {}, logger);
+    expect(entries).toEqual([]);
+  });
+});

package/tests/esbuild/esbuild-angular-compiler-plugin-worker.verify.md

@@ -1,31 +1,59 @@
-# Web Worker 번들링 — LLM 검증
+# Web Worker 통합 (Feature 1.2) — LLM 검증
 
 ## 검증 항목
 
-### bundleWebWorker 함수
-
-- [x] buildSync 옵션: `esbuild-angular-compiler-plugin.ts:165-177` — platform: "browser", write: false, bundle: true, metafile: true, format: "esm", entryNames: "worker-[hash]", plugins: undefined, supported: undefined 모두 확인
-- [x] sourcemap 전달: `esbuild-angular-compiler-plugin.ts:174` — `sourcemap` 파라미터 직접 전달
-- [x] initialOptions spread: `esbuild-angular-compiler-plugin.ts:165` — `...build.initialOptions`로 target/absWorkingDir/outdir 전달
-- [x] catch — errors/warnings 있으면 반환: `esbuild-angular-compiler-plugin.ts:178-186` — `"errors" in error && "warnings" in error` 확인 후 `error as esbuild.BuildResult` 반환
-- [x] catch — 없으면 re-throw: `esbuild-angular-compiler-plugin.ts:187` — `throw error`
-
-### processWebWorker 콜백
-
-- [x] workerFile resolve: `esbuild-angular-compiler-plugin.ts:346` — `path.join(path.dirname(containingFile), workerFile)`
-- [x] 성공 — additionalResults 저장: `esbuild-angular-compiler-plugin.ts:365-368` — `additionalResults.set(fullWorkerPath, { outputFiles, metafile })`
-- [x] 성공 — FileReferenceTracker 등록: `esbuild-angular-compiler-plugin.ts:371-376` — `metafile.inputs` 키를 `path.join(cwd, input)`으로 변환하여 등록
-- [x] 성공 — 반환값: `esbuild-angular-compiler-plugin.ts:379-388` — `/^worker-[A-Z0-9]{8}\.[cm]?js$/` 패턴으로 검색, `path.relative(outdir, ...)` + `replaceAll("\\", "/")` forward slash 반환
-- [x] 에러 — errors push: `esbuild-angular-compiler-plugin.ts:352` — `errors.push(...workerResult.errors)`
-- [x] 에러 — warnings push: `esbuild-angular-compiler-plugin.ts:349` — `warnings.push(...workerResult.warnings)` (성공/실패 공통 실행)
-- [x] 에러 — FileReferenceTracker 등록: `esbuild-angular-compiler-plugin.ts:354-359` — `location?.file` 필터 후 `path.join(cwd, f)` 변환
-- [x] 에러 — additionalResults 저장: `esbuild-angular-compiler-plugin.ts:361` — `{ errors: workerResult.errors }`
-- [x] 에러 — 원본 반환: `esbuild-angular-compiler-plugin.ts:362` — `return workerFile`
-
-### Plugin 통합
-
-- [x] import: `esbuild-angular-compiler-plugin.ts:14` — `import { createWorkerTransformer } from "../angular/web-worker-transformer.js"`
-- [x] transformer 생성: `esbuild-angular-compiler-plugin.ts:392` — `createWorkerTransformer(processWebWorker)`
-- [x] emitAffectedFiles 전달: `esbuild-angular-compiler-plugin.ts:393-395` — `{ additionalTransformers: { before: [workerTransformer] } }`
-- [x] 클로저 접근: `esbuild-angular-compiler-plugin.ts:344-389` — onStart 내부에서 생성, `errors`/`warnings`/`additionalResults`/`referencedFileTracker`/`cwd`/`build` 접근 가능
-- [x] onEnd 병합: `esbuild-angular-compiler-plugin.ts:449-460` — additionalResults 순회에서 worker 결과 포함
+### 제거된 코드
+
+- [x] `createWorkerTransformer` import가 제거됨: `esbuild-angular-compiler-plugin.ts`에 `web-worker-transformer.js`로부터의 import가 존재하지 않음
+- [x] `AdditionalResult` 인터페이스 선언이 제거됨
+- [x] `bundleWebWorker` 함수 및 `#region bundleWebWorker` 주석이 제거됨
+- [x] `additionalResults` Map 선언이 제거됨
+- [x] `createWebWorkerProcessor` 함수가 제거됨
+- [x] onStart 내부의 `processWebWorker` + `workerTransformer` 생성 코드가 제거됨
+- [x] `compileAsync` 호출에서 `additionalTransformers` 옵션이 제거됨
+- [x] 증분 빌드 루프에서 `additionalResults.delete(file)` 호출이 제거됨
+
+### 추가된 코드
+
+- [x] `transformWorkerPatterns` import가 `./esbuild-worker-plugin`에서 추가됨 (같은 디렉토리, .js 확장자 미사용)
+- [x] setup 스코프에 `workerResultsByContainingFile = new Map<string, { outputFiles?: esbuild.OutputFile[]; metafile?: esbuild.Metafile }>()` 선언이 존재함 (증분 빌드 시 변경되지 않은 Worker metafile 유지 목적)
+
+### onStart — TS 파일 Worker 패턴 처리 (Rule 1)
+
+- [x] 증분 빌드 시 `expandedModifiedFiles` 각 파일에 대해 `workerResultsByContainingFile.delete(file)` 호출 (선택적 제거)
+- [x] `emitResults` 루프에서 각 파일에 대해 `transformWorkerPatterns(contents, normalized, build)` 호출
+- [x] `workerResult != null`이면 `typeScriptFileCache.set(normalized, workerResult.contents)` 저장
+- [x] `workerResult.errors`/`workerResult.warnings`를 onStart의 `errors`/`warnings` 배열에 push
+- [x] `workerResult.workerMetafile != null`이면 `referencedFileTracker.add(normalized, Object.keys(workerResult.workerMetafile.inputs).map(input => path.join(cwd, input)))` 호출
+- [x] `workerMetafile` 또는 `workerOutputFiles`가 있으면 `workerResultsByContainingFile.set(normalized, { outputFiles, metafile })` 저장
+- [x] `workerResult == null`이면 기존처럼 `typeScriptFileCache.set(normalized, contents)` 저장
+- [x] Worker 번들 에러가 errors 배열에 포함되어 onStart 결과에 반영됨 (Scenario: 에러 전파)
+
+### JS onLoad — .js 파일 Worker 패턴 처리 (Rule 2)
+
+- [x] `createCachedLoad` 콜백에서 `javascriptTransformer.transformFile` 호출 후 결과를 `TextDecoder`로 문자열로 변환
+- [x] 변환된 문자열에 `transformWorkerPatterns(textContents, request, build)` 적용
+- [x] `workerResult != null`일 때:
+  - `workerResult.workerMetafile`이 있으면 `referencedFileTracker.add` 호출
+  - `workerMetafile` 또는 `workerOutputFiles`가 있으면 `workerResultsByContainingFile.set(request, { outputFiles, metafile })` 저장
+  - 반환: `{ contents, loader: "js", resolveDir, errors (>0일때), warnings (>0일때) }` — TS/JS 에러 처리 일관성 확보 (L2 리뷰 반영)
+- [x] `workerResult == null`일 때 기존과 동일한 `{ contents, loader: "js", resolveDir }` 반환
+
+### onEnd — metafile 병합 (Rule 3)
+
+- [x] onEnd에서 `workerResultsByContainingFile.values()` 순회
+- [x] 각 항목의 `outputFiles`가 있으면 `result.outputFiles?.push(...outputFiles)`
+- [x] 각 항목의 `metafile`이 있으면 `Object.assign(result.metafile.inputs, wr.metafile.inputs)` + `Object.assign(result.metafile.outputs, wr.metafile.outputs)`
+- [x] onEnd에서 Map 전체 리셋 없음 — 증분 빌드에서 변경되지 않은 Worker 결과가 다음 빌드에서도 병합됨
+- [x] 기존 `additionalResults` 순회 루프가 제거됨
+
+### client config 무변경 (Rule 6)
+
+- [x] `esbuild-client-config.ts`에 Worker 플러그인 추가 코드가 존재하지 않음 (plugins 배열에 `createWorkerBundlePlugin` 또는 `sd-worker-bundle` 미포함)
+- [x] `esbuild-client-config.ts` 파일 자체가 Feature 1.2로 인해 변경되지 않음 (git diff 기준)
+
+### 회귀 방지
+
+- [x] `pnpm test --run packages/sd-cli/tests/esbuild/esbuild-angular-compiler-plugin.spec.ts` 통과 (기존 plugin 구조 테스트)
+- [x] `pnpm test --run packages/sd-cli/tests/esbuild/esbuild-worker-plugin.spec.ts` 통과 (Feature 1.1 Unit 테스트)
+- [x] `pnpm test --run packages/sd-cli/tests/esbuild/esbuild-worker-plugin.acc.spec.ts` 통과 (Feature 1.1 Acceptance 테스트)

package/tests/esbuild/esbuild-postcss-plugin-chunking.verify.md

@@ -0,0 +1,17 @@
+# PostCSS 문자열 교체 청크화 — LLM 검증
+
+## 검증 항목
+
+- [x] 정방향 청크 배열 + join이 역순 slice와 수학적으로 동일한 결과를 생성하는가:
+  역순 slice 방식은 `code[0..start_n] + rep_n + code[end_n..start_{n-1}] + rep_{n-1} + ... + code[end_1..]` 순서로 최종 문자열을 구성한다.
+  정방향 청크 방식은 `code[0..start_1] + rep_1 + code[end_1..start_2] + rep_2 + ... + code[end_n..]` 순서로 청크를 수집하고 join한다.
+  두 방식 모두 원본 텍스트의 비교체 구간과 PostCSS 처리된 교체 텍스트를 동일한 순서로 결합하므로, replacements가 비중첩(acorn AST 노드 보장)인 한 결과가 동일하다.
+  검증 결과: **동일성 보장됨**
+
+- [x] cursor 초기값 0과 마지막 `code.slice(cursor)` 호출이 파일 전체를 커버하는가:
+  cursor는 0에서 시작하여 각 replacement의 end로 갱신된다. 마지막 `chunks.push(code.slice(cursor))`가 마지막 replacement 이후의 원본 텍스트를 수집한다. replacements가 0건이면 `code.slice(0)` = 전체 코드가 되지만, 이 경우 `replacements.length === 0`에서 continue되므로 도달하지 않는다.
+  검증 결과: **전체 커버됨**
+
+- [x] `replacements.sort()`가 원본 배열을 변경하는 것이 문제되지 않는가:
+  `replacements`는 각 파일 처리 시 새로 생성되는 로컬 배열이므로 in-place sort가 안전하다. 기존 코드도 동일하게 in-place sort를 사용했다.
+  검증 결과: **문제 없음**