@kood/claude-code 0.6.6 → 0.7.0

package/templates/.claude/skills/project-optimizer/rules/concurrency-pool.md

@@ -0,0 +1,68 @@
+---
+title: Limit Concurrency with Pools
+impact: HIGH
+impactDescription: Prevents resource exhaustion, stable throughput
+tags: concurrency, pool, semaphore, rate-limiting, backpressure
+languages: all
+related: [concurrency-parallel, io-connection-reuse, memory-bounded-cache]
+---
+
+## 동시 실행 수 제한
+
+무제한 병렬화는 리소스 고갈을 유발. 커넥션 풀, 세마포어, 워커 풀로 동시 실행 수를 제한합니다.
+
+**❌ 잘못된 예시 (무제한 동시 실행):**
+
+```typescript
+// 1000개 URL 동시 요청 → 커넥션 고갈, OOM
+const results = await Promise.all(
+  urls.map(url => fetch(url))
+)
+```
+
+**✅ 올바른 예시 (동시 실행 수 제한):**
+
+```typescript
+// JS/TS (p-limit)
+import pLimit from 'p-limit'
+const limit = pLimit(10)  // 최대 10개 동시
+const results = await Promise.all(
+  urls.map(url => limit(() => fetch(url)))
+)
+```
+
+```python
+# Python (asyncio.Semaphore)
+sem = asyncio.Semaphore(10)
+async def limited_fetch(url):
+    async with sem:
+        return await fetch(url)
+
+results = await asyncio.gather(*[limited_fetch(url) for url in urls])
+```
+
+```go
+// Go (worker pool)
+func worker(jobs <-chan string, results chan<- Result) {
+    for url := range jobs {
+        results <- fetch(url)
+    }
+}
+// 10개 워커 실행
+for i := 0; i < 10; i++ { go worker(jobs, results) }
+```
+
+```rust
+// Rust (tokio::sync::Semaphore)
+let sem = Arc::new(Semaphore::new(10));
+let tasks: Vec<_> = urls.iter().map(|url| {
+    let permit = sem.clone().acquire_owned();
+    async move {
+        let _permit = permit.await.unwrap();
+        fetch(url).await
+    }
+}).collect();
+let results = futures::future::join_all(tasks).await;
+```
+
+**적정 동시 실행 수:** DB 커넥션 10-25, HTTP 요청 10-50, 파일 I/O 5-20.

package/templates/.claude/skills/project-optimizer/rules/deps-lightweight-alt.md

@@ -0,0 +1,37 @@
+---
+title: Replace Heavy Libraries with Lightweight Alternatives
+impact: MEDIUM
+impactDescription: 30-80% bundle/install size reduction
+tags: deps, lightweight, alternative, bundle-size
+languages: all
+related: [build-tree-shake, build-minify]
+---
+
+## 무거운 라이브러리 경량 대안으로 교체
+
+사용 기능 대비 과도하게 큰 라이브러리를 경량 대안 또는 네이티브 API로 교체합니다.
+
+**흔한 교체 대상:**
+
+| 무거운 라이브러리 | 경량 대안 | 크기 감소 |
+|-----------------|----------|----------|
+| `moment.js` (300KB) | `date-fns` 또는 `dayjs` (2-7KB) | 97% |
+| `lodash` (72KB) | 네이티브 JS 메서드 / `lodash-es` 직접 import | 90%+ |
+| `axios` (29KB) | `fetch` (내장) / `ky` (3KB) | 90% |
+| `uuid` (12KB) | `crypto.randomUUID()` (내장) | 100% |
+| `chalk` (20KB) | `picocolors` (2KB) | 90% |
+| `express` | `h3` / `Hono` (더 빠르고 작음) | 50%+ |
+
+**Python:**
+
+| 무거운 | 경량 대안 |
+|-------|----------|
+| `requests` | `httpx` (async 지원) |
+| `beautifulsoup4` | `selectolax` (10x 빠름) |
+| `pandas` (작은 작업) | `polars` (메모리 효율) |
+| `flake8+isort+black` | `ruff` (100x 빠름, 올인원) |
+
+**판단 기준:**
+1. 사용하는 기능이 전체의 10% 미만 → 교체 고려
+2. 네이티브 API로 대체 가능 → 교체
+3. 번들 크기 50KB+ 차이 → 교체 고려

package/templates/.claude/skills/project-optimizer/rules/deps-peer-align.md

@@ -0,0 +1,44 @@
+---
+title: Resolve Peer Dependency Conflicts
+impact: LOW-MEDIUM
+impactDescription: Eliminates runtime version conflicts
+tags: deps, peer, conflict, resolution
+languages: all
+related: [deps-version-pin, deps-security-audit]
+---
+
+## Peer Dependency 버전 충돌 해결
+
+peer dependency 경고/에러를 해결하여 런타임 버전 충돌을 방지합니다.
+
+**감지:**
+
+```bash
+# npm
+npm ls --all 2>&1 | grep "peer dep"
+npm install  # 경고 메시지 확인
+
+# yarn
+yarn install  # 경고 확인
+
+# pnpm
+pnpm install  # strict peer deps 기본
+```
+
+**해결 전략:**
+
+| 상황 | 해결 |
+|------|------|
+| 라이브러리 A가 react@18 요구, B가 react@19 요구 | A 업데이트 또는 overrides 사용 |
+| 여러 버전의 같은 라이브러리 설치됨 | `npm ls [pkg]`로 확인, 상위 버전으로 통일 |
+| 호환 불가 | `overrides` (npm) / `resolutions` (yarn) / `overrides` (pnpm) |
+
+```json
+// package.json - 강제 버전 통일
+{
+  "overrides": { "react": "^19.0.0" },
+  "resolutions": { "react": "^19.0.0" }
+}
+```
+
+**원칙:** overrides는 최후 수단. 먼저 라이브러리 업데이트 시도.

package/templates/.claude/skills/project-optimizer/rules/deps-security-audit.md

@@ -0,0 +1,45 @@
+---
+title: Audit Dependencies for Security Vulnerabilities
+impact: MEDIUM
+impactDescription: Prevent known CVE exploitation
+tags: deps, security, audit, vulnerability, cve
+languages: all
+related: [deps-version-pin]
+---
+
+## 보안 취약점 스캔 및 업데이트
+
+알려진 보안 취약점이 있는 의존성을 감지하고 업데이트합니다.
+
+**스캔 도구:**
+
+| 언어 | 도구 | 명령어 |
+|------|------|--------|
+| **JS/TS** | npm audit | `npm audit` / `npm audit fix` |
+| **JS/TS** | yarn audit | `yarn npm audit` |
+| **Python** | pip-audit | `pip-audit` |
+| **Python** | safety | `safety check` |
+| **Go** | govulncheck | `govulncheck ./...` |
+| **Rust** | cargo-audit | `cargo audit` |
+| **범용** | trivy | `trivy fs .` |
+| **범용** | Snyk | `snyk test` |
+
+**CI 통합:**
+
+```yaml
+# GitHub Actions
+- name: Security audit
+  run: npm audit --audit-level=high
+
+# Dependabot (자동 PR)
+# .github/dependabot.yml
+version: 2
+updates:
+  - package-ecosystem: "npm"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 10
+```
+
+**원칙:** CI에서 high/critical 취약점 발견 시 빌드 실패 설정.

package/templates/.claude/skills/project-optimizer/rules/deps-unused-removal.md

@@ -0,0 +1,25 @@
+---
+title: Remove Unused Dependencies
+impact: MEDIUM
+impactDescription: Smaller install size, fewer vulnerabilities, faster CI
+tags: deps, unused, cleanup, audit
+languages: all
+related: [build-tree-shake, code-dead-elimination]
+---
+
+## 미사용 의존성 제거
+
+설치되었지만 코드에서 import/require 되지 않는 패키지를 제거합니다.
+
+**감지 도구:**
+
+| 언어 | 도구 | 명령어 |
+|------|------|--------|
+| **JS/TS** | knip | `npx knip` |
+| **JS/TS** | depcheck | `npx depcheck` |
+| **Python** | deptry | `deptry .` |
+| **Go** | go mod tidy | `go mod tidy` (자동 정리) |
+| **Rust** | cargo-udeps | `cargo +nightly udeps` |
+| **Java** | gradle-dependency-analysis | Gradle 플러그인 |
+
+**주의:** devDependencies (빌드/테스트 도구)는 코드에서 직접 import하지 않아도 필요할 수 있음. 빌드 확인 후 제거.

package/templates/.claude/skills/project-optimizer/rules/deps-version-pin.md

@@ -0,0 +1,40 @@
+---
+title: Pin Production Dependency Versions
+impact: MEDIUM
+impactDescription: Reproducible builds, no surprise breakages
+tags: deps, version, pin, lock, reproducible
+languages: all
+related: [deps-security-audit, deps-peer-align]
+---
+
+## 프로덕션 의존성 버전 고정
+
+lockfile을 커밋하고 프로덕션 의존성은 정확한 버전으로 설치합니다.
+
+**✅ 필수:**
+
+| 파일 | 언어 | Git 커밋 |
+|------|------|---------|
+| `package-lock.json` / `yarn.lock` / `pnpm-lock.yaml` | JS/TS | 필수 |
+| `Cargo.lock` | Rust (바이너리) | 필수 |
+| `go.sum` | Go | 필수 |
+| `poetry.lock` / `uv.lock` | Python | 필수 |
+| `Gemfile.lock` | Ruby | 필수 |
+
+**CI에서 lockfile 기반 설치:**
+
+```bash
+# npm
+npm ci  # (npm install 아님!)
+
+# yarn
+yarn install --immutable
+
+# pnpm
+pnpm install --frozen-lockfile
+
+# pip
+pip install -r requirements.txt --no-deps
+```
+
+**원칙:** `npm install`/`yarn install`은 lockfile을 수정할 수 있으므로 CI에서는 `ci`/`--frozen-lockfile` 사용.

package/templates/.claude/skills/project-optimizer/rules/dx-ci-speed.md

@@ -0,0 +1,47 @@
+---
+title: Optimize CI Pipeline Speed
+impact: MEDIUM
+impactDescription: 30-70% CI time reduction
+tags: dx, ci, pipeline, speed, cache
+languages: all
+related: [build-cache, build-incremental, dx-test-coverage]
+---
+
+## CI 파이프라인 속도 최적화
+
+CI 파이프라인의 불필요한 단계를 제거하고 병렬화/캐싱을 적용합니다.
+
+**최적화 전략:**
+
+| 전략 | 효과 | 적용 |
+|------|------|------|
+| **의존성 캐시** | 50-80% 설치 시간 감소 | lockfile 해시 기반 캐시 키 |
+| **병렬 단계** | 단계 수에 비례 감소 | lint, test, build 동시 실행 |
+| **변경 파일만** | 대규모 모노레포에서 효과적 | `turbo run --filter=...` |
+| **불필요 단계 제거** | 즉시 효과 | 중복 설치, 불필요 빌드 제거 |
+
+```yaml
+# GitHub Actions - 병렬 + 캐시
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/cache@v4
+        with: { path: node_modules, key: deps-${{ hashFiles('yarn.lock') }} }
+      - run: yarn lint
+
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/cache@v4
+        with: { path: node_modules, key: deps-${{ hashFiles('yarn.lock') }} }
+      - run: yarn test
+
+  build:
+    runs-on: ubuntu-latest
+    needs: [lint, test]  # lint/test 병렬 후 build
+    steps:
+      - run: yarn build
+```
+
+**모노레포:** Turborepo `--filter=[HEAD^1]`, Nx `affected:test`.

package/templates/.claude/skills/project-optimizer/rules/dx-dev-server.md

@@ -0,0 +1,35 @@
+---
+title: Speed Up Local Development Server
+impact: MEDIUM
+impactDescription: Faster feedback loop, improved developer productivity
+tags: dx, dev-server, hmr, startup, watch
+languages: [js, ts, go, python, rust]
+related: [build-incremental, dx-ci-speed]
+---
+
+## 로컬 개발 서버 시작 속도 개선
+
+개발 서버 시작 시간과 HMR(Hot Module Replacement) 속도를 최적화합니다.
+
+**프론트엔드:**
+
+| 도구 | 팁 |
+|------|-----|
+| **Vite** | 이미 빠름. `server.warmup` 활성화, `optimizeDeps.include` 프리번들링 |
+| **webpack** | Vite/Turbopack으로 마이그레이션 고려 |
+| **Next.js** | Turbopack (`next dev --turbo`) |
+
+**백엔드:**
+
+| 언어 | 도구 | 설정 |
+|------|------|------|
+| **Node.js** | `tsx --watch` | 네이티브 ESM, 즉시 시작 |
+| **Go** | `air` | `.air.toml` 설정 |
+| **Python** | `uvicorn --reload` | FastAPI 기본 |
+| **Rust** | `cargo-watch` | `cargo watch -x run` |
+
+**공통 개선:**
+
+- TypeScript: `tsconfig.json`에서 `skipLibCheck: true` (개발 시)
+- 불필요 플러그인 비활성화 (개발 시 린팅 플러그인 분리)
+- `.gitignore`/`watchignore`에 빌드 출력 디렉토리 추가

package/templates/.claude/skills/project-optimizer/rules/dx-lint-config.md

@@ -0,0 +1,36 @@
+---
+title: Optimize Linter and Formatter Configuration
+impact: MEDIUM
+impactDescription: Consistent code style, faster feedback loop
+tags: dx, lint, format, eslint, prettier, biome, ruff
+languages: all
+related: [dx-type-safety, code-complexity]
+---
+
+## 린터/포매터 최적 설정
+
+프로젝트에 맞는 린터/포매터를 설정하여 일관된 코드 스타일과 빠른 피드백을 보장합니다.
+
+**언어별 권장 도구 (2026):**
+
+| 언어 | 린터 | 포매터 | 비고 |
+|------|------|--------|------|
+| **JS/TS** | ESLint 9 (flat config) | Prettier 또는 Biome | Biome = lint+format 올인원 |
+| **Python** | Ruff | Ruff (format) | flake8+isort+black 100x 빠른 대체 |
+| **Go** | go vet + staticcheck | gofmt (내장) | |
+| **Rust** | clippy | rustfmt (내장) | |
+| **Java** | SpotBugs / Error Prone | google-java-format | |
+
+**빠른 피드백을 위한 설정:**
+
+```json
+// lint-staged (Git 커밋 시 변경 파일만)
+{
+  "*.{ts,tsx}": ["eslint --fix", "prettier --write"],
+  "*.py": ["ruff check --fix", "ruff format"],
+  "*.go": ["gofmt -w"],
+  "*.rs": ["rustfmt"]
+}
+```
+
+**원칙:** 전체 프로젝트 린트는 CI에서, 로컬은 변경 파일만 (lint-staged).

package/templates/.claude/skills/project-optimizer/rules/dx-test-coverage.md

@@ -0,0 +1,34 @@
+---
+title: Ensure Test Coverage on Critical Paths
+impact: MEDIUM
+impactDescription: Confidence in refactoring, catches regressions
+tags: dx, test, coverage, critical-path
+languages: all
+related: [code-error-handling, dx-ci-speed]
+---
+
+## 핵심 로직 테스트 커버리지 확보
+
+100% 커버리지보다 핵심 비즈니스 로직의 높은 커버리지가 중요합니다.
+
+**우선순위:**
+
+| 우선순위 | 대상 | 이유 |
+|---------|------|------|
+| **1** | 비즈니스 로직/도메인 | 변경 빈도 높음, 버그 영향 큼 |
+| **2** | 데이터 변환/파싱 | 엣지 케이스 많음 |
+| **3** | API 엔드포인트 | 외부 계약 |
+| **4** | 에러 처리 경로 | 간과하기 쉬움 |
+| LOW | UI 컴포넌트 렌더링 | 자주 변경, ROI 낮음 |
+| LOW | 외부 서비스 호출 | Mock 필요, 깨지기 쉬움 |
+
+**테스트 도구 (2026):**
+
+| 언어 | 도구 | 특징 |
+|------|------|------|
+| **JS/TS** | Vitest | Vite 통합, ESM 네이티브, 빠름 |
+| **Python** | pytest | 풍부한 에코시스템 |
+| **Go** | testing (내장) | `go test -cover` |
+| **Rust** | cargo test (내장) | `cargo tarpaulin` (커버리지) |
+
+**목표:** 핵심 로직 80%+, 전체 60%+ (프로젝트 성격에 따라 조정).

package/templates/.claude/skills/project-optimizer/rules/dx-type-safety.md

@@ -0,0 +1,49 @@
+---
+title: Maximize Type System Usage
+impact: MEDIUM
+impactDescription: Catches bugs at compile time, better IDE support
+tags: dx, type, safety, strict, generics
+languages: [ts, go, rust, java, csharp]
+related: [code-error-handling, code-naming]
+---
+
+## 타입 시스템 최대 활용
+
+언어의 타입 시스템을 최대한 활용하여 런타임 에러를 컴파일 타임에 잡습니다.
+
+**언어별 strict 설정:**
+
+```json
+// TypeScript - tsconfig.json
+{ "compilerOptions": { "strict": true, "noUncheckedIndexedAccess": true } }
+```
+
+```toml
+# Rust - Clippy strict
+[lints.clippy]
+pedantic = "warn"
+```
+
+```python
+# Python - mypy strict
+[tool.mypy]
+strict = true
+disallow_any_generics = true
+```
+
+```go
+// Go - go vet + staticcheck
+// go vet ./...
+// staticcheck ./...
+```
+
+**패턴:**
+
+| 패턴 | 효과 | 언어 |
+|------|------|------|
+| **Discriminated union** | 상태별 안전한 분기 | TS, Rust (enum), Python (Literal) |
+| **Branded type** | 같은 원시형 혼동 방지 | TS (`type UserId = string & { __brand: 'UserId' }`) |
+| **Exhaustive check** | switch에서 누락 분기 감지 | TS (`never`), Rust (match), Go (exhaustive) |
+| **Generic constraint** | 타입 파라미터 제한 | 모든 정적 타입 언어 |
+
+**원칙:** `any`/`object`/`interface{}` 사용 최소화. 가능한 가장 구체적인 타입 사용.

package/templates/.claude/skills/project-optimizer/rules/io-batch-queries.md

@@ -0,0 +1,67 @@
+---
+title: Batch Queries to Eliminate N+1
+impact: HIGH
+impactDescription: 100x fewer queries, 10x faster response
+tags: io, database, n+1, batch, query
+languages: all
+related: [concurrency-parallel, io-cache-layer]
+---
+
+## N+1 쿼리 제거
+
+목록 조회 후 각 항목마다 추가 쿼리를 실행하는 N+1 패턴을 배치/조인으로 전환합니다.
+
+**❌ 잘못된 예시 (N+1):**
+
+```python
+# 100명 유저 = 101 쿼리
+users = db.query("SELECT * FROM users")
+for user in users:
+    orders = db.query(f"SELECT * FROM orders WHERE user_id = {user.id}")
+```
+
+```typescript
+// Prisma N+1
+const users = await prisma.user.findMany()
+for (const user of users) {
+  const orders = await prisma.order.findMany({ where: { userId: user.id } })
+}
+```
+
+**✅ 올바른 예시 (배치/조인):**
+
+```python
+# 2 쿼리
+users = db.query("SELECT * FROM users")
+user_ids = [u.id for u in users]
+orders = db.query("SELECT * FROM orders WHERE user_id = ANY($1)", user_ids)
+
+# SQLAlchemy - eager loading
+users = session.query(User).options(selectinload(User.orders)).all()
+```
+
+```typescript
+// Prisma - include
+const users = await prisma.user.findMany({
+  include: { orders: true }
+})
+```
+
+```go
+// GORM - Preload
+var users []User
+db.Preload("Orders").Find(&users)
+```
+
+```ruby
+# ActiveRecord - includes
+users = User.includes(:orders).all
+```
+
+```java
+// JPA - EntityGraph
+@EntityGraph(attributePaths = {"orders"})
+List<User> findAll();
+```
+
+**감지 방법:** 쿼리 로그에서 반복되는 유사 쿼리 패턴 확인. ORM 쿼리 카운터 활용.

package/templates/.claude/skills/project-optimizer/rules/io-cache-layer.md

@@ -0,0 +1,67 @@
+---
+title: Add Cache Layer for Repeated Reads
+impact: HIGH
+impactDescription: 10-100x latency reduction for cached data
+tags: io, cache, lru, ttl, redis, in-memory
+languages: all
+related: [io-batch-queries, memory-bounded-cache]
+---
+
+## 반복 읽기에 캐시 레이어 추가
+
+동일 데이터를 반복 조회하는 경우 인메모리/외부 캐시를 추가하여 DB/API 부하를 줄입니다.
+
+**❌ 잘못된 예시 (매번 DB 조회):**
+
+```python
+def get_user(user_id: str) -> User:
+    return db.query("SELECT * FROM users WHERE id = $1", user_id)
+```
+
+**✅ 올바른 예시 (캐시 레이어):**
+
+```python
+# Python (functools.lru_cache)
+from functools import lru_cache
+
+@lru_cache(maxsize=1000)
+def get_config(key: str) -> str:
+    return db.query("SELECT value FROM config WHERE key = $1", key)
+
+# TTL 있는 캐시 (cachetools)
+from cachetools import TTLCache
+cache = TTLCache(maxsize=1000, ttl=300)  # 5분
+```
+
+```typescript
+// Node.js (lru-cache)
+import { LRUCache } from 'lru-cache'
+const cache = new LRUCache<string, User>({ max: 1000, ttl: 5 * 60 * 1000 })
+
+async function getUser(id: string): Promise<User> {
+  const cached = cache.get(id)
+  if (cached) return cached
+  const user = await db.user.findUnique({ where: { id } })
+  if (user) cache.set(id, user)
+  return user
+}
+```
+
+```go
+// Go (groupcache / ristretto)
+import "github.com/dgraph-io/ristretto"
+cache, _ := ristretto.NewCache(&ristretto.Config{
+    NumCounters: 1e7, MaxCost: 1 << 30, BufferItems: 64,
+})
+```
+
+```rust
+// Rust (moka)
+use moka::future::Cache;
+let cache: Cache<String, User> = Cache::builder()
+    .max_capacity(1000)
+    .time_to_live(Duration::from_secs(300))
+    .build();
+```
+
+**캐시 전략:** 읽기 빈도 높고, 쓰기 빈도 낮은 데이터에 적용. TTL로 신선도 보장.

package/templates/.claude/skills/project-optimizer/rules/io-connection-reuse.md

@@ -0,0 +1,67 @@
+---
+title: Reuse Connections with Pooling
+impact: HIGH
+impactDescription: Eliminates connection overhead, 5-20x throughput
+tags: io, connection, pool, keep-alive, reuse
+languages: all
+related: [concurrency-pool, memory-pool-reuse]
+---
+
+## 커넥션 풀/재사용
+
+매 요청마다 새 커넥션을 생성하지 않고 풀에서 재사용합니다.
+
+**❌ 잘못된 예시 (매번 새 커넥션):**
+
+```python
+def get_user(user_id):
+    conn = psycopg2.connect(DSN)  # 매번 TCP 핸드셰이크 + TLS + 인증
+    cursor = conn.cursor()
+    cursor.execute("SELECT ...", (user_id,))
+    result = cursor.fetchone()
+    conn.close()
+    return result
+```
+
+**✅ 올바른 예시 (커넥션 풀):**
+
+```python
+# Python (SQLAlchemy)
+engine = create_engine(DSN, pool_size=10, max_overflow=20, pool_recycle=3600)
+
+# Python (asyncpg)
+pool = await asyncpg.create_pool(DSN, min_size=5, max_size=20)
+async with pool.acquire() as conn:
+    result = await conn.fetchrow("SELECT ...", user_id)
+```
+
+```typescript
+// Prisma (자동 풀링)
+// datasource db { url = "..." } → connection_limit 설정
+// schema.prisma: url = "...?connection_limit=10"
+```
+
+```go
+// Go (database/sql - 내장 풀)
+db, _ := sql.Open("postgres", dsn)
+db.SetMaxOpenConns(25)
+db.SetMaxIdleConns(10)
+db.SetConnMaxLifetime(5 * time.Minute)
+```
+
+```rust
+// Rust (deadpool-postgres)
+let pool = Pool::builder(manager).max_size(16).build().unwrap();
+let client = pool.get().await?;
+let rows = client.query("SELECT ...", &[&user_id]).await?;
+```
+
+```java
+// Java (HikariCP)
+HikariConfig config = new HikariConfig();
+config.setMaximumPoolSize(10);
+config.setMinimumIdle(5);
+config.setConnectionTimeout(30000);
+```
+
+**HTTP 커넥션 재사용:** `Keep-Alive` 헤더, HTTP/2 멀티플렉싱, HTTP 클라이언트 인스턴스 재사용.