diff --git a/10_Wiki/Topics/Business_Strategy/E-commerce Platforms.md b/10_Wiki/Topics/Business_Strategy/E-commerce Platforms.md
new file mode 100644
index 00000000..b3ff3f19
--- /dev/null
+++ b/10_Wiki/Topics/Business_Strategy/E-commerce Platforms.md	
@@ -0,0 +1,22 @@
+# [[E-commerce Platforms]]
+
+## 📌 Brief Summary
+E-commerce Platforms(이커머스 플랫폼)은 제품 카탈로그, 장바구니, 결제 처리 등의 기능을 제공하여 온라인 상거래를 지원하는 시스템입니다 [1, 2]. 이 시스템의 핵심은 검색 엔진 최적화(SEO)를 통한 제품 발견, 빠른 페이지 로딩을 통한 구매 전환율 향상, 그리고 재고 및 가격 변동을 반영하는 최신 데이터의 유지입니다 [3-5]. 소스 자료에 따르면, 이커머스 플랫폼은 성능과 확장성을 극대화하기 위해 SSR(서버 사이드 렌더링), ISR(점진적 정적 재생성)과 같은 최적화된 웹 렌더링 전략과 컴포넌트 기반 아키텍처(CBA)를 적극적으로 채택합니다 [2, 6].
+
+## 📖 Core Content
+* **이커머스 플랫폼을 위한 웹 렌더링 전략 (Web Rendering Strategies):**
+  * **SSR (Server-Side Rendering):** 이커머스 플랫폼의 제품 목록 페이지, 카테고리 탐색 및 개별 제품 상세 페이지에 가장 이상적인 렌더링 방식 중 하나입니다 [3]. 서버에서 제품의 세부 정보, 가격, 구매 버튼이 포함된 완전한 HTML을 즉시 제공하므로, 자바스크립트 로딩을 기다릴 필요 없이 사용자에게 콘텐츠를 보여주어 구매 전환율을 크게 향상시킵니다 [5]. 또한 훌륭한 SEO를 제공하여 제품 검색 노출에 유리하며, 항상 최신의 실시간 데이터를 요구하는 결제(Checkout) 페이지에 적합합니다 [3, 7].
+  * **SSG (Static Site Generation):** 제품 라인이 변동 없이 안정적이고 콘텐츠 업데이트 주기가 규칙적인 제품 카탈로그 페이지에 적용될 수 있습니다 [8]. 
+  * **ISR (Incremental Static Regeneration):** 이커머스 플랫폼에 최적의 균형(성능과 최신성)을 제공하는 고도화된 접근 방식입니다 [4, 6]. 대규모 제품 카탈로그를 초고속으로 로딩하는 동시에, 전체 사이트를 다시 빌드하는 오버헤드 없이 백그라운드에서 재고 정보와 가격을 주기적으로 업데이트하여 최신 상태로 유지할 수 있습니다 [4, 6, 9].
+
+* **컴포넌트 기반 아키텍처 적용 (Component-Based Architecture):**
+  * 이커머스 플랫폼은 제품 목록(Product listings), 결제 게이트웨이(Payment gateways), 장바구니(Shopping carts), 고객 리뷰 모듈 등 명확히 분리된 기능을 가진 재사용 가능한 소프트웨어 컴포넌트들의 조립으로 구축됩니다 [2].
+  * 이러한 모듈식 접근 방식을 통해 비즈니스가 확장됨에 따라 새로운 결제 옵션을 추가하거나 제품 추천 기능을 갱신해야 할 때, 플랫폼 전체에 중단을 일으키지 않고 특정 컴포넌트만 쉽게 교체하거나 확장할 수 있는 유연성을 확보합니다 [2, 10].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Server-Side Rendering (SSR)]], [[Incremental Static Regeneration (ISR)]], [[Component-Based Architecture]], [[Search Engine Optimization (SEO)]]
+- **Projects/Contexts:** 대규모 트래픽을 처리하면서도 검색 엔진 노출을 극대화하고 실시간 재고/가격 변동을 반영해야 하는 프론트엔드 웹 성능 최적화 및 렌더링 아키텍처 구축 맥락 [3, 4, 7].
+- **Contradictions/Notes:** 제공된 소스는 이커머스 플랫폼의 백엔드 비즈니스 로직이나 운영 모델보다는 주로 프론트엔드의 화면 렌더링 최적화(SSR/ISR)와 아키텍처(컴포넌트화) 측면에 초점을 맞추고 있어, 결제 시스템의 내부 동작 원리 등에 대해서는 소스에 관련 정보가 부족합니다.
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Business_Strategy/Meta Quest Store.md b/10_Wiki/Topics/Business_Strategy/Meta Quest Store.md
new file mode 100644
index 00000000..04477daf
--- /dev/null
+++ b/10_Wiki/Topics/Business_Strategy/Meta Quest Store.md	
@@ -0,0 +1,18 @@
+# [[Meta Quest Store]]
+
+## 📌 Brief Summary
+Meta Quest Store는 Meta에서 운영하는 플랫폼으로, 제공된 문서 내에서는 프론트엔드 성능 최적화 도구인 React Compiler를 실제 프로덕션 환경에 성공적으로 도입한 대표적인 사례로만 짧게 등장합니다 [1, 2]. 해당 스토어의 구체적인 서비스 목적, 판매 항목, 혹은 전반적인 아키텍처에 대해서는 소스에 관련 정보가 부족합니다.
+
+## 📖 Core Content
+- **React Compiler의 성공적 배포**: Meta는 대중에게 공개하기 전 자사 애플리케이션 생태계 전반에 걸쳐 React Compiler를 내부적으로 테스트했으며, Instagram과 함께 Meta Quest Store에 성공적으로 배포했습니다 [1, 2].
+- **로딩 속도 지표 개선**: 수동 메모이제이션(Manual Memoization) 문제를 해결하는 React Compiler 적용 결과, Quest Store의 로딩 속도는 최소 4% 이상 향상되었으며, 초기 로딩(initial loads) 시간은 최대 12%까지 개선되었습니다 [2].
+- **상호작용(Interaction)의 즉각성**: 최적화의 결과로 Quest Store 내의 복잡한 제품 페이지(complex product pages)들이 눈에 띄게 빠르게 로드되었습니다 [1]. 특히 일부 상호작용은 2배 이상 빨라져 사용자들이 거의 즉각적(instantaneous)이라고 느낄 수 있는 수준의 개선이 이루어졌습니다 [1, 2].
+- 이외에 플랫폼 자체의 상업적 기능이나 비즈니스 로직 등에 대해서는 소스에 관련 정보가 부족합니다.
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[React Compiler]], [[Performance Optimization]]
+- **Projects/Contexts:** [[Meta's Internal Testing (React Compiler 성능 검증)]]
+- **Contradictions/Notes:** Meta Quest Store에 대한 독립적이고 포괄적인 설명은 제공된 소스에 관련 정보가 부족합니다. 오직 React Compiler의 적용으로 인한 성능 최적화 지표를 보여주는 단편적인 사례(Case Study)로만 활용되었습니다.
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Business_Strategy/SaaS 플랫폼 및 인터랙티브 대시보드 개발.md b/10_Wiki/Topics/Business_Strategy/SaaS 플랫폼 및 인터랙티브 대시보드 개발.md
new file mode 100644
index 00000000..6a68f440
--- /dev/null
+++ b/10_Wiki/Topics/Business_Strategy/SaaS 플랫폼 및 인터랙티브 대시보드 개발.md	
@@ -0,0 +1,23 @@
+# [[SaaS 플랫폼 및 인터랙티브 대시보드 개발]]
+
+## 📌 Brief Summary
+SaaS 플랫폼과 인터랙티브 대시보드는 실시간 데이터 업데이트, 풍부한 사용자 상호작용, 그리고 매끄러운 화면 전환이 필수적인 웹 애플리케이션입니다 [1, 2]. 이러한 시스템은 대부분 로그인 벽(Authentication wall) 뒤에서 작동하므로 검색 엔진 최적화(SEO)의 중요성이 낮아 클라이언트 사이드 렌더링(CSR)이 가장 이상적인 렌더링 방식으로 평가받습니다 [1, 3, 4]. 또한 대규모 데이터 처리와 복잡한 UI 업데이트 시 성능 병목 현상을 방지하기 위해 컴포넌트 기반 아키텍처와 동시성 렌더링(Concurrent Rendering) 같은 최적화 기술이 적극적으로 활용됩니다 [5, 6].
+
+## 📖 Core Content
+- **최적의 렌더링 전략 (CSR의 활용):**
+  SaaS 플랫폼 및 사용자 대시보드 구축 시에는 클라이언트 사이드 렌더링(CSR)이 주로 권장됩니다 [1, 2]. 대시보드 특성상 검색 엔진 인덱싱이 필요하지 않고 동적인 상호작용이 가장 중요하기 때문입니다 [1, 3]. 초기 로딩 속도는 다소 느릴 수 있으나, 브라우저에서 동적으로 라우팅과 데이터를 처리하므로 사용자가 여러 애플리케이션 섹션을 부드럽게 탐색할 수 있고 인터랙티브한 앱과 같은 경험을 제공합니다 [2, 3, 7]. 일부 프레임워크에서는 실시간 상호작용이 중요한 대시보드에는 CSR을, 그 외 문서나 블로그 페이지에는 SSG나 SSR을 사용하는 하이브리드 방식을 적용하기도 합니다 [8, 9].
+
+- **데이터 집약적 대시보드의 렌더링 성능 최적화:**
+  - **자동 배칭(Automatic Batching):** 데이터가 많은 대시보드에서 React 18의 자동 배칭 기능을 활성화하면 여러 상태 업데이트가 단일 리렌더링으로 묶여 처리됩니다 [10, 11]. 내부 사례 연구에 따르면, 이를 통해 최대 부하 시 총 렌더링 횟수를 약 40% 줄이고 프레임 속도를 25% 향상시킬 수 있습니다 [12, 13].
+  - **동시성 기능(Concurrent Features):** 대시보드에서 10,000개 이상의 대규모 데이터 리스트를 필터링하거나 차트를 다시 계산하는 등 비용이 많이 드는 작업 시 UI가 멈추는 현상을 방지해야 합니다 [5, 14]. `useTransition`이나 `useDeferredValue` 훅을 사용해 무거운 상태 업데이트를 지연시키면 메인 스레드를 차단하지 않고 UI의 즉각적인 반응성(예: 타이핑 시 입력 지연 방지)을 유지할 수 있습니다 [5, 14, 15].
+
+- **컴포넌트 기반 아키텍처(CBA)의 적용:**
+  인터랙티브 대시보드는 차트, 데이터 테이블, 그래프 등 독립적이고 재사용 가능한 컴포넌트들을 조합하여 구축하는 컴포넌트 기반 아키텍처가 적합합니다 [6, 16]. 이를 통해 기능별 모듈화가 이루어져 일부 기능(예: 결제 프로세서 교체, 특정 위젯 업데이트)만 안전하게 수정하거나 확장할 수 있어 유지보수와 확장이 용이해집니다 [17, 18]. 
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Client-Side Rendering (CSR)]], [[Component-Based Architecture]], [[Automatic Batching]], [[Concurrent Rendering]]
+- **Projects/Contexts:** [[데이터 집약적 대시보드 성능 최적화 사례]], [[Sanity Studio]]
+- **Contradictions/Notes:** React 서버 컴포넌트(RSC) 적용과 관련하여 소스 간 시각 차이가 존재합니다. 일부 소스는 읽기 전용 데이터 디스플레이(제품 카탈로그, 단순 대시보드)에 RSC를 사용하면 클라이언트 JavaScript 번들을 40-60%까지 줄일 수 있다고 주장하지만 [19], 다른 소스에서는 빈번한 리렌더링과 로컬 상태, 직접적인 브라우저 API에 크게 의존하는 '복잡한 대시보드 및 고도의 상호작용이 필요한 인터페이스'에는 RSC가 부적합(Poor fit)하며 클라이언트 컴포넌트를 사용해야 한다고 경고합니다 [20].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Business_Strategy/전자상거래 플랫폼 (E-commerce Platforms).md b/10_Wiki/Topics/Business_Strategy/전자상거래 플랫폼 (E-commerce Platforms).md
new file mode 100644
index 00000000..18a11cd5
--- /dev/null
+++ b/10_Wiki/Topics/Business_Strategy/전자상거래 플랫폼 (E-commerce Platforms).md	
@@ -0,0 +1,24 @@
+# [[전자상거래 플랫폼 (E-commerce Platforms)]]
+
+## 📌 Brief Summary
+전자상거래 플랫폼은 제품 카탈로그, 재고 관리, 결제 시스템 등을 처리하기 위해 고도의 확장성과 렌더링 최적화가 요구되는 복잡한 웹 시스템입니다 [1-3]. 검색 엔진 최적화(SEO)와 빠른 페이지 로딩 속도, 그리고 장바구니와 같은 동적 상호작용 간의 균형을 맞추는 것이 핵심 목표입니다 [1, 4, 5]. 이를 달성하기 위해 현대의 전자상거래 플랫폼은 SSR, ISR, SSG와 같은 다양한 렌더링 전략과 컴포넌트 기반 아키텍처(CBA)를 적극적으로 활용합니다 [6-8].
+
+## 📖 Core Content
+* **전자상거래를 위한 최적의 렌더링 전략:**
+  * **서버 사이드 렌더링 (SSR):** 제품 목록 페이지, 카테고리 탐색 및 개별 제품 상세 뷰에 이상적입니다. 강력한 검색 엔진 가시성(SEO)을 보장하고 클라이언트 측의 처리 지연 없이 제품의 가격과 재고 등을 즉각적으로 렌더링하여 사용자 경험과 전환율을 향상시킵니다 [1].
+  * **점진적 정적 재생성 (ISR):** 빠른 제품 페이지 로딩 속도를 제공하면서도 전체 사이트를 다시 빌드할 필요 없이 재고 정보 및 가격을 최신 상태로 유지할 수 있어 대규모 전자상거래 플랫폼에 완벽한 균형을 제공합니다 [4, 6, 7]. 
+  * **정적 사이트 생성 (SSG):** 실시간 재고 변경보다는 예약된 빌드 프로세스를 통해 제품 정보가 주로 업데이트되는 안정적인 제품 카탈로그 페이지에 유리합니다 [9, 10].
+  * **클라이언트 사이드 렌더링 (CSR):** 소셜 미디어나 전자상거래 웹사이트처럼 고도의 상호 작용이 필요한 애플리케이션에 부분적으로 사용됩니다 [5].
+
+* **전자상거래에서의 컴포넌트 기반 아키텍처 (CBA) 활용:**
+  * 전자상거래 플랫폼은 제품 목록, 결제 게이트웨이, 장바구니, 고객 리뷰 모듈과 같은 개별 기능을 독립적인 컴포넌트로 구축하여 아키텍처의 모듈화와 재사용성을 극대화합니다 [2, 3].
+  * 트래픽 급증 시 전체 애플리케이션이 아닌 쇼핑 카트 컴포넌트와 같은 특정 인스턴스만 추가하여 원활한 운영을 유지하는 등 뛰어난 확장성을 제공합니다 [8].
+  * 마케팅 캠페인이나 시즌별 프로모션에 맞춰 기본 비즈니스 기능을 손상시키지 않고 다양한 테마를 적용하여 사이트의 디자인을 신속하게 변경할 수 있습니다 [11].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Server-Side Rendering (SSR)]], [[Incremental Static Regeneration (ISR)]], [[Component-Based Architecture (CBA)]]
+- **Projects/Contexts:** [[제품 카탈로그 및 장바구니 시스템 (Product Catalogs and Shopping Carts)]]
+- **Contradictions/Notes:** 소스 [5]에서는 높은 수준의 상호작용이 필요한 전자상거래 웹사이트에 CSR이 흔히 사용된다고 언급합니다. 하지만 다른 소스들은 검색 엔진 최적화(SEO)와 최신 데이터 제공의 중요성 때문에 제품 탐색 및 세부 페이지에는 SSR 또는 ISR을 사용하는 것이 훨씬 이상적이고 필수적이라고 강조합니다 [1, 4, 7].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/2026-04-25-Skybound_Vampire_Survivors_Loop_and_Stage_Curve_Preparation.md b/10_Wiki/Topics/Frontend_Mastery/2026-04-25-Skybound_Vampire_Survivors_Loop_and_Stage_Curve_Preparation.md
new file mode 100644
index 00000000..04f297a2
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/2026-04-25-Skybound_Vampire_Survivors_Loop_and_Stage_Curve_Preparation.md
@@ -0,0 +1,116 @@
+# Skybound Vampire Survivors Loop and Stage Curve Preparation
+
+작성일: 2026-04-25 23:52 KST
+
+## 요청 요약
+
+- Skybound가 뱀파이어 서바이벌 계열 게임처럼 느껴지도록 재미 요소와 스테이지별 레벨 구조를 준비한다.
+- 단순히 적을 많이 내보내는 것이 아니라, 성장 선택, 밀도 상승, 진화 완성, 보스 체크포인트가 자연스럽게 이어지도록 만든다.
+
+## 핵심 방향
+
+Skybound는 탑다운 생존 슈터이지만, 기존 구조는 스테이지 시간이 짧고 보스 진입이 빨라 빌드가 완성되기 전에 전투가 끊기는 문제가 있었다. 뱀서류 재미를 만들려면 다음 루프가 안정적으로 반복되어야 한다.
+
+1. 초반: 첫 무기 선택 후 약한 적을 많이 처치하며 빠르게 1-2회 성장한다.
+2. 중반: 적 밀도와 엘리트 압박이 올라가며 광역/관통/방어 선택의 의미가 생긴다.
+3. 후반: 스웜과 미니보스가 들어오며 빌드 조합과 진화 무기가 필요해진다.
+4. 보스: 완성된 빌드가 제대로 작동하는지 검증한다.
+5. 다음 스테이지: 같은 빌드를 이어가되 적 밀도, 패턴, 보스 기믹이 상승한다.
+
+## 적용한 변경
+
+### 8스테이지 Survivor 프로필 추가
+
+`CombatTimeline.ts`에 `SURVIVOR_STAGE_PROFILES`를 추가했다. 각 스테이지는 아래 정보를 가진다.
+
+- 스테이지 이름
+- 스테이지 길이
+- 기본 난이도 배율
+- 동시 적 수 기준
+- 스폰 템포
+- 오프닝 웨이브
+- 압박 엘리트 웨이브
+- 스웜 웨이브
+- 클라이맥스 엘리트 웨이브
+- 미니보스 체크포인트
+
+### 스테이지별 구조
+
+- Stage 1 `First Contact`: 첫 무기와 기본 생존 학습
+- Stage 2 `Fast Lanes`: 빠른 적과 이동 압박
+- Stage 3 `Ruined Circuit`: 혼합 편대와 엘리트 압박
+- Stage 4 `Crossfire Grid`: 길막/라인 클리어 압박
+- Stage 5 `Magma Forge`: 고밀도 스웜 시작
+- Stage 6 `Storm Foundry`: 빌드 완성 요구
+- Stage 7 `Arcane Collapse`: 진화 무기 권장
+- Stage 8 `Final Singularity`: 완성 빌드 검증
+
+### 스테이지 시간 조정
+
+기존 Standard 스테이지는 약 165초부터 시작해 빌드업 시간이 부족했다. 새 구조에서는 Stage 1이 240초, Stage 8이 420초까지 증가한다.
+
+이렇게 하면 플레이어는 한 스테이지 안에서 다음 리듬을 경험할 수 있다.
+
+- 0-25%: 세팅과 첫 성장
+- 25-48%: 엘리트 압박
+- 48-72%: 스웜 압박
+- 72%-보스 전: 클라이맥스와 미니보스
+- 마지막 35초 전후: 보스전 진입
+
+### 스폰 밀도 조정
+
+- 적 하드캡을 56에서 76으로 올렸다.
+- 스웜 배치 단위를 6에서 8로 올렸다.
+- 기본 절차 스폰 간격을 96프레임에서 84프레임으로 줄였다.
+
+목표는 “가만히 있어도 클리어”가 아니라, 점점 밀려오는 압박을 움직임과 빌드 선택으로 해결하게 만드는 것이다.
+
+### Tac EXP 커브 조정
+
+바닥 EXP 젬을 다시 뿌리지는 않고, 처치 즉시 Tac EXP를 지급하는 현재 방향을 유지했다. 다만 뱀서류 성장 리듬을 만들기 위해 처치 경험치를 조정했다.
+
+- 일반 적: `+2 TAC`
+- 엘리트 적: `+10 TAC`
+- 미드보스: `+30 TAC`
+
+초기 요구 EXP는 `90`에서 `80`으로 낮췄다. 대신 레벨업 후 초과 EXP carryover는 25%만 유지해 연속 레벨업 폭주는 막는다.
+
+레벨 요구량 배율은 아래처럼 조정했다.
+
+- Level 1-4: `x1.34`
+- Level 5-8: `x1.42`
+- Level 9-14: `x1.52`
+- Level 15+: `x1.62`
+
+## 설계 의도
+
+이번 변경은 “Vampire Survivors의 재미”를 다음 요소로 해석했다.
+
+- 적은 점점 많아진다.
+- 플레이어는 더 자주 선택하고 강해진다.
+- 선택에는 빌드 방향성이 있다.
+- 중반 이후에는 광역, 관통, 방어, 기동 중 최소 하나가 부족하면 압박을 느낀다.
+- 보스는 단절된 엔딩이 아니라 빌드 검증 구간이다.
+- 다음 스테이지는 새 게임이 아니라 이전 빌드의 확장 시험이다.
+
+## 수정 파일
+
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/config/CombatTimeline.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/SpawnerSystem.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/CombatSystem.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/ProgressionSystem.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/types.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/store/useGameStore.ts`
+
+## 검증
+
+- `npm run build` 성공
+- Vite 경고: `/sprites/player.png referenced in /sprites/player.png didn't resolve at build time`
+- 위 경고는 기존 런타임 경로 경고이며 이번 변경으로 인한 빌드 실패는 아니다.
+
+## 후속 작업 제안
+
+- 각 스테이지별 고유 몬스터 역할 비중을 더 명확히 분리한다.
+- 스테이지별 보스 패턴을 현재보다 더 강하게 차별화한다.
+- 진화 무기별 화면 가독성과 성능을 플레이테스트로 검증한다.
+- 미니보스 처치 시 보물상자/카드 선택 보상을 확정 지급하는 구조를 추가하면 뱀서류 보상감이 더 강해진다.
diff --git a/10_Wiki/Topics/Frontend_Mastery/2026-04-26-Skybound_Miniboss_Treasure_Cache_Reward_Loop.md b/10_Wiki/Topics/Frontend_Mastery/2026-04-26-Skybound_Miniboss_Treasure_Cache_Reward_Loop.md
new file mode 100644
index 00000000..0bc19fac
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/2026-04-26-Skybound_Miniboss_Treasure_Cache_Reward_Loop.md
@@ -0,0 +1,109 @@
+# Skybound Miniboss Treasure Cache Reward Loop
+
+작성일: 2026-04-26 09:32 KST
+
+## 요청 요약
+
+- 뱀파이어 서바이벌 계열의 재미를 더 강하게 만들기 위한 다음 단계로, 미니보스 처치 보상 루프를 추가한다.
+- 단순 EXP 성장만 반복되는 구조가 아니라, 중간 강적을 잡았을 때 빌드 방향을 강화하는 확정 보상을 제공한다.
+- 보상은 기존 Tac Level Up 화면을 재사용하되, 보물상자 성격의 `Emergency Supply` 카드 선택으로 연결한다.
+
+## 핵심 방향
+
+Skybound의 현재 전투 루프는 적을 처치하면 Tac EXP를 바로 얻고, 일정 EXP에 도달하면 업그레이드를 선택하는 구조다. 이 방식은 화면 가독성에는 좋지만, 플레이 중간에 “강적을 잡아서 특별한 보상을 얻었다”는 뱀서류 특유의 보상감이 부족했다.
+
+이번 변경의 목표는 미니보스를 다음 역할로 재정의하는 것이다.
+
+1. 전투 흐름 중간의 압박 체크포인트
+2. 플레이어 빌드가 충분히 강한지 확인하는 작은 검증 구간
+3. 처치하면 현재 빌드를 더 선명하게 만드는 확정 업그레이드 보상
+4. 보스 전 진화/EVO 경로를 완성할 기회를 주는 중간 보물상자
+
+## 적용한 변경
+
+### 미니보스 식별 플래그 추가
+
+기존 `MINI_BOSS` 스폰은 내부적으로 `ELITE` 적을 생성했기 때문에, 처치 시 일반 엘리트와 구분되는 보상 처리가 어려웠다. `SystemEnemy`에 아래 플래그를 추가했다.
+
+- `isMiniBoss`
+- `rewardClaimed`
+
+`SpawnerSystem`의 `MINI_BOSS` 스폰에서는 이제 `isMiniBoss: true`를 부여한다.
+
+### 미니보스 HP 스케일링
+
+미니보스가 후반 스테이지에서도 너무 빨리 녹지 않도록 스테이지와 난이도 배율을 반영했다.
+
+- 기본 HP: `620`
+- 스테이지당 증가: `+22%`
+- 현재 `difficultyMult` 반영
+
+의도는 미니보스가 보스만큼 길지는 않지만, 플레이어가 위치와 공격 방향을 신경 써야 하는 짧은 전투 목표가 되게 하는 것이다.
+
+### 처치 보상 인텐트 추가
+
+`EngineProtocol`에 `MINIBOSS_REWARD` 인텐트를 추가했다. `CombatSystem`은 미니보스 처치 시 직접 UI를 열지 않고, 엔진 인텐트를 통해 보상 처리를 요청한다.
+
+이렇게 한 이유는 다음과 같다.
+
+- 전투 시스템이 UI 상태를 직접 제어하지 않게 한다.
+- 기존 `LEVEL_UP` 이벤트와 `LevelUpModal` 흐름을 재사용한다.
+- 추후 보물상자 연출, 룰렛, 보상 티어를 추가하기 쉽다.
+
+### 빌드 우선 보상 카드 생성
+
+`ProgressionSystem`에 `generateMiniBossRewardCards`를 추가했다. 이 보상은 일반 레벨업 카드보다 더 전략적으로 구성된다.
+
+우선순위는 다음과 같다.
+
+1. 이미 보유한 무기/스킬의 레벨업
+2. Lv.3 이상 무기의 EVO에 필요한 서포트 패시브
+3. 스웜/압박 구간 대응용 `isSpikeCounter` 스킬
+4. 부족한 자리는 기존 3카드 생성 규칙으로 보충
+
+이 구조는 플레이어가 아무 카드나 고르는 것이 아니라, “내 빌드를 완성해가는 선택”을 하도록 유도한다.
+
+### 보상 UI 연결
+
+미니보스 처치 시 아래 흐름으로 동작한다.
+
+1. 미니보스 사망
+2. `CombatSystem`이 `MINIBOSS_REWARD` 인텐트 발행
+3. `useGameEngine`이 현재 스킬 상태를 기반으로 보상 카드 생성
+4. 게임 일시정지
+5. `LEVEL_UP` 이벤트를 `isChest: true`로 발행
+6. 기존 `Emergency Supply` 카드 선택 UI 표시
+7. `COMMAND CACHE UNLOCKED` 피드백 텍스트 출력
+
+## 설계 의도
+
+이 변경은 Skybound의 목적성을 더 명확하게 만들기 위한 작업이다.
+
+- 일반 적 처치: Tac EXP를 쌓는 기본 성장
+- 엘리트 처치: 더 많은 EXP와 재료/장비 가능성
+- 미니보스 처치: 확정 빌드 강화 선택
+- 스테이지 보스 처치: 다음 스테이지 진행과 영구 보상
+
+즉, 전투 중 목표가 “그냥 버티기”에서 “위험한 타이밍을 넘기고 빌드를 완성하기”로 바뀐다.
+
+## 수정 파일
+
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/hooks/useGameEngine.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/CombatSystem.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/EngineProtocol.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/ProgressionSystem.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/SpawnerSystem.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/types.ts`
+
+## 검증
+
+- `npm run build` 성공
+- Vite 경고: `/sprites/player.png referenced in /sprites/player.png didn't resolve at build time`
+- 위 경고는 기존 런타임 경로 경고이며 이번 변경으로 인한 빌드 실패는 아니다.
+
+## 후속 작업 제안
+
+- 미니보스 처치 순간에 실제 상자/코어가 열리는 0.6초 전용 연출을 추가한다.
+- 보상 카드에 `EVO READY`, `BUILD CORE`, `SURVIVAL PICK` 같은 태그를 붙여 선택 이유를 더 명확하게 보여준다.
+- 스테이지별 미니보스 외형과 탄막 패턴을 분리해 “이번 스테이지의 중간 위협” 정체성을 강화한다.
+- 보물상자 보상을 1장 선택에서 3장 순차 오픈 또는 희귀도 보상으로 확장할지 플레이테스트 후 결정한다.
diff --git a/10_Wiki/Topics/Frontend_Mastery/2026-04-26-Skybound_Reward_Card_Clarity_and_Command_Cache_UI.md b/10_Wiki/Topics/Frontend_Mastery/2026-04-26-Skybound_Reward_Card_Clarity_and_Command_Cache_UI.md
new file mode 100644
index 00000000..38aedfa3
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/2026-04-26-Skybound_Reward_Card_Clarity_and_Command_Cache_UI.md
@@ -0,0 +1,104 @@
+# Skybound Reward Card Clarity and Command Cache UI
+
+작성일: 2026-04-26 09:40 KST
+
+## 요청 요약
+
+- 미니보스 보상 루프 다음 단계로, 보상 카드가 왜 좋은 선택인지 사용자가 즉시 이해할 수 있게 개선한다.
+- 미니보스 처치 보상과 위기 보급 보상을 같은 화면처럼 보이지 않게 구분한다.
+- Stylized Casual Magitech 톤앤매너 안에서 보상감 있는 카드 선택 UI를 강화한다.
+
+## 핵심 방향
+
+이전 단계에서 미니보스 처치 시 확정 업그레이드 선택 보상이 추가되었다. 하지만 카드 3장이 뜨는 것만으로는 사용자가 “왜 이 보상이 지금 내 빌드에 좋은지” 바로 이해하기 어렵다.
+
+이번 변경의 목표는 보상 화면을 단순 선택지가 아니라, 플레이어에게 다음 메시지를 전달하는 UI로 만드는 것이다.
+
+1. 이 카드는 현재 주력 빌드를 강화한다.
+2. 이 카드는 EVO 진화 경로에 필요하다.
+3. 이 카드는 스웜/압박 상황에서 생존에 도움이 된다.
+4. 이 카드는 새로운 공격 패턴을 열어준다.
+
+## 적용한 변경
+
+### 보상 출처 타입 추가
+
+`LEVEL_UP` 이벤트에 `rewardSource`를 추가했다.
+
+- `STARTER`
+- `LEVEL_UP`
+- `POWER_SPIKE`
+- `MINIBOSS`
+
+기존에는 `isChest`만 있어서 미니보스 보상과 위기 보급 보상이 모두 같은 `Emergency Supply`처럼 보였다. 이제 보상 출처에 따라 헤더, 문구, 카드 태그를 다르게 표시할 수 있다.
+
+### 미니보스 보상 헤더 차별화
+
+미니보스 보상은 이제 `Emergency Supply`가 아니라 `Command Cache`로 표시된다.
+
+- Badge: `Cache`
+- Title: `Command Cache`
+- Subtitle: `Choose one build-defining reward`
+
+위기 보급은 기존 의도대로 `Emergency Supply`를 유지한다.
+
+### 카드 선택 이유 태그 추가
+
+각 카드 상단에 보상 이유 태그를 추가했다.
+
+- `FIRST CORE`: 첫 무기 선택, 런의 시작 방향 결정
+- `CORE UPGRADE`: 현재 주력 무기 강화
+- `MODULE BOOST`: 보유 패시브/모듈 강화
+- `EVO LINK`: 현재 무기의 진화 조건을 지원
+- `EVO READY`: 진화 조건 완성
+- `SURVIVAL PICK`: 스웜/압박 구간 대응
+- `NEW WEAPON`: 새로운 공격 패턴 개방
+- `UTILITY MOD`: 기본 성능 강화
+
+이 태그는 단순 라벨이 아니라, 카드가 “왜 지금 의미 있는 선택인지”를 설명하는 짧은 문장과 함께 표시된다.
+
+### Command Cache 연출 추가
+
+보상 화면 상단에 작은 마법공학 캐시 코어를 추가했다.
+
+- 팝 인 애니메이션
+- 회전하는 점선 링
+- 미니보스 캐시는 청록/라임 계열 빛
+- 일반 보급은 오렌지/시안 계열 빛
+
+실제 게임 시간을 더 지연시키지는 않지만, 화면이 뜨는 순간 보상 상자가 열린다는 감각을 강화한다.
+
+## 설계 의도
+
+뱀파이어 서바이벌 계열의 재미는 단순히 레벨업을 많이 하는 것이 아니라, “내가 고른 선택 때문에 빌드가 강해지고 있다”는 확신에서 나온다.
+
+이번 변경은 그 확신을 UI로 보강한다.
+
+- 미니보스 처치: `Command Cache`
+- 위기 보급: `Emergency Supply`
+- 일반 레벨업: `Tactical Upgrade`
+- 시작 선택: `Choose First Weapon`
+
+이제 각 성장 이벤트는 같은 카드 선택이라도 서로 다른 의미를 가진다.
+
+## 수정 파일
+
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/hooks/useGameEngine.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/ProgressionSystem.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/types.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/ui/GameSceneRenderer.tsx`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/ui/LevelUpModal.tsx`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/ui/LevelUpModal.css`
+
+## 검증
+
+- `npm run build` 성공
+- Vite 경고: `/sprites/player.png referenced in /sprites/player.png didn't resolve at build time`
+- 위 경고는 기존 런타임 경로 경고이며 이번 변경으로 인한 빌드 실패는 아니다.
+
+## 후속 작업 제안
+
+- 스테이지별 미니보스 패턴을 분리해 `Command Cache`를 얻는 과정 자체를 더 재미있게 만든다.
+- 보상 카드에 실제 EVO 결과 미리보기 아이콘을 추가한다.
+- 보물상자 보상을 1장 선택에서 희귀도 기반 다중 보상으로 확장할지 플레이테스트한다.
+- Command Cache가 열리는 짧은 0.5초 전용 컷인/상자 오픈 애니메이션을 Canvas 위에 추가한다.
diff --git a/10_Wiki/Topics/Frontend_Mastery/CSS Modules.md b/10_Wiki/Topics/Frontend_Mastery/CSS Modules.md
new file mode 100644
index 00000000..120c47a5
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/CSS Modules.md	
@@ -0,0 +1,30 @@
+# [[CSS Modules]]
+
+## 📌 Brief Summary
+CSS Modules는 표준 CSS 문법을 사용하면서도 빌드 단계에서 클래스명을 고유하게 변환하여 컴포넌트 단위로 스타일을 자동으로 스코핑(scoping)하는 CSS 아키텍처 접근법입니다 [1-3]. 전역 네임스페이스 충돌을 방지하기 위해 BEM과 같은 수동 규칙에 의존하는 대신, 도구를 통해 고유한 해시 클래스명을 생성함으로써 유지보수성을 극대화합니다 [4, 5]. 런타임 오버헤드가 없는 정적 CSS를 생성하므로 성능이 뛰어나며, React 및 Next.js와 같은 최신 프레임워크 환경에서 전역 오염 없이 안전하게 UI를 구축할 수 있게 해줍니다 [6-8].
+
+## 📖 Core Content
+* **동작 방식 및 특징:**
+  CSS Modules를 사용하면 개발자는 익숙한 표준 CSS 문법을 그대로 작성할 수 있습니다 [6, 9]. 작성된 CSS 파일(`.module.css`)을 JavaScript 컴포넌트에 임포트하면, 빌드 도구가 `.button`과 같은 클래스명을 `Button_button__x9KdL`과 같은 고유한 식별자로 자동 변환합니다 [3, 9]. 또한, `composes` 기능을 통해 기존 스타일을 쉽게 확장할 수 있으며 [1], Sass(SCSS)나 PostCSS와 같은 기존 CSS 도구와도 완벽하게 통합됩니다 [1, 10].
+
+* **장점:**
+  * **완벽한 스코핑 및 충돌 방지:** 클래스명이 자동으로 컴포넌트에 스코핑되므로, 스타일이 의도치 않게 다른 곳에 영향을 미치는 전역 충돌(global namespace collision) 문제를 원천적으로 차단합니다 [5, 6, 9, 11].
+  * **제로 런타임 오버헤드 (Zero Runtime Overhead):** 스타일이 빌드 타임에 처리되어 정적 CSS로 출력되므로, 런타임에 스타일을 파싱하는 CSS-in-JS 방식과 달리 브라우저 성능에 악영향을 주지 않으며 브라우저 캐싱을 최대한 활용할 수 있습니다 [6, 7, 12].
+  * **기존 CSS 생태계 및 유연성 활용:** 복잡한 애니메이션, 미디어 쿼리, 가상 요소(pseudo-elements) 및 복잡한 선택자 등 CSS의 모든 기능을 제한 없이 자연스럽게 사용할 수 있습니다 [7, 9]. 특정 프레임워크에 종속되지 않습니다 [7].
+  * **개발자 경험 향상:** TypeScript와 결합하여 모듈 클래스명에 대한 타이핑을 생성함으로써 오타를 빌드 타임에 잡아낼 수 있습니다 [13]. 
+
+* **단점 및 한계:**
+  * **파일 전환 (Context Switching):** 스타일을 수정할 때 JavaScript/JSX 파일과 `.module.css` 파일을 번갈아 가며 작업해야 하는 번거로움이 있습니다 [7].
+  * **동적 스타일링의 어려움:** CSS-in-JS와 달리 CSS와 JavaScript 간에 데이터를 공유하거나 컴포넌트 상태(Props)에 따른 동적인 스타일을 직접 부여하는 과정이 까다로우며, 이를 위해 조건부 문자열 연결(string concatenation) 작업이 필요합니다 [1, 7, 10].
+  * **네이밍 피로 (Naming Fatigue):** 유틸리티 클래스를 제공하는 Tailwind CSS와 달리 개발자가 여전히 요소마다 의미 있는 클래스 이름을 고민하고 지어주어야 합니다 [14]. 
+
+* **실무 활용 전략:**
+  CSS Modules는 탄탄한 CSS 역량을 갖춘 팀이나, 복잡한 애니메이션 및 세밀한 CSS 제어가 필요한 프로젝트에 가장 적합합니다 [14]. 특히 2025년 기준 Next.js App Router와 같은 React Server Components(RSC) 환경에서는 런타임 CSS-in-JS 라이브러리의 호환성 문제로 인해 Tailwind CSS나 CSS Modules를 사용하는 것이 강력히 권장됩니다 [8, 15]. 대규모 프로젝트의 실무에서는 레이아웃과 간격에는 빠르고 일관된 Tailwind CSS를 사용하고, 복잡한 커스텀 로직이나 애니메이션이 필요한 컴포넌트 스타일에는 CSS Modules를 사용하는 방식으로 두 기술의 장점을 결합한 하이브리드 아키텍처를 채택하기도 합니다 [16-18].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[BEM]], [[Tailwind CSS]], [[CSS-in-JS]], [[SCSS]]
+- **Projects/Contexts:** [[컴포넌트 기반 아키텍처]], [[React Server Components]], [[Next.js App Router]]
+- **Contradictions/Notes:** 소스 문헌들은 BEM이 개발자의 수동적인 명명 규칙 준수에 의존해 휴먼 에러가 발생하기 쉬운 반면, CSS Modules는 빌드 도구를 통해 "자동화된 캡슐화"를 제공하여 BEM이 풀고자 했던 문제를 더 깔끔하게 해결한다고 비교합니다 [4, 5, 11, 13]. 또한, Tailwind CSS는 클래스명을 짓는 수고와 파일 전환의 피로를 없애주지만 마크업 코드가 길어지고 자의적인 값이 쌓일 수 있는 반면, CSS Modules는 깔끔한 HTML을 유지하지만 파일 전환과 네이밍 피로가 존재한다는 트레이드오프 관계를 가집니다 [7, 14, 19, 20].
+
+---
+*Last updated: 2026-04-26*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/CSS-in-JS.md b/10_Wiki/Topics/Frontend_Mastery/CSS-in-JS.md
new file mode 100644
index 00000000..ff0076f6
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/CSS-in-JS.md
@@ -0,0 +1,28 @@
+# [[CSS-in-JS]]
+
+## 📌 Brief Summary
+CSS-in-JS는 JavaScript 파일 내에서 CSS를 직접 작성하여 컴포넌트 단위로 스타일을 결합하는 모던 웹 스타일링 접근 방식입니다 [1, 2]. 기존의 전통적인 CSS가 가진 글로벌 스코프(Global Scope) 문제를 해결하고, 컴포넌트의 상태(State)나 프롭스(Props)에 기반한 동적 스타일링을 가능하게 합니다 [1, 3, 4]. 대표적인 라이브러리로는 styled-components와 Emotion이 있지만, 최근 런타임 성능 오버헤드와 프레임워크 호환성 문제로 인해 빌드 타임에 CSS를 추출하는 Zero-Runtime 방식으로 진화하고 있습니다 [5-8].
+
+## 📖 Core Content
+- **주요 장점:**
+  - **스코프 고립 및 충돌 방지:** 자동으로 고유한 클래스명을 생성하여 스타일의 충돌을 막아주며, BEM과 같은 복잡한 네이밍 컨벤션 없이도 캡슐화를 달성할 수 있습니다 [9, 10].
+  - **동적 스타일링 및 테마 적용:** 컴포넌트의 프롭스(Props)와 애플리케이션 상태(State)에 직접 접근하여 스타일을 생성할 수 있어, 복잡한 테마(Theming) 시스템을 매끄럽게 구현할 수 있습니다 [3, 4, 8].
+  - **응집도(Co-location):** 컴포넌트의 로직과 스타일이 한 파일에 위치하므로, 유지보수성이 높고 컴포넌트를 이동하거나 삭제할 때 스타일 코드가 버려지는(orphaned CSS) 문제를 방지합니다 [3, 4, 11].
+  - **개발자 경험(DX):** TypeScript 통합을 통한 타입 안정성, 자동 완성, 자동 벤더 프리픽싱(Vendor prefixing) 등을 지원하여 버그를 줄이고 개발 시간을 단축시킵니다 [12, 13].
+
+- **주요 단점 및 한계:**
+  - **런타임 성능 오버헤드:** 브라우저 런타임에서 CSS 문자열을 파싱하고 DOM에 주입해야 하며, 프롭스 변경 시 스타일을 재계산해야 하므로 렌더링 시간이 지연됩니다 [4, 12, 14, 15].
+  - **번들 크기 증가:** styled-components(약 12.7kb~30kb)나 Emotion(약 7.9kb~12kb) 등의 라이브러리 자체가 JavaScript 번들에 추가되어 초기 로딩 및 실행에 부담을 줍니다 [7, 14].
+  - **React Server Components (RSC) 호환성 문제:** React의 컨텍스트(Context)에 의존하는 런타임 CSS-in-JS 라이브러리들은 서버 환경에서 구동되는 React Server Components 환경과 근본적으로 호환되지 않아, 2024~2025년 이후 현대적인 프레임워크(예: Next.js App Router) 환경에서 큰 문제로 대두되었습니다 [7, 8, 16].
+
+- **미래 동향 및 해결책 (Zero-Runtime CSS-in-JS):**
+  - 런타임 오버헤드 및 RSC 호환성 문제를 극복하기 위해, 개발 시에는 CSS-in-JS의 문법을 사용하되 빌드 타임(Build time)에 정적인 CSS 파일로 추출하는 **Zero-Runtime** 접근법이 등장했습니다 [5, 6, 15, 16].
+  - Linaria, vanilla-extract, Panda CSS 등이 대표적이며, 이들은 런타임 페널티 없이 타입 안정성과 컴포넌트 기반 스타일링의 이점을 제공하여 대규모 엔터프라이즈 시스템에서도 권장되는 방식으로 자리 잡고 있습니다 [15, 17, 18].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[CSS Modules]], [[Tailwind CSS]], [[Zero-Runtime CSS-in-JS]], [[React Server Components]], [[Design Tokens]]
+- **Projects/Contexts:** [[컴포넌트 기반 아키텍처]], [[Next.js App Router 프로젝트]], [[대규모 엔터프라이즈 테마 시스템]]
+- **Contradictions/Notes:** 소스 문헌들은 CSS-in-JS가 강력한 동적 스타일링과 우수한 개발자 경험을 제공한다고 동의하지만 [3, 4, 8], 성능 오버헤드와 최신 React Server Components의 등장이라는 기술적 배경 변화로 인해 새로운 프로젝트에서는 런타임 기반의 CSS-in-JS(styled-components, Emotion 등)의 사용을 피하고, 대신 [[Tailwind CSS]], [[CSS Modules]], 혹은 [[vanilla-extract]] 같은 Zero-runtime 솔루션으로 마이그레이션할 것을 강력히 권장하고 있습니다 [8, 16, 19].
+
+---
+*Last updated: 2026-04-26*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/CSSOM(CSS Object Model).md b/10_Wiki/Topics/Frontend_Mastery/CSSOM(CSS Object Model).md
new file mode 100644
index 00000000..e171a627
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/CSSOM(CSS Object Model).md	
@@ -0,0 +1,18 @@
+# [[CSSOM(CSS Object Model)]]
+
+## 📌 Brief Summary
+CSSOM(CSS Object Model)은 웹 페이지의 DOM(Document Object Model) 요소들이 어떻게 스타일링되는지에 대한 모든 정보를 담고 있는 객체 모델입니다 [1, 2]. 브라우저가 제공받은 CSS 규칙을 파싱하여 부모, 자식, 형제 관계를 가진 노드 트리 형태로 구성합니다 [3, 4]. 완성된 CSSOM은 DOM과 결합하여 화면에 픽셀을 그리기 위한 렌더 트리(Render Tree)를 생성하는 데 필수적인 역할을 합니다 [5, 6].
+
+## 📖 Core Content
+- **렌더링 차단 특성 (Render-Blocking):** DOM 트리의 생성은 점진적으로 이루어지지만, CSSOM 생성은 점진적이지 않은 렌더링 차단(render-blocking) 작업입니다 [1, 2]. 브라우저는 스타일이 적용되지 않은 날 것의 HTML 콘텐츠가 화면에 번쩍이며 나타나는 현상(FOUC, Flash of Unstyled Content)을 방지하기 위해, 연결된 모든 스타일시트를 다운로드하고 처리하여 CSSOM이 완성될 때까지 페이지 렌더링을 차단합니다 [1, 2].
+- **트리 구조와 캐스케이딩 (Cascading):** CSSOM은 CSS 규칙에 따라 노드 트리를 형성하며, 하위 노드는 상위 노드의 스타일 일부를 상속받습니다(하향식 종속) [3, 7]. 이후에 파싱된 규칙이 이전 규칙을 덮어쓸 수 있는 속성이 있으므로, 브라우저는 전체 CSS가 완전히 파싱될 때까지 CSSOM을 렌더 트리 구성에 사용할 수 없습니다 [7]. CSSOM 트리에는 브라우저의 기본 사용자 에이전트(User Agent) 스타일시트 정보도 포함되어 있으며, 브라우저는 가장 일반적인 규칙부터 구체적인 규칙을 거듭 적용하여 최종 스타일을 계산합니다 [8].
+- **선택자 파싱 원리와 성능:** 브라우저는 CSS 선택자를 오른쪽에서 왼쪽으로 파싱합니다 [9]. 따라서 클래스 여러 개가 결합된 구체적인 선택자(예: `.container.navigation.item`)는 조상 관계를 확인하기 위해 DOM 트리를 거슬러 올라가야 하므로, 단순한 선택자(예: `.item`)에 비해 브라우저에 약간의 작업 부하를 더 줍니다 [9, 10]. 
+- **렌더 트리(Render Tree)와의 결합:** 브라우저는 화면에 표시될 요소의 레이아웃을 계산하기 위해 DOM 트리와 CSSOM 트리를 병합하여 렌더 트리를 만듭니다 [6, 11]. DOM 트리의 루트에서 시작해 눈에 보이는 각 노드를 순회하며 적절한 CSSOM 규칙을 찾아 적용합니다 [6]. 이때 화면에 시각적 영향을 주지 않는 노드나 `display: none` 스타일이 적용된 노드는 렌더 트리에서 제외됩니다 [6, 11].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[DOM(Document Object Model)]], [[Render Tree]], [[Critical Rendering Path]], [[Reflow & Repaint]]
+- **Projects/Contexts:** [[브라우저 렌더링 최적화(Browser Rendering Optimization)]]
+- **Contradictions/Notes:** 소스에 따르면 CSSOM 구축은 중요한 렌더링 차단 과정이지만, 최신 브라우저 엔진에서 CSSOM 생성 및 스타일 계산 속도는 마이크로초 단위로 이루어질 만큼 매우 빠릅니다 [8-10]. 따라서 CSS 선택자의 구체성을 낮추는 등의 마이크로 최적화보다는, 필요 없는 CSS 규칙을 최소화하거나 논블로킹(non-blocking) 요청을 적절히 사용하는 것이 더 의미 있는 성능 개선 방법이라고 지적합니다 [8, 10, 12].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/Component-Based Architecture (CBA).md b/10_Wiki/Topics/Frontend_Mastery/Component-Based Architecture (CBA).md
new file mode 100644
index 00000000..3c3e07ea
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Component-Based Architecture (CBA).md	
@@ -0,0 +1,30 @@
+# [[Component-Based Architecture (CBA)]]
+
+## 📌 Brief Summary
+컴포넌트 기반 아키텍처(Component-Based Architecture, CBA)는 독립적이고 모듈화된, 재사용 가능한 소프트웨어 컴포넌트들을 조립하여 애플리케이션을 구축하는 최신 소프트웨어 설계 패러다임입니다[1-3]. 레고 블록을 맞추듯 각 컴포넌트가 특정 기능을 수행하며, 명확히 정의된 인터페이스(API)를 통해 서로 통신합니다[2, 4]. 이 접근 방식은 소프트웨어를 처음부터 개발하는 대신 표준화된 부품을 재사용함으로써 유지보수성을 높이고 개발 속도를 앞당기며 뛰어난 확장성을 제공합니다[4-6].
+
+## 📖 Core 소스 Content
+
+*   **컴포넌트의 정의 및 핵심 특징**
+    컴포넌트는 특정 기능을 캡슐화한 재사용 가능하고 독립적인 소프트웨어 단위입니다[7]. 주요 특징으로는 내부 구현과 데이터를 숨기고 필요한 인터페이스만 노출하는 **캡슐화(Encapsulation)**, 여러 언어나 플랫폼 간에도 표준 인터페이스를 통해 통신할 수 있는 **상호 운용성(Interoperability)**, 더 큰 시스템을 구성하기 위해 쉽게 플러그인 할 수 있는 **조립성(Composability)**, 그리고 기존 기능을 손상시키지 않고 교체할 수 있는 **대체 가능성(Replaceability)**이 있습니다[8-13].
+
+*   **컴포넌트 기반 개발의 주요 장점**
+    *   **개발 속도 향상 및 비용 절감(Faster Time-to-Market):** 기존 컴포넌트를 재사용하여 반복적인 코딩을 방지함으로써 제품 출시를 가속화하고 개발 비용을 낮춥니다[14, 15].
+    *   **확장성(Scalability):** 트래픽이나 요구사항이 증가할 때 시스템 전체가 아닌 장바구니, 결제 등 특정 컴포넌트만 개별적으로 추가 및 확장할 수 있습니다[16-18].
+    *   **유지보수 및 병렬 개발(Maintainability & Collaboration):** 한 컴포넌트의 버그 수정이나 업데이트가 전체 시스템에 미치는 영향을 최소화합니다. 또한, 여러 팀이 서로 다른 컴포넌트(프론트엔드, 백엔드 등)를 동시에 개발할 수 있어 협업이 효율적입니다[14, 16, 18-20].
+
+*   **설계 원칙 및 구현 방법**
+    CBA 시스템을 구현할 때는 모듈성, 추상화, 그리고 역할에 따른 '관심사 분리(Separation of Concerns)'를 원칙으로 삼아야 합니다[8, 21]. 시스템의 기능 및 비기능적 요구사항을 분석한 후 도메인 주도 설계(DDD) 등의 기법을 사용해 컴포넌트 경계를 식별합니다[22, 23]. 이후 명확한 API 및 통신 프로토콜(예: REST, gRPC 등)을 설계하고, 각각 독립적으로 개발 및 유닛 테스트를 진행한 뒤, CI/CD 파이프라인을 통해 통합 및 배포를 수행합니다[24-26].
+
+*   **구현 시 직면하는 한계 및 과제**
+    *   **초기 설계의 복잡성과 통합 오버헤드:** 시스템을 모듈화하고 인터페이스와 의존성을 명확히 정의하는 초기 계획 단계가 까다롭습니다[27-29]. 서로 다른 팀이 개발한 컴포넌트 간의 통신과 매끄러운 통합을 보장하는 것에도 오버헤드가 발생합니다[29, 30].
+    *   **성능 저하 및 의존성 관리:** 네트워크 호출이나 프로세스 간 통신 등 컴포넌트 상호작용으로 인해 성능 오버헤드와 지연(Latency)이 발생할 수 있습니다[27, 30, 31]. 또한, 다수의 컴포넌트가 다양한 버전의 라이브러리에 의존할 경우 버전 충돌 및 관리가 매우 복잡해집니다[31, 32].
+    *   **보안 및 과잉 엔지니어링 위험:** 각 컴포넌트의 업데이트 주기가 달라 최신화되지 않은 컴포넌트가 전체 시스템의 보안 취약점이 될 수 있으며[33], 유연성만을 추구하다 보면 시스템을 너무 잘게 쪼개어 과잉 엔지니어링(Over-engineering)으로 이어질 위험도 존재합니다[34].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Microservices Architecture]], [[Service-Oriented Architecture (SOA)]], [[Monolithic Architecture]], [[Object-Oriented Architecture]]
+- **Projects/Contexts:** [[React]], [[Angular]], [[Vue.js]], [[PayPal]], [[Spotify]], [[Uber]], [[Walmart]]
+- **Contradictions/Notes:** 소스에 따르면, 객체 지향 아키텍처(Object-Oriented Architecture)와 CBA는 원칙을 일부 공유하지만 차이가 있습니다. 객체 지향 아키텍처가 단일 애플리케이션 내에서 데이터와 동작을 캡슐화하는 데 중점을 둔다면, CBA는 여러 시스템 및 애플리케이션 전반에서 상호작용하고 재사용할 수 있는 독립적인 단위 생성을 강조합니다[35]. 또한 기존의 모놀리식 아키텍처(Monolithic Architecture)는 시스템 전체를 하나의 코드베이스로 묶어 확장 및 유지보수가 어렵지만, CBA는 느슨하게 결합된 모듈을 통해 독립적인 배포와 병렬 개발을 가능하게 합니다[36, 37].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/Component-Based Architecture.md b/10_Wiki/Topics/Frontend_Mastery/Component-Based Architecture.md
new file mode 100644
index 00000000..3d0c239e
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Component-Based Architecture.md	
@@ -0,0 +1,32 @@
+# [[Component-Based Architecture]]
+
+## 📌 Brief Summary
+컴포넌트 기반 아키텍처(Component-Based Architecture, CBA)는 소프트웨어 시스템을 모듈화되고 독립적이며 재사용 가능한 단위인 '컴포넌트(Component)'로 나누어 구축하는 설계 방법론입니다 [1, 2]. 레고 블록을 조립하듯 각 컴포넌트를 결합하여 크고 복잡한 애플리케이션을 완성할 수 있으며, 이로 인해 개발 속도와 시스템 확장성을 크게 향상시킵니다 [3, 4]. 각 컴포넌트는 내부 로직과 상태를 캡슐화하고 명확히 정의된 인터페이스를 통해서만 상호작용하도록 설계되어, 유지보수성과 팀 간의 협업 효율을 극대화합니다 [5, 6].
+
+## 📖 Core Content
+- **핵심 원칙 및 특징:**
+  - **모듈성 및 캡슐화 (Modularity & Encapsulation):** 컴포넌트는 특정한 목적을 위해 기능과 데이터를 내부로 숨기고(캡슐화), 외부에 필요한 부분만 잘 정의된 인터페이스로 노출합니다 [5, 7].
+  - **재사용성 및 독립성 (Reusability & Independence):** 한 번 개발된 컴포넌트는 수정 없이 여러 프로젝트에 재사용될 수 있으며, 전체 시스템을 파괴하지 않고 독립적으로 개발, 테스트, 배포 및 교체가 가능합니다 [8-10].
+  - **상호운용성 (Interoperability):** 서로 다른 기술이나 플랫폼으로 구축된 컴포넌트라도 표준화된 인터페이스와 API를 통해 원활하게 통신하고 결합될 수 있습니다 [6, 11].
+
+- **아키텍처의 주요 이점:**
+  - **개발 속도 향상 및 비용 절감:** 기존 컴포넌트를 재사용하여 코드를 처음부터 다시 작성하는 수고를 덜어 제품 출시 기간(Time-to-Market)을 앞당깁니다 [12, 13].
+  - **확장성 및 유지보수 용이성:** 전체 시스템을 재구성할 필요 없이 트래픽이나 요구사항에 따라 특정 컴포넌트만 독립적으로 확장하거나 업그레이드할 수 있으며, 버그 수정 시 다른 시스템에 미치는 영향을 최소화합니다 [8, 14-16].
+  - **병렬 개발 (Parallel Development):** 시스템이 명확하게 나뉘어 있어 여러 개발 팀이 동시에 각기 다른 컴포넌트를 분담하여 작업할 수 있습니다 [8, 17].
+
+- **설계 시 당면 과제 및 단점:**
+  - **복잡성 및 의존성 관리:** 컴포넌트의 수가 증가할수록 컴포넌트 간의 상호작용, 호환성, 버전 관리 등 의존성을 통제하고 통합하는 것이 복잡해집니다 [18-20].
+  - **성능 오버헤드:** 시스템을 지나치게 작은 컴포넌트로 나눌 경우(Over-engineering), 컴포넌트 간 통신(네트워크 호출 및 RPC 등)으로 인한 지연(Latency)과 오버헤드가 발생하여 성능을 저하시킬 수 있습니다 [18, 21, 22].
+  - **보안 관리의 어려움:** 각 컴포넌트가 각기 다른 라이브러리와 업데이트 주기를 가질 경우, 제때 업데이트되지 않은 구식 컴포넌트가 전체 애플리케이션의 보안 취약점이 될 위험이 존재합니다 [23].
+
+- **실제 활용 및 대안 아키텍처:**
+  - **활용 사례:** 사용자 로그인, 결제 게이트웨이, 쇼핑카트와 같은 모듈이 독립적으로 필요한 전자상거래 플랫폼, CRM 시스템, 모바일 앱 등에서 활발히 사용됩니다 [24, 25]. 프론트엔드 라이브러리(React, Angular, Vue.js)뿐만 아니라 백엔드 플랫폼(Java EE, .NET 등)에서도 이 방식을 채택하며, PayPal, Walmart, Spotify, Uber 등의 기업들이 이 아키텍처를 도입해 확장성을 입증했습니다 [3, 26, 27].
+  - **대안 아키텍처:** 프로젝트의 규모와 팀 구조에 따라 하나의 코드베이스로 구성된 [[Monolithic Architecture]], 서비스 단위로 결합도를 낮춘 [[Microservices Architecture]], 기업 환경에 맞춘 [[Service-Oriented Architecture (SOA)]], [[Layered Architecture]] 등과 비교되거나 혼합되어 사용됩니다 [28-31].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Modularity]], [[Encapsulation]], [[Monolithic Architecture]], [[Microservices Architecture]], [[Service-Oriented Architecture (SOA)]]
+- **Projects/Contexts:** [[React, Angular, Vue.js 기반 프론트엔드 UI 구축]], [[전자상거래 플랫폼 및 CRM 시스템 설계]], [[Java EE 및 .NET 엔터프라이즈 애플리케이션]]
+- **Contradictions/Notes:** 컴포넌트 기반 아키텍처는 유연성과 재사용성을 극대화하지만, 모듈화를 극대화하려는 목적으로 시스템을 너무 잘게 쪼개는 것(Over-engineering)은 오히려 통합 비용과 통신 오버헤드를 발생시키고 디버깅을 어렵게 만들 수 있으므로 적절한 세분화(Granularity) 수준을 결정하는 것이 핵심입니다 [18, 22, 32].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/Core Web Vitals Optimization (INP, LCP 개선).md b/10_Wiki/Topics/Frontend_Mastery/Core Web Vitals Optimization (INP, LCP 개선).md
new file mode 100644
index 00000000..a39e0ec0
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Core Web Vitals Optimization (INP, LCP 개선).md	
@@ -0,0 +1,31 @@
+# [[Core Web Vitals Optimization (INP, LCP 개선)]]
+
+## 📌 Brief Summary
+Core Web Vitals는 구글이 웹 페이지의 검색 순위와 사용자 경험을 평가하기 위해 정의한 핵심 성능 지표입니다 [1]. 여기에는 화면의 주요 콘텐츠가 로드되는 속도를 측정하는 LCP(Largest Contentful Paint)와 페이지 세션 내내 애플리케이션이 사용자 상호작용에 얼마나 빠르게 응답하는지 측정하는 INP(Interaction to Next Paint)가 포함됩니다 [1, 2]. 이 지표들의 기준치(LCP 2.5초 미만, INP 200 밀리초 미만)를 달성하면 사용자 이탈률을 낮추고 유기적 검색(SEO) 성과를 직접적으로 높일 수 있습니다 [1-3].
+
+## 📖 Core Content
+
+- **Largest Contentful Paint (LCP) 최적화**
+  LCP는 브라우저 화면의 가장 큰 콘텐츠 요소가 렌더링되는 시간을 측정하며, 이를 2.5초 미만으로 유지하는 것이 목표입니다 [1]. 
+  - **코드 스플리팅(Code Splitting):** 기본적으로 번들러는 전체 애플리케이션을 하나의 큰 파일로 묶지만, `React.lazy()` 등을 통해 라우트 수준에서 코드를 분할하면 초기 번들 크기를 30~50%가량 줄여 LCP를 크게 개선할 수 있습니다 [4].
+  - **렌더링 전략 변경:** 클라이언트 측 렌더링(CSR)은 초기 로딩이 느리다는 단점이 있습니다 [5, 6]. 따라서 서버 사이드 렌더링(SSR)이나 정적 사이트 생성(SSG)을 도입해 자바스크립트 파싱 전에 완성된 HTML을 사용자에게 즉시 제공함으로써 LCP 병목 현상을 해소할 수 있습니다 [7-9].
+  - **이미지 최적화:** WebP나 AVIF 같은 현대적인 이미지 포맷을 사용하여 파일 크기를 줄이고, 화면에 보일 때만 이미지를 로드하는 `loading="lazy"` 지연 로딩을 도입해 초기 주요 리소스와의 대역폭 경쟁을 막습니다 [10, 11].
+
+- **Interaction to Next Paint (INP) 최적화**
+  INP는 기존의 First Input Delay(FID)를 대체한 지표로, 클릭이나 키보드 입력 같은 상호작용 지연 시간을 200ms 이내로 응답하게 만드는 것이 핵심입니다 [2].
+  - **동시성 렌더링(Concurrent Rendering):** React 19의 `useTransition` 및 `useDeferredValue` 훅을 통해 무거운 상태 업데이트(예: 대규모 목록 필터링)를 후순위로 미루고, 긴급한 사용자 입력(타이핑 등)을 먼저 처리하여 메인 스레드의 응답성을 유지합니다 [2, 12, 13].
+  - **메모이제이션과 연산 최적화:** 부모 컴포넌트의 상태가 변할 때 발생하는 불필요한 '리렌더링 폭포(Re-render Cascade)' 현상을 막기 위해 `React.memo`, `useMemo`, `useCallback`을 활용합니다 [14-16]. 더불어 키 입력마다 발생하는 과도한 API 호출을 줄이기 위해 디바운싱(Debouncing)을 적용합니다 [17].
+  - **목록 가상화(Virtualization):** 수백, 수천 개의 항목이 포함된 긴 목록을 렌더링할 때, 화면에 보이는 노드만 렌더링하는 가상화를 도입하면 레이아웃 및 페인트 작업 부하를 방지하여 상호작용 속도를 높입니다 [2, 18, 19].
+  - **React Server Components (RSC):** 읽기 전용 데이터 컴포넌트를 서버에서 전적으로 실행함으로써 클라이언트의 자바스크립트 크기를 40~60% 감소시키고, 상호작용 시 브라우저 메인 스레드가 처리할 코드를 줄여 INP를 직접적으로 낮출 수 있습니다 [20].
+
+- **Cumulative Layout Shift (CLS) 관리 및 성능 프로파일링**
+  - 시각적 안정성을 측정하는 CLS는 0.1 미만을 목표로 하며, 불필요한 DOM 노드를 줄이기 위한 React Fragment의 사용, 이미지의 명시적 크기 지정 등의 방법으로 개선합니다 [2, 21].
+  - 최적화를 적용하기 전에 항상 `React DevTools Profiler`나 `Lighthouse`를 사용하여 병목을 유발하는 컴포넌트를 찾고, 프로덕션 환경의 실측 데이터를 얻기 위해 `Web Vitals` 라이브러리로 필드 데이터를 모니터링해야 합니다 [22-26].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Largest Contentful Paint (LCP)]], [[Interaction to Next Paint (INP)]], [[Concurrent Rendering]], [[Server-Side Rendering (SSR)]], [[React Server Components (RSC)]]
+- **Projects/Contexts:** [[React Performance Optimization]], [[Search Engine Optimization (SEO) Strategy]]
+- **Contradictions/Notes:** Lighthouse와 같은 도구로 측정한 연구실 데이터(Lab measurements)는 다양한 기기 성능과 네트워크 조건을 겪는 실제 사용자들의 경험(Field data)과 항상 일치하지는 않으므로 프로덕션 상의 Web Vitals 데이터를 함께 수집해야 합니다 [23, 24].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/Core Web Vitals.md b/10_Wiki/Topics/Frontend_Mastery/Core Web Vitals.md
new file mode 100644
index 00000000..77590760
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Core Web Vitals.md	
@@ -0,0 +1,18 @@
+# [[Core Web Vitals]]
+
+## 📌 Brief Summary
+Core Web Vitals(코어 웹 바이탈)은 웹사이트의 실제 성능과 사용자 경험을 평가하는 필수 지표로, 로딩 속도, 레이아웃의 안정성, 사용자 입력에 대한 반응 속도를 측정합니다 [1]. 핵심 지표로는 LCP(Largest Contentful Paint), CLS(Cumulative Layout Shift), INP(Interaction to Next Paint)가 있으며, 이는 구글의 검색 순위(Ranking signal)와 모바일 우선 인덱싱에 직접적인 영향을 미칩니다 [2, 3].
+
+## 📖 Core Content
+* **핵심 지표와 목표치**: Core Web Vitals는 크게 세 가지 주요 지표로 구성됩니다. LCP(Largest Contentful Paint)는 주요 콘텐츠의 로딩 속도를 의미하며 2.5초 미만을 유지해야 하고, CLS(Cumulative Layout Shift)는 레이아웃의 시각적 안정성을 나타내며 0.1 미만이어야 하며, INP(Interaction to Next Paint)는 사용자의 입력에 대한 반응성을 측정하여 200밀리초 미만을 목표로 최적화해야 합니다 [4].
+* **CSS 및 반응형 디자인과의 연관성**: 잘못된 이미지 크기 지정, 너비(width) 및 높이(height) 속성 누락, 최적화되지 않은 폰트 등은 모바일 환경에서 Core Web Vitals 점수 하락의 가장 흔한 원인이 됩니다 [2, 3]. 잘 구축된 반응형 레이아웃은 불필요한 레이아웃 이동(Layout shift)을 줄이고 로딩 시간을 개선하며 사용자 상호작용을 민첩하게 만듭니다 [1].
+* **성능 최적화 기법**: CLS를 방지하기 위해 컨테이너에 `aspect-ratio` 속성을 적용하거나 명시적인 너비와 높이를 지정해야 합니다 [5, 6]. LCP 향상을 위해서는 LCP 요소(주로 히어로 이미지)에 `fetchpriority="high"`를 설정하고 폴드(fold) 아래의 이미지는 지연 로딩(lazy-load) 처리하며, WebP나 AVIF 같은 압축률이 높은 차세대 포맷을 사용하는 방법이 있습니다 [5-7].
+* **SEO 및 비즈니스 영향**: 구글은 페이지 경험 신호의 일부로 Core Web Vitals를 활용하므로, 로딩이 느리고 레이아웃 이동이 잦은 비반응형 웹사이트는 검색 결과에서 성능이 저하될 수 있습니다 [3, 4]. 따라서 이 지표들을 지속적으로 모니터링하고 최적화하는 것은 2026년 현재 반응형 웹 디자인의 핵심 요구 사항입니다 [4, 8].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Responsive Web Design]], [[CSS Performance Optimization]]
+- **Projects/Contexts:** [[Search Engine Optimization (SEO)]]
+- **Contradictions/Notes:** 소스 전반에 걸쳐 CSS 및 반응형 디자인의 최적화가 Core Web Vitals 지표 개선으로 직결된다고 강조하고 있으며, 소스 간 상충되는 의견은 존재하지 않습니다.
+
+---
+*Last updated: 2026-04-26*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/DOM (Document Object Model).md b/10_Wiki/Topics/Frontend_Mastery/DOM (Document Object Model).md
new file mode 100644
index 00000000..b531a1b5
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/DOM (Document Object Model).md	
@@ -0,0 +1,25 @@
+# [[DOM (Document Object Model)]]
+
+## 📌 Brief Summary
+DOM(Document Object Model)은 브라우저가 수신한 HTML 문서 데이터를 파싱하여 생성하는 페이지 구조의 계층적 트리 표현입니다 [1-3]. 브라우저는 HTML 태그의 포함 관계를 바탕으로 부모 및 자식 노드의 트리를 형성하며, `<html>` 요소를 루트 노드로 갖습니다 [4, 5]. DOM은 페이지의 모든 콘텐츠 정보를 담고 있으며, 스타일 정보를 담은 CSSOM과 결합해 최종 화면 출력에 필요한 렌더 트리(Render Tree)를 형성하는 브라우저 렌더링 과정의 핵심 기반입니다 [6-8].
+
+## 📖 Core Content
+* **DOM 트리의 점진적 구축 (Incremental Construction)**
+  브라우저는 네트워크를 통해 HTML 문서의 전체 데이터를 다 받기 전부터 점진적으로 DOM 트리를 구축할 수 있습니다 [1, 4]. 초기 14KB의 데이터 패킷이 수신되면 바이트를 문자로, 문자를 토큰(startTag 및 endTag 등)으로 변환한 뒤, 최종적으로 노드(Node)로 변환하여 트리를 조립합니다 [1, 4]. 이 점진적 생성 메커니즘 덕분에 네트워크 요청이 진행 중인 상태에서도 브라우저는 렌더링 준비를 시작할 수 있습니다 [9].
+
+* **렌더링 파이프라인에서의 DOM과 CSSOM**
+  DOM은 문서의 '콘텐츠'를 표현하는 반면, CSSOM은 해당 콘텐츠의 '스타일'을 정의하는 독립적인 트리 구조입니다 [9, 10]. 이 두 모델은 브라우저에 의해 결합되어 화면에 시각적으로 출력되어야 하는 노드만을 포함하는 '렌더 트리(Render Tree)'로 합성됩니다 [6, 11, 12]. 이 과정에서 `<script>`, `<meta>` 또는 `display: none`이 적용된 요소처럼 시각적 영향을 주지 않는 DOM 노드는 렌더 트리에서 제외됩니다 [8, 11-13].
+
+* **크기와 복잡성이 성능에 미치는 영향**
+  DOM 트리의 깊이와 생성된 노드의 개수는 웹 성능과 직결됩니다 [5, 9]. 노드의 수가 많아질수록 렌더 트리 합성, 레이아웃(Reflow), 페인트 단계에서 브라우저가 처리해야 할 계산의 양과 시간이 증가하여 애플리케이션의 성능이 저하될 수 있습니다 [5, 7, 9, 14]. 불필요한 래퍼를 줄이고 React Fragment 등을 사용하여 DOM 노드 수를 최소화하는 것이 성능 향상에 도움이 됩니다 [15].
+
+* **DOM 조작의 비효율성과 최적화**
+  JavaScript를 사용해 DOM을 직접 조작하고 크기나 위치 등을 변경하면, 브라우저는 문서 전체의 레이아웃(Reflow)과 페인트(Repaint) 과정을 다시 실행해야 하므로 처리 비용이 매우 높습니다 [16-18]. 이를 최적화하기 위해서는 사용된 DOM 노드나 속성값을 캐싱하고, DOM의 읽기 및 쓰기 작업을 분리하여 레이아웃 스래싱(Layout thrashing)을 방지해야 합니다 [16, 19, 20]. React와 같은 프레임워크는 실제 DOM을 직접 수정하는 비효율성을 피하고자 메모리 내에 가벼운 사본인 가상 DOM(Virtual DOM)을 생성하여 조작을 추상화합니다 [17, 21, 22].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[CSSOM (CSS Object Model)]], [[Render Tree]], [[Virtual DOM]], [[Critical Rendering Path (CRP)]], [[Reflow (Layout)]], [[Repaint]]
+- **Projects/Contexts:** 프론트엔드 성능 최적화(DOM 접근 최소화 및 렌더링 파이프라인 관리), React의 렌더링 엔진 구조 및 재조정(Reconciliation) 과정 이해 [6, 17, 23, 24].
+- **Contradictions/Notes:** DOM 구축은 HTML을 파싱하면서 '점진적(incremental)'으로 이루어지지만, CSSOM 구축은 렌더링을 차단(render-blocking)하며 점진적으로 처리되지 않는다는 구조적 차이가 있습니다 [1, 7, 9].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/DOM 및 CSSOM.md b/10_Wiki/Topics/Frontend_Mastery/DOM 및 CSSOM.md
new file mode 100644
index 00000000..df9a8011
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/DOM 및 CSSOM.md	
@@ -0,0 +1,31 @@
+# [[DOM 및 CSSOM]]
+
+## 📌 Brief Summary
+DOM(문서 객체 모델)과 CSSOM(CSS 객체 모델)은 브라우저의 핵심 렌더링 경로(Critical Rendering Path)에서 웹 페이지를 화면에 그리기 위해 생성되는 두 가지 독립적인 트리 구조 데이터입니다 [1, 2]. DOM은 HTML 마크업을 점진적으로 파싱하여 문서의 구조와 내용을 나타냅니다 [3, 4]. 반면, CSSOM은 문서에 적용될 스타일 규칙을 정의하며, 렌더링 시 스타일이 적용되지 않은 콘텐츠가 깜빡이는 현상(FOUC)을 방지하기 위해 렌더링 차단(render-blocking) 방식으로 생성됩니다 [5, 6]. 이 두 트리가 결합하여 화면에 표시될 시각적 요소들만 포함하는 렌더 트리(Render Tree)를 최종적으로 형성합니다 [7, 8].
+
+## 📖 Core Content
+**DOM(Document Object Model) 구축**
+- 브라우저는 HTML 응답을 받으면 데이터를 문자, 토큰(token)으로 변환하고, 이를 다시 노드(node)로 변환하여 계층적인 DOM 트리를 구축합니다 [3, 4, 9].
+- DOM 트리는 문서의 콘텐츠와 각 요소 간의 관계 및 계층 구조를 나타냅니다 [4, 8, 9].
+- DOM 구축은 점진적(incremental)으로 이루어지므로, 브라우저는 네트워크 요청이 진행 중인 상태에서도 파싱을 시작하여 트리를 구성할 수 있습니다 [3, 5, 6].
+- 단, DOM 노드의 수가 많아질수록 레이아웃 및 페인트 등 이후의 렌더링 단계에서 브라우저의 연산 부담이 커지고 처리 시간이 길어집니다 [5, 6, 9].
+
+**CSSOM(CSS Object Model) 구축**
+- CSSOM은 DOM이 어떻게 스타일링될지에 대한 모든 정보를 담고 있으며, 브라우저가 CSS 규칙을 이해하고 적용할 수 있도록 만든 트리 구조의 스타일 맵입니다 [2, 6, 8].
+- DOM과 달리 CSSOM 구축은 점진적이지 않으며, 문서의 렌더링을 차단(render-blocking)합니다 [5, 6].
+- 브라우저는 스타일이 적용되지 않은 원시 HTML이 사용자에게 노출되는 현상(FOUC)을 막기 위해 링크된 모든 스타일시트를 다운로드하고 파싱할 때까지 렌더링을 중단합니다 [5].
+- CSS 규칙은 하향식으로 종속(Cascade)되는 특성이 있어 파싱 도중 이전 규칙이 덮어써질 수 있으므로, 완전히 파싱이 끝나기 전까지는 렌더 트리를 구축하는 데 사용될 수 없습니다 [10, 11].
+- 브라우저는 CSS 선택자를 오른쪽에서 왼쪽으로 파싱합니다 [12]. 따라서 `.container.navigation.item`과 같이 구체적인 선택자는 단순히 `.item`을 찾는 것보다 DOM 트리를 거슬러 올라가며 조상 관계를 확인해야 하므로 연산 비용이 더 듭니다 [12, 13].
+
+**렌더 트리(Render Tree) 합성**
+- DOM과 CSSOM 구조가 모두 준비되면, 브라우저는 이 둘을 결합하여 화면에 그릴 렌더 트리를 생성합니다 [7, 14].
+- 렌더 트리는 시각적으로 렌더링되는 요소들만 캡처합니다 [7]. 따라서 시각적 레이아웃에 영향을 주지 않는 `<script>`, `<meta>` 요소나, CSS에 의해 `display: none`으로 처리된 요소는 렌더 트리에서 제외됩니다 [7, 8, 14, 15]. 
+- 하지만 `visibility: hidden`이 적용된 요소는 보이지 않더라도 레이아웃 상에서 공간을 차지하므로 렌더 트리에 포함됩니다 [15].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** `[[Critical Rendering Path]]`, `[[Render Tree]]`, `[[Reflow and Repaint]]`
+- **Projects/Contexts:** `[[프론트엔드 성능 최적화]]`, `[[브라우저 렌더링 파이프라인 이해]]`
+- **Contradictions/Notes:** CSS 선택자의 구체성이 CSSOM 생성 연산 속도에 영향을 미치지만, 최신 브라우저는 파싱 속도가 매우 빨라 이로 인한 지연은 마이크로초 단위에 불과합니다 [11, 13]. 따라서 과도하게 선택자 구체성 최적화에 집착하기보다는 미니파이(minification)나 렌더링 차단을 방지하는 다른 CSS 최적화 기법에 집중하는 것이 좋습니다 [13].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/DOM(Document Object Model).md b/10_Wiki/Topics/Frontend_Mastery/DOM(Document Object Model).md
new file mode 100644
index 00000000..ad27a493
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/DOM(Document Object Model).md	
@@ -0,0 +1,25 @@
+# [[DOM(Document Object Model)]]
+
+## 📌 Brief Summary
+DOM(Document Object Model)은 브라우저가 HTML 마크업을 내부적으로 표현하기 위해 생성하는 계층적인 트리 구조의 객체 모델입니다 [1, 2]. 브라우저가 HTML 데이터를 수신하면서 점진적으로 생성하며, 웹 페이지의 모든 콘텐츠와 요소 간의 구조적 관계를 담고 있습니다 [1, 3, 4]. 자바스크립트(JavaScript) 내의 다양한 API를 통해 DOM에 접근하고 이를 동적으로 조작할 수 있습니다 [2].
+
+## 📖 Core Content
+- **DOM 생성 과정 (DOM Construction Process)**
+  브라우저는 서버로부터 HTML 문서를 수신하면 즉시 파싱(Parsing)을 시작합니다 [5]. 이 과정은 전체 문서가 도착하기를 기다리지 않고 점진적(incremental)으로 이루어집니다 [1]. 수신된 데이터(바이트)는 문자로 변환되고, 이후 토큰(tokens)으로 변환된 다음 최종적으로 노드(nodes)로 변환되어 계층적인 DOM 트리를 형성합니다 [1, 6]. 시작 태그(startTag)와 종료 태그(endTag) 사이에 다른 태그들이 포함되는 방식으로 노드 간의 계층 구조가 정의됩니다 [6].
+
+- **트리 구조와 구성 (Tree Structure and Composition)**
+  DOM 트리는 문서의 콘텐츠를 묘사하며, `<html>` 요소가 트리 구조의 첫 번째 요소이자 루트(root) 노드가 됩니다 [4]. 다른 요소 안에 중첩된 요소들은 자식 노드(child nodes)가 되어 트리 내부에서 각 요소의 관계와 계층을 반영합니다 [4]. 생성된 DOM 트리는 이후 스타일 정보를 담고 있는 CSSOM(CSS Object Model)과 결합하여 화면에 그려질 요소를 결정하는 렌더 트리(Render Tree)를 구축하는 데 사용됩니다 [7, 8].
+
+- **성능에 미치는 영향 (Performance Implications)**
+  DOM 트리의 깊이와 복잡성은 브라우저의 성능과 직결됩니다 [9]. DOM에 존재하는 노드의 수가 많아질수록 렌더 트리 생성, 레이아웃(Layout), 페인트(Paint)와 같은 중요 렌더링 경로(Critical Rendering Path)의 후속 작업에 소요되는 시간과 연산 부담이 커지게 됩니다 [3, 4, 9]. 
+
+- **직접적인 DOM 조작의 한계 (Limitations of Direct DOM Manipulation)**
+  자바스크립트 등을 통해 DOM을 직접 변경하는 작업은 브라우저의 레이아웃(Reflow)과 페인트 단계를 지속적으로 트리거하기 때문에 본질적으로 속도가 느리고 비용이 많이 듭니다 [10]. 애플리케이션이 복잡해질 경우 여러 노드를 개별적으로 업데이트하면 중복 연산이 발생하며, 이는 React와 같은 프레임워크가 가상 DOM(Virtual DOM)을 도입하게 된 핵심 배경이 되었습니다 [10].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[CSSOM(CSS Object Model)]], [[Critical Rendering Path(CRP)]], [[Render Tree]], [[Virtual DOM]], [[Reflow / Repaint]]
+- **Projects/Contexts:** 브라우저 렌더링 과정 (Browser Rendering Process), 프론트엔드 성능 최적화 및 React의 Virtual DOM 도입 배경 이해 [7, 10, 11]
+- **Contradictions/Notes:** 소스 간의 모순된 정보는 없습니다. 참고로 DOM의 생성은 점진적(incremental)으로 진행되어 문서를 파싱하는 동안에도 화면을 그리기 시작할 수 있지만, CSSOM의 생성은 렌더링을 차단(render-blocking)한다는 점에서 두 모델의 구축 방식에 차이가 있습니다 [3, 9].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/E-commerce Platforms.md b/10_Wiki/Topics/Frontend_Mastery/E-commerce Platforms.md
new file mode 100644
index 00000000..b3ff3f19
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/E-commerce Platforms.md	
@@ -0,0 +1,22 @@
+# [[E-commerce Platforms]]
+
+## 📌 Brief Summary
+E-commerce Platforms(이커머스 플랫폼)은 제품 카탈로그, 장바구니, 결제 처리 등의 기능을 제공하여 온라인 상거래를 지원하는 시스템입니다 [1, 2]. 이 시스템의 핵심은 검색 엔진 최적화(SEO)를 통한 제품 발견, 빠른 페이지 로딩을 통한 구매 전환율 향상, 그리고 재고 및 가격 변동을 반영하는 최신 데이터의 유지입니다 [3-5]. 소스 자료에 따르면, 이커머스 플랫폼은 성능과 확장성을 극대화하기 위해 SSR(서버 사이드 렌더링), ISR(점진적 정적 재생성)과 같은 최적화된 웹 렌더링 전략과 컴포넌트 기반 아키텍처(CBA)를 적극적으로 채택합니다 [2, 6].
+
+## 📖 Core Content
+* **이커머스 플랫폼을 위한 웹 렌더링 전략 (Web Rendering Strategies):**
+  * **SSR (Server-Side Rendering):** 이커머스 플랫폼의 제품 목록 페이지, 카테고리 탐색 및 개별 제품 상세 페이지에 가장 이상적인 렌더링 방식 중 하나입니다 [3]. 서버에서 제품의 세부 정보, 가격, 구매 버튼이 포함된 완전한 HTML을 즉시 제공하므로, 자바스크립트 로딩을 기다릴 필요 없이 사용자에게 콘텐츠를 보여주어 구매 전환율을 크게 향상시킵니다 [5]. 또한 훌륭한 SEO를 제공하여 제품 검색 노출에 유리하며, 항상 최신의 실시간 데이터를 요구하는 결제(Checkout) 페이지에 적합합니다 [3, 7].
+  * **SSG (Static Site Generation):** 제품 라인이 변동 없이 안정적이고 콘텐츠 업데이트 주기가 규칙적인 제품 카탈로그 페이지에 적용될 수 있습니다 [8]. 
+  * **ISR (Incremental Static Regeneration):** 이커머스 플랫폼에 최적의 균형(성능과 최신성)을 제공하는 고도화된 접근 방식입니다 [4, 6]. 대규모 제품 카탈로그를 초고속으로 로딩하는 동시에, 전체 사이트를 다시 빌드하는 오버헤드 없이 백그라운드에서 재고 정보와 가격을 주기적으로 업데이트하여 최신 상태로 유지할 수 있습니다 [4, 6, 9].
+
+* **컴포넌트 기반 아키텍처 적용 (Component-Based Architecture):**
+  * 이커머스 플랫폼은 제품 목록(Product listings), 결제 게이트웨이(Payment gateways), 장바구니(Shopping carts), 고객 리뷰 모듈 등 명확히 분리된 기능을 가진 재사용 가능한 소프트웨어 컴포넌트들의 조립으로 구축됩니다 [2].
+  * 이러한 모듈식 접근 방식을 통해 비즈니스가 확장됨에 따라 새로운 결제 옵션을 추가하거나 제품 추천 기능을 갱신해야 할 때, 플랫폼 전체에 중단을 일으키지 않고 특정 컴포넌트만 쉽게 교체하거나 확장할 수 있는 유연성을 확보합니다 [2, 10].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Server-Side Rendering (SSR)]], [[Incremental Static Regeneration (ISR)]], [[Component-Based Architecture]], [[Search Engine Optimization (SEO)]]
+- **Projects/Contexts:** 대규모 트래픽을 처리하면서도 검색 엔진 노출을 극대화하고 실시간 재고/가격 변동을 반영해야 하는 프론트엔드 웹 성능 최적화 및 렌더링 아키텍처 구축 맥락 [3, 4, 7].
+- **Contradictions/Notes:** 제공된 소스는 이커머스 플랫폼의 백엔드 비즈니스 로직이나 운영 모델보다는 주로 프론트엔드의 화면 렌더링 최적화(SSR/ISR)와 아키텍처(컴포넌트화) 측면에 초점을 맞추고 있어, 결제 시스템의 내부 동작 원리 등에 대해서는 소스에 관련 정보가 부족합니다.
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/Feature-Sliced Design (FSD).md b/10_Wiki/Topics/Frontend_Mastery/Feature-Sliced Design (FSD).md
new file mode 100644
index 00000000..8b767928
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Feature-Sliced Design (FSD).md	
@@ -0,0 +1,18 @@
+# [[Feature-Sliced Design (FSD)]]
+
+## 📌 Brief Summary
+Feature-Sliced Design (FSD)는 전반적인 프론트엔드 아키텍처를 체계적으로 구성하기 위한 구조적 방법론입니다 [1]. 애플리케이션을 여러 계층(layers)으로 조직화하여 엄격한 의존성 규칙과 명확한 모듈 경계를 정의하는 것이 특징입니다 [1]. BEM과 같은 컴포넌트 스타일링 방법론과 결합하여 프로젝트 전체의 유지보수성을 높이고 기술 부채를 최소화하는 데 사용됩니다 [2, 3].
+
+## 📖 Core Content
+* **프론트엔드 아키텍처의 체계화:** FSD는 CSS의 이름 짓기나 내부 구조에만 집중하는 것을 넘어, 프론트엔드 애플리케이션의 전반적인 아키텍처 방향성을 다루는 구조적 방법론입니다 [1]. 
+* **엄격한 계층 및 모듈 경계:** FSD는 애플리케이션을 여러 계층으로 나누어 조직하며, 각 계층에 대해 엄격한 의존성(dependency) 규칙과 명확한 모듈 경계를 부여하여 코드베이스의 복잡도를 제어합니다 [1].
+* **BEM과의 역할 분담 (시너지 효과):** FSD의 아키텍처 내부에서 컴포넌트 스타일을 구성할 때 BEM(Block Element Modifier) 구조를 함께 사용할 수 있습니다 [1]. FSD가 프로젝트 수준의 구조를 제공하고 BEM이 CSS 구조와 모듈성을 보장함으로써, 두 방법론은 강력한 아키텍처적 조화를 이룹니다 [2, 3].
+* **기술 부채 감소 및 확장성 확보:** 프로젝트 구조(FSD)와 스타일 구조(BEM)를 분리하고 명확히 관리함으로써 대규모 프론트엔드 시스템에서 흔히 발생하는 기술 부채를 획기적으로 줄이고, 확장 가능하며 유지보수하기 쉬운 프로젝트를 구축할 수 있습니다 [2-4].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[BEM]], [[CSS 구조 설계 방식]], [[프론트엔드 아키텍처]]
+- **Projects/Contexts:** [[대규모 프론트엔드 프로젝트의 확장성 있는 구조 및 스타일링 시스템 설계]]
+- **Contradictions/Notes:** 제공된 소스에서는 FSD가 애플리케이션을 여러 계층(layers)으로 나눈다는 원칙과 BEM과의 상호보완적 이점은 명확히 설명하고 있으나, FSD에서 정의하는 구체적인 계층들의 이름이나 내부적인 세부 설계 지침에 대한 구체적인 정보는 부족합니다 [1, 2].
+
+---
+*Last updated: 2026-04-26*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/Fiber 아키텍처 (Fiber Architecture).md b/10_Wiki/Topics/Frontend_Mastery/Fiber 아키텍처 (Fiber Architecture).md
new file mode 100644
index 00000000..14e0ec88
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Fiber 아키텍처 (Fiber Architecture).md	
@@ -0,0 +1,25 @@
+# [[Fiber 아키텍처 (Fiber Architecture)]]
+
+## 📌 Brief 신Summary
+Fiber 아키텍처는 동시성 렌더링(concurrent rendering)을 지원하고 렌더링 프로세스를 세밀하게 제어하기 위해 React 16에서 도입된 재조정(reconciliation) 엔진의 완전한 재작성 버전이다 [1-3]. 이 아키텍처는 렌더링 작업을 '파이버 노드(Fiber node)'라고 불리는 작은 작업 단위(unit of work)로 분할하여 점진적으로 처리하는 작업 루프(work loop)를 기반으로 작동한다 [4, 5]. 렌더링 도중 우선순위가 높은 상호작용이 발생하면 작업을 일시 중지하고 브라우저에 제어권을 넘겼다가 다시 시작할 수 있는 '타임 슬라이싱(time-slicing)'을 가능하게 하여 UI의 반응성을 크게 향상시킨다 [4, 5].
+
+## 📖 Core Content
+
+*   **작업 루프와 파이버 트리 (Work Loop and Fiber Tree):** 
+    이전의 React는 스택 재조정자(stack reconciler)를 사용하여 전체 컴포넌트 트리를 단일 재귀 호출로 한 번에 처리했기 때문에 메인 스레드를 차단하는 문제가 있었다 [4]. Fiber는 컴포넌트 트리의 각 노드를 자식(child), 형제(sibling), 부모(return)에 대한 포인터를 가진 '파이버 노드'로 구성하며, 이를 단위로 작업 루프를 돈다 [6, 7]. 스케줄러는 트리를 깊이 우선 탐색(depth-first) 방식으로 순회하며 렌더링 작업을 수행하고, 현재 프레임에 남은 시간이 없으면 작업을 일시 중단(yield)하여 브라우저의 끊김을 방지한다 [7, 8].
+*   **재조정 단계 (Reconciliation Phases):**
+    React의 재조정 프로세스는 작업 중단 및 우선순위 지정을 가능하게 하기 위해 두 가지 명확한 단계로 나뉜다 [9].
+    *   **렌더 단계 (Render phase):** 트리를 순회하며 이전 상태와 새로운 상태 간의 차이를 계산하는 단계로, DOM을 직접 수정하지 않는다 [9, 10]. 이 단계는 언제든 중단, 취소, 재시작이 가능하며 부작용(side effects)을 실행해서는 안 된다 [9, 10]. 렌더 단계가 끝나면 변경이 필요한 파이버들만 모아 이펙트 목록(effect list)을 구성한다 [11].
+    *   **커밋 단계 (Commit phase):** 중단될 수 없는 동기적인 단계로, 렌더 단계에서 생성된 이펙트 목록을 바탕으로 DOM 노드의 삽입, 삭제, 업데이트를 한 번에 적용한다 [10, 12]. 이 단계에서 `useLayoutEffect` 및 `useEffect`와 같은 생명주기 메서드와 훅이 실행된다 [10, 12, 13].
+*   **우선순위 스케줄링과 레인 모델 (Priority and Lane Model):**
+    Fiber는 여러 업데이트의 혼합된 우선순위를 효율적으로 관리하기 위해 '레인(Lanes)'이라는 비트마스크 시스템을 사용한다 [14, 15]. 작업은 사용자 타이핑이나 클릭처럼 즉각적인 처리가 필요한 동기(Sync) 레인부터 스크롤과 같은 사용자 차단(User-blocking) 레인, 데이터 페칭 결과를 나타내는 기본(Default) 레인, 백그라운드 작업인 유휴(Idle) 레인 등으로 분류된다 [14, 16]. 이를 통해 긴급한 UI 상호작용이 무거운 비동기 업데이트보다 먼저 처리될 수 있다 [14, 17].
+*   **동시성 기능의 기반 (Foundation for Concurrent Features):**
+    이러한 중단 가능한 렌더링 및 우선순위 관리 구조 덕분에 React는 `useTransition` 및 `useDeferredValue`와 같은 동시성 훅(concurrent hooks)을 도입할 수 있게 되었다 [18]. 이 훅들은 무거운 연산이 진행되는 동안에도 긴급한 사용자 입력을 위해 메인 스레드를 확보하여 부드러운 앱 경험을 유지하게 돕는다 [18, 19].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[가상 DOM (Virtual DOM)]], [[재조정 (Reconciliation)]], [[동시성 렌더링 (Concurrent Rendering)]], [[타임 슬라이싱 (Time-Slicing)]]
+- **Projects/Contexts:** [[React 16]], [[React 19 동시성 훅 (useTransition, useDeferredValue)]]
+- **Contradictions/Notes:** 소스 간의 의견 충돌은 없으며, Fiber 아키텍처의 목표는 복잡한 렌더링 작업으로 인해 프레임이 떨어지는 기존의 스택 재조정자(Stack Reconciler) 문제를 해결하기 위해 필수적으로 도입된 구조적 변화라고 일관되게 설명된다 [2, 4].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/Interaction to Next Paint (INP).md b/10_Wiki/Topics/Frontend_Mastery/Interaction to Next Paint (INP).md
new file mode 100644
index 00000000..9bc8c7c8
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Interaction to Next Paint (INP).md	
@@ -0,0 +1,21 @@
+# [[Interaction to Next Paint (INP)]]
+
+## 📌 Brief Summary
+Interaction to Next Paint (INP)는 2024년 3월에 기존의 First Input Delay (FID)를 대체하여 도입된 구글의 핵심 웹 바이탈(Core Web Vitals) 지표입니다 [1]. 이 지표는 전체 페이지 세션 동안 발생하는 사용자의 상호작용에 애플리케이션이 얼마나 빠르게 응답하는지를 측정하며, 권장되는 기준값(threshold)은 200밀리초(ms) 이하입니다 [1]. INP를 최적화하기 위해서는 메인 스레드가 긴급한 사용자 입력을 지연 없이 즉각적으로 처리할 수 있는 상태를 유지하는 것이 가장 중요합니다 [2].
+
+## 📖 Core Content
+- **INP의 정의 및 중요성:** INP는 페이지 내에서 사용자의 클릭, 타이핑 등 상호작용이 일어났을 때 화면에 다음 페인트(Next Paint)가 그려지기까지의 실질적인 반응성을 평가합니다 [1, 3]. 메인 스레드가 자바스크립트 처리 등으로 차단되어 있으면 응답성이 떨어져 INP 점수가 악화됩니다 [4].
+- **React 환경에서의 INP 최적화 기법:**
+  - **동시성 기능(Concurrent Features) 활용:** React 19의 `useTransition` 및 `useDeferredValue` 훅을 사용하면, 무거운 연산이나 긴급하지 않은 UI 업데이트를 지연시킬 수 있습니다 [2, 5]. 이를 통해 메인 스레드를 긴급한 사용자 상호작용에 우선 할당하여 INP 점수를 향상시킬 수 있습니다 [2].
+  - **메모이제이션(Memoization):** 불필요한 리렌더링을 방지하는 메모이제이션은 INP 최적화에 직접 기여합니다 [1]. 특히 **React Compiler**를 통해 자동 메모이제이션을 적용한 실제 운영 환경(예: Wakelet)에서는 INP가 15%에서 최대 47%까지 대폭 개선된 사례가 보고되었습니다 [3, 6, 7].
+  - **React Server Components (RSC):** 서버 컴포넌트를 도입하면 클라이언트로 전송되는 자바스크립트 번들 크기를 40~60%까지 줄일 수 있습니다 [4]. 브라우저 메인 스레드가 상호작용 시 처리해야 할 자바스크립트 양이 줄어들기 때문에 INP가 직접적으로 낮아지는 효과가 있습니다 [4].
+  - 기타 최적화: 디바운싱(Debouncing) 처리나 긴 목록에 대한 가상화(Virtualization) 기법 또한 렌더링 부하를 줄여 INP를 낮추는 데 긍정적으로 작용합니다 [1].
+- **성능 측정 도구:** INP 지표는 Lighthouse와 같은 랩(Lab) 데이터 도구뿐만 아니라, `web-vitals` 자바스크립트 라이브러리, 그리고 DebugBear 등의 Real User Monitoring(RUM) 도구를 통해 실제 사용자의 환경에서 지속적으로 모니터링할 수 있습니다 [8-10].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Core Web Vitals]], [[First Input Delay (FID)]], [[Concurrent Rendering]], [[React Compiler]], [[React Server Components]]
+- **Projects/Contexts:** [[Wakelet (React Compiler 도입으로 INP 47% 개선 사례)]], [[DebugBear (INP 데이터를 모니터링하는 RUM 솔루션)]]
+- **Contradictions/Notes:** 소스에 관련 정보가 부족한 모순점은 없습니다. 모든 소스가 공통적으로 INP를 향상시키기 위해 자바스크립트 실행을 줄이고 메인 스레드의 부하를 관리해야 한다고 주장합니다.
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/Island Architecture.md b/10_Wiki/Topics/Frontend_Mastery/Island Architecture.md
new file mode 100644
index 00000000..b860e0c7
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Island Architecture.md	
@@ -0,0 +1,17 @@
+# [[Island Architecture]]
+
+## 📌 Brief Summary
+Island Architecture(아일랜드 아키텍처)는 웹 페이지의 대부분을 정적인 HTML로 제공하면서, 클라이언트 측 기능을 처리하는 대화형 컴포넌트들을 작은 '섬(islands)'으로 격리하여 서비스하는 아키텍처입니다 [1]. 이는 초기 로드 시간과 상호작용성을 모두 향상시키기 위해 SSR(서버 사이드 렌더링)과 CSR(클라이언트 사이드 렌더링)의 장점을 결합한 고급 하이드레이션(Hydration) 최적화 기법 중 하나로 활용됩니다 [1]. 다만 제공된 소스 문서 내에 이 주제를 심도 있게 다루는 세부 내용이 없어 소스에 관련 정보가 부족합니다.
+
+## 📖 Core Content
+- **고급 하이드레이션 최적화 기법:** 아일랜드 아키텍처는 SSR과 CSR 중 하나만을 선택하는 대신 두 방식의 장점을 결합하여 초기 로드 시간과 상호작용성(Interactivity)을 동시에 개선하기 위해 사용되는 최적화 방법론 중 하나입니다 [1].
+- **정적 요소와 동적 요소의 분리:** 이 아키텍처의 핵심은 페이지의 상당 부분(bulk)을 정적 HTML 문서로 제공하고, 오직 상호작용이 필요한 특정 컴포넌트들만을 '섬(islands)' 형태로 분리하여 클라이언트 측 기능을 독자적으로 처리하게 만드는 것입니다 [1].
+- **정보 부족 명시:** 이 외에 아일랜드 아키텍처가 구체적으로 어떤 프레임워크에서 어떻게 구현되는지, 어떠한 장단점이나 제약 사항을 가지는지에 대해서는 소스에 관련 정보가 부족합니다. 
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Hydration]], [[SSR (Server-Side Rendering)]], [[CSR (Client-Side Rendering)]]
+- **Projects/Contexts:** [[Advanced Hydration Optimization Methods]]
+- **Contradictions/Notes:** 제공된 소스 문서 전체에서 아일랜드 아키텍처에 대한 설명은 하이드레이션 최적화 기법을 나열하는 부분에서 단 한 문장으로만 언급되어 있어, 개념을 깊이 이해하기에는 소스에 관련 정보가 부족합니다.
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/Lane Model.md b/10_Wiki/Topics/Frontend_Mastery/Lane Model.md
new file mode 100644
index 00000000..23e50a7a
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Lane Model.md	
@@ -0,0 +1,31 @@
+# [[Lane Model]]
+
+## 📌 Brief Summary
+React의 Lane Model은 동시성 렌더링(Concurrent Rendering) 및 작업 스케줄링을 관리하기 위해 도입된 정교한 우선순위 시스템입니다 [1]. 이 모델은 업데이트의 성격(예: 사용자 입력, 데이터 페칭 등)에 따라 작업에 각기 다른 우선순위(Lane)를 할당하여 중요한 UI 업데이트가 먼저 처리되도록 보장합니다 [2-4]. 각 Lane은 32비트 정수의 비트마스크(bitmask)로 표현되어 효율적인 우선순위 연산과 다중 우선순위 관리를 가능하게 합니다 [5].
+
+## 📖 Core Content
+* **작동 원리 및 비트마스크 시스템:** 
+  React의 Lane Model은 각 Lane이 특정 우선순위 레벨이나 작업 범주를 나타내는 비트마스크 시스템을 사용합니다 [5]. 이 시스템은 32비트 정수로 표현되며, React가 비트 연산(`lanes & otherLanes`)을 사용하여 우선순위 겹침 여부를 확인하고, 어떤 Lane의 우선순위가 더 높은지 판별하거나 작업을 신속하게 배치(batch) 처리할 수 있도록 돕습니다 [4, 5]. 상태 업데이트가 발생하면 React는 해당 우선순위에 따라 업데이트를 특정 Lane에 할당하며, 렌더링 단계에서 가장 높은 우선순위부터 처리합니다 [4].
+
+* **주요 우선순위 레벨 (Priority Lanes):**
+  작업의 긴급성에 따라 여러 Lane이 존재합니다 [3, 6].
+  * **Sync Lane:** 타이핑이나 클릭과 같이 즉각적인 반응이 필요한 가장 긴급한 업데이트로 즉시 처리됩니다 [3, 6, 7].
+  * **InputContinuous Lane:** 스크롤이나 호버링 등 연속적인 사용자 입력 작업으로, 부드러운 화면 전환을 보장합니다 [3, 6, 7].
+  * **Default Lane:** 데이터 페칭 결과 등 일반적인 상태 업데이트를 위한 표준 우선순위입니다 [3, 6, 7].
+  * **Idle Lane:** 화면 밖(Offscreen) 렌더링이나 분석/로깅 등 브라우저가 유휴 상태일 때만 배경에서 처리되는 작업입니다 [3, 6, 7].
+
+* **Lane Model의 주요 이점:**
+  * **기아 상태 방지 (Starvation prevention):** 우선순위가 낮은 작업이 계속 밀려 오랫동안 대기하는 경우, 이를 더 높은 우선순위의 Lane으로 승격시켜 최종적으로 반드시 처리되도록 보장합니다 [4].
+  * **우선순위 얽힘 (Entanglement):** 우선순위가 낮은 업데이트가 높은 우선순위의 업데이트에 의존하는 경우, 두 Lane을 얽어(entangle) 함께 렌더링되도록 처리합니다 [4].
+  * **다중 작업 진행 관리 (Multi-WIP management):** 단일 Fiber 노드가 각기 다른 Lane에 대해 여러 개의 진행 중인 작업(WIP, Work-In-Progress)을 가질 수 있으며, 스케줄러는 항상 가장 우선순위가 높은 WIP를 먼저 실행합니다 [8].
+
+* **동시성 기능과의 연계:**
+  이 모델은 `useTransition` 및 `useDeferredValue`와 같은 React 19의 동시성 기능(Concurrent features)을 구현하는 핵심 기반입니다 [9, 10]. 이 기능들은 긴급하지 않은 무거운 연산의 우선순위를 낮춤으로써(우선순위가 높은 업데이트가 도착하면 하위 작업은 중단 및 연기됨), UI의 반응성을 지속적으로 유지할 수 있게 해줍니다 [4, 9, 10].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[React Fiber Architecture]], [[Concurrent Rendering]], [[Reconciliation]], [[Time-Slicing]]
+- **Projects/Contexts:** [[React Scheduler]], [[useTransition]], [[useDeferredValue]]
+- **Contradictions/Notes:** 소스 내에 특별한 모순점은 발견되지 않았습니다. Lane Model은 과거 React의 동기식 차단(Synchronous Blocking) 렌더링의 한계를 극복하고 긴급한 상호작용과 긴급하지 않은 UI 전환을 효율적으로 분류하기 위해 Fiber 아키텍처와 함께 도입된 구조로 일관되게 설명되고 있습니다 [1-3, 11].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/Lanes Model.md b/10_Wiki/Topics/Frontend_Mastery/Lanes Model.md
new file mode 100644
index 00000000..51d25422
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Lanes Model.md	
@@ -0,0 +1,31 @@
+# [[Lanes Model]]
+
+## 📌 Brief Summary
+Lanes Model은 React의 Fiber 아키텍처에서 동시성(Concurrent) 작업과 렌더링의 우선순위를 관리하기 위해 도입된 정교한 시스템입니다 [1]. 32비트 정수 형태의 비트마스크(bitmask)를 활용하여 UI 업데이트 작업을 여러 우선순위 레벨(Lane)로 분류하고 관리합니다 [2]. 이를 통해 즉각적인 사용자 상호작용과 같은 긴급한 업데이트를 우선적으로 처리하며, 무거운 연산 중에도 UI의 반응성을 유지하도록 돕습니다 [3, 4].
+
+## 📖 Core Content
+* **작동 원리 및 비트마스크 시스템:**
+  React의 Lanes Model은 각 'Lane'이 작업의 우선순위 또는 범주를 나타내는 32비트 정수 비트마스크 시스템을 사용합니다 [2]. 비트 연산(`lanes & otherLanes`)을 활용하여 작업 간의 우선순위 중첩 여부를 매우 빠르고 효율적으로 확인합니다 [5]. 상태 업데이트가 발생하면 React는 해당 작업의 중요도에 따라 Lane을 할당하며, 렌더링 단계(Render phase)에서 우선순위가 가장 높은 Lane부터 처리합니다 [5]. 
+
+* **우선순위 레벨 (Priority Lanes):**
+  작업은 중요도에 따라 다음과 같은 주요 Lane으로 분류됩니다 [3, 6].
+  * **Sync Lane:** 타이핑이나 클릭과 같은 이산적인 사용자 입력입니다. 화면이 멈추는 것을 방지하기 위해 즉시(동기적으로) 처리되며 다른 작업에 의해 차단되지 않습니다 [3, 6, 7].
+  * **InputContinuous Lane:** 스크롤이나 마우스 호버처럼 연속적인 입력입니다. 유동적인 모션을 보장하기 위해 높은 우선순위를 갖습니다 [3, 6, 7].
+  * **Default Lane:** 데이터 페칭 결과 처리 등 대부분의 일반적인 상태 업데이트에 부여되는 기본 우선순위입니다 [3, 6, 7].
+  * **Idle Lane:** 화면 밖의 렌더링과 같이 브라우저가 유휴(Idle) 상태일 때만 백그라운드에서 처리되는 작업입니다 [3, 6, 7].
+
+* **Lanes Model의 핵심 최적화 기능:**
+  * **우선순위 선점 및 중단:** 렌더링 중 더 높은 우선순위의 업데이트가 도착하면, 진행 중이던 낮은 우선순위의 작업(WIP, Work-In-Progress)을 일시 중지하고 높은 우선순위의 작업을 먼저 처리할 수 있습니다 [5, 8].
+  * **기아 현상 방지 (Starvation Prevention):** 낮은 우선순위의 작업이 오랫동안 대기 상태에 머물러 처리되지 못하는 것을 막기 위해, 일정 시간이 지나면 더 높은 우선순위 Lane으로 승격(promote)시켜 실행을 보장합니다 [5].
+  * **작업 얽힘 (Entanglement):** 낮은 우선순위의 업데이트가 높은 우선순위 업데이트의 결과에 의존해야 할 경우, 두 Lane을 서로 얽히게 만들어 함께 렌더링되도록 동기화합니다 [5].
+
+* **동시성 기능(Concurrent Features)의 기반:**
+  Lanes Model은 React의 `useTransition` 및 `useDeferredValue`와 같은 동시성 훅(Hooks)을 구동하는 핵심 기술입니다 [4]. 이 모델 덕분에 긴급하지 않은 렌더링 업데이트를 낮은 우선순위로 미뤄두어, 무거운 연산이 진행되는 동안에도 UI가 멈추지 않고 반응성을 유지할 수 있습니다 [4].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[React Fiber Architecture]], [[Concurrent Rendering]], [[React Scheduler]], [[Virtual DOM]]
+- **Projects/Contexts:** [[React의 렌더링 최적화 및 우선순위 기반 스케줄링 맥락]]
+- **Contradictions/Notes:** 소스 간의 모순점은 발견되지 않았습니다. 제공된 소스들은 공통적으로 Lanes Model이 React의 우선순위 관리와 동시성 렌더링을 가능하게 하는 중추적인 아키텍처임을 강조합니다.
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/Lighthouse.md b/10_Wiki/Topics/Frontend_Mastery/Lighthouse.md
new file mode 100644
index 00000000..3a8f066c
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Lighthouse.md
@@ -0,0 +1,18 @@
+# [[Lighthouse]]
+
+## 📌 Brief Summary
+Lighthouse는 Chrome DevTools에 내장되어 웹 애플리케이션의 성능을 측정하고 종합적인 감사를 제공하는 도구입니다 [1, 2]. 주로 Core Web Vitals 지표를 기반으로 구체적이고 실행 가능한 성능 최적화 권장 사항을 제시하며, CI(지속적 통합) 파이프라인에서 실행하여 프로덕션 환경으로 성능 회귀(Performance regression)가 유입되는 것을 방지할 수 있습니다 [2].
+
+## 📖 Core 대Content
+* **성능 감사 및 문제 진단 워크플로우:** 성능 최적화의 첫 단계로 Lighthouse를 실행하여 어떤 Core Web Vital 지표가 개선이 필요한지 식별하는 것이 권장됩니다 [1]. 이후 React DevTools Profiler와 같은 도구를 사용해 가장 느린 컴포넌트를 격리하고 개선 사항을 적용한 뒤, 다시 측정하여 결과를 확인하는 방식으로 사용됩니다 [1].
+* **렌더링 차단 리소스(Render-blocking resources) 분석:** Lighthouse는 페이지 렌더링을 방해하는 리소스를 분석하고 식별합니다. 특히 실제로 페이지 렌더링을 지연시키는 리소스만을 선별하여 보여주기 때문에 불필요한 오탐(false positives)을 피하는 데 유용합니다 [3, 4].
+* **LCP 및 주요 요청 체인(Critical Request Chains) 시각화:** 사이트의 LCP(Largest Contentful Paint) 요소 및 렌더링 시점을 식별해 줍니다 [5]. 또한 각 LCP 단계와 거기에 소요된 시간을 분석하여 최적화 노력을 어디에 집중해야 할지 돕고, 복잡한 사이트에서는 별도의 감사를 통해 렌더링 차단 여부와 무관하게 중요도가 높은 리소스들의 요청 체인을 시각적으로 강조해 줍니다 [5].
+* **실제 사용자 데이터(RUM)와의 병행 사용:** Lighthouse는 실험실 도구(Lab tool)이므로 실제 사용자의 기기, 네트워크 상태 및 사용 패턴을 완벽히 반영하지 못할 수 있습니다 [1]. 따라서 프로덕션 환경에서는 `web-vitals` 자바스크립트 라이브러리를 활용해 실제 사용자 데이터(Field data)를 수집하여 함께 모니터링하는 것이 필수적입니다 [1, 2].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Core Web Vitals]], [[LCP]], [[Render-blocking resources]], [[Chrome DevTools]]
+- **Projects/Contexts:** [[React Performance Optimization]], [[Critical Rendering Path]]
+- **Contradictions/Notes:** 다른 성능 측정 도구인 WebPageTest가 모든 렌더링 차단 리소스를 명확하게 표시하는 반면, Lighthouse는 페이지 렌더링을 실제로 지연시키는 요소만 미묘하게 강조한다는 접근 방식의 차이가 있습니다 [3].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/Meta Quest Store.md b/10_Wiki/Topics/Frontend_Mastery/Meta Quest Store.md
new file mode 100644
index 00000000..04477daf
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Meta Quest Store.md	
@@ -0,0 +1,18 @@
+# [[Meta Quest Store]]
+
+## 📌 Brief Summary
+Meta Quest Store는 Meta에서 운영하는 플랫폼으로, 제공된 문서 내에서는 프론트엔드 성능 최적화 도구인 React Compiler를 실제 프로덕션 환경에 성공적으로 도입한 대표적인 사례로만 짧게 등장합니다 [1, 2]. 해당 스토어의 구체적인 서비스 목적, 판매 항목, 혹은 전반적인 아키텍처에 대해서는 소스에 관련 정보가 부족합니다.
+
+## 📖 Core Content
+- **React Compiler의 성공적 배포**: Meta는 대중에게 공개하기 전 자사 애플리케이션 생태계 전반에 걸쳐 React Compiler를 내부적으로 테스트했으며, Instagram과 함께 Meta Quest Store에 성공적으로 배포했습니다 [1, 2].
+- **로딩 속도 지표 개선**: 수동 메모이제이션(Manual Memoization) 문제를 해결하는 React Compiler 적용 결과, Quest Store의 로딩 속도는 최소 4% 이상 향상되었으며, 초기 로딩(initial loads) 시간은 최대 12%까지 개선되었습니다 [2].
+- **상호작용(Interaction)의 즉각성**: 최적화의 결과로 Quest Store 내의 복잡한 제품 페이지(complex product pages)들이 눈에 띄게 빠르게 로드되었습니다 [1]. 특히 일부 상호작용은 2배 이상 빨라져 사용자들이 거의 즉각적(instantaneous)이라고 느낄 수 있는 수준의 개선이 이루어졌습니다 [1, 2].
+- 이외에 플랫폼 자체의 상업적 기능이나 비즈니스 로직 등에 대해서는 소스에 관련 정보가 부족합니다.
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[React Compiler]], [[Performance Optimization]]
+- **Projects/Contexts:** [[Meta's Internal Testing (React Compiler 성능 검증)]]
+- **Contradictions/Notes:** Meta Quest Store에 대한 독립적이고 포괄적인 설명은 제공된 소스에 관련 정보가 부족합니다. 오직 React Compiler의 적용으로 인한 성능 최적화 지표를 보여주는 단편적인 사례(Case Study)로만 활용되었습니다.
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/Next.js App Router.md b/10_Wiki/Topics/Frontend_Mastery/Next.js App Router.md
new file mode 100644
index 00000000..069d9a84
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Next.js App Router.md	
@@ -0,0 +1,18 @@
+# [[Next.js App Router]]
+
+## 📌 Brief Summary
+Next.js App Router는 Next.js 13 버전 이상부터 도입된 새로운 아키텍처로, 클라이언트 측 JavaScript 코드를 줄이기 위한 새로운 접근 방식을 제공합니다 [1]. 이 환경에서는 페이지와 레이아웃이 기본적으로 서버에서 렌더링되며 [2], 상호작용이 필요 없는 정적 컴포넌트의 경우 하이드레이션(Hydration) 과정 자체를 제거하여 성능을 최적화할 수 있습니다 [3].
+
+## 📖 Core Content
+- **기본 서버 컴포넌트(Default Server Components) 적용:** Next.js App Router를 사용하면 애플리케이션의 페이지(Pages)와 레이아웃(Layouts)이 기본적으로 React Server Components로 동작합니다 [2]. 이를 통해 해당 영역의 코드가 클라이언트 브라우저에서 실행되지 않게 되므로, 브라우저가 다운로드해야 하는 JavaScript 페이로드를 완전히 줄일 수 있습니다 [1, 3].
+- **단순화된 데이터 페칭:** App Router 환경에서는 비동기(async) 컴포넌트 내에서의 데이터 페칭(Data fetching) 기능이 별도의 추가 설정 없이 기본적으로(out of the box) 지원됩니다 [2].
+- **명시적인 클라이언트 컴포넌트 사용:** 버튼이나 폼과 같은 상호작용(Interactivity)이 필요한 부분은 파일 최상단에 `"use client"` 지시어를 선언하여 클라이언트 컴포넌트로 만들어야 합니다 [2]. App Router 환경에서 클라이언트 컴포넌트를 사용할 때는 하이드레이션 오버헤드를 줄이기 위해 코드 스플리팅(Code splitting), 트리 쉐이킹(Tree-shaking) 등을 통해 컴포넌트 번들 크기를 최소화하는 것이 필수적입니다 [4].
+- *참고: Next.js App Router의 디렉토리 구조, 중첩 라우팅 메커니즘 등 라우터 자체의 동작 원리에 대한 구체적인 세부 사항은 제공된 소스에 관련 정보가 부족합니다. 현재 소스는 주로 렌더링 및 하이드레이션 성능 관점에서의 App Router 활용에 집중되어 있습니다.*
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[React Server Components]], [[Client Components]], [[Hydration]]
+- **Projects/Contexts:** [[Next.js 13+]]
+- **Contradictions/Notes:** 제공된 소스는 App Router를 React Server Components 및 하이드레이션 최적화의 맥락에서만 설명하고 있으며, 파일 시스템 기반의 라우팅 구조나 캐싱 메커니즘 전반에 대해서는 소스에 관련 정보가 부족합니다.
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/Next.js 기반의 Hybrid Rendering (SSR-CSR-RSC 혼합 적용).md b/10_Wiki/Topics/Frontend_Mastery/Next.js 기반의 Hybrid Rendering (SSR-CSR-RSC 혼합 적용).md
new file mode 100644
index 00000000..e551737c
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Next.js 기반의 Hybrid Rendering (SSR-CSR-RSC 혼합 적용).md	
@@ -0,0 +1,18 @@
+# [[Next.js 기반의 Hybrid Rendering (SSR/CSR/RSC 혼합 적용)]]
+
+## 📌 Brief Summary
+Next.js 기반의 Hybrid Rendering은 단일 애플리케이션 내에서 SSR, CSR, SSG 및 React Server Components(RSC) 등 다양한 렌더링 방식을 페이지나 컴포넌트 특성에 맞게 혼합하여 사용하는 아키텍처입니다 [1, 2]. 이 접근 방식은 각 렌더링 전략의 장점만을 결합하여 초기 로딩 속도, SEO, 그리고 상호작용성(Interactivity)을 동시에 최적화할 수 있도록 돕습니다 [1]. 특히 최신 Next.js 환경에서는 기본적으로 무거운 작업을 서버에서 처리하는 RSC를 사용하고, 상호작용이 필요한 영역에만 선택적으로 CSR을 적용하여 클라이언트의 자바스크립트 부담을 최소화합니다 [3-5].
+
+## 📖 Core Content
+- **페이지 단위의 유연한 렌더링 전략 선택:** Next.js와 같은 최신 프레임워크는 프로젝트의 요구사항에 따라 렌더링 방식을 유연하게 혼용할 수 있게 해줍니다 [1, 2]. 예를 들어, 내용이 변하지 않는 홈페이지나 마케팅 페이지에는 SSG(Static Site Generation)를 사용하고, 항상 최신 데이터를 반영해야 하는 상품 목록에는 SSR(Server-Side Rendering)을, 고도의 상호작용이 요구되는 유저 대시보드에는 CSR(Client-Side Rendering)을 개별적으로 적용할 수 있습니다 [1, 2].
+- **React Server Components (RSC)의 도입:** Next.js App Router 구조에서는 모든 컴포넌트가 기본적으로 서버 컴포넌트로 동작합니다 [5, 6]. 서버 컴포넌트는 오직 서버에서만 실행되어 렌더링된 HTML과 직렬화된 UI 표현(명령어)만 클라이언트로 전달하므로, 클라이언트 측 자바스크립트 번들에 어떠한 용량도 추가하지 않습니다(Zero Client-Side JavaScript) [3, 7, 8]. 이를 통해 브라우저에서의 하이드레이션(Hydration) 비용을 제거하고 데이터베이스에 직접 접근할 수 있습니다 [3, 8, 9].
+- **서버와 클라이언트 컴포넌트의 결합 원칙:** 모든 UI가 정적일 수는 없으므로 버튼 클릭이나 폼 입력과 같은 상호작용, 혹은 상태(State) 관리가 필요한 경우에는 파일 최상단에 `"use client"` 지시어를 선언하여 클라이언트 컴포넌트로 명시합니다 [3, 6]. 하이브리드 구조에서는 서버 컴포넌트가 데이터에 접근하고 클라이언트 컴포넌트를 렌더링(포함)하는 방식으로 혼합 구성됩니다 [3, 10]. 단, 클라이언트 컴포넌트가 서버 컴포넌트를 직접 임포트(import)할 수는 없으며, 의존성의 방향은 항상 서버에서 클라이언트로 흘러야 합니다 [11, 12].
+- **성능 최적화 및 부분 하이드레이션:** 이러한 혼합 아키텍처는 선택적 하이드레이션과 스트리밍(Streaming)을 가능하게 합니다 [10, 13, 14]. 상호작용이 필요 없는 영역은 서버에서 HTML로 완성되어 즉시 렌더링되며 자바스크립트 실행이 생략되지만, 클라이언트 컴포넌트가 위치한 조각에 대해서만 자바스크립트 번들이 전송되어 부분적으로 하이드레이션이 일어납니다 [10]. 이로 인해 초기 화면 표시 시간과 INP(Interaction to Next Paint) 지표가 극적으로 개선됩니다 [4, 7, 13].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[React Server Components (RSC)]], [[Client-Side Rendering (CSR)]], [[Server-Side Rendering (SSR)]], [[Static Site Generation (SSG)]], [[Hydration]]
+- **Projects/Contexts:** [[Next.js App Router]], [[React 19]]
+- **Contradictions/Notes:** 서버 컴포넌트를 도입하여 클라이언트의 번들 크기를 줄일 수는 있지만, 렌더링 및 데이터 호출 부하가 서버로 집중되므로 복잡한 스트리밍 인프라나 명확한 캐싱 전략이 부재할 경우 서버 병목 현상이라는 새로운 문제가 발생할 수 있습니다 [15-17]. 또한 클라이언트 컴포넌트에서 서버 컴포넌트를 직접 호출할 수 없는 등 엄격한 트리 구성 규칙을 지켜야 합니다 [11, 12].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/Next.js를 활용한 SEO 및 성능 최적화 하이브리드 렌더링 아키텍처 설계.md b/10_Wiki/Topics/Frontend_Mastery/Next.js를 활용한 SEO 및 성능 최적화 하이브리드 렌더링 아키텍처 설계.md
new file mode 100644
index 00000000..be5f24ed
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Next.js를 활용한 SEO 및 성능 최적화 하이브리드 렌더링 아키텍처 설계.md	
@@ -0,0 +1,28 @@
+# [[Next.js를 활용한 SEO 및 성능 최적화 하이브리드 렌더링 아키텍처 설계]]
+
+## 📌 Brief Summary
+Next.js를 활용한 하이브리드 렌더링 아키텍처 설계는 단일 애플리케이션 내에서 각 페이지와 컴포넌트의 특성에 맞춰 CSR, SSR, SSG, ISR 등 다양한 렌더링 방식을 혼합하여 사용하는 전략입니다 [1-3]. 검색 엔진 최적화(SEO)와 빠른 초기 로딩이 중요한 페이지에는 서버 사이드 렌더링(SSR)이나 정적 생성(SSG)을 적용하고, 동적인 상호작용이 필요한 영역에는 클라이언트 사이드 렌더링(CSR)을 배치하여 성능과 사용자 경험을 극대화할 수 있습니다 [1]. 또한, React Server Components(RSC)와 선택적 하이드레이션(Hydration) 기법을 결합하여 클라이언트로 전송되는 자바스크립트 번들 크기를 최소화하고 체감 성능을 향상시킬 수 있습니다 [4-7].
+
+## 📖 Core Content
+*   **하이브리드 렌더링 전략의 필요성**
+    과거에는 애플리케이션 전체에 대해 단일 렌더링 방식만 선택해야 했으나, Next.js 프레임워크는 페이지별로 요구사항에 맞춰 CSR, SSR, SSG, ISR을 혼합하여 사용하는 하이브리드 접근법을 지원합니다 [1, 2]. 예를 들어 홈페이지나 문서에는 SSG를, 재고 데이터가 필요한 제품 페이지에는 SSR을, 실시간 상호작용이 중요한 사용자 대시보드에는 CSR을 각각 적용하여 SEO와 콘텐츠의 최신성, 성능 간의 균형을 완벽히 맞출 수 있습니다 [1, 3].
+
+*   **성능 및 SEO를 위한 주요 렌더링 방식 최적화**
+    *   **SSR (Server-Side Rendering):** 사용자가 페이지를 요청할 때마다 서버에서 데이터를 가져와 HTML을 렌더링하는 방식입니다 [8]. 초기 콘텐츠 표시 속도(FCP)가 빠르고 검색 엔진 크롤러가 완성된 HTML을 읽을 수 있어 SEO에 매우 유리하지만 [9-11], 서버 부하가 증가하고 자바스크립트 하이드레이션 과정으로 인해 상호작용 가능 시간(TTI)이 지연될 수 있다는 단점이 있습니다 [9, 12-14]. 뉴스 사이트나 전자상거래 제품 페이지에 이상적입니다 [15].
+    *   **SSG (Static Site Generation):** 빌드 시점에 모든 HTML 페이지를 미리 생성하여 CDN을 통해 배포하므로 서버 사이드 연산 없이 가장 빠른 로딩 속도를 제공합니다 [16-19]. 블로그나 마케팅 페이지에 적합하며 완벽한 SEO를 보장하지만, 콘텐츠가 자주 변경되는 경우에는 한계가 있습니다 [16, 20-22].
+    *   **ISR (Incremental Static Regeneration):** 전체 사이트를 다시 빌드할 필요 없이 백그라운드에서 설정된 간격으로 정적 페이지를 재생성합니다 [16, 23, 24]. SSG의 놀라운 속도와 SSR의 유연성을 결합하여 성능과 콘텐츠 최신화를 동시에 달성하므로, 대규모 전자상거래 플랫폼이나 대형 콘텐츠 사이트에 최적화된 방식입니다 [25, 26].
+    *   **CSR (Client-Side Rendering):** 브라우저가 최소한의 HTML을 받은 후 자바스크립트를 실행하여 UI를 동적으로 생성합니다 [27, 28]. 초기 로드 시간은 길고 SEO에 불리할 수 있으나, 페이지 로드 후에는 깜빡임 없는 부드러운 앱 전환(SPA)과 고도의 상호작용을 제공하므로 사용자 대시보드나 SaaS 플랫폼에 최적의 선택입니다 [29-31].
+
+*   **React Server Components (RSC)의 도입**
+    RSC는 하이브리드 아키텍처를 컴포넌트 단위로 확장한 최신 기술입니다. 서버 컴포넌트는 오직 서버에서만 실행되며 브라우저로 전송되는 자바스크립트 번들에 0바이트를 기여합니다 [4, 5]. 데이터베이스나 파일 시스템에 직접 접근할 수 있고, 불필요한 클라이언트-API 간 네트워크 왕복을 제거합니다 [6, 32, 33]. 성능 최적화를 위해서는 데이터 집약적인 정적 영역을 서버 컴포넌트로 처리하고, 폼이나 버튼 같은 상호작용 요소만 "use client" 지시어를 사용해 클라이언트 컴포넌트로 감싸는 방식이 권장됩니다 [6, 34-36].
+
+*   **하이드레이션(Hydration) 병목 현상 해결**
+    SSR 환경에서 생성된 정적 HTML을 동적으로 만드는 하이드레이션 과정은 메인 스레드를 차단하여 총 차단 시간(TBT)을 악화시킬 수 있습니다 [37, 38]. 이를 해결하기 위해 Next.js의 동적 임포트(dynamic imports)를 통한 선택적 하이드레이션, 스크롤 진입 시점에 로드하는 지연 하이드레이션(lazy hydration), 그리고 React Suspense를 활용하여 HTML을 점진적으로 렌더링하는 스트리밍 방식을 활용해야 합니다 [7, 39, 40].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Server-Side Rendering (SSR)]], [[Static Site Generation (SSG)]], [[Incremental Static Regeneration (ISR)]], [[Client-Side Rendering (CSR)]], [[React Server Components (RSC)]], [[Hydration]]
+- **Projects/Contexts:** [[대규모 전자상거래 플랫폼 및 제품 카탈로그]], [[SEO 중심의 뉴스 및 마케팅 웹사이트]], [[사용자 상호작용이 복잡한 SaaS 대시보드]]
+- **Contradictions/Notes:** SSR은 FCP(First Contentful Paint)를 단축시켜 초기 시각적 성능과 SEO에는 유리하다고 소스들에서 강조되지만, 그에 수반되는 하이드레이션 과정 때문에 상호작용 가능 시간(TTI)이 눈에 띄게 지연될 수 있다는 점을 성능 설계 시 중요한 트레이드오프로 지적하고 있습니다 [9, 41, 42].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/Next.js를 활용한 하이브리드 렌더링 및 SEO 최적화.md b/10_Wiki/Topics/Frontend_Mastery/Next.js를 활용한 하이브리드 렌더링 및 SEO 최적화.md
new file mode 100644
index 00000000..c98e5f47
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Next.js를 활용한 하이브리드 렌더링 및 SEO 최적화.md	
@@ -0,0 +1,28 @@
+# [[Next.js를 활용한 하이브리드 렌더링 및 SEO 최적화]]
+
+## 📌 Brief Summary
+Next.js는 단일 웹 애플리케이션 내에서 서버 사이드 렌더링(SSR), 정적 사이트 생성(SSG), 클라이언트 사이드 렌더링(CSR), 점진적 정적 재생성(ISR) 등 다양한 렌더링 방식을 페이지별 목적에 맞게 선택하여 결합할 수 있는 하이브리드 렌더링 프레임워크입니다 [1-3]. 이를 통해 개발자는 상호작용이 필요한 페이지와 정적인 페이지의 렌더링 방식을 다르게 가져가 초기 로딩 속도를 최적화할 수 있습니다 [4]. 결과적으로 검색 엔진 봇에게 완성된 HTML을 즉시 제공하여 SEO 성능을 극대화하면서도, 풍부한 사용자 경험과 서버 성능의 균형을 효과적으로 맞출 수 있습니다 [5-7].
+
+## 📖 Core Content
+* **하이브리드 렌더링 아키텍처 (Hybrid Rendering Architecture)**
+  Next.js는 각 페이지의 특성에 따라 최적의 렌더링 방식을 혼합해서 사용할 수 있도록 지원합니다 [1, 2]. 검색 엔진 노출이 중요한 마케팅 페이지나 블로그에는 SSG를, 실시간 재고나 가격 확인이 필수적인 이커머스 상품 페이지에는 SSR을 적용할 수 있습니다 [1, 3, 8]. 반면, 로그인 이후 접근하는 사용자 맞춤형 대시보드나 높은 상호작용이 요구되는 UI에서는 CSR을 사용하여 SEO 제약 없이 풍부한 기능을 제공할 수 있습니다 [1, 3, 9].
+  
+* **검색 엔진 최적화(SEO) 극대화**
+  순수 CSR 환경은 빈 HTML 셸을 초기에 로드하기 때문에 자바스크립트가 실행되기 전까지 검색 엔진 크롤러가 콘텐츠를 인덱싱하지 못할 위험이 큽니다 [10-12]. Next.js의 SSR 및 SSG 방식은 완성된 HTML 콘텐츠, 메타 태그, 오픈 그래프(Open Graph) 데이터를 브라우저와 검색 엔진 봇에 즉각적으로 전송하므로, 빠르고 완전한 크롤링과 인덱싱이 가능해져 SEO 랭킹 향상에 크게 기여합니다 [5, 13-17].
+
+* **ISR을 통한 성능과 데이터 최신성의 균형**
+  점진적 정적 재생성(ISR)은 SSG의 빠른 로딩 속도와 SSR의 데이터 최신성을 결합한 방식입니다 [18-20]. 사전에 생성된 정적 페이지를 캐시하여 즉각적으로 서비스하되, 백그라운드에서 설정된 시간(예: 60초)마다 페이지를 다시 빌드하여 최신 콘텐츠로 업데이트합니다 [20-22]. 이는 대규모 이커머스 카탈로그나 뉴스 포털 등 페이지 수가 방대하고 주기적인 업데이트가 필요한 서비스에서 전체 빌드 시간의 지연 없이 높은 성능과 SEO를 달성할 수 있게 합니다 [23, 24].
+
+* **React Server Components (RSC) 통합**
+  Next.js 환경에서 사용 가능한 React Server Components(RSC)는 서버에서만 실행되고 클라이언트로 자바스크립트 번들을 전송하지 않는 제로 번들 렌더링(Zero-Bundle Rendering)을 제공합니다 [25-28]. 인터랙션이 필요 없는 레이아웃이나 정적 콘텐츠는 서버 컴포넌트로 처리하여 페이로드를 대폭 줄이고, 상호작용이 필요한 부분에만 클라이언트 컴포넌트(`"use client"`)를 선택적으로 혼합하여 페이지의 TTI(Time to Interactive) 및 LCP(Largest Contentful Paint)와 같은 코어 웹 바이탈(Core Web Vitals) 지표를 향상시킬 수 있습니다 [27, 29-32].
+
+* **기본 제공 최적화 도구 (next/image)**
+  Next.js는 `next/image` 컴포넌트 등을 통해 이미지 포맷 변환(WebP, AVIF), 뷰포트에 맞춘 반응형 크기 조절, 그리고 화면에 보일 때만 이미지를 로드하는 지연 로딩(Lazy Loading)을 자동으로 처리합니다 [33]. 이는 초기 페이지 용량을 줄이고 레이아웃 시프트(CLS)를 방지하여 성능과 SEO에 모두 긍정적인 영향을 미칩니다 [33-35].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Server-Side Rendering (SSR)]], [[Static Site Generation (SSG)]], [[Client-Side Rendering (CSR)]], [[Incremental Static Regeneration (ISR)]], [[React Server Components (RSC)]]
+- **Projects/Contexts:** [[검색 엔진 가시성 및 실시간 데이터가 필요한 대규모 이커머스 플랫폼]], [[풍부한 사용자 상호작용과 SEO가 동시에 요구되는 엔터프라이즈 마케팅 사이트]]
+- **Contradictions/Notes:** SSR은 SEO에 매우 뛰어나고 항상 최신 데이터를 제공하지만, 모든 요청마다 서버에서 렌더링을 수행하므로 트래픽 급증 시 서버 부하가 커지고 TTFB(Time to First Byte)가 느려질 수 있다는 단점이 존재합니다 [36-40]. 이에 반해 SSG는 속도가 가장 빠르고 서버 부하가 없으나, 실시간 데이터 변동을 반영하기 위해 매번 전체 사이트를 재빌드해야 하는 한계가 있어 [41-43] ISR과 같은 하이브리드 전략의 도입이 중요해집니다 [19, 41].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/React 18 & 19 Performance Optimization.md b/10_Wiki/Topics/Frontend_Mastery/React 18 & 19 Performance Optimization.md
new file mode 100644
index 00000000..21c40c22
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/React 18 & 19 Performance Optimization.md	
@@ -0,0 +1,28 @@
+# [[React 18 & 19 Performance Optimization]]
+
+## 📌 Brief Summary
+React 18 및 19의 성능 최적화는 동시성 렌더링, 자동 배칭(Automatic Batching), 그리고 빌드 타임 컴파일러를 통해 불필요한 렌더링을 최소화하고 UI 반응성을 극대화하는 기술적 진보를 의미합니다 [1-4]. React 18은 다양한 비동기 이벤트의 상태 업데이트를 한 번에 묶는 자동 배칭과 `useTransition`을 통한 동시성 훅을 도입했습니다 [3, 5, 6]. React 19는 React Compiler를 도입하여 수동 메모이제이션의 부담을 없애고, React Server Components(RSC) 아키텍처를 통해 클라이언트로 전송되는 JavaScript 번들 크기를 획기적으로 줄였습니다 [2, 4, 7, 8].
+
+## 📖 Core Content
+* **React 18 자동 배칭(Automatic Batching)**
+  React 18부터는 프로미스, `setTimeout`, 네이티브 이벤트 핸들러 내부에서 발생하는 상태 업데이트까지 모두 한 번의 리렌더링으로 묶어서 처리하는 자동 배칭이 기본으로 적용됩니다 [3, 9, 10]. 이를 통해 Virtual DOM 디핑(Diffing) 연산을 최소화하며, 특정 데이터 집약적인 대시보드 사례에서는 렌더링 횟수를 최대 40% 줄이고 프레임 속도를 25% 향상시키는 성과를 냈습니다 [1, 11, 12]. 만약 즉각적인 DOM 업데이트가 반드시 필요한 경우라면 `flushSync` API를 사용하여 자동 배칭을 우회할 수 있습니다 [12-14].
+
+* **동시성 렌더링 기능(Concurrent Features)**
+  React 18/19의 동시성 훅인 `useTransition`과 `useDeferredValue`는 메인 스레드가 차단되는 것을 방지합니다 [5, 12, 13]. 타이핑이나 클릭과 같은 긴급한 상호작용 업데이트와, 대용량 리스트 필터링 등 비긴급 상태 업데이트를 분리 처리하여 앱의 INP(Interaction to Next Paint) 지표를 크게 개선합니다 [5, 12, 15-17].
+
+* **React 19 Compiler와 자동 메모이제이션**
+  2025년 말 안정화된 React Compiler는 빌드 타임에 추상 구문 트리(AST)를 분석하여 데이터 흐름을 파악하고 최적의 위치에 자동으로 메모이제이션 경계를 삽입합니다 [2, 18-21]. 이 컴파일러는 참조 동일성 문제로 발생하는 연쇄적인 리렌더링(Re-render Cascade)을 근본적으로 방지하며, 개발자가 직접 `useMemo`, `useCallback`, `React.memo`를 수동으로 작성해야 하는 인지적 부담을 덜어줍니다 [2, 4, 22, 23]. 정밀한 자동 메모이제이션 덕분에 Meta 내부 테스트에서는 렌더링 횟수가 60% 감소하고 사용자 상호작용 속도가 2.5배 향상되었습니다 [24].
+
+* **React Server Components (RSC) 활용**
+  RSC는 렌더링과 컴포넌트 로직이 서버에서만 배타적으로 실행되는 새로운 아키텍처로, 클라이언트 JavaScript 번들 사이즈에 추가 바이트를 발생시키지 않습니다(0 바이트) [7, 8, 25, 26]. 클라이언트에서 여러 번 발생하는 데이터 페칭 왕복(waterfall)을 유발하는 대신, 서버에서 직접 데이터베이스나 로컬 시스템에 안전하게 접근하여 처리한 뒤, 직렬화된 React 명령(React Flight 프로토콜)과 HTML만을 클라이언트에 스트리밍하여 초기 로딩 속도와 보안을 개선합니다 [27-31].
+
+* **기본적인 성능 최적화 기법**
+  최신 렌더링 기능 외에도, 성능 확보를 위해서는 긴 목록 렌더링 시 가상화를 적용하는 `react-window` 라이브러리 사용, 라우트 단위의 `React.lazy()`를 이용한 코드 분할, 그리고 인라인 객체 및 함수의 불필요한 생성 방지 같은 원칙적인 최적화가 꾸준히 권장됩니다 [32-35].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** `[[Automatic Batching]]`, `[[React Compiler]]`, `[[Concurrent Rendering]]`, `[[React Server Components]]`
+- **Projects/Contexts:** `[[Next.js App Router]]`, `[[Virtual DOM]]`
+- **Contradictions/Notes:** 소스 자료에 따르면 React Compiler가 최적화의 90% 이상을 자동화하고 대부분의 경우 `useMemo`와 `useCallback`을 대체하지만, Effect 종속성을 명시적으로 제어해야 하거나 타사 라이브러리의 참조 안정성이 필수적인 밀리초 단위의 중요한 성능 경로(Critical performance path)에서는 여전히 수동 메모이제이션이 "이스케이프 해치(Escape Hatch)"로 작동해야 한다고 강조합니다 [36-39].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/React 18 Concurrent Features.md b/10_Wiki/Topics/Frontend_Mastery/React 18 Concurrent Features.md
new file mode 100644
index 00000000..0855ae04
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/React 18 Concurrent Features.md	
@@ -0,0 +1,25 @@
+# [[React 18 Concurrent Features]]
+
+## 📌 Brief Summary
+React 18의 동시성 기능(Concurrent Features)은 렌더링 작업을 중단, 일시 중지 및 재개할 수 있도록 하여 애플리케이션의 반응성을 획기적으로 향상시키는 핵심 메커니즘입니다. 이 기능은 긴급한 사용자 상호작용(예: 타이핑, 클릭)과 덜 긴급한 작업(예: 무거운 데이터 필터링)을 분리하여 메인 스레드의 차단을 방지합니다. 결과적으로 연산량이 많은 상황에서도 UI가 멈추지 않고 부드럽게 작동하게 하여 사용자 경험을 개선하고 핵심 웹 지표(Core Web Vitals)를 최적화합니다.
+
+## 📖 Core Content
+
+*   **동시성 렌더링의 기반 (Fiber Architecture & Lane Model):** 
+    React의 동시성 기능은 Fiber 아키텍처의 작업 루프(Work loop)와 타임 슬라이싱(Time-slicing)을 기반으로 작동합니다. 렌더링 작업을 작은 단위로 쪼개어 처리하며, 긴급한 사용자 입력이 발생할 경우 작업을 멈추고 브라우저에 제어권을 양보(Yield)할 수 있습니다 [1-3]. 업데이트의 중요도는 비트마스크 시스템인 'Lane 모델'을 통해 동기적(Sync), 사용자 차단(User-blocking), 기본(Normal), 유휴(Idle) 등의 우선순위 레벨로 관리됩니다 [4-6].
+*   **`useTransition`과 `startTransition`:** 
+    긴급하지 않은 상태 업데이트의 우선순위를 낮추어 UI의 반응성을 유지하는 기능입니다. 타이핑과 동시에 검색 결과를 필터링하는 등의 무거운 연산을 `startTransition`으로 감싸면, React는 사용자의 긴급한 상호작용을 먼저 처리하고 메인 스레드가 여유로울 때 해당 업데이트를 백그라운드에서 처리합니다 [7-9]. 또한 `isPending` 플래그를 제공하여 무거운 작업이 진행되는 동안 사용자에게 시각적 피드백(로딩 상태 등)을 보여줄 수 있습니다 [10].
+*   **`useDeferredValue`:** 
+    상태를 업데이트하는 코드(setState)를 직접 제어할 수 없고 외부(예: Props)에서 값을 받아올 때 렌더링을 지연시키는 훅입니다 [10]. React는 새로운 필터링 결과 등 연산이 완료될 때까지 이전 렌더링 결과를 계속 화면에 표시하여 UI가 얼어붙는(Freezing) 현상을 방지합니다 [11].
+*   **`flushSync`를 통한 강제 동기화:** 
+    동시성 기능이 적용된 상태에서도 DOM 요소에 즉각적으로 포커싱을 하거나 레이아웃을 측정해야 하는 예외적인 상황을 위해 제공되는 API입니다. `flushSync`로 감싼 상태 업데이트는 React가 즉각적이고 동기적으로 렌더링하도록 강제합니다 [8, 9].
+*   **자동 일괄 처리 (Automatic Batching):** 
+    React 18은 Promise, setTimeout, 비동기 작업 및 네이티브 이벤트 핸들러 내에서 연속적으로 발생하는 여러 상태 업데이트를 하나로 묶어 단일 리렌더링으로 처리합니다 [12-14]. 이로 인해 불필요한 Virtual DOM 비교와 렌더링 횟수가 급감하여 애플리케이션 성능이 향상됩니다 [13, 15].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** `[[Fiber Architecture]]`, `[[Automatic Batching]]`, `[[Lane Priority Model]]`, `[[Virtual DOM]]`
+- **Projects/Contexts:** `[[React Performance Optimization]]`, `[[Interaction to Next Paint (INP)]]`
+- **Contradictions/Notes:** 동시성 훅(`useTransition`, `useDeferredValue`)은 코드의 실제 실행 속도를 높여주는 것이 아닙니다. 대신 무거운 연산이 즉각적인 사용자 피드백을 방해하지 않도록 처리 순서를 미뤄, 앱이 시각적으로 더 "빠르게 반응하는 것처럼(feel faster)" 느끼게 만드는 아키텍처적 접근입니다 [16]. 또한 `flushSync`는 남용할 경우 동시성 및 일괄 처리로 얻는 성능 이점을 무효화할 수 있으므로 주의해서 사용해야 합니다 [17].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/React 19.md b/10_Wiki/Topics/Frontend_Mastery/React 19.md
new file mode 100644
index 00000000..0812ca64
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/React 19.md	
@@ -0,0 +1,18 @@
+# [[React 19]]
+
+## 📌 Brief Summary
+React 19는 UI의 반응성을 높이고 성능 최적화를 자동화하는 데 중점을 둔 React의 주요 업데이트 버전입니다 [1, 2]. 이 버전은 빌드 타임에 자동으로 메모이제이션을 수행하는 React Compiler를 도입하여 개발자의 수동 최적화 부담을 크게 줄여줍니다 [3, 4]. 또한, 모든 컴포넌트를 기본적으로 서버 컴포넌트(Server Components)로 처리하여 클라이언트 측 자바스크립트 번들 크기를 획기적으로 줄이고 렌더링 효율을 높이는 패러다임의 전환을 가져왔습니다 [5, 6].
+
+## 📖 Core Content
+- **React Compiler (자동 메모이제이션):** React 19 이상 환경에서 작동하는 React Compiler는 코드의 추상 구문 트리(AST)를 분석하여 데이터 흐름을 추적하고, 반응형 값과 정적 값을 스스로 구분합니다 [3, 4]. 결과적으로 `useMemo`, `useCallback`, `React.memo`와 같은 수동 메모이제이션 래퍼 없이도 자동으로 최적화 경계를 삽입해 불필요한 리렌더링 연쇄를 방지합니다 [3, 7, 8].
+- **동시성 렌더링(Concurrent Rendering) 강화:** `useTransition`과 `useDeferredValue` 같은 훅을 제공하여, 긴급한 UI 업데이트(사용자 입력 등)와 비긴급 업데이트(대용량 리스트 필터링 등)의 우선순위를 분리합니다 [2]. 이를 통해 무거운 연산이 메인 스레드를 블로킹하는 것을 방지하고 애플리케이션의 반응성(INP 등)을 최적의 상태로 유지합니다 [1, 9].
+- **서버 컴포넌트(RSC)의 기본화:** React 19에서는 모든 컴포넌트가 기본적으로 서버 컴포넌트로 동작합니다 [5]. 상호작용이 필요하여 브라우저에서 실행되어야 하는 경우에만 최상단에 `"use client"` 지시어를 명시해 클라이언트 컴포넌트로 선언합니다 [5]. 서버 컴포넌트는 클라이언트로 전송되는 JS 번들 크기를 없애고, 하이드레이션(Hydration) 단계를 생략하게 해 초기 로딩 속도와 성능을 대폭 향상시킵니다 [10-13].
+- **데이터 패칭 및 상태 관리의 진화:** 서버 컴포넌트는 브라우저를 거치지 않고 서버 환경에서 직접 데이터베이스나 파일 시스템에 접근하여 데이터를 가져올 수 있습니다 [14]. 또한 `useOptimistic`, `useActionState`, 프로미스를 직접 다루는 `use` 훅 등을 통해 데이터 패칭 및 비동기 상태 관리를 한층 더 효율적으로 수행할 수 있도록 지원합니다 [15].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[React Compiler]], [[React Server Components (RSC)]], [[Concurrent Rendering]], [[useTransition]], [[useDeferredValue]]
+- **Projects/Contexts:** [[Frontend Performance Optimization]], [[Next.js App Router]]
+- **Contradictions/Notes:** React 19의 React Compiler가 수동 메모이제이션 작업의 90% 이상을 자동으로 처리하지만, 타사 라이브러리와의 통합이나 명시적 제어가 필요한 이펙트 의존성 관리를 위해서는 여전히 `useMemo`나 `useCallback`을 수동으로 사용하는 예외 수단(Escape Hatch)이 필요할 수 있습니다 [16-18].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/React Fiber 아키텍처.md b/10_Wiki/Topics/Frontend_Mastery/React Fiber 아키텍처.md
new file mode 100644
index 00000000..aea4c7c1
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/React Fiber 아키텍처.md	
@@ -0,0 +1,24 @@
+# [[React Fiber 아키텍처]]
+
+## 📌 Brief Summary
+React Fiber는 React 16에서 도입된 조정(reconciliation) 엔진의 완전한 재작성 버전으로, 동시성 렌더링(concurrent rendering)을 지원하기 위해 설계되었습니다 [1, 2]. 기존의 동기식 '스택 조정자(stack reconciler)'가 렌더링 중 메인 스레드를 차단하던 문제를 해결하기 위해, 렌더링 작업을 'Fiber 노드'라는 작은 작업 단위(units of work)로 분할하여 다수의 프레임에 걸쳐 처리합니다 [2, 3]. 이를 통해 우선순위에 따라 렌더링 작업을 일시 중지, 중단, 또는 재개할 수 있는 세밀한 제어와 타임 슬라이싱(time-slicing) 기능을 제공하여 UI의 응답성을 극대화합니다 [3-5].
+
+## 📖 Core Content
+**Fiber 노드와 작업 루프 (Work Loop)**
+React의 각 컴포넌트는 Fiber 노드로 표현되며, 해당 컴포넌트의 타입, 상태(state), 속성(props)뿐만 아니라 부모(return), 자식(child), 형제(sibling) 관계를 나타내는 포인터를 포함합니다 [6-8]. Fiber 아키텍처의 중심에는 작업 루프가 존재하며, 스케줄러를 통해 우선순위와 가용 시간에 따라 다음 작업 단위를 선택하여 순차적으로 처리합니다 [2, 9]. 작업을 수행(`beginWork`, `completeWork`)한 후에는 더 높은 우선순위의 작업(예: 사용자 입력)을 처리하기 위해 브라우저에 제어권을 넘겨야 하는지(yield)를 지속적으로 확인합니다 [6, 9, 10].
+
+**두 단계의 렌더링 프로세스 (Reconciliation Phases)**
+Fiber의 조정 과정은 작업을 중단하고 우선순위를 매기기 위해 두 가지 구별된 단계로 나뉩니다 [4].
+*   **렌더 단계 (Render Phase):** 이 단계는 중단 가능(interruptible)하며, 브라우저의 DOM을 직접 변경하지 않고 메모리 내의 Fiber 트리를 순회하여 순수 계산만을 수행합니다 [4, 11]. 이전 상태와 새로운 상태를 비교하여 DOM 삽입, 삭제, 업데이트 등의 부작용(side effects)이 필요한 노드들을 파악하고, 이를 모아 최적화된 '이펙트 리스트(Effect list)'를 구축합니다 [4, 12, 13]. 더 높은 우선순위 작업이 들어오면 기존 작업을 일시 중지하고, 진행 중이던 작업(WIP, Work-In-Progress)을 저장하거나 폐기 및 재시작할 수 있습니다 [11, 14].
+*   **커밋 단계 (Commit Phase):** 이 단계는 동기적으로 실행되며 중단할 수 없습니다(uninterruptible) [11, 15]. 렌더 단계에서 생성된 이펙트 리스트만을 순회하며 모든 변경 사항을 실제 DOM에 한 번에 적용합니다 [12, 15]. 이 과정에서 `useLayoutEffect`와 같은 동기적 레이아웃 효과와 비동기적인 `useEffect`가 함께 실행됩니다 [11, 15, 16].
+
+**우선순위와 레인 모델 (Priority Levels and Lane Model)**
+Fiber는 여러 동시 작업을 관리하기 위해 32비트 정수 비트마스크를 활용한 '레인(Lane)'이라는 정교한 우선순위 모델을 사용합니다 [13, 17]. 타이핑이나 클릭과 같은 이산적인 사용자 입력은 즉시 처리되어야 하는 가장 높은 우선순위(Sync Lane)를 부여받고, 스크롤이나 호버 등의 연속적 입력은 그 다음 높은 우선순위를 갖습니다 [18, 19]. 반면 화면에 보이지 않는 오프스크린 렌더링이나 데이터 로깅 작업은 유휴(Idle) 상태에 처리되도록 낮은 우선순위가 할당됩니다 [18, 19]. 이 모델을 통해 React는 여러 우선순위가 섞인 업데이트를 효율적으로 관리하고, 지연된 작업이 영원히 실행되지 않는 기아 상태(starvation)를 방지하며 항상 쾌적한 반응성을 유지할 수 있습니다 [17, 20].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Concurrent Rendering]], [[Reconciliation]], [[Virtual DOM]]
+- **Projects/Contexts:** [[React 16]], [[Time-Slicing]]
+- **Contradictions/Notes:** 소스에 관련 정보가 부족합니다.
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/React Flight Protocol.md b/10_Wiki/Topics/Frontend_Mastery/React Flight Protocol.md
new file mode 100644
index 00000000..35251d59
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/React Flight Protocol.md	
@@ -0,0 +1,17 @@
+# [[React Flight Protocol]]
+
+## 📌 Brief Summary
+React Flight Protocol은 React Server Components(RSC)가 서버에서 렌더링된 결과를 클라이언트에게 전달할 때 사용하는 직렬화된 React 명령어 통신 규약입니다 [1]. 이 프로토콜은 무거운 전체 자바스크립트 코드를 전송하는 대신, 클라이언트의 React가 UI 조각들을 어떻게 결합해야 하는지 알려주는 가벼운 형태의 '청사진 언어(blueprint language)' 역할을 합니다 [1]. 비유하자면 브라우저에게 반쯤 조립된 가구와 함께, 빠진 상호작용 부품을 어떻게 끼워 넣는지 적힌 작은 조립 설명서를 보내는 것과 같습니다 [1].
+
+## 📖 Core Content
+- **직렬화된 명령어와 HTML의 결합**: React Server Components는 단순히 순수한 HTML만을 브라우저에 출력하지 않습니다. 정적인 부분을 위한 HTML과 함께, 클라이언트 측에서 각 요소들을 어떻게 꿰매어 연결할지(stitch together) 지시하는 직렬화된 React 명령어를 생성하는데, 이 과정이 바로 React Flight 프로토콜을 통해 이루어집니다 [1].
+- **클라이언트 자바스크립트 전송 최소화**: 브라우저에 컴포넌트를 위한 전체 자바스크립트 번들을 보내는 대신, React Flight 프로토콜은 브라우저 내의 React가 여러 UI 조각들을 어떻게 맞추고 조립해야 하는지 알려주는 매우 가벼운 지침(instructions)만을 전달하여 통신과 렌더링을 최적화합니다 [1].
+- **상세 원리 한계**: 제공된 소스 내에서는 React Flight Protocol이 어떤 데이터 포맷을 사용하는지 등의 더 깊은 기술적 명세에 대해서는 다루고 있지 않습니다. 따라서 소스에 관련 정보가 부족합니다.
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[React Server Components]], [[Serialized React Instructions]]
+- **Projects/Contexts:** [[Modern React Architecture]], [[React 19]]
+- **Contradictions/Notes:** 소스 간의 모순점은 발견되지 않았으나, React Flight Protocol 자체의 심층적인 구조나 동작 방식에 대해서는 소스에 관련 정보가 부족합니다.
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/React Frontend Development.md b/10_Wiki/Topics/Frontend_Mastery/React Frontend Development.md
new file mode 100644
index 00000000..92306ca0
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/React Frontend Development.md	
@@ -0,0 +1,35 @@
+# [[React Frontend Development]]
+
+## 📌 Brief Summary
+React는 가상 DOM(Virtual DOM)과 컴포넌트 기반 아키텍처(CBA)를 활용하여 사용자 인터페이스를 효율적이고 선언적으로 구축하는 프론트엔드 라이브러리입니다 [1-3]. 브라우저의 비용이 많이 드는 Reflow와 Repaint 작업을 최소화하기 위해 '재조정(Reconciliation)' 알고리즘을 사용하며, 최신 버전에서는 Fiber 아키텍처와 자동 메모이제이션(React Compiler)을 통해 렌더링 성능을 극대화합니다 [1, 3-5]. 또한, 애플리케이션의 특성에 맞춰 CSR, SSR, SSG 및 React Server Components(RSC) 등 다양한 렌더링 전략을 지원하여 초기 로딩 속도, SEO, 상호작용(Interactivity)의 균형을 맞춥니다 [6-9].
+
+## 📖 Core Content
+*   **브라우저 렌더링 과정 (CRP) 및 비용 최소화**
+    브라우저의 중요 렌더링 경로(Critical Rendering Path)는 HTML과 CSS를 파싱하여 DOM과 CSSOM 트리를 생성하고, 이를 결합해 렌더 트리(Render Tree)를 만듭니다 [10, 11]. 이후 요소의 정확한 위치와 크기를 계산하는 레이아웃(Reflow) 단계와 화면에 픽셀을 그리는 페인트(Repaint) 단계를 거칩니다 [12, 13]. Reflow는 연산 비용이 매우 높으며, 잦은 Reflow와 Repaint는 성능 저하를 유발하므로 DOM 접근과 조작을 최소화하는 것이 필수적입니다 [14-16].
+
+*   **Virtual DOM 및 재조정 (Reconciliation)**
+    실제 DOM의 직접적인 조작으로 인한 성능 저하를 막기 위해, React는 메모리에 가벼운 UI 표현인 Virtual DOM을 유지합니다 [1, 3]. 상태가 변경되면 새로운 Virtual DOM을 생성하고 이전 트리와 비교(Diffing)하여 변경된 부분만 실제 DOM에 업데이트합니다 [1, 3]. 이 재조정 알고리즘은 요소의 타입 비교 및 리스트의 `key` 속성을 활용해 $O(n^3)$의 복잡도를 $O(n)$으로 최적화합니다 [17-20].
+
+*   **React Fiber 아키텍처와 동시성 렌더링 (Concurrent Rendering)**
+    React 16에 도입된 Fiber 아키텍처는 렌더링 작업을 'Fiber 노드'라는 작은 작업 단위로 분할하여 동시성 렌더링을 가능하게 합니다 [21-23]. 우선순위 기반 모델(Lane Model)과 시간 분할(Time-Slicing)을 적용하여, 사용자의 입력(타이핑, 클릭 등)과 같은 긴급한 작업이 들어오면 무거운 렌더링 작업을 잠시 중단(Yield)하고 메인 스레드를 비워두어 UI의 반응성을 유지합니다 [22, 24-26].
+
+*   **컴포넌트 기반 아키텍처 (Component-Based Architecture)**
+    애플리케이션을 독립적이고 재사용 가능한 컴포넌트 단위로 분할하여 구축합니다 [27-29]. 각 컴포넌트는 자체 로직과 UI 상태를 캡슐화하여 렌더링하므로 유지보수성과 확장성이 높으며, 다른 프로젝트에서도 재사용하기 쉽습니다 [30-32].
+
+*   **렌더링 전략: CSR vs SSR vs SSG vs RSC**
+    *   **CSR (Client-Side Rendering):** 서버에서 빈 HTML을 받고 브라우저가 JavaScript를 다운로드하여 UI를 그립니다. 동적 상호작용에 유리하지만, JS 다운로드 전까지 화면이 보이지 않아 초기 로딩과 SEO에 불리합니다 [6, 33-35].
+    *   **SSR (Server-Side Rendering):** 서버에서 HTML을 미리 렌더링하여 전송하므로 초기 콘텐츠 표시가 빠르고 SEO에 유리합니다 [7, 36, 37]. 이후 브라우저에서 JS를 연결해 상호작용을 가능하게 하는 수화(Hydration) 과정을 거칩니다 [7, 36, 38].
+    *   **SSG (Static Site Generation):** 빌드 타임에 HTML을 생성하여 CDN으로 배포하므로 로딩 속도가 가장 빠릅니다 [8, 39].
+    *   **React Server Components (RSC):** 서버에서만 렌더링되며 클라이언트로 JavaScript 번들을 전혀 보내지 않습니다 [9, 40]. 번들 크기를 줄이고 서버 데이터베이스에 직접 접근할 수 있으며, 상호작용이 필요한 곳에만 Client Component를 혼합해 사용할 수 있습니다 [41-43].
+
+*   **최신 렌더링 최적화 기법 (React 18 & 19)**
+    *   **자동 배칭 (Automatic Batching):** React 18부터는 이벤트 핸들러뿐만 아니라 Promise, setTimeout 등 비동기 작업 내의 여러 상태 업데이트를 하나로 묶어(Batching) 단일 리렌더링만 유발합니다 [44-46].
+    *   **React Compiler:** React 19에 도입된 빌드 타임 최적화 도구로, 개발자가 수동으로 작성하던 `useMemo`, `useCallback`을 제거하고 AST를 분석해 자동으로 메모이제이션 경계를 삽입합니다 [5, 47-49]. 이를 통해 불필요한 연산과 리렌더링을 지능적으로 방지합니다 [49, 50].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Virtual DOM]], [[Critical Rendering Path (CRP)]], [[React Fiber]], [[Component-Based Architecture]], [[Client-Side Rendering (CSR)]], [[Server-Side Rendering (SSR)]], [[React Server Components (RSC)]]
+- **Projects/Contexts:** [[Next.js]], [[Single-Page Applications (SPA)]]
+- **Contradictions/Notes:** React Compiler의 도입으로 `React.memo`, `useMemo`, `useCallback`과 같은 수동 메모이제이션이 90% 이상 불필요해졌으나, 서드파티 라이브러리의 불안정한 객체 참조를 다루거나 특정 Effect 의존성을 명시적으로 제어해야 하는 경우에는 여전히 탈출구(Escape Hatch)로써 수동 메모이제이션의 사용이 필요할 수 있습니다 [51-53].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/React 기반 대규모 웹 애플리케이션 최적화.md b/10_Wiki/Topics/Frontend_Mastery/React 기반 대규모 웹 애플리케이션 최적화.md
new file mode 100644
index 00000000..b1c10ec8
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/React 기반 대규모 웹 애플리케이션 최적화.md	
@@ -0,0 +1,31 @@
+# [[React 기반 대규모 웹 애플리케이션 최적화]]
+
+## 📌 Brief Summary
+React 기반 대규모 웹 애플리케이션 최적화는 브라우저의 렌더링 과정(CRP)과 React의 가상 DOM(Virtual DOM) 및 재조정(Reconciliation) 메커니즘을 이해하여 불필요한 연산과 DOM 변경을 최소화하는 전략입니다 [1-3]. 이를 위해 메모이제이션, 코드 스플리팅, 가상화(Virtualization) 등의 클라이언트 측 기법과, Fiber 아키텍처를 통한 동시성 렌더링(Concurrent Rendering)을 활용하여 UI 응답성을 유지합니다 [4-7]. 또한, SSR, SSG와 같은 렌더링 방식과 React 서버 컴포넌트(RSC) 및 React Compiler를 결합하여 자바스크립트 번들 크기를 대폭 줄이고 초기 로딩 속도와 상호작용성을 극대화합니다 [8-11].
+
+## 📖 Core Content
+
+*   **브라우저 렌더링 과정과 Reflow/Repaint 최소화**
+    브라우저는 HTML과 CSS를 파싱하여 DOM과 CSSOM을 생성하고, 이를 결합하여 화면에 표시될 렌더 트리(Render Tree)를 구축합니다 [3, 12-14]. 이후 요소의 정확한 크기와 위치를 계산하는 레이아웃(Reflow) 단계와 화면에 픽셀을 그리는 페인트(Repaint) 단계를 거칩니다 [15-18]. 리플로우는 계산 비용이 매우 높아 성능 저하의 주원인이 되므로, 불필요한 DOM 깊이를 줄이고 DOM 상호작용을 최소화해야 합니다 [19-21]. 애니메이션 처리 시 `top`이나 `left` 대신 `transform`과 같이 GPU 가속을 지원하는 속성을 사용하면 리플로우와 리페인트를 최소화하여 프레임 드롭(Jank)을 방지할 수 있습니다 [16, 22, 23].
+
+*   **가상 DOM(Virtual DOM)과 재조정(Reconciliation)**
+    React는 실제 DOM을 직접 조작하는 대신, 가벼운 메모리 내 표현인 가상 DOM을 사용하여 UI 상태를 선언적으로 관리합니다 [2, 24, 25]. 상태가 변경되면 React는 이전 가상 DOM 트리와 새로운 트리를 비교(Diffing)하여 실제 DOM에 필요한 최소한의 업데이트만 반영합니다 [2, 26]. 이 과정에서 React는 O(n) 복잡도의 휴리스틱 알고리즘을 사용하며, 요소의 타입이 다르면 트리를 완전히 새로 구축하고, 동일한 타입의 리스트 컴포넌트는 고유한 `key` 속성을 통해 요소의 이동 여부를 식별하여 불필요한 재생성을 방지합니다 [27-29].
+
+*   **Fiber 아키텍처와 동시성 렌더링(Concurrent Rendering)**
+    기존의 동기식 렌더링은 대규모 컴포넌트 트리를 처리할 때 메인 스레드를 블로킹하여 UI 응답성을 떨어뜨렸습니다 [30]. 이를 해결하기 위해 도입된 Fiber 아키텍처는 렌더링 작업을 '작업 단위(Unit of Work)'로 나누어 타임 슬라이싱(Time-slicing)을 가능하게 합니다 [30, 31]. 렌더 단계는 중단 및 재개가 가능하며, 차선(Lane) 기반 우선순위 모델을 통해 사용자 입력과 같은 긴급한 작업을 렌더링 계산보다 먼저 처리할 수 있습니다 [32-34]. React 19의 `useTransition` 및 `useDeferredValue` 훅을 활용하면 무거운 계산 상태 업데이트의 우선순위를 낮추어 메인 스레드를 차단하지 않고 대규모 데이터를 부드럽게 처리할 수 있습니다 [5, 35, 36].
+
+*   **자동 일괄 처리(Automatic Batching)와 React Compiler**
+    React 18에 도입된 자동 일괄 처리는 Promise나 setTimeout 같은 비동기 콜백 내의 여러 상태 업데이트를 단일 리렌더링으로 묶어 렌더링 횟수를 대폭 줄입니다 [37-39]. 나아가 React 19부터 안정화된 React Compiler는 빌드 타임에 AST(추상 구문 트리)를 분석하여 컴포넌트와 값의 의존성을 파악하고, `useMemo`, `useCallback`, `React.memo`와 같은 수동 메모이제이션을 자동으로 삽입합니다 [10, 11, 40]. 이를 통해 불필요한 렌더링 전파(Re-render Cascade)를 차단하고, 수동 최적화의 복잡성과 오류를 근본적으로 제거합니다 [10, 41, 42].
+
+*   **컴포넌트 렌더링 전략 (CSR, SSR, SSG) 및 서버 컴포넌트(RSC)**
+    대규모 애플리케이션에서는 페이지의 특성에 따라 렌더링 전략을 혼합(Hybrid)하여 사용합니다 [43, 44].
+    *   **CSR/SSR/SSG:** 클라이언트 사이드 렌더링(CSR)은 로드 후 상호작용성이 좋으나 초기 속도가 느리고 SEO에 불리하며, 서버 사이드 렌더링(SSR)과 정적 사이트 생성(SSG)은 초기 로딩(FCP)과 SEO에 유리하지만 SSR의 경우 하이드레이션(Hydration) 완료 전까지 상호작용(TTI)이 지연되는 단점이 있습니다 [8, 45-48].
+    *   **React 서버 컴포넌트 (RSC):** RSC는 서버에서 독점적으로 렌더링되며 클라이언트로 자바스크립트 번들을 전혀 보내지 않습니다 [9, 49, 50]. 데이터베이스나 파일 시스템에 직접 접근할 수 있어 클라이언트-서버 간 불필요한 API 호출을 줄입니다 [51-53]. 대규모 앱에서는 읽기 전용 UI를 서버 컴포넌트로 처리하고, 상태나 이벤트 핸들러가 필요한 요소만 `use client` 지시어를 통해 클라이언트 컴포넌트로 분리함으로써 번들 크기를 극적으로 줄이고 성능을 최적화할 수 있습니다 [51, 54, 55].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Critical Rendering Path]], [[Virtual DOM]], [[Reconciliation]], [[Fiber Architecture]], [[React Server Components]], [[React Compiler]], [[Automatic Batching]]
+- **Projects/Contexts:** [[초기 로딩 및 SEO 최적화가 필수적인 대규모 이커머스 및 콘텐츠 플랫폼]], [[수천 개의 리스트와 실시간 데이터 처리가 필요한 대형 SaaS 대시보드 애플리케이션]]
+- **Contradictions/Notes:** 수동 메모이제이션(`React.memo`, `useMemo`)은 리렌더링을 방지할 수 있지만 참조 객체 저장 및 비교 연산에 따른 자체적인 오버헤드가 발생하므로 모든 컴포넌트에 무분별하게 적용하는 것은 오히려 성능을 저하시키는 안티 패턴입니다 [42, 56]. 그러나 최신 React Compiler가 적용된 환경에서는 이러한 최적화 판단과 메모이제이션 삽입이 빌드 타임에 자동으로 이루어지므로 개발자가 수동으로 제어할 필요성이 크게 줄어들었습니다 [11, 57]. 또한, SSR은 빠른 초기 화면(FCP)을 제공하지만 하이드레이션 병목 현상으로 인해 상호작용(TTI)까지 지연 시간이 발생할 수 있으므로 주의가 필요합니다 [45, 48].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/React 동시성 훅 (useTransition, useDeferredValue).md b/10_Wiki/Topics/Frontend_Mastery/React 동시성 훅 (useTransition, useDeferredValue).md
new file mode 100644
index 00000000..9b823cf4
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/React 동시성 훅 (useTransition, useDeferredValue).md	
@@ -0,0 +1,25 @@
+# [[React 동시성 훅 (useTransition, useDeferredValue)]]
+
+## 📌 Brief Summary
+React의 동시성 훅(Concurrent Hooks)인 `useTransition`과 `useDeferredValue`는 긴급한 업데이트와 비긴급 업데이트를 분리하여 UI의 응답성을 유지하는 데 사용되는 도구입니다 [1]. 이 훅들은 연산 속도 자체를 높이는 것이 아니라 무거운 연산이 메인 스레드를 차단하는 것을 방지함으로써 애플리케이션의 체감 속도를 높여줍니다 [2]. 결과적으로 사용자 피드백을 즉각적으로 처리하게 하여 INP(Interaction to Next Paint)와 같은 성능 지표를 개선하는 데 핵심적인 역할을 합니다 [3].
+
+## 📖 Core Content
+* **동시성 렌더링의 원리 및 효과:**
+  React의 동시성 기능은 타이핑이나 클릭 같은 '긴급한 상호작용'과 대규모 리스트 필터링이나 차트 재계산 같은 '비긴급 업데이트'를 분리합니다 [1]. 이 기능은 React의 우선순위 시스템인 'Lane 모델'을 기반으로 작동하며, 특정 업데이트를 낮은 우선순위로 표시하여 UI의 응답성을 유지할 수 있게 합니다 [4]. 이 훅들을 사용하면 메인 스레드가 긴급한 사용자 상호작용에 즉시 대응할 수 있으므로, INP 점수를 낮추는 데 직접적으로 기여합니다 [3].
+
+* **useTransition (비차단 상태 업데이트):**
+  `useTransition`은 개발자가 상태 업데이트 코드를 직접 제어할 수 있을 때 사용합니다 [3]. 상태 변경 함수(`setState` 등)를 `startTransition`으로 감싸면, 해당 업데이트를 낮은 우선순위로 처리하여 메인 스레드가 여유로워질 때까지 연산을 지연시킵니다 [1, 3].
+  * 주로 사용자가 타이핑할 때마다 검색 결과를 필터링하는 패턴이나, 데이터가 많은 애플리케이션에서의 탭 전환 등에 매우 효과적입니다 [1].
+  * `isPending`이라는 플래그를 함께 제공하여, 무거운 연산이 백그라운드에서 실행되는 동안 사용자에게 즉각적인 시각적 피드백(예: 로딩 상태)을 줄 수 있습니다 [5].
+
+* **useDeferredValue (무거운 렌더링 지연):**
+  `useDeferredValue`는 외부 스토어나 부모 컴포넌트에서 props로 전달받는 등 상태 업데이트 코드를 직접 제어할 수 없을 때 상태 값 자체를 감싸기 위해 사용합니다 [3, 5].
+  * 무거운 렌더링을 처리하는 동안 UI가 멈추는(freezing) 현상을 방지하기 위해, React는 새로운 결과가 준비될 때까지 화면에 이전 결과를 계속 표시합니다 [3].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[React Fiber Architecture]], [[Lane Model]], [[INP (Interaction to Next Paint)]]
+- **Projects/Contexts:** [[검색어 입력 필터링 (Search-as-you-type)]], [[데이터 집약적 대시보드의 탭 전환]]
+- **Contradictions/Notes:** 동시성 훅(`useTransition`)과 디바운싱(Debouncing)은 불필요한 작업을 줄여준다는 공통점이 있지만 목적이 다릅니다. 컴포넌트 수준에서 UI 업데이트를 지연시키는 데는 React 네이티브 방식인 `useTransition`이 더 적합한 반면, 잦은 API 호출 빈도를 낮추는 데는 여전히 디바운싱 기법을 사용하는 것이 최선입니다 [6].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/React 성능 최적화 (React Performance Optimization).md b/10_Wiki/Topics/Frontend_Mastery/React 성능 최적화 (React Performance Optimization).md
new file mode 100644
index 00000000..7ed0e48a
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/React 성능 최적화 (React Performance Optimization).md	
@@ -0,0 +1,29 @@
+# [[React 성능 최적화 (React Performance Optimization)]]
+
+## 📌 Brief Summary
+React 성능 최적화는 불필요한 연산과 재렌더링을 최소화하고 브라우저의 중요 렌더링 경로(Critical Rendering Path)를 효율적으로 관리하여 애플리케이션의 속도 및 응답성을 극대화하는 과정이다 [1, 2]. 이는 렌더링 계단식(Re-render Cascade) 문제 해결, 초기 번들 크기 감소, 리플로우(Reflow) 및 리페인트(Repaint) 제어를 주요 목표로 삼는다 [3-6]. 최근에는 React 18의 자동 배칭(Automatic Batching)과 React 19 컴파일러의 자동 메모이제이션 도입으로 인해, 개발자의 수동 최적화 부담이 크게 줄어들고 프레임워크 및 빌드 타임 레벨에서 성능 향상이 이루어지는 추세이다 [7-9].
+
+## 📖 Core Content
+
+*   **불필요한 재렌더링 방지 및 가상 DOM 최적화**
+    부모 컴포넌트의 상태가 변경될 때 모든 자식 컴포넌트가 재렌더링되는 '렌더링 계단식' 문제는 성능 저하의 주된 원인이다 [3, 10]. 이를 방지하기 위해 기존에는 `React.memo`, `useMemo`, `useCallback`과 같은 수동 메모이제이션 기법을 사용하여 참조(Reference)의 동등성을 유지하고 불필요한 비교(Diffing) 연산을 차단했다 [11-13]. 또한, React 18에 도입된 자동 배칭(Automatic Batching)은 이벤트 핸들러뿐만 아니라 Promise나 `setTimeout` 같은 비동기 작업 내의 여러 상태 업데이트를 단일 렌더링으로 묶어주어 가상 DOM 작업과 렌더링 횟수를 획기적으로 줄여준다 [7, 14, 15].
+
+*   **빌드 타임 최적화: React 컴파일러(React Compiler)**
+    React 19 컴파일러는 애플리케이션 코드를 구문 분석(AST)하여 정적 값과 반응형 값을 자동으로 식별하고, 최적의 위치에 메모이제이션 경계를 삽입하는 빌드 타임 도구이다 [8, 9, 16, 17]. 이를 통해 개발자가 수동으로 의존성 배열을 관리하며 겪는 과도한 메모이제이션(Over-memoization)이나 누락 문제를 해결하고, 값이 변경된 특정 부분만 렌더링하는 세밀한 반응성(Fine-Grained Reactivity)을 달성하여 성능 최적화 작업의 90%를 제거한다 [18-20].
+
+*   **동시성 렌더링과 파이버(Fiber) 아키텍처**
+    React 16부터 도입된 파이버 아키텍처는 동기적으로 블로킹되던 기존 렌더링 방식을 벗어나, 렌더링 작업을 작은 단위로 나누고(Time-slicing) 우선순위(Lane model)를 부여하여 중단 및 재개가 가능하도록 만들었다 [21-24]. 이를 기반으로 하는 `useTransition` 및 `useDeferredValue` 훅을 사용하면, 무거운 데이터 필터링이나 화면 전환 같은 비긴급 업데이트의 우선순위를 낮춤으로써 타이핑과 같은 긴급한 상호작용이 지연 없이 처리되도록 하여 UI의 응답성(INP 개선)을 높일 수 있다 [25-28].
+
+*   **브라우저 렌더링 최적화: Reflow와 Repaint 최소화**
+    React가 가상 DOM을 업데이트한 후, 브라우저가 화면을 그리는 과정에서 레이아웃 계산(Reflow)과 시각적 업데이트(Repaint)는 큰 비용을 수반한다 [5, 6, 29]. 렌더링 성능을 개선하려면 React Fragment를 사용해 불필요한 DOM 노드 래퍼를 줄이고 DOM의 깊이를 얕게 유지해야 한다 [30, 31]. 100개가 넘어가는 긴 리스트의 경우 화면에 보이는 노드만 렌더링하는 가상화(Virtualization) 라이브러리를 도입하여 다중 노드 생성 비용을 극적으로 줄일 수 있다 [32, 33]. 더불어 애니메이션 구현 시 레이아웃을 다시 계산하는 속성 대신 `transform` 속성 등을 활용해 GPU 가속을 적용하면 리플로우를 피할 수 있다 [34-36].
+
+*   **번들 사이즈 제어 및 렌더링 전략 고도화**
+    초기 로딩 속도(LCP)를 개선하려면 다운로드해야 할 JavaScript 번들 크기를 최소화해야 한다. `React.lazy()`를 활용한 라우트 레벨의 코드 스플리팅을 적용하면 초기 번들 크기를 30~50%가량 줄일 수 있다 [37]. 한 걸음 더 나아가 서버에서만 실행되는 React Server Components(RSC)를 활용하면 무거운 라이브러리나 정적 데이터 페칭 로직이 브라우저로 전송되지 않아 JavaScript 번들 크기를 '0 바이트'에 가깝게 줄이고 수화(Hydration) 비용을 완전히 제거할 수 있다 [38-40].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Virtual DOM (가상 DOM)]], [[Critical Rendering Path (중요 렌더링 경로)]], [[React Compiler (React 컴파일러)]], [[React Server Components (RSC)]], [[Concurrent Rendering (동시성 렌더링)]]
+- **Projects/Contexts:** [[코어 웹 바이탈(Core Web Vitals) 개선 프로젝트]], [[프론트엔드 컴포넌트 기반 아키텍처(CBA) 구축]]
+- **Contradictions/Notes:** React 18의 자동 배칭(Automatic Batching) 기능은 기본적으로 활성화되어 렌더링 최적화에 기여하지만, 사용자가 즉각적인 시각적 피드백(예: 입력 포커스, 폼 값 즉각 업데이트)을 필요로 하는 경우에는 `flushSync` API를 사용하여 의도적으로 배칭을 우회하고 동기적 렌더링을 강제해야 한다 [28, 41, 42]. 한편 기존 React 생태계에서는 `useMemo`와 같은 수동 최적화가 필수적이었으나, React 컴파일러 도입 이후에는 이들이 불필요해지며 의도적인 제어나 서드파티 라이브러리 대응과 같은 예외적 상황에서만 사용하는(Escape Hatch) 방식으로 패러다임이 바뀌고 있다 [19, 43-45].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/React 컴파일러 (React Compiler).md b/10_Wiki/Topics/Frontend_Mastery/React 컴파일러 (React Compiler).md
new file mode 100644
index 00000000..2374ab18
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/React 컴파일러 (React Compiler).md	
@@ -0,0 +1,19 @@
+# [[React 컴파일러 (React Compiler)]]
+
+## 📌 Brief Summary
+React 컴파일러(React Compiler, 이전 명칭 'React Forget')는 빌드 타임에 React 애플리케이션을 자동으로 최적화해주는 도구이다 [1-4]. 개발자가 수동으로 작성하던 `useMemo`, `useCallback`, `React.memo` 등의 메모이제이션 작업을 컴파일러가 코드를 분석하여 필요한 곳에 자동으로 삽입한다 [2, 3]. 이를 통해 불필요한 리렌더링을 방지하고 코드의 가독성을 높이며, 메모이제이션 누락이나 오용으로 인한 성능 저하를 효과적으로 해결한다 [4-6].
+
+## 📖 Core Content
+- **작동 원리**: React 컴파일러는 Babel 또는 SWC 플러그인 형태로 동작하며 빌드 단계에서 코드를 변환한다 [7-9]. Abstract Syntax Tree(AST)를 분석하여 데이터 흐름을 추적하고, 각 값을 정적(Static), 반응형(Reactive), 파생(Derived)으로 분류한 뒤 최적의 위치에 메모이제이션 경계를 자동으로 삽입한다 [1, 10, 11]. 단순히 전체 컴포넌트를 캐싱하는 것을 넘어, 개별 JSX 요소와 내부 계산 작업까지 세밀하게(granular) 최적화하는 것이 특징이다 [12, 13].
+- **주요 장점**: 수동 메모이제이션이 유발하는 개발자의 인지적 부담과 '의존성 배열 지옥(Dependency Array Hell)'을 제거하여 코드를 깔끔하게 유지할 수 있다 [2, 6, 13]. 실제 프로덕션 환경(Meta, Sanity Studio, Wakelet 등)에서 적용한 결과 초기 로드 시간 단축, 상호작용 지연 시간(INP) 개선, 리렌더링 횟수 60% 감소 등의 괄목할 만한 성능 향상이 입증되었다 [14-16].
+- **단점 및 한계**: 일부 서드파티 라이브러리(예: TanStack Query 등 렌더링마다 의도적으로 새로운 객체를 반환하는 훅)와 호환성 문제가 발생하여 컴파일러의 최적화가 무력화될 수 있다 [17]. 또한, 내부 동작이 블랙박스처럼 처리되어 예기치 않은 리렌더링 발생 시 원인 규명과 디버깅이 더 까다로워질 수 있으며, React의 기본 원칙(Rules of React)을 다수 위반한 레거시 코드베이스에서는 곧바로 도입하기 어렵다 [18-20].
+- **도입 및 마이그레이션 전략**: 모든 코드에 일괄 적용할 필요 없이 특정 디렉터리부터 시작하거나 `'use compiler'` 지시어를 사용하여 파일 단위로 점진적인 도입이 가능하다 [21, 22]. 컴파일러 적용 전 ESLint 플러그인을 사용하여 React 규칙 위반 사항을 식별하고 수정하는 것이 적극 권장된다 [18, 22].
+- **수동 메모이제이션의 잔존 필요성**: 컴파일러가 대부분의 최적화를 자동으로 처리하지만, 이펙트(Effect)의 의존성 제어나 안정적인 참조가 필수적인 서드파티 라이브러리 연동 등 명시적인 제어가 필요한 상황(Escape Hatch)에서는 여전히 `useMemo` 및 `useCallback`을 사용해야 한다 [23-26]. 
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[메모이제이션 (Memoization)]], [[빌드 타임 최적화 (Build-Time Optimization)]], [[리렌더링 (Re-rendering)]]
+- **Projects/Contexts:** [[Meta 프로덕션 앱 (Instagram, Quest Store)]], [[Sanity Studio]], [[Next.js 및 Vite 통합]]
+- **Contradictions/Notes:** 소스에 따르면 React 컴파일러가 적용된 컴포넌트는 React DevTools에서 `Memo ✨` 배지가 표시되지만, 이것이 항상 최적화의 성공을 의미하는 것은 아니다 [17, 27]. 속성에 인라인 객체나 함수 등 불안정한 참조가 전달될 경우, 배지가 있더라도 부모 컴포넌트 업데이트 시 여전히 리렌더링이 발생할 수 있으므로 주의해야 한다 [17].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/Reflow & Repaint.md b/10_Wiki/Topics/Frontend_Mastery/Reflow & Repaint.md
new file mode 100644
index 00000000..935f7178
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Reflow & Repaint.md	
@@ -0,0 +1,34 @@
+# [[Reflow & Repaint]]
+
+## 📌 Brief Summary
+리플로우(Reflow)는 브라우저가 렌더 트리를 기반으로 문서 내 요소들의 정확한 위치와 크기(기하학적 구조)를 계산하여 배치하는 과정이며, 리페인트(Repaint)는 계산된 레이아웃을 바탕으로 화면에 실제 픽셀을 그리는 시각적 업데이트 과정이다 [1-6]. 리플로우는 요소의 추가/삭제나 크기 변경 시 발생하며 계산 비용이 매우 높은 반면, 리페인트는 배경색이나 그림자 등 시각적 속성만 변경될 때 발생한다 [5-7]. 이 두 과정은 브라우저의 중요 렌더링 경로(Critical Rendering Path)의 핵심 단계로, 과도하게 발생할 경우 브라우저 성능 저하와 화면 끊김(Jank) 현상을 유발하므로 웹 프론트엔드 성능 최적화에 있어 필수적으로 관리해야 하는 요소이다 [5, 8-10].
+
+## 📖 Core Content
+
+**렌더링 파이프라인 내의 역할**
+브라우저는 수신된 HTML과 CSS를 파싱하여 DOM(Document Object Model)과 CSSOM을 구축한 후, 가시적인 콘텐츠만 포함하는 렌더 트리(Render Tree)를 생성한다 [11-14]. 이 렌더 트리가 완성되면 요소들을 화면에 나타내기 위해 리플로우(Layout)와 리페인트(Paint) 단계가 순차적으로 실행된다 [1, 13].
+
+**리플로우 (Reflow / Layout)**
+*   리플로우는 렌더 트리의 루트부터 아래로 탐색하며 뷰포트 크기와 박스 모델을 기반으로 모든 표시되는 요소의 정확한 너비, 높이, x/y 위치 좌표를 계산하는 과정이다 [1, 3, 7, 15].
+*   HTML 요소들은 연속적인 문서 흐름의 일부이기 때문에, 특정 요소 하나의 기하학적 변화만으로도 트리 전체에 걸친 연쇄적인 재계산(Cascade of recalculations)을 유발할 수 있다 [1, 5, 16].
+*   브라우저 창 크기 조절, DOM 노드의 추가 및 제거, `width`, `height`, `margin`, `padding` 등의 레이아웃 관련 속성을 조작할 때 발생한다 [5, 7, 17, 18].
+*   이는 매우 계산 집약적인 작업이며, 실행되는 동안 브라우저 메인 스레드에서 사용자의 상호작용을 차단(User-blocking)할 수 있다 [5, 7, 16].
+
+**리페인트 (Repaint / Paint)**
+*   레이아웃 계산이 완료된 후, 기하학적 구조와 스타일을 바탕으로 텍스트, 색상, 그림자 등의 시각적 요소를 화면에 픽셀로 래스터화(Rasterize)하여 그리는 단계이다 [2, 4, 6, 7].
+*   `background-color`, `box-shadow`, `visibility`, 텍스트 색상 등 레이아웃이나 요소의 크기에 영향을 주지 않는 시각적인 속성만 변경될 때 독립적으로 발생한다 [6, 7, 18].
+*   기하학적 계산을 수반하지 않기 때문에 리플로우보다는 계산 비용이 적게 들지만, 시각적 변경이 과도하게 발생할 경우 (예: 배경색 애니메이션) 렌더링 파이프라인을 방해하여 프레임 드롭(Jank)을 일으킬 수 있다 [2, 19, 20].
+
+**성능 최적화 전략**
+*   **불필요한 연산 최소화:** DOM 트리의 깊이를 줄이고, 복잡한 CSS 선택자(특히 자손 선택자)나 사용하지 않는 CSS 규칙을 제거하여 브라우저의 매칭 및 계산 부담을 줄여야 한다 [21, 22].
+*   **배칭(Batching) 및 레이아웃 스래싱 방지:** DOM 변경 사항을 가급적 일괄 처리하고, 리플로우를 유발하는 속성을 읽고 쓰는 작업을 코드 내에서 번갈아 실행하여 발생하는 '레이아웃 스래싱(Layout thrashing)' 현상을 피해야 한다 [7, 10, 23].
+*   **문서 흐름 분리:** 복잡한 렌더링 변경이나 애니메이션을 수행할 때는 대상 요소에 `position: absolute` 또는 `position: fixed`를 적용하여 일반적인 문서 흐름에서 분리(Out of the flow)시킴으로써 다른 요소들에 미치는 연쇄적인 리플로우를 방지할 수 있다 [22].
+*   **GPU 가속 활용:** `top`이나 `left` 대신 `transform: translate()` 속성을 활용하거나 `opacity`를 제어하면, 레이아웃이나 페인트 사이클을 유발하지 않고 GPU를 활용한 컴포지팅(Compositing) 단계에서 화면을 업데이트할 수 있어 60fps의 부드러운 애니메이션을 유지할 수 있다 [2, 20, 24, 25].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Critical Rendering Path]], [[DOM & CSSOM]], [[Render Tree]], [[GPU Compositing]]
+- **Projects/Contexts:** [[Frontend Performance Optimization]], [[React Virtual DOM and Reconciliation]]
+- **Contradictions/Notes:** 소스에 따르면 리페인트(Repaint)는 레이아웃 재계산이 없기 때문에 리플로우(Reflow)보다 상대적으로 시스템 비용이 덜 드는 작업으로 설명된다 [2, 20]. 그러나 두 작업 모두 과도하게 트리거될 경우 메인 스레드를 점유하고 배터리 소모 및 버벅임(Jank)을 유발하므로, 성능 최적화 시에는 둘 중 어느 하나를 무시하지 않고 두 과정 모두를 최소화하는 것이 브라우저 렌더링 최적화의 핵심이다 [19, 20].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/Reflow와 Repaint.md b/10_Wiki/Topics/Frontend_Mastery/Reflow와 Repaint.md
new file mode 100644
index 00000000..f2afc77e
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Reflow와 Repaint.md	
@@ -0,0 +1,30 @@
+# [[Reflow와 Repaint]]
+
+## 📌 Brief Summary
+Reflow(리플로우)와 Repaint(리페인트)는 웹 브라우저가 화면에 콘텐츠를 렌더링할 때 거치는 핵심 과정이다. Reflow는 DOM 요소의 기하학적 속성(크기, 위치 등)이나 구조가 변경될 때 브라우저가 전체 혹은 일부의 레이아웃을 다시 계산하는 작업이다. 반면, Repaint는 요소의 레이아웃에는 영향을 주지 않고 색상이나 그림자 같은 시각적 스타일만 변경될 때 픽셀을 화면에 다시 그리는 과정을 의미한다. 두 과정 모두 브라우저의 성능과 사용자 경험에 큰 영향을 미치므로 최소화하는 최적화 전략이 필수적이다.
+
+## 📖 Core Content
+*   **브라우저 렌더링 파이프라인 내의 역할**
+    브라우저가 HTML과 CSS를 파싱하여 DOM과 CSSOM을 만들고 이를 결합해 렌더 트리(Render Tree)를 생성한 후, 화면에 요소를 그리기 위해 거치는 핵심 단계가 레이아웃(Layout)과 페인트(Paint)이다 [1-3]. 
+
+*   **Reflow (레이아웃 재계산)**
+    *   **정의:** 브라우저가 뷰포트 크기와 박스 모델을 기반으로 화면에 표시되는 모든 요소의 정확한 위치와 크기를 계산하는 과정으로, 레이아웃(Layout)이라고도 불린다 [3-5]. 
+    *   **발생 조건 및 비용:** 브라우저 창 크기 조절, DOM 요소 추가/제거, 폰트 크기 변경, 또는 `width`, `height`, `margin`, `padding` 등 레이아웃에 영향을 주는 속성을 수정할 때 발생한다 [6-8]. 렌더 트리의 루트에서 시작하여 아래로 진행되며, 하나의 기하학적 변화가 트리 전체의 연산 캐스케이드를 유발할 수 있어 연산 비용이 매우 높다 [3, 9].
+
+*   **Repaint (화면 다시 그리기)**
+    *   **정의:** 계산된 기하학적 구조와 스타일을 화면의 픽셀로 변환하여 래스터화(Rasterizing)하는 과정이다 [6, 10, 11].
+    *   **발생 조건 및 비용:** 기하학적 구조 변경 없이 `background-color`, `box-shadow`, 텍스트 색상, 투명도 등 시각적 스타일만 변경될 때 발생한다 [6-8]. 기하학적 구조를 다시 계산하지 않으므로 Reflow보다는 연산 비용이 적게 들지만, 애니메이션 도중 과도하게 발생하면 프레임 저하(frame drop)를 유발할 수 있다 [9, 10].
+
+*   **성능 영향 및 최적화 전략**
+    *   **성능 저하 문제:** 빈번한 Reflow와 Repaint는 렌더링 파이프라인을 방해하여 스크롤이나 애니메이션 시 끊김 현상(Jank)을 발생시키고, 모바일 기기에서 CPU와 GPU 사용량을 높여 배터리 수명을 단축시킨다 [12, 13].
+    *   **최적화 방법:** 
+        *   **Reflow 최소화:** 레이아웃 스래싱(layout thrashing)을 피하고 DOM 업데이트를 일괄 처리(batching)해야 한다 [6, 13]. `width`나 `height` 대신 최신 레이아웃 기법인 Flexbox나 Grid를 사용하면 더 효율적이다 [13]. 또한 애니메이션 요소에는 `top`, `left` 대신 `transform` 속성을 사용하면 Reflow를 유발하지 않고 GPU 가속을 활용할 수 있다 [9, 10, 13].
+        *   **Repaint 최소화:** 그림자나 그라데이션 같이 리페인트를 유발하는 속성 사용을 줄이고, 요소를 숨길 때 요소가 공간을 차지하게 두려면 `display: none`(Reflow 유발) 대신 `visibility: hidden`을 사용하여 Reflow 없이 Repaint만 발생하도록 최적화할 수 있다 [14].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Critical Rendering Path]], [[Render Tree]], [[DOM]], [[CSSOM]], [[GPU 가속(GPU Acceleration)]]
+- **Projects/Contexts:** [[프론트엔드 성능 최적화(Frontend Performance Optimization)]], [[웹 렌더링 최적화(Web Rendering Optimization)]]
+- **Contradictions/Notes:** 소스에 따르면 Reflow는 Repaint에 비해 훨씬 무거운 작업이므로(computationally heavier) 최적화의 1순위 대상이 됩니다 [15]. Reflow가 발생하면 변경된 레이아웃을 다시 그려야 하므로 필연적으로 Repaint가 뒤따르지만, 반대로 Repaint는 Reflow 없이 단독으로 발생할 수 있습니다 [7, 8].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/SaaS 플랫폼 및 인터랙티브 대시보드 개발.md b/10_Wiki/Topics/Frontend_Mastery/SaaS 플랫폼 및 인터랙티브 대시보드 개발.md
new file mode 100644
index 00000000..6a68f440
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/SaaS 플랫폼 및 인터랙티브 대시보드 개발.md	
@@ -0,0 +1,23 @@
+# [[SaaS 플랫폼 및 인터랙티브 대시보드 개발]]
+
+## 📌 Brief Summary
+SaaS 플랫폼과 인터랙티브 대시보드는 실시간 데이터 업데이트, 풍부한 사용자 상호작용, 그리고 매끄러운 화면 전환이 필수적인 웹 애플리케이션입니다 [1, 2]. 이러한 시스템은 대부분 로그인 벽(Authentication wall) 뒤에서 작동하므로 검색 엔진 최적화(SEO)의 중요성이 낮아 클라이언트 사이드 렌더링(CSR)이 가장 이상적인 렌더링 방식으로 평가받습니다 [1, 3, 4]. 또한 대규모 데이터 처리와 복잡한 UI 업데이트 시 성능 병목 현상을 방지하기 위해 컴포넌트 기반 아키텍처와 동시성 렌더링(Concurrent Rendering) 같은 최적화 기술이 적극적으로 활용됩니다 [5, 6].
+
+## 📖 Core Content
+- **최적의 렌더링 전략 (CSR의 활용):**
+  SaaS 플랫폼 및 사용자 대시보드 구축 시에는 클라이언트 사이드 렌더링(CSR)이 주로 권장됩니다 [1, 2]. 대시보드 특성상 검색 엔진 인덱싱이 필요하지 않고 동적인 상호작용이 가장 중요하기 때문입니다 [1, 3]. 초기 로딩 속도는 다소 느릴 수 있으나, 브라우저에서 동적으로 라우팅과 데이터를 처리하므로 사용자가 여러 애플리케이션 섹션을 부드럽게 탐색할 수 있고 인터랙티브한 앱과 같은 경험을 제공합니다 [2, 3, 7]. 일부 프레임워크에서는 실시간 상호작용이 중요한 대시보드에는 CSR을, 그 외 문서나 블로그 페이지에는 SSG나 SSR을 사용하는 하이브리드 방식을 적용하기도 합니다 [8, 9].
+
+- **데이터 집약적 대시보드의 렌더링 성능 최적화:**
+  - **자동 배칭(Automatic Batching):** 데이터가 많은 대시보드에서 React 18의 자동 배칭 기능을 활성화하면 여러 상태 업데이트가 단일 리렌더링으로 묶여 처리됩니다 [10, 11]. 내부 사례 연구에 따르면, 이를 통해 최대 부하 시 총 렌더링 횟수를 약 40% 줄이고 프레임 속도를 25% 향상시킬 수 있습니다 [12, 13].
+  - **동시성 기능(Concurrent Features):** 대시보드에서 10,000개 이상의 대규모 데이터 리스트를 필터링하거나 차트를 다시 계산하는 등 비용이 많이 드는 작업 시 UI가 멈추는 현상을 방지해야 합니다 [5, 14]. `useTransition`이나 `useDeferredValue` 훅을 사용해 무거운 상태 업데이트를 지연시키면 메인 스레드를 차단하지 않고 UI의 즉각적인 반응성(예: 타이핑 시 입력 지연 방지)을 유지할 수 있습니다 [5, 14, 15].
+
+- **컴포넌트 기반 아키텍처(CBA)의 적용:**
+  인터랙티브 대시보드는 차트, 데이터 테이블, 그래프 등 독립적이고 재사용 가능한 컴포넌트들을 조합하여 구축하는 컴포넌트 기반 아키텍처가 적합합니다 [6, 16]. 이를 통해 기능별 모듈화가 이루어져 일부 기능(예: 결제 프로세서 교체, 특정 위젯 업데이트)만 안전하게 수정하거나 확장할 수 있어 유지보수와 확장이 용이해집니다 [17, 18]. 
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Client-Side Rendering (CSR)]], [[Component-Based Architecture]], [[Automatic Batching]], [[Concurrent Rendering]]
+- **Projects/Contexts:** [[데이터 집약적 대시보드 성능 최적화 사례]], [[Sanity Studio]]
+- **Contradictions/Notes:** React 서버 컴포넌트(RSC) 적용과 관련하여 소스 간 시각 차이가 존재합니다. 일부 소스는 읽기 전용 데이터 디스플레이(제품 카탈로그, 단순 대시보드)에 RSC를 사용하면 클라이언트 JavaScript 번들을 40-60%까지 줄일 수 있다고 주장하지만 [19], 다른 소스에서는 빈번한 리렌더링과 로컬 상태, 직접적인 브라우저 API에 크게 의존하는 '복잡한 대시보드 및 고도의 상호작용이 필요한 인터페이스'에는 RSC가 부적합(Poor fit)하며 클라이언트 컴포넌트를 사용해야 한다고 경고합니다 [20].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/Sanity Studio.md b/10_Wiki/Topics/Frontend_Mastery/Sanity Studio.md
new file mode 100644
index 00000000..cccc9ab8
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Sanity Studio.md	
@@ -0,0 +1,18 @@
+# [[Sanity Studio]]
+
+## 📌 Brief Summary
+Sanity Studio는 실시간 협업 콘텐츠 편집기(real-time collaborative content editor)입니다 [1]. 복잡한 폼(form) 편집기와 깊게 중첩된 업데이트 패턴을 갖춘 컴포넌트들로 구성되어 있는 것이 특징입니다 [1]. 본 문서의 주요 초점 외의 구체적인 플랫폼 기능에 대해서는 소스에 관련 정보가 부족합니다.
+
+## 📖 Core Content
+- **React Compiler 적용 및 렌더링 성능 향상:** Sanity Studio는 React Compiler를 애플리케이션에 도입하여 렌더링 시간을 20~30% 단축하는 데 성공했습니다 [1, 2]. 
+- **지연 시간 개선 및 수동 메모이제이션 제거:** 컴파일러 도입을 통해 복잡한 폼 편집기에서 발생하던 지연 시간(latency)을 크게 개선했습니다 [1]. 특히 과거에는 개발자가 세심하게 수동으로 메모이제이션(manual memoization)을 처리해야만 했던 깊게 중첩된 컴포넌트 업데이트 패턴들이 컴파일러를 통해 별다른 조치 없이 자동으로 최적화되었습니다 [1].
+- **엔지니어링 생산성 증가:** 성능 최적화와 디버깅에 소요되던 시간이 줄어들면서 엔지니어링 팀은 즉각적인 생산성 향상 효과를 얻을 수 있었습니다 [1].
+- (※ 소스에 관련 정보가 부족합니다. 제공된 자료에서는 Sanity Studio를 'React Compiler 성능 개선을 입증하는 케이스 스터디'의 용도로만 제한적으로 다루고 있습니다.)
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[React Compiler]], [[Manual Memoization]]
+- **Projects/Contexts:** [[React Performance Optimization]]
+- **Contradictions/Notes:** 소스에 관련 정보가 부족합니다. Sanity Studio 자체의 아키텍처나 전반적인 제품군에 대한 설명은 없으며, 오직 React Compiler 도입을 통해 렌더링 속도 개선 및 수동 메모이제이션 부담을 해결한 성공 사례로만 언급됩니다 [1, 2].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/Tailwind CSS.md b/10_Wiki/Topics/Frontend_Mastery/Tailwind CSS.md
new file mode 100644
index 00000000..5e393f0e
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Tailwind CSS.md	
@@ -0,0 +1,24 @@
+# [[Tailwind CSS]]
+
+## 📌 Brief Summary
+Tailwind CSS는 미리 정의된 단일 목적의 유틸리티 클래스(utility-first)를 활용하여 HTML이나 JSX 내에서 직접 UI를 구성하는 CSS 프레임워크입니다 [1-3]. 컴포넌트와 스타일 간의 컨텍스트 전환 없이 개발 속도를 높이고, 디자인 토큰을 통해 시각적 일관성을 유지할 수 있도록 돕습니다 [2, 4, 5]. 하지만 HTML 마크업이 장황해진다는 단점이 있어, "유지보수 가능성"과 "생산성"이라는 측면에서 개발자들 사이에서 활발히 논의되는 도구입니다 [4, 6, 7].
+
+## 📖 Core Content
+* **기본 개념 및 작동 방식:** Tailwind CSS는 `flex`, `pt-4`, `text-gray-500`, `rounded-lg` 등과 같이 작고 특정 역할만 수행하는 클래스들을 조합하여 마크업 내에서 직접 스타일을 부여합니다 [2]. 이는 전통적인 '관심사의 분리(Separation of Concerns)' 원칙보다는 개발의 속도와 디자인의 일관성에 더 큰 비중을 둔 유틸리티 우선(Utility-first) 패러다임입니다 [5].
+* **주요 장점:**
+  * **빠른 개발 속도:** CSS 파일과 마크업 사이를 오가는 컨텍스트 전환(context switching)이 없으며, 클래스 이름을 고민할 필요가 없어 빠르게 프로토타이핑하고 개발할 수 있습니다 [2, 8]. 또한, 컴포넌트를 삭제할 때 연관된 스타일도 함께 삭제되므로 불필요한 코드가 남지 않습니다 [4].
+  * **디자인 시스템 강제:** 간격, 색상, 타이포그래피 등의 값을 설정 파일로 관리하여, 대규모 프로젝트에서 일관성 없는 임의의 값(예: 무수히 많은 회색 음영)이 무분별하게 추가되는 것을 방지합니다 [4, 7, 8].
+  * **성능 및 빌드 최적화:** JIT(Just-In-Time) 컴파일러가 코드를 스캔하여 실제 사용된 클래스만 최종 CSS에 포함시키기 때문에, 프로젝트 규모가 커지더라도 CSS 파일 크기가 일정 수준(보통 5~20kb)에서 유지되며 렌더링 성능이 뛰어납니다 [4, 5, 7]. 또한 런타임 오버헤드가 없어 React Server Components(RSC) 등 최신 렌더링 환경과도 호환성이 뛰어납니다 [9, 10].
+* **주요 단점 및 한계:**
+  * **가독성 저하 및 마크업 비대화:** 여러 유틸리티 클래스가 겹치면서 JSX의 `className` 속성이 200자 이상으로 길어지고 코드가 지저분해지는 등 HTML 마크업이 비대해집니다 [4, 7, 11].
+  * **학습 곡선:** 방대한 양의 유틸리티 클래스 명명 규칙을 익혀야 하므로 초기 진입 장벽과 학습 시간이 필요합니다 [1, 12].
+  * **제한된 유연성과 디자인 시스템 우회:** 픽셀 단위의 세밀한 제어가 필요한 고유한 디자인을 구현할 때 제한적일 수 있으며, 이를 해결하고자 `w-[347px]`와 같은 임의의 값(arbitrary values)을 남발하게 되면 결국 디자인 시스템의 통제에서 벗어나게 됩니다 [12, 13].
+* **실무적 해결 및 적용 전략:** 길어지는 클래스명을 관리하기 위해 `clsx`, `tailwind-merge`, CVA(Class Variance Authority)와 같은 라이브러리를 함께 사용하는 것이 일반적입니다 [4, 14]. 또한 기업 단위의 프로젝트에서는 레이아웃 및 간격 설정에는 Tailwind의 빠른 속도를 활용하고, 복잡한 애니메이션이나 특수한 구조가 필요한 컴포넌트에는 CSS Modules나 SCSS를 결합하여 사용하는 하이브리드 아키텍처를 많이 채택합니다 [15-17].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Utility-first CSS]], [[CSS Modules]], [[SCSS (Sass)]], [[BEM]], [[디자인 시스템 (Design System)]], [[CSS-in-JS]]
+- **Projects/Contexts:** [[Next.js App Router]] (서버 컴포넌트의 제약으로 인해 런타임 코스트가 없는 Tailwind가 적극 권장되는 주요 맥락 [9, 18]), [[컴포넌트 기반 아키텍처]]
+- **Contradictions/Notes:** 많은 개발자들이 Tailwind의 빠른 개발 속도와 디자인 일관성에 찬사를 보내는 반면 [5, 8], 일부 개발자들은 마치 2000년대의 "인라인 스타일(inline css)" 작성으로 회귀한 것 같다며 추상화의 부재와 코드의 난잡함에 불만을 표하고, CSS Modules나 BEM 같은 방식이 더 깨끗한 코드를 유지한다고 반대하기도 합니다 [1, 19-21].
+
+---
+*Last updated: 2026-04-26*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/Time Slicing.md b/10_Wiki/Topics/Frontend_Mastery/Time Slicing.md
new file mode 100644
index 00000000..d48a28dc
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Time Slicing.md	
@@ -0,0 +1,17 @@
+# [[Time Slicing]]
+
+## 📌 Brief Summary
+Time Slicing(타임 슬라이싱)은 React에서 대규모 렌더링 업데이트 작업을 더 작은 단위(청크)로 분할하여 UI의 반응성을 유지하는 최적화 기법입니다 [1, 2]. 이 기능을 통해 React는 렌더링 작업을 일시 중지하고 사용자 입력 등 우선순위가 높은 작업을 위해 브라우저에 제어권을 넘긴 후, 중단된 위치부터 렌더링을 다시 재개할 수 있습니다 [3]. 결과적으로 동시성 렌더링(Concurrent Rendering)과 함께 작동하여 복잡한 업데이트 상황에서도 애플리케이션이 멈추지 않고 원활하게 동작하도록 보장합니다 [4].
+
+## 📖 Core Content
+*   **작업의 분할과 제어권 양보 (Yielding):** Time Slicing은 긴 시간이 소요되는 대규모 업데이트를 더 작은 청크(chunk) 단위로 쪼개어 처리합니다 [1, 2]. 이를 통해 React는 렌더링 작업을 수행하는 도중에 브라우저로 제어권을 양보(yield)할 수 있어 메인 스레드가 장시간 차단되는 것을 방지합니다 [2].
+*   **우선순위 기반 렌더링 (Lane-Based Priority):** 이 과정은 React의 Fiber 아키텍처 내에서 "Lanes(레인)"라고 불리는 우선순위 기반 시스템을 통해 관리됩니다 [3]. 클릭 이벤트나 타이핑 같은 우선순위가 높은 작업이 발생하면, 진행 중이던 렌더링을 일시 중지하고 긴급한 작업을 먼저 처리한 뒤 남은 렌더링을 이어서 진행합니다 [3].
+*   **성능 및 UI 반응성 향상:** Time Slicing은 동시성 렌더링(Concurrent Rendering) 및 점진적 렌더링(Incremental Rendering) 아키텍처와 긴밀하게 결합되어 작동합니다 [4]. 이들의 조합은 복잡하고 무거운 UI 업데이트가 수행되는 동안에도 앱의 응답성을 유지시켜 사용자 경험을 크게 향상시킵니다 [4].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Fiber Architecture]], [[Concurrent Rendering]], [[Lanes]]
+- **Projects/Contexts:** [[React]]
+- **Contradictions/Notes:** 소스에 관련 정보가 부족합니다.
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/Time-Slicing.md b/10_Wiki/Topics/Frontend_Mastery/Time-Slicing.md
new file mode 100644
index 00000000..ccb5c373
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Time-Slicing.md
@@ -0,0 +1,18 @@
+# [[Time-Slicing]]
+
+## 📌 Brief Summary
+타임 슬라이싱(Time-Slicing)은 대규모 렌더링 작업을 더 작은 조각(chunk)으로 분할하여 사용자 인터페이스(UI)의 반응성을 유지하는 React의 최신 기능입니다 [1, 2]. 이 기능을 통해 React는 렌더링 프로세스를 일시 중지하고, 클릭 이벤트 처리와 같은 우선순위가 높은 작업을 위해 브라우저에 제어권을 양보(yield)한 뒤 중단된 부분부터 다시 렌더링을 재개할 수 있습니다 [3]. 타임 슬라이싱은 메인 스레드가 차단되는 것을 방지하고 동시성 렌더링(Concurrent Rendering)을 가능하게 하는 핵심 메커니즘입니다 [1, 3, 4].
+
+## 📖 Core Content
+- **렌더링 작업의 분할 및 양보(Yielding):** React의 타임 슬라이싱은 크고 복잡한 상태 업데이트를 단일 통째로 처리하는 대신 작은 단위로 쪼갭니다 [2]. 이를 통해 React는 작업 중간마다 브라우저에 제어권을 양보할 수 있으며, 사용자 입력(타이핑, 클릭 등)과 같은 긴급한 상호작용이 렌더링 작업으로 인해 지연되거나 멈추는 현상을 방지합니다 [2, 3].
+- **Fiber 아키텍처와의 연계:** 타임 슬라이싱은 React 16에서 동기식(synchronous) 렌더링의 한계를 극복하기 위해 도입된 파이버(Fiber) 아키텍처에 의해 활성화됩니다 [3, 4]. 파이버 아키텍처 하에서 렌더러는 작업을 관리 가능한 '작업 단위(units of work)'로 나누어 스케줄러가 렌더링 과정을 더 유연하게 제어할 수 있도록 합니다 [3, 5].
+- **Lanes 기반 우선순위 시스템:** 타임 슬라이싱을 통한 작업의 일시 중지 및 재개는 'Lanes'라고 불리는 우선순위 기반 시스템을 통해 관리됩니다 [3]. 예를 들어, 사용자의 클릭이나 타이핑처럼 즉각적인 반응이 필요한 작업은 'Sync Lane'으로 분류되어 즉시 처리되며, 화면 밖 렌더링과 같은 비긴급 작업은 'Idle Lane'에 할당되어 브라우저가 유휴 상태일 때만 처리되도록 우선순위를 지정합니다 [6, 7].
+- **동시성 및 점진적 렌더링 달성:** 타임 슬라이싱은 동시성 렌더링(Concurrent Rendering) 및 점진적 렌더링(Incremental Rendering)과 결합하여, 복잡하고 무거운 업데이트가 발생하더라도 애플리케이션이 항상 부드럽고 응답성 있게 동작하도록 보장합니다 [1, 8].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[React Fiber Architecture]], [[Concurrent Rendering]], [[Lanes Priority System]], [[Incremental Rendering]]
+- **Projects/Contexts:** [[React Scheduler]]
+- **Contradictions/Notes:** 소스 내에서 타임 슬라이싱과 관련하여 상충되는 정보는 없습니다.
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/Virtual DOM과 Reconciliation.md b/10_Wiki/Topics/Frontend_Mastery/Virtual DOM과 Reconciliation.md
new file mode 100644
index 00000000..39a02a9d
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Virtual DOM과 Reconciliation.md	
@@ -0,0 +1,37 @@
+# [[Virtual DOM과 Reconciliation]]
+
+## 📌 Brief Summary
+Virtual DOM은 UI의 이상적인 가상 표현을 메모리에 유지하는 프로그래밍 개념입니다 [1]. Reconciliation(재조정)은 이 Virtual DOM을 실제 DOM과 동기화하여 변경된 부분만 파악하고 효율적으로 업데이트하는 React의 핵심 프로세스입니다 [1, 2]. React는 O(n) 복잡도를 가진 휴리스틱 Diffing 알고리즘을 사용하여 실제 DOM 조작으로 인해 발생하는 비싼 렌더링 비용과 성능 저하를 최소화합니다 [3-5].
+
+## 📖 Core Content
+**Virtual DOM의 개념과 도입 배경**
+*   브라우저의 실제 DOM을 직접 수정하는 작업은 레이아웃(Reflow)과 페인트(Repaint) 단계를 반복적으로 트리거하기 때문에 본질적으로 매우 느립니다 [2]. 
+*   React는 이 문제를 추상화하기 위해 가볍고 메모리 내에 존재하는 UI 표현인 Virtual DOM을 도입했습니다 [2]. 
+*   이를 통해 개발자는 원하는 UI 상태를 선언적으로 명시하기만 하면 되며, React의 ReactDOM과 같은 라이브러리가 내부적으로 속성 조작, 이벤트 처리 및 수동 DOM 업데이트를 알아서 관리하게 됩니다 [1, 2]. 
+*   React 세계에서 Virtual DOM은 일반적으로 사용자 인터페이스를 나타내는 객체인 'React Elements'를 의미하며, 컴포넌트 트리에 대한 추가 정보를 담고 있는 내부 객체인 'Fiber' 역시 그 구현의 일부로 간주될 수 있습니다 [6].
+
+**Reconciliation과 휴리스틱 Diffing 알고리즘**
+*   상태(State)나 속성(Props)이 업데이트되면 `render()` 함수는 새로운 React Element 트리를 반환하며, React는 이를 가장 최근의 트리와 비교하여 UI를 어떻게 효율적으로 업데이트할지 계산합니다 [4].
+*   두 트리를 비교하여 변환하기 위한 최소한의 연산을 찾는 일반적인 알고리즘은 O(n^3)의 복잡도를 가지므로 실제 애플리케이션에 적용하기에는 비용이 너무 높습니다 [4].
+*   따라서 React는 다음 두 가지 가정에 기반한 **O(n) 휴리스틱 알고리즘**을 구현했습니다 [3-5]:
+    1. 서로 다른 타입의 요소(Elements)는 본질적으로 다른 트리를 생성한다 [3, 5].
+    2. 개발자가 `key` 속성을 제공하여 여러 렌더링 간에 어떤 자식 요소가 안정적인지 힌트를 줄 수 있다 [3, 5].
+
+**비교(Diffing) 프로세스 상세 처리**
+*   **다른 타입의 요소:** 루트 요소의 타입이 다르면(예: `<a>`에서 `<img>`로, 혹은 `<div>`에서 `<span>`으로 변경), React는 기존 트리를 완전히 파괴하고 처음부터 새 트리를 구축합니다 [3, 7]. 이 과정에서 이전 DOM 노드는 파괴되며 연관된 모든 컴포넌트의 상태(State)가 유실됩니다 [7].
+*   **같은 타입의 DOM 요소:** 동일한 타입의 React DOM 요소를 비교할 때는 기본 DOM 노드를 유지한 채, `className`이나 `style` 등 변경된 속성(Attributes)만을 업데이트합니다 [8, 9].
+*   **같은 타입의 컴포넌트 요소:** 컴포넌트가 업데이트될 때 인스턴스는 동일하게 유지되어 렌더링 간에 상태가 보존됩니다. React는 새 요소와 일치하도록 기본 컴포넌트 인스턴스의 props를 업데이트하고 수명 주기(Lifecycle) 메서드를 호출한 뒤, 자식 노드에 대해 재귀적으로 처리합니다 [9, 10].
+*   **자식 노드 처리와 Key 속성:** 자식 노드를 순회할 때 리스트의 맨 앞에 요소를 추가하면 전체 트리가 변경된 것으로 인식해 매우 비효율적으로 작동할 수 있습니다 [10, 11]. 이를 해결하기 위해 `key` 속성을 사용하여 원본 트리와 후속 트리의 자식을 정확히 매칭시킵니다 [3, 11]. `key`는 형제 노드 사이에서 안정적이고 예측 가능하며 고유해야 성능 저하와 상태 유실을 방지할 수 있습니다 [12].
+
+**React Fiber 아키텍처를 통한 렌더링 최적화**
+*   과거 동기적인 스택 재조정자(Stack reconciler)는 대규모 애플리케이션 처리 시 메인 스레드를 차단(Blocking)하여 UI의 반응성을 떨어뜨리는 문제가 있었습니다 [13, 14].
+*   React 16은 이를 해결하기 위해 동시성 렌더링(Concurrent rendering)을 지원하는 **Fiber 아키텍처**로 재조정 엔진을 완전히 재작성했습니다 [15-17].
+*   Fiber는 렌더링 작업을 '작업 단위(Unit of work)'로 나누고, 우선순위(Lanes) 시스템을 통해 긴급한 상호작용(클릭, 타이핑 등)을 위해 작업을 일시 중단, 양보(Yield), 및 재개할 수 있도록 지원합니다 [14, 16, 18, 19]. 이로 인해 Virtual DOM의 재조정 과정 중에도 UI 반응성을 유지할 수 있습니다 [16, 18].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[React Fiber Architecture]], [[Critical Rendering Path (CRP)]], [[Concurrent Rendering]]
+- **Projects/Contexts:** [[React Application Performance Optimization]]
+- **Contradictions/Notes:** 소스에 따르면 Virtual DOM 트리는 설계상 불변(immutable)으로 취급되지만, 단일 자식 노드를 여러 위치에서 사용하는 경우 복사 비용 문제가 발생할 수 있습니다. 이를 해결하기 위해 React는 현재 설치된 상태를 나타내는 가변적인 형태의 "Augmented DOM" 구조를 구축하며, 이것이 바로 React의 Fiber 데이터 구조가 수행하는 역할입니다 [20]. 
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/Zero-Runtime CSS-in-JS.md b/10_Wiki/Topics/Frontend_Mastery/Zero-Runtime CSS-in-JS.md
new file mode 100644
index 00000000..9c4a9e3e
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Zero-Runtime CSS-in-JS.md	
@@ -0,0 +1,28 @@
+# [[Zero-Runtime CSS-in-JS]]
+
+## 📌 Brief Summary
+Zero-Runtime CSS-in-JS는 JavaScript 코드 내에서 스타일을 작성하는 기존 CSS-in-JS의 개발자 경험을 유지하면서도, 빌드 타임에 스타일을 정적 CSS 파일로 추출하여 런타임 오버헤드를 제거한 현대적인 스타일링 기법입니다 [1, 2]. 대표적인 도구로는 Linaria, Panda CSS, vanilla-extract 등이 있으며, 뛰어난 성능과 타입 안정성을 제공합니다 [1, 3, 4]. 특히 React Server Components(RSC) 환경과의 높은 호환성을 통해 대규모 프론트엔드 아키텍처에서 중요한 대안으로 자리 잡고 있습니다 [4-6].
+
+## 📖 Core Content
+
+*   **등장 배경 및 필요성**
+    *   초기 세대의 CSS-in-JS 라이브러리(styled-components, Emotion 등)는 런타임에 CSS 문자열을 파싱하고 DOM에 주입하는 과정에서 발생하는 성능 오버헤드(로딩 및 리렌더링 시간 증가)와 번들 크기 증가라는 단점이 있었습니다 [2, 7, 8].
+    *   특히 2024~2025년경 React Server Components(RSC)가 도입되면서, React Context에 의존하는 기존 런타임 CSS-in-JS 라이브러리들이 서버 컴포넌트 환경에서 작동하지 않는 치명적인 호환성 문제가 발생했습니다 [5, 6, 9]. 이를 해결하기 위해 성능 저하가 없는 Zero-Runtime 방식이 대두되었습니다 [2].
+*   **작동 원리 및 주요 특징**
+    *   Zero-Runtime CSS-in-JS는 개발 시 컴포넌트 로직과 스타일을 함께 배치하는 편리함을 제공하지만, 빌드 단계에서 이를 완전히 정적인 CSS 파일로 추출합니다 [1, 2].
+    *   동적으로 변해야 하는 스타일 속성은 CSS 사용자 지정 속성(CSS 변수)을 활용하여 처리하므로 런타임에 CSS를 재계산하거나 파싱할 필요가 없습니다 [1].
+    *   이 방식을 통해 브라우저 캐싱을 효과적으로 활용하고 렌더링 성능(초기 HTML에 크리티컬 CSS 포함 등)을 최적화할 수 있습니다 [1, 10].
+*   **대표적인 라이브러리**
+    *   **Linaria**: CSS-in-JS 문법을 그대로 사용하면서 빌드 타임에 정적 CSS로 추출하며, 기존 런타임 라이브러리 대비 눈에 띄는 렌더링 속도 향상을 보여줍니다 [1].
+    *   **Panda CSS**: 제로 런타임 성능, 유틸리티 퍼스트(Utility-first) 원칙, 디자인 토큰 시스템 및 원자적(Atomic) CSS 생성을 결합한 차세대 도구입니다 [2, 3].
+    *   **vanilla-extract**: 타입스크립트(TypeScript) 기반으로 타입 안정성을 제공하는 제로 런타임 도구로, RSC와 완벽히 호환되며 다중 테마(Multi-theme)를 관리해야 하는 시스템에 강력히 권장됩니다 [2, 4, 11].
+*   **실무적 적용 및 아키텍처적 가치**
+    *   유지보수 가능한 대규모 엔터프라이즈 프론트엔드 환경에서, Zero-Runtime CSS-in-JS는 CSS Modules처럼 정적 CSS의 성능을 보장하면서도 JavaScript 기반의 정밀한 캡슐화와 테밍 기능을 제공합니다 [3, 12].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[CSS-in-JS]], [[React Server Components (RSC)]], [[CSS Modules]], [[디자인 시스템 (Design Systems)]], [[Tailwind CSS]]
+- **Projects/Contexts:** [[Next.js App Router 환경의 컴포넌트 스타일링]], [[성능 최적화가 필수적인 대규모 다중 테마 플랫폼]]
+- **Contradictions/Notes:** 기존 CSS-in-JS(styled-components, Emotion)는 동적 런타임 테밍에 특화되어 있으나 성능 오버헤드와 RSC 비호환성을 야기합니다. 반면, Zero-Runtime CSS-in-JS는 빌드 시 정적 추출 방식을 사용하여 런타임 비용을 "0"으로 만들고 RSC와 호환되도록 하여 기존 CSS-in-JS의 단점을 효과적으로 극복합니다 [1, 4-7].
+
+---
+*Last updated: 2026-04-26*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/flushSync.md b/10_Wiki/Topics/Frontend_Mastery/flushSync.md
new file mode 100644
index 00000000..ef05259a
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/flushSync.md
@@ -0,0 +1,20 @@
+# [[flushSync]]
+
+## 📌 Brief Summary
+`flushSync`는 React 18에서 도입된 API로, React가 상태 업데이트를 즉각적이고 동기적으로 강제 적용하도록 만드는 메서드입니다 [1-3]. 이 메서드를 사용하면 React 18의 기본 동작인 자동 배칭(Automatic Batching)에서 예외적으로 벗어나 즉시 리렌더링을 유발할 수 있습니다 [2, 3]. 그러나 과도하게 사용할 경우 배칭을 통한 성능 향상 이점을 무효화할 수 있으므로, DOM 측정이나 즉각적인 폼 업데이트처럼 필수적인 경우에만 제한적으로 사용해야 합니다 [2, 4].
+
+## 📖 Core Content
+*   **개념 및 역할:** React 18부터는 성능 최적화를 위해 여러 상태 업데이트를 단일 리렌더링으로 묶는 자동 배칭(Automatic Batching)이 기본적으로 적용됩니다 [5-7]. 하지만 ReactDOM에 포함된 `flushSync()` 메서드를 사용하면 이 자동 배칭을 의도적으로 우회(Opt-out)하여, 특정 상태 업데이트 시 React가 업데이트를 동기적으로 처리하고 즉시 리렌더링하도록 강제할 수 있습니다 [1, 3].
+*   **적절한 사용 사례(Use Cases):** `flushSync`는 사용자가 변경 사항을 지연 없이 즉각적으로 보아야 하는 매우 긴급한 업데이트에 사용됩니다 [2].
+    *   사용자의 입력 지연을 방지하기 위해 폼(Form) 값을 즉시 업데이트할 때 [2].
+    *   상태 변경 직후 특정 DOM 요소에 포커스(Focus)를 주거나, DOM 요소의 크기/위치를 측정(Measure)해야 할 때 [2].
+*   **사용 방법:** 상태 업데이트 로직을 래핑하여 사용합니다. (예: `flushSync(() => { setValue(''); });`) [2].
+*   **성능 관련 주의사항:** 자동 배칭은 렌더링 횟수를 줄여 성능을 향상시키는 핵심 기능이므로, `flushSync`를 남용하면 이러한 성능상 이점이 무효화될 수 있습니다 [4]. 따라서 가급적 드물게(sparingly) 사용해야 합니다 [4].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Automatic Batching]], [[React 18]], [[startTransition]]
+- **Projects/Contexts:** [[DOM Element Measurement]], [[Form Value Synchronization]]
+- **Contradictions/Notes:** React 18의 상태 업데이트 제어 방식 중 `flushSync`는 업데이트를 즉시 동기적으로 강제(Force synchronously)하는 반면, `startTransition`은 업데이트를 비긴급(Non-urgent)으로 지정하여 더 높은 우선순위 작업(타이핑, 클릭 등)에 메인 스레드를 양보한다는 점에서 상반된 목적을 가집니다 [1, 2]. 
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/startTransition.md b/10_Wiki/Topics/Frontend_Mastery/startTransition.md
new file mode 100644
index 00000000..dd16a4fc
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/startTransition.md
@@ -0,0 +1,18 @@
+# [[startTransition]]
+
+## 📌 Brief Summary
+`startTransition`은 React 18 및 19에서 도입된 동시성 렌더링(concurrent rendering) API로, 특정 상태 업데이트를 긴급하지 않은(non-urgent) 작업으로 표시하여 우선순위를 낮추는 역할을 합니다 [1-3]. 이를 통해 무거운 상태 변경이나 렌더링이 진행되는 동안에도 타이핑이나 클릭 같은 긴급한 사용자 상호작용이 메인 스레드를 차단(blocking)하지 않게 만들어 UI의 반응성을 유지합니다 [1, 2]. 
+
+## 📖 Core Content
+- **동시성 렌더링과 상태 업데이트 분리:** `startTransition`은 개발자가 상태 업데이트 로직을 직접 제어할 수 있을 때 주로 사용하며, `setState` 호출을 `startTransition` 내부에 래핑하여 실행합니다 [4]. 이 방식은 긴급한 업데이트(타이핑, 클릭 등)와 긴급하지 않은 업데이트(대규모 목록 필터링, 자동완성 결과 가져오기, 차트 재계산 등)를 분리하여 UI가 멈추거나 얼어붙는 현상을 방지합니다 [1, 2].
+- **작업 우선순위 제어:** `startTransition`으로 감싸진 상태 업데이트는 시스템 내에서 낮은 우선순위(low-priority)로 취급됩니다 [1, 3]. 따라서 React는 긴급한 사용자 상호작용을 먼저 처리하고, 메인 스레드에 여유가 생길 때까지 지연된(non-urgent) 업데이트를 백그라운드에서 처리하며 다른 고우선순위 작업에 실행을 양보(yield)합니다 [1, 3].
+- **디바운싱(Debouncing)과의 관계:** 컴포넌트 수준에서 UI 업데이트를 지연시키는 측면에서는 디바운싱의 훌륭한 대안이자 React의 렌더링 모델에 더 잘 부합하는 네이티브 접근법입니다 [5]. 다만, 불필요한 API 호출 빈도 자체를 줄이는 것이 목적일 경우에는 여전히 디바운싱이 가장 적합한 방법으로 권장됩니다 [5].
+- **flushSync와의 대비:** React 18은 업데이트의 우선순위를 제어하는 도구로 `startTransition`과 `flushSync`를 함께 제공합니다 [2]. 사용자가 입력한 값을 즉시 화면에 반영하기 위해 강제로 동기적 렌더링을 적용해야 할 때는 `flushSync`를 사용하지만, 업데이트를 뒤로 미루어 높은 우선순위 작업에 길을 내어줄 때는 `startTransition`을 사용합니다 [2, 3].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[useTransition]], [[flushSync]], [[Concurrent Rendering]], [[Debouncing]]
+- **Projects/Contexts:** 대규모 데이터가 포함된 애플리케이션에서의 탭 전환(tab switching), 타이핑할 때마다 검색 결과를 필터링하는 패턴(search-as-you-type), 그리고 수천 개의 항목 필터링 시 발생하는 입력 지연(input lag)을 해결하기 위해 주로 적용됩니다 [1, 2, 6].
+- **Contradictions/Notes:** 소스 자료에서는 동시성 훅(`startTransition`, `useTransition` 등)이 코드의 물리적인 실행 속도 자체를 높여주는 것은 아니라고 명시합니다 [7]. 무거운 계산이 사용자의 즉각적인 피드백을 가로막지 않도록 함으로써 앱이 "더 빠르다고 느끼게(feel faster)" 만들어 줄 뿐입니다 [7].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/useDeferredValue.md b/10_Wiki/Topics/Frontend_Mastery/useDeferredValue.md
new file mode 100644
index 00000000..1b2ce803
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/useDeferredValue.md
@@ -0,0 +1,22 @@
+# [[useDeferredValue]]
+
+## 📌 Brief Summary
+`useDeferredValue`는 무거운 연산이 진행되는 동안 즉각적인 사용자 피드백을 방해하지 않고 UI의 반응성을 유지할 수 있도록 돕는 React 19의 동시성 렌더링(concurrent rendering) 훅입니다 [1-3]. 상태 업데이트 코드를 직접 제어할 수 없을 때 상태 대신 값 자체를 감싸는 방식으로 사용되며, 부모 컴포넌트로부터 props를 통해 값을 전달받을 때 특히 유용합니다 [4]. 이 훅을 사용하면 비긴급 업데이트를 지연시켜 메인 스레드가 긴급한 사용자 상호작용을 먼저 처리할 수 있게 함으로써 INP(Interaction to Next Paint) 점수를 개선합니다 [3].
+
+## 📖 Core Content
+* **동시성 렌더링과 반응성 유지:**
+  `useDeferredValue`는 긴급한 상호작용(타이핑, 클릭 등)과 긴급하지 않은 업데이트(대규모 목록 필터링, 차트 재계산 등)를 분리하여, 계산이 오래 걸리는 작업 중에도 UI가 멈추는(freezing) 것을 방지합니다 [2, 3]. 새로운 연산 결과가 준비될 때까지 React는 화면에 이전 결과를 계속 표시합니다 [3].
+* **`useTransition`과의 구조적 차이점:**
+  `useTransition`이 상태 업데이트(`setState`) 자체를 감싸는 훅이라면, `useDeferredValue`는 상태에서 파생된 값 자체를 감싸는 용도로 사용됩니다 [3, 4]. 외부 스토어나 부모 컴포넌트의 props를 통해 값이 전달되어 개발자가 상태 업데이트 코드를 직접 제어할 수 없을 때, 값이 렌더링에 소비되는 방식을 지연시키기 위한 더 나은 아키텍처적 선택입니다 [3, 4].
+* **성능 및 우선순위 관리 적용:**
+  이 훅은 코드의 실행 속도 자체를 높이는 것이 아니라, UI가 더 빠르게 '느껴지도록' 만듭니다 [5]. React의 Lane 모델(우선순위 기반 시스템)과 연동되어 업데이트를 더 낮은 우선순위로 표시함으로써, 메인 스레드를 긴급한 작업에 우선적으로 할당합니다 [6]. 
+* **성능 최적화 패턴:**
+  수만 개 이상의 항목이 포함된 대규모 목록 등을 처리할 때 `useMemo`와 함께 결합하여 사용하면, 사용자가 인지할 수 있는 지연(lag) 없이 매끄러운 렌더링을 달성할 수 있습니다 [3].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Concurrent Rendering]], [[useTransition]], [[Interaction to Next Paint (INP)]], [[Lane Model]]
+- **Projects/Contexts:** [[React 19]], [[React Performance Optimization]]
+- **Contradictions/Notes:** 소스 내용에 모순은 없으며, `useDeferredValue`가 코드를 직접적으로 빠르게 만드는 것이 아니라 체감 속도와 UI 반응성(Responsiveness)을 개선하는 목적으로 설계되었다는 점이 강조되고 있습니다 [5].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/useTransition 및 useDeferredValue.md b/10_Wiki/Topics/Frontend_Mastery/useTransition 및 useDeferredValue.md
new file mode 100644
index 00000000..cbd7b503
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/useTransition 및 useDeferredValue.md	
@@ -0,0 +1,18 @@
+# [[useTransition 및 useDeferredValue]]
+
+## 📌 Brief Summary
+`useTransition`과 `useDeferredValue`는 무거운 연산 중에도 UI의 반응성을 유지할 수 있도록 돕는 React의 동시성 렌더링(Concurrent Rendering) 훅입니다 [1]. 이 기능들은 타이핑이나 클릭과 같은 긴급한 사용자 상호작용과 대규모 데이터 필터링 같은 긴급하지 않은 업데이트를 분리하여 처리합니다 [1]. 코드의 물리적인 실행 속도를 높이는 것이 아니라, 작업을 지연시키고 메인 스레드를 확보하여 애플리케이션이 더 빠르게 느껴지게 만들며 코어 웹 바이탈의 INP(Interaction to Next Paint) 성능을 개선합니다 [2, 3].
+
+## 📖 Core Content
+- **작동 원리 및 아키텍처 배경**: 이 기능들은 React의 우선순위 레인(Lane) 모델을 기반으로 작동하여 업데이트의 우선순위를 관리합니다 [4, 5]. 무거운 연산이 즉각적인 UI 업데이트를 방해하지 않도록 비긴급 상태 업데이트를 지연시켜 메인 스레드가 긴급한 사용자 상호작용을 먼저 처리할 수 있게 합니다 [2, 5].
+- **useTransition (비차단 상태 업데이트)**: 개발자가 상태 업데이트 코드(`setState` 등)를 직접 제어할 수 있을 때 주로 사용합니다 [2]. `startTransition` 함수로 래핑된 상태 업데이트는 낮은 우선순위로 간주되어 메인 스레드가 여유로워질 때까지 처리가 지연됩니다 [1]. 작업이 백그라운드에서 실행되는 동안 `isPending` 플래그를 사용하여 즉각적인 시각적 피드백을 제공할 수 있으며, '입력과 동시에 검색(search-as-you-type)'이나 데이터가 많은 탭 전환 패턴에 매우 효과적입니다 [1, 6].
+- **useDeferredValue (무거운 렌더링 지연)**: 부모 컴포넌트에서 전달받은 props처럼 상태를 설정하는 코드에 직접 접근할 수 없을 때, '값 자체'를 래핑하여 사용합니다 [2, 6]. 무거운 연산(예: 대규모 목록 필터링)이 진행되는 동안 UI가 멈추는 현상(Freezing)을 방지하기 위해, React는 새로운 값이 준비될 때까지 이전 화면 결과를 계속해서 표시합니다 [2]. 
+- **성능 최적화와의 관계**: 두 훅의 근본적인 목적은 연산 속도를 높이는 것이 아닙니다 [3]. 오히려 디바이스의 메인 스레드를 긴급한 작업에 우선적으로 양보함으로써 체감 성능을 향상시키고, 애플리케이션 전체의 INP(Interaction to Next Paint) 점수를 낮추는 데 기여합니다 [2, 3].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Concurrent Rendering]], [[Lane Model]], [[Interaction to Next Paint (INP)]]
+- **Projects/Contexts:** [[React Performance Optimization]]
+- **Contradictions/Notes:** 소스에서는 `useTransition`과 `useDeferredValue`가 코드를 더 빠르게 실행(speed up)시키는 마법이 아니며, 단지 무거운 계산이 사용자의 즉각적인 피드백을 끊지 않도록 보장함으로써 앱이 "더 빠르게 느껴지도록(feel faster)" 도와주는 아키텍처적 도구임을 명확히 강조합니다 [3].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/useTransition.md b/10_Wiki/Topics/Frontend_Mastery/useTransition.md
new file mode 100644
index 00000000..ee4637ef
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/useTransition.md
@@ -0,0 +1,19 @@
+# [[useTransition]]
+
+## 📌 Brief Summary
+`useTransition`은 무거운 연산이 진행되는 동안에도 UI가 멈추지 않고 응답성을 유지할 수 있도록 돕는 React의 동시성 렌더링(Concurrent Rendering) 기능 중 하나이다 [1, 2]. 이 훅은 특정 상태 업데이트를 우선순위가 낮은 '비긴급(non-urgent)' 작업으로 표시하여, 메인 스레드가 여유로울 때까지 처리를 지연시킨다 [2]. 주로 데이터가 많은 리스트의 필터링이나 차트 재계산과 같이 시간이 오래 걸리는 작업과 타이핑, 클릭 등 긴급한 사용자 상호작용을 분리하는 데 사용된다 [2].
+
+## 📖 Core Content
+- **동작 원리 및 상태 제어:** `useTransition`은 개발자가 상태 업데이트 코드를 직접 제어할 수 있을 때 사용하며, 상태 업데이트 함수(`setState`)를 `startTransition`으로 감싸서 호출한다 [3]. 이를 통해 React는 긴급한 사용자 입력을 우선적으로 처리하고 무거운 업데이트는 백그라운드로 지연시킨다 [2].
+- **시각적 피드백 제공:** 이 훅은 `isPending`이라는 플래그를 제공한다 [4]. 이를 활용하면 백그라운드에서 무거운 필터링 연산이 진행되는 동안에도 입력 필드의 응답성을 유지하면서 사용자에게 로딩 상태 등 즉각적인 시각적 피드백을 제공할 수 있다 [4].
+- **성능 및 지표 개선:** 우선순위를 관리하여 메인 스레드를 긴급한 상호작용에 가용하도록 유지하므로, 결과적으로 웹 성능 지표인 INP(Interaction to Next Paint) 점수를 개선하는 데 기여한다 [3].
+- **디바운싱(Debouncing)과의 차이:** UI 업데이트를 지연시키는 관점에서는 디바운싱보다 컴포넌트 레벨에서 렌더링을 지연시키는 `useTransition`이 React의 렌더링 모델에 더 적합한 대안이다 [5]. 다만, API 호출 빈도를 줄여야 하는 상황에서는 여전히 디바운싱이 최선의 방법이다 [5].
+- **내부 아키텍처 (Fiber 및 Lane 모델):** `useTransition`이 제공하는 동시성 기능은 업데이트 우선순위를 관리하는 React Fiber 아키텍처의 'Lane 모델'을 기반으로 동작하여 UI의 반응성을 유지한다 [6, 7].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Concurrent Rendering]], [[useDeferredValue]], [[Fiber Architecture]], [[Interaction to Next Paint (INP)]], [[startTransition]]
+- **Projects/Contexts:** [[Search-as-you-type patterns]], [[Data-heavy Applications]], [[React Performance Optimization]]
+- **Contradictions/Notes:** 소스에 따르면 UI 업데이트를 지연할 때는 디바운싱(debouncing)보다 `useTransition`이 React의 렌더링 모델에 더 잘 맞아 권장되지만, 잦은 API 호출을 줄이는 것이 목적일 경우에는 여전히 디바운싱을 사용하는 것이 가장 좋다고 구분하여 조언하고 있다 [5].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/가상 DOM (Virtual DOM) 및 Fiber.md b/10_Wiki/Topics/Frontend_Mastery/가상 DOM (Virtual DOM) 및 Fiber.md
new file mode 100644
index 00000000..cbc5fef4
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/가상 DOM (Virtual DOM) 및 Fiber.md	
@@ -0,0 +1,27 @@
+# [[가상 DOM (Virtual DOM) 및 Fiber]]
+
+## 📌 Brief Summary
+가상 DOM(Virtual DOM)은 사용자 인터페이스(UI)의 이상적인 상태를 메모리에 저장하고 가볍게 표현한 자바스크립트 객체로, 실제 DOM과의 동기화(재조정, Reconciliation)를 통해 직접적인 DOM 조작의 비효율성을 추상화하는 개념입니다 [1-3]. React Fiber는 이러한 재조정 엔진을 완전히 재작성하여 React 16에 도입된 아키텍처로, 동기식 렌더링의 한계를 극복하고 렌더링 작업을 중단 및 재개할 수 있는 동시성 렌더링(Concurrent Rendering)을 지원합니다 [4, 5]. Fiber 아키텍처는 렌더링 작업을 '작업 단위(Fiber node)'로 분할하여 우선순위에 따라 스케줄링함으로써 애플리케이션의 반응성을 극대화합니다 [6-8].
+
+## 📖 Core Content
+* **가상 DOM과 휴리스틱 재조정 알고리즘**
+  실제 DOM을 직접 수정하는 것은 브라우저의 레이아웃 및 페인트 단계를 유발하므로 계산 비용이 많이 듭니다 [1]. React는 가상 DOM을 도입하여 이전 가상 DOM 트리와 새롭게 계산된 가상 DOM 트리를 비교(Diffing)하여 변경 사항을 감지합니다 [2]. 이론적인 트리 비교 알고리즘의 복잡도는 $O(n^3)$이지만, React는 두 가지 가정(다른 타입의 요소는 다른 트리를 생성하며, 개발자가 부여한 'key'를 통해 안정적인 요소를 식별함)을 바탕으로 $O(n)$의 휴리스틱 알고리즘을 구현하여 성능을 최적화합니다 [9-11].
+
+* **스택 재조정자(Stack Reconciler)의 한계와 Fiber의 도입**
+  Fiber 도입 이전의 React는 컴포넌트 트리를 단일 재귀 호출로 처리하는 동기식 스택 재조정자를 사용했습니다 [6]. 이 방식은 작업이 길어질 경우 16.6ms의 프레임 예산을 초과하여 메인 스레드를 차단하고 UI를 멈추게 하는 한계가 있었습니다 [6]. 이를 해결하기 위해 등장한 Fiber는 컴포넌트를 나타내는 변경 가능한 인메모리 구조(Fiber 데이터 구조)를 통해 렌더링 작업을 관리합니다 [12].
+
+* **Fiber의 렌더링 단계 (Render & Commit Phases)**
+  Fiber는 재조정 과정을 두 가지 명확한 단계로 분리하여 실행합니다 [13].
+  1. **렌더 단계(Render Phase):** 이 단계는 비동기적이며 중단 가능합니다 [13]. React는 Fiber 트리를 순회하며 변경 사항을 계산하고 실제 DOM을 변형하지 않은 채로 부작용(Effect) 목록을 작성합니다 [13, 14]. 처리 도중 우선순위가 높은 작업(예: 사용자 입력)이 발생하면 브라우저에 제어권을 양보(Yield)할 수 있습니다 [6, 15].
+  2. **커밋 단계(Commit Phase):** 이 단계는 동기적이며 중단할 수 없습니다 [16]. 렌더 단계에서 생성된 부작용 목록(DOM 삽입, 업데이트, 삭제 등)을 실제 DOM에 한 번에 적용하고, 동기식 레이아웃 효과(`useLayoutEffect`)를 실행합니다 [16, 17].
+
+* **우선순위 레인(Lane) 모델과 스케줄링**
+  React의 스케줄러는 비트마스크(Bitmask) 시스템을 사용하는 'Lane 모델'을 통해 동시성 작업을 관리합니다 [18, 19]. 업데이트의 성격에 따라 Sync Lane(사용자 타이핑, 클릭 등 즉시 처리), InputContinuous Lane(스크롤 등), Default Lane, Idle Lane(백그라운드 작업) 등으로 우선순위를 분류합니다 [20, 21]. 이를 통해 무거운 연산이 진행 중이더라도 메인 스레드를 차단하지 않고 긴급한 사용자 상호작용에 즉각적으로 반응할 수 있습니다 [20, 22].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[재조정 (Reconciliation)]], [[동시성 렌더링 (Concurrent Rendering)]], [[Critical Rendering Path (CRP)]], [[레이아웃 스래싱 (Layout Thrashing)]]
+- **Projects/Contexts:** [[React 16]], [[React 18 Concurrent Features (useTransition, useDeferredValue)]]
+- **Contradictions/Notes:** 가상 DOM 트리는 설계상 불변(Immutable)으로 취급되지만, React 내부적으로는 현재 설치된 상태(설치된 DOM 노드에 대한 참조 등)를 추적하기 위해 변경 가능한(Mutable) "증강된 DOM(Augmented DOM)" 형태인 Fiber 데이터 구조를 사용합니다 [12].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/가상 DOM과 재조정 (Virtual DOM and Reconciliation).md b/10_Wiki/Topics/Frontend_Mastery/가상 DOM과 재조정 (Virtual DOM and Reconciliation).md
new file mode 100644
index 00000000..3fc18d45
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/가상 DOM과 재조정 (Virtual DOM and Reconciliation).md	
@@ -0,0 +1,33 @@
+# [[가상 DOM과 재조정 (Virtual DOM and Reconciliation)]]
+
+## 📌 Brief 시 Summary
+가상 DOM(Virtual DOM)은 실제 DOM과 동기화되는 사용자 인터페이스(UI)의 가벼운 인메모리(in-memory) 표현입니다 [1, 2]. React는 이 가상 DOM을 사용하여 이전 상태와 새로운 상태를 비교(Diffing)한 뒤, 가장 효율적인 방식으로 실제 DOM을 업데이트하는 '재조정(Reconciliation)' 과정을 수행합니다 [2, 3]. 이 메커니즘은 수동적인 DOM 조작의 비효율성을 추상화하고 선언적인 API를 가능하게 하여 애플리케이션의 렌더링 성능을 최적화합니다 [1, 2].
+
+## 📖 Core Content
+*   **가상 DOM의 도입 배경 및 개념**
+    *   웹 브라우저에서 DOM을 직접 수정하는 것은 브라우저의 중요 렌더링 경로(Critical Rendering Path)에 있는 레이아웃(Layout) 및 페인트(Paint) 단계를 트리거하기 때문에 본질적으로 속도가 느립니다 [1].
+    *   React는 평범한 JavaScript 객체 형태인 가상 DOM을 도입하여 UI 엘리먼트를 표현함으로써 이 문제를 해결합니다 [3]. 이는 일시적인 프레젠테이션 상태를 지속적인 애플리케이션 상태에서 분리하여 불필요한 렌더링 작업을 줄입니다 [3].
+
+*   **휴리스틱 기반의 비교 알고리즘 (Heuristic Diffing Algorithm)**
+    *   일반적으로 두 트리를 비교하는 알고리즘은 $O(n^3)$의 시간 복잡도를 가지며, 이는 실제 애플리케이션에 적용하기에는 너무 무겁습니다 [4, 5].
+    *   React는 두 가지 가정을 바탕으로 $O(n)$의 시간 복잡도를 갖는 휴리스틱 알고리즘을 사용합니다 [4, 6].
+        1.  서로 다른 타입의 엘리먼트는 완전히 다른 트리를 생성합니다 [4, 6].
+        2.  개발자는 `key` prop을 통해 여러 렌더링 사이에서 어떤 자식 엘리먼트가 안정적으로 유지되는지 React에 힌트를 제공할 수 있습니다 [4, 6].
+
+*   **엘리먼트 타입에 따른 업데이트 방식**
+    *   **다른 타입의 엘리먼트:** 루트 엘리먼트의 타입이 다르면(예: `<a>`에서 `<img>`로 변경), React는 이전 트리를 완전히 파괴하고 새로운 트리를 처음부터 다시 구축하며, 이때 이전 트리와 연관된 상태(State)는 모두 소실됩니다 [4, 7].
+    *   **동일한 타입의 DOM 엘리먼트:** 동일한 타입일 경우 기반이 되는 DOM 노드를 그대로 유지하고, 변경된 속성이나 스타일(예: `className`, `color`)만 업데이트합니다 [8, 9].
+    *   **동일한 타입의 컴포넌트 엘리먼트:** 컴포넌트 인스턴스가 동일하게 유지되어 렌더링 간에 상태가 보존됩니다 [9]. 새로운 엘리먼트에 맞춰 props를 업데이트한 후 `render()` 메서드를 호출하고, 그 결과에 대해 비교 알고리즘을 재귀적으로 수행합니다 [9, 10].
+
+*   **자식 노드 재귀 처리와 `key`의 역할**
+    *   React가 자식 노드들을 순회할 때, 기본적으로 두 리스트를 동시에 순회하며 차이가 있을 때마다 변이(mutation)를 생성합니다 [10].
+    *   목록의 맨 앞에 새로운 엘리먼트가 추가되는 경우, 순서가 밀린 모든 자식 노드를 변경해야 하므로 성능이 크게 저하될 수 있습니다 [11].
+    *   이를 해결하기 위해 `key` 속성을 부여하면, React는 원래 트리의 자식과 새로운 트리의 자식을 효율적으로 매치하여 기존 엘리먼트를 그대로 이동시킬 수 있습니다 [11, 12]. 단, 배열의 인덱스를 키로 사용하면 항목이 재정렬될 때 컴포넌트의 상태가 꼬이는 등의 문제가 발생할 수 있습니다 [12, 13].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Fiber Architecture]], [[DOM (Document Object Model)]], [[Critical Rendering Path]]
+- **Projects/Contexts:** [[React]]
+- **Contradictions/Notes:** 초기 구현이나 단순화된 개념에서는 '새롭게 계산된 가상 DOM'과 '이전 가상 DOM'을 직접 비교한다고 설명하지만, React는 단일 자식 노드가 여러 곳에서 공유되는 문제를 해결하기 위해 현재 설치된 상태를 나타내는 변경 가능한(mutable) "증강된 DOM(augmented DOM)"인 Fiber 데이터 구조를 생성하여 활용합니다 [14, 15].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/검색 엔진 최적화 (SEO).md b/10_Wiki/Topics/Frontend_Mastery/검색 엔진 최적화 (SEO).md
new file mode 100644
index 00000000..4394cf20
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/검색 엔진 최적화 (SEO).md	
@@ -0,0 +1,19 @@
+# [[검색 엔진 최적화 (SEO)]]
+
+## 📌 Brief Summary
+현대 프론트엔드 웹 개발 환경에서 검색 엔진 최적화(SEO)는 웹 페이지의 렌더링 방식(CSR, SSR, SSG)에 의해 직접적인 영향을 받습니다 [1-3]. 검색 엔진 크롤러가 웹 페이지의 구조화된 콘텐츠와 메타 태그를 효율적으로 파싱하고 색인화할 수 있도록 보장하는 것이 핵심 목적이며, 서버 측에서 완성된 HTML을 제공하는 방식이 SEO에 가장 유리하게 작용합니다 [4-7].
+
+## 📖 Core 대Content
+*   **렌더링 방식과 SEO의 상관관계:** 어떤 웹 렌더링 전략을 선택하느냐에 따라 검색 엔진이 사이트의 콘텐츠를 크롤링하고 해석하는 속도와 효과가 결정됩니다 [8]. 검색 엔진은 크롤링(Crawling), 렌더링(Rendering), 색인(Indexing)의 세 단계를 거치며, 렌더링 방식은 이 과정의 속도와 완전성에 영향을 미칩니다 [7, 8].
+*   **클라이언트 사이드 렌더링(CSR)의 한계:** CSR은 서버로부터 비어 있는 HTML 셸과 JavaScript 번들을 초기에 전달받습니다 [1, 2, 7, 9]. 검색 엔진 크롤러는 콘텐츠를 보기 위해 JavaScript를 실행해야 하는데, 이 과정은 지연을 유발하거나 신뢰성이 떨어질 수 있으며, 최악의 경우 크롤러가 콘텐츠를 완전히 놓치거나 색인이 늦어지는 문제를 초래하여 SEO에 불리합니다 [1, 2, 7, 9-11].
+*   **서버 사이드 렌더링(SSR)의 이점:** SSR은 사용자의 요청이 있을 때마다 서버에서 완성된 HTML을 생성하여 클라이언트에 전달합니다 [6, 7, 12, 13]. 검색 엔진 크롤러는 JavaScript 실행을 기다릴 필요 없이 즉시 콘텐츠, 메타 태그, 구조화된 데이터(Open Graph 데이터 등)에 접근할 수 있으므로 SEO와 검색 가시성 확보에 매우 강력한 강점을 가집니다 [4-7, 12]. 뉴스 사이트나 이커머스 제품 페이지처럼 검색 발견이 중요한 플랫폼에 이상적입니다 [14, 15].
+*   **정적 사이트 생성(SSG)의 효율성:** SSG는 빌드 타임에 HTML 페이지를 미리 생성하여 CDN을 통해 즉시 제공합니다 [7, 16-18]. 매우 빠른 초기 로드 속도를 제공할 뿐만 아니라, 검색 엔진 봇이 미리 렌더링된 완전한 HTML을 즉시 수신하므로 훌륭한 SEO 역량을 갖춥니다 [7, 16, 19]. 블로그나 마케팅 사이트에 적합합니다 [7, 20].
+*   **SEO 최적화 권장 사항:** CSR을 사용하는 경우 검색 봇이 의미 있는 콘텐츠에 접근할 수 있도록 트래픽이 높은 중요 페이지에 동적 렌더링(Dynamic rendering)이나 서버 렌더링을 적용하는 것이 좋습니다 [21]. SSR이나 SSG를 사용할 때는 미리 렌더링된 결과물에 메타데이터, Open Graph 태그, 구조화된 데이터를 구현하여 SEO 이점을 극대화해야 합니다 [21].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[서버 사이드 렌더링 (SSR)]], [[클라이언트 사이드 렌더링 (CSR)]], [[정적 사이트 생성 (SSG)]]
+- **Projects/Contexts:** [[현대적인 프론트엔드 웹 애플리케이션 아키텍처 설계 및 렌더링 전략 선택 맥락]]
+- **Contradictions/Notes:** 소스에 따르면 최근 구글(Google)과 같은 검색 엔진이 JavaScript를 크롤링하는 능력이 과거에 비해 향상되었다고 언급하고 있으나, 그럼에도 불구하고 CSR 방식은 빈 HTML을 먼저 보여주기 때문에 여전히 서버 렌더링(SSR, SSG) 방식에 비해 SEO 친화적이지 않으며 크롤링 지연이나 누락의 위험이 존재한다고 일관되게 지적합니다 [1, 2, 7].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/단일 페이지 애플리케이션(SPA) 렌더링 설계.md b/10_Wiki/Topics/Frontend_Mastery/단일 페이지 애플리케이션(SPA) 렌더링 설계.md
new file mode 100644
index 00000000..62e68e0e
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/단일 페이지 애플리케이션(SPA) 렌더링 설계.md	
@@ -0,0 +1,25 @@
+# [[단일 페이지 애플리케이션(SPA) 렌더링 설계]]
+
+## 📌 Brief Summary
+단일 페이지 애플리케이션(SPA)의 렌더링 설계는 주로 클라이언트 사이드 렌더링(CSR) 방식을 채택하여 브라우저가 자바스크립트를 통해 동적으로 사용자 인터페이스를 생성하도록 하는 아키텍처를 말합니다 [1], [2]. 이 방식은 서버로부터 기본적인 HTML 셸과 자바스크립트를 한 번에 전달받은 후, 클라이언트 환경에서 페이지의 라우팅과 데이터 표시를 처리합니다 [3], [4], [2]. 화면 전체를 새로고침하지 않아 앱처럼 매끄러운 사용자 경험을 제공하지만, 초기 로드 시간과 검색엔진 최적화(SEO) 측면에서는 약점이 있습니다 [3], [5], [6]. 이러한 특성 때문에 SPA 설계에서는 가상 DOM(Virtual DOM) 활용, 상태 업데이트 배칭(Batching), 하이드레이션(Hydration) 등의 렌더링 성능 최적화 기술이 필수적으로 동반됩니다 [7], [8], [9].
+
+## 📖 Core Content
+*   **클라이언트 사이드 렌더링(CSR)의 동작 방식**
+    SPA 렌더링의 핵심은 렌더링의 주도권이 서버에서 브라우저로 넘어간다는 점입니다. 사용자가 페이지를 요청하면 서버는 본문 내용이 거의 없는 뼈대 형태의 최소 HTML 파일과 자바스크립트 파일을 보냅니다 [4], [2]. 브라우저가 이 자바스크립트 코드를 다운로드, 파싱 및 실행한 뒤에야 동적으로 데이터를 가져오고 사용자 인터페이스를 구축하여 화면에 렌더링합니다 [3], [2].
+*   **SPA 렌더링 설계의 장단점(Trade-offs)**
+    *   **장점:** 전체 페이지를 다시 렌더링하지 않고 필요한 부분만 동적으로 업데이트하기 때문에 상호작용 속도가 매우 빠르고 부드러운 전환이 가능합니다 [10], [5]. 또한 서버는 초기 정적 파일과 API 응답만 제공하면 되므로 서버 부하 및 호스팅 비용이 크게 감소합니다 [10], [11], [12]. 이러한 특성 때문에 SEO보다 상호작용이 중요한 대시보드나 SaaS 플랫폼에 최적화되어 있습니다 [10], [13].
+    *   **단점:** 자바스크립트 번들을 모두 다운로드하고 파싱하기 전까지는 사용자가 빈 화면이나 로딩 스피너만 보게 되어 초기 로딩 속도(First Contentful Paint)가 매우 느립니다 [3], [10], [6], [14]. 더불어 크롤러가 자바스크립트를 실행하지 못하면 빈 페이지만 인식하게 되어 SEO에 매우 불리합니다 [3], [15], [6].
+*   **가상 DOM(Virtual DOM)을 통한 DOM 조작 최적화**
+    SPA는 페이지 업데이트 과정에서 DOM 트리를 빈번하게 조작합니다. 그러나 DOM 트리를 직접 변경할 경우 브라우저의 레이아웃(Reflow)과 페인트(Repaint) 작업이 연쇄적으로 발생하여 렌더링 파이프라인의 성능이 크게 저하될 수 있습니다 [16], [7], [17], [18]. 이를 해결하기 위해 React와 같은 SPA 프레임워크는 메모리상에 가상 DOM을 두고, UI 상태 변경 시 두 트리 간의 차이점(Diffing)을 O(n)의 복잡도로 비교하여 실제 변경된 부분만 한 번에 DOM에 반영합니다 [19], [7], [20], [21].
+*   **렌더링 병목 해결 및 동시성(Concurrent) 설계**
+    사용자 상호작용이 많은 SPA에서 무거운 데이터 처리나 업데이트가 렌더링을 차단하는 것을 막기 위해, 최신 렌더링 설계는 다음과 같은 기법들을 사용합니다.
+    *   **자동 배칭(Automatic Batching):** 여러 상태 업데이트를 단일 렌더링으로 묶어 DOM 렌더링 횟수를 대폭 줄입니다 [8], [22], [23].
+    *   **파이버(Fiber) 아키텍처와 우선순위 분할:** 렌더링 작업을 중단하거나 재개할 수 있는 작은 '작업 단위'로 분할하고, 사용자 입력과 같은 긴급한 업데이트에 높은 렌더링 우선순위를 부여하여 메인 스레드 차단을 방지합니다 [24], [25], [26], [27].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Client-Side Rendering (CSR)]], [[Virtual DOM]], [[Reflow and Repaint]], [[Hydration]]
+- **Projects/Contexts:** React, Vue 등의 프레임워크를 기반으로 하며 SEO보다는 동적이고 즉각적인 인터랙션이 필수적인 대시보드, SaaS 플랫폼, 내부 비즈니스 도구 등을 구축하는 맥락 [4], [13].
+- **Contradictions/Notes:** SPA의 기본 렌더링 방식인 순수 CSR은 초기 로딩과 SEO에 치명적인 약점이 있기 때문에, 최근에는 초기 로딩 시 서버에서 완성된 HTML을 보내고 이후 브라우저에서 상호작용을 연결(Hydration)하는 서버 사이드 렌더링(SSR)이나 정적 사이트 생성(SSG)을 페이지 특성에 맞춰 혼합(Hybrid)하여 사용하는 방식으로 발전하고 있습니다 [28], [9], [29], [30], [31].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/대규모 엔지니어링 프론트엔드 아키텍처 구축.md b/10_Wiki/Topics/Frontend_Mastery/대규모 엔지니어링 프론트엔드 아키텍처 구축.md
new file mode 100644
index 00000000..c3d61a00
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/대규모 엔지니어링 프론트엔드 아키텍처 구축.md	
@@ -0,0 +1,38 @@
+# [[대규모 엔지니어링 프론트엔드 아키텍처 구축]]
+
+## 📌 Brief Summary
+대규모 엔지니어링 프론트엔드 아키텍처에서 CSS는 단순한 시각적 장식이 아닌 유지보수와 협업을 위한 엄격한 엔지니어링 시스템입니다 [1]. 확장 가능한 스타일 시스템을 구축하기 위해서는 네임스페이스 충돌을 막고 모듈화를 강제하는 설계 방식(BEM, CSS Modules, Tailwind)을 전략적으로 채택해야 합니다 [2-7]. 나아가 Layout-in과 Content-out 원칙에 따른 Flexbox 및 Grid의 적절한 혼합, 컨테이너 기반 반응형 디자인, 디자인 토큰 계층화, 그리고 리플로우(Reflow)를 최소화하는 애니메이션 최적화가 필수적입니다 [8-19]. 
+
+## 📖 Core Content
+
+*   **실무를 위한 CSS 구조 설계 방식 및 비교**
+    *   **BEM (Block, Element, Modifier)**: 컴포넌트를 독립적인 단위로 나누고, 예측 가능한 평면적 클래스명 구조를 통해 결합도를 낮추며 응집도를 높이는 수동 규칙 기반 아키텍처입니다 [2, 3, 20, 21]. 하지만 규모가 커질 경우 사람의 실수로 규칙이 훼손될 수 있으며, 빌드 단계에서 사용되지 않는 'Dead Code'를 제거하기 어렵다는 단점이 있습니다 [4, 22, 23].
+    *   **CSS Modules**: 빌드 시점에서 고유하게 해시된 클래스명을 자동 생성하여 완전한 컴포넌트 단위의 격리(Local Scoping)를 보장합니다 [7, 24, 25]. 이는 표준 CSS를 그대로 사용할 수 있어 복잡한 애니메이션과 선택자(가상 요소 등) 작성에 강력하며 런타임 비용이 없습니다 [7, 25, 26].
+    *   **Tailwind CSS (Utility-first 전략)**: 작은 단일 목적의 유틸리티 클래스들을 HTML/JSX에서 직접 조합하는 방식입니다 [27, 28]. JIT(Just-In-Time) 컴파일러를 통해 사용하는 클래스만 번들에 포함되므로 대규모 프로젝트에서도 CSS 파일 크기가 증가하지 않고 일정하게 유지되는 것이 가장 큰 기술적 장점입니다 [28-30]. 하지만 HTML이 장황해지고(Verbose), 복잡한 마크업을 야기한다는 한계가 있습니다 [29, 30].
+    *   **하이브리드 전략 (실무 관리 방법)**: 대규모 엔지니어링 환경에서는 레이아웃과 간격 등 빠른 속도와 일관성이 필요한 곳에는 Tailwind를 활용하고, 고도로 복잡한 컴포넌트나 특별한 선택자가 필요한 곳에는 CSS Modules를 혼합하여 사용하는 전략이 널리 채택되고 있습니다 [31, 32]. 또한 기능 주도형(Feature-Driven) 폴더 구조를 채택하여, 각 기능 디렉토리 내에 컴포넌트와 관련 CSS 모듈을 함께 배치(Co-location)함으로써 코드를 쉽게 유지보수 및 삭제할 수 있게 합니다 [33, 34].
+
+*   **레이아웃 아키텍처: Flexbox와 CSS Grid**
+    *   레이아웃을 설계할 때는 두 도구의 목적을 명확히 구분해야 합니다. CSS Grid는 'Layout-in(레이아웃 우선)' 방식으로, 행과 열의 전체 뼈대를 먼저 정의하고 내부 셀에 요소를 배치하는 2차원 페이지 구조화에 이상적입니다 [9, 35-37]. 반면 Flexbox는 'Content-out(콘텐츠 우선)' 방식으로, 단일 행 또는 열 내에서 개별 아이템들의 크기와 여백을 콘텐츠 길이에 따라 유연하게 분배 및 정렬하는 데 사용하는 1차원 도구입니다 [9, 10, 35, 38].
+    *   가장 확장성 있는 아키텍처는 메인 대규모 레이아웃은 Grid로 구축하고, 해당 셀 내부의 세부 UI 요소들은 Flexbox로 정렬하는 조합입니다 [10, 39].
+
+*   **컨테이너 기반 반응형 디자인**
+    *   모바일 최우선(Mobile-first) 디자인 접근이 표준이며 [40, 41], 뷰포트 크기 기반의 전통적 미디어 쿼리를 넘어 컴포넌트 부모 크기에 반응하는 **컨테이너 쿼리(Container Queries)**가 권장됩니다 [12, 13, 42, 43]. 이는 동일한 컴포넌트라도 좁은 사이드바에 있을 때와 넓은 메인 영역에 있을 때 스스로 적응할 수 있도록 하여 재사용성을 높입니다 [13, 42].
+    *   또한 `clamp(min, preferred, max)` 함수를 이용한 **반응형 타이포그래피(Fluid Typography)**를 통해 수많은 중단점(Breakpoint) 추가 없이 유동적으로 글꼴 크기를 조정할 수 있습니다 [14, 44, 45]. 
+
+*   **성능 중심 애니메이션 (Transition / Keyframes)**
+    *   기능적 UX 애니메이션은 마이크로 인터랙션을 통한 작업 피드백 제공, 공간적 위치 안내(Spatial Orientation), 주의 집중을 위해 주로 사용되며 보통 200ms에서 500ms 사이의 지속시간과 ease-in-out의 가속도를 가져야 자연스럽습니다 [46-54].
+    *   애니메이션 적용 시 가장 주의할 점은 성능 최적화입니다. `width`, `height`, `margin` 등의 속성은 렌더링 파이프라인에서 무거운 연산인 리플로우(Reflow)와 리페인트(Repaint)를 유발하므로 애니메이션 적용을 피해야 합니다 [18, 55-57]. 부드러운 60fps 화면을 위해 브라우저의 GPU 가속이 가능한 `transform` 및 `opacity` 속성만을 변경해야 합니다 [19, 58, 59]. 
+
+*   **디자인 시스템 개념 및 토큰화**
+    *   디자인 시스템은 시각적 정체성의 프로그래밍적 구현체입니다. 디자인 시스템의 핵심은 **디자인 토큰(Design Tokens)**으로, 색상, 타이포그래피, 간격 등의 원시 값을 저장하는 플랫폼 독립적 변수입니다 [15, 60].
+    *   토큰은 1) 원시 값인 전역 토큰(Global), 2) 시맨틱한 의도를 가진 별칭 토큰(Alias), 3) 개별 요소에 할당되는 컴포넌트 토큰(Component)의 3단계로 추상화됩니다 [16, 61]. Style Dictionary와 같은 도구를 통해 이러한 토큰 JSON 파일을 CSS, iOS(Swift), Android(XML)용 코드로 자동 변환하는 파이프라인을 구축하면, 모든 플랫폼에서 '단일 진실 공급원(Single Source of Truth)'을 보장할 수 있습니다 [17, 62].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[CSS Container Queries]], [[Fluid Typography]], [[Design Tokens]], [[Reflow and Repaint]], [[Feature-Driven Architecture]]
+- **Projects/Contexts:** [[Style Dictionary Pipelines]], [[Next.js App Router Styling Strategies]]
+- **Contradictions/Notes:** 
+  - 과거에 인기를 끌었던 Styled-components와 같은 CSS-in-JS 라이브러리는 동적인 스타일링에 장점이 있으나, React Server Components(RSC) 환경과의 비호환성 및 런타임 오버헤드 문제가 대두되었습니다 [63, 64]. 그 결과 2025년 이후의 대규모 엔지니어링 시스템에서는 빌드 시 정적 CSS를 생성하는 Zero-runtime CSS-in-JS (Vanilla Extract) 혹은 CSS Modules, Tailwind로의 회귀가 권장되고 있습니다 [65-68].
+  - Tailwind CSS에 대한 견해 차이가 존재합니다. 작성 속도, CSS 파일 크기 관리 측면에서 압도적 우위를 지니지만 [27-29], 클래스명이 지나치게 길어져 HTML의 시인성이 떨어지고 "인라인 스타일과 다를 바 없다"는 비판도 존재합니다 [29, 30, 69]. 따라서 대형 프로젝트는 Tailwind와 CSS Modules를 결합하는 하이브리드 아키텍처를 선호하기도 합니다 [32].
+
+---
+*Last updated: 2026-04-26*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/대규모 콘텐츠 기반 애플리케이션 및 전자상거래 플랫폼 구축.md b/10_Wiki/Topics/Frontend_Mastery/대규모 콘텐츠 기반 애플리케이션 및 전자상거래 플랫폼 구축.md
new file mode 100644
index 00000000..9d03407c
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/대규모 콘텐츠 기반 애플리케이션 및 전자상거래 플랫폼 구축.md	
@@ -0,0 +1,22 @@
+# [[대규모 콘텐츠 기반 애플리케이션 및 전자상거래 플랫폼 구축]]
+
+## 📌 Brief Summary
+대규모 콘텐츠 기반 애플리케이션 및 전자상거래 플랫폼 구축은 방대한 데이터와 트래픽을 처리하면서도 빠른 초기 로딩 속도와 최적화된 검색 엔진 최적화(SEO)를 달성하기 위해 적절한 렌더링 전략과 아키텍처를 선택하는 과정입니다. 이러한 대규모 플랫폼은 컴포넌트 기반 아키텍처(CBA)를 활용하여 시스템을 모듈화하고 확장성을 확보합니다. 또한, 콘텐츠의 업데이트 빈도와 상호작용 요구사항에 따라 서버 사이드 렌더링(SSR), 정적 사이트 생성(SSG), 점진적 정적 재생성(ISR), React 서버 컴포넌트(RSC)를 전략적으로 혼합 적용하여 성능과 사용자 경험의 균형을 맞추는 것이 핵심입니다.
+
+## 📖 Core Content
+*   **렌더링 전략의 전략적 선택 (SSR, SSG, ISR):** 대규모 콘텐츠 웹사이트(블로그, 뉴스)와 전자상거래 플랫폼은 SEO와 초기 콘텐츠 가시성이 매우 중요합니다.
+    *   **SSR (서버 사이드 렌더링):** 제품 목록 페이지, 카테고리 브라우징, 개별 제품 세부 정보 뷰 등에 이상적입니다[1, 2]. 검색 엔진 크롤러가 전체 HTML 콘텐츠에 즉시 접근할 수 있어 제품 발견을 위한 검색 가시성이 향상되며, 초기 콘텐츠를 빠르게 표시하여 전환율에 긍정적인 영향을 미칩니다[1, 3, 4].
+    *   **SSG (정적 사이트 생성):** 콘텐츠가 자주 변경되지 않는 문서, 마케팅 웹사이트, 블로그에 적합하며, 미리 빌드된 페이지를 CDN을 통해 즉각적으로 제공하여 초고속 성능과 뛰어난 SEO를 보장합니다[5, 6]. 전자상거래의 경우, 실시간 재고 변경보다는 정해진 빌드 프로세스를 통해 업데이트되는 안정적인 제품 라인에 유용합니다[7].
+    *   **ISR (점진적 정적 재생성):** 전자상거래 플랫폼 및 대규모 콘텐츠 사이트에 성능과 신선도의 최적의 균형을 제공합니다[7, 8]. 캐시된 정적 페이지를 즉시 제공하면서 백그라운드에서 콘텐츠를 갱신하므로, 수천 개의 콘텐츠 페이지나 방대한 제품 카탈로그를 빌드 시간의 급증 없이 효율적으로 관리하고 가격이나 인벤토리를 최신 상태로 유지할 수 있습니다[9-11].
+
+*   **React 서버 컴포넌트(RSC)를 통한 대규모 최적화:** 대규모 프로덕션 시스템에서 RSC는 클라이언트 측 복잡성과 자바스크립트 번들 크기를 극적으로 줄입니다. 제품 카탈로그나 읽기 전용 콘텐츠 페이지와 같은 비대화형 컴포넌트의 렌더링을 서버로 이동시켜, 클라이언트로 전송되는 자바스크립트를 최소화합니다[12, 13]. 또한, 컴포넌트 렌더링 중에 데이터베이스나 백엔드 서비스에 직접 병렬로 접근함으로써 데이터 페칭의 순차적 지연(Waterfall) 현상을 제거하고 응답 속도를 개선합니다[14-16].
+
+*   **컴포넌트 기반 아키텍처(CBA)의 적용:** 대규모 플랫폼은 CBA를 통해 확장성과 유지보수성을 극대화합니다. 전체 시스템을 쇼핑 카트, 결제 처리기, 추천 엔진, 제품 목록 등 독립적이고 재사용 가능한 컴포넌트로 분리합니다[17, 18]. 이 구조는 트래픽 급증 시 특정 컴포넌트(예: 쇼핑카트) 인스턴스를 독립적으로 확장할 수 있게 해 주며[19], 여러 팀이 병렬로 각 컴포넌트를 개발하고 배포할 수 있어 대규모 비즈니스 요구에 민첩하게 대응할 수 있도록 돕습니다[20-22].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Server-Side Rendering (SSR)]], [[Incremental Static Regeneration (ISR)]], [[Component-Based Architecture (CBA)]], [[React Server Components (RSC)]]
+- **Projects/Contexts:** [[전자상거래 플랫폼의 제품 카탈로그 및 렌더링 최적화]], [[대규모 뉴스 및 블로그 시스템 구축]]
+- **Contradictions/Notes:** 소스에 따르면, SSG는 초고속 로딩을 제공하지만 라이브 스코어나 실시간 대시보드, 빈번한 재고 변경이 필요한 데이터에는 적합하지 않아 전체 사이트 재빌드의 부담이 있습니다. 이에 대한 대안이자 타협점으로 백그라운드에서 점진적으로 페이지를 업데이트하는 ISR이 대규모 전자상거래 시스템에 강력히 권장됩니다[2, 9, 23, 24].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/동시성 렌더링 (Concurrent Rendering).md b/10_Wiki/Topics/Frontend_Mastery/동시성 렌더링 (Concurrent Rendering).md
new file mode 100644
index 00000000..24f54c6f
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/동시성 렌더링 (Concurrent Rendering).md	
@@ -0,0 +1,25 @@
+# [[동시성 렌더링 (Concurrent Rendering)]]
+
+## 📌 Brief Summary
+동시성 렌더링(Concurrent Rendering)은 React의 Fiber 아키텍처를 기반으로 메인 스레드를 동기적으로 차단하지 않고 렌더링 작업을 중단 및 재개할 수 있도록 하는 렌더링 방식입니다 [1, 2]. 이 기술은 전체 렌더링 작업을 작은 단위로 쪼개어 처리하는 타임 슬라이싱(Time-Slicing)을 통해, 긴급한 사용자 상호작용을 우선적으로 처리할 수 있도록 브라우저에 제어권을 양보합니다 [2-4]. 이를 통해 무거운 연산이 백그라운드에서 진행되는 동안에도 UI의 반응성을 부드럽게 유지할 수 있습니다 [4, 5].
+
+## 📖 Core Content
+- **Fiber 아키텍처와 작업 분할 (Time-Slicing)**
+  기존의 동기식 스택 리컨실러(Stack Reconciler)가 메인 스레드를 길게 차단하여 UI가 멈추는 문제를 해결하기 위해, React 16부터 도입된 Fiber 아키텍처는 동시성 렌더링을 지원합니다 [1, 2]. 전체 렌더링 작업을 '작업 단위(unit of work)'인 Fiber 노드로 나누어 처리하며, 각 작업 후 브라우저에 제어권을 양보(yield)하여 더 높은 우선순위의 작업(예: 사용자 입력)이 있는지 확인합니다 [3, 6]. 렌더링 단계는 이렇게 중단과 재개가 가능하지만, 실제 DOM을 변경하는 커밋 단계는 동기적으로 처리됩니다 [7, 8].
+
+- **우선순위 기반의 레인(Lane) 모델**
+  동시성 렌더링은 '레인(Lane)'이라는 비트마스크 시스템을 통해 렌더링 작업의 우선순위를 관리합니다 [9, 10]. 클릭이나 타이핑 같은 사용자 상호작용은 가장 높은 우선순위(Sync Lane)로 즉시 처리되고, 화면에 보이지 않는 요소의 렌더링이나 무거운 데이터 업데이트는 낮은 우선순위(Idle 또는 Default Lane)로 미루어집니다 [9, 11].
+
+- **React 18/19의 동시성 훅 (Concurrent Features)**
+  `useTransition`과 `useDeferredValue` 훅은 이 동시성 렌더링 모델을 직접적으로 활용합니다 [5]. `useTransition`은 대규모 목록 필터링과 같은 비긴급 상태 업데이트의 우선순위를 낮춰 입력 지연을 방지하며 [5, 12], `useDeferredValue`는 무거운 렌더링 계산이 필요한 값의 적용을 지연시킵니다 [12, 13]. 
+
+- **동시성 하이드레이션 (Concurrent Hydration)**
+  React 18부터는 하이드레이션 과정에도 동시성 렌더링이 적용됩니다 [14]. 거대한 덩어리의 하이드레이션 작업을 작은 조각으로 나누어 브라우저의 상호작용 처리를 방해하지 않게 하며, Suspense와 결합할 경우 사용자가 상호작용하는 UI 컴포넌트부터 우선적으로 하이드레이션하여 초기 로딩 성능(Total Blocking Time)을 크게 개선합니다 [14, 15].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[React Fiber Architecture]], [[Time-Slicing]], [[Lane Model]], [[Reconciliation]]
+- **Projects/Contexts:** [[React 18/19 Performance Optimization]], [[Concurrent Hydration]]
+- **Contradictions/Notes:** 동시성 렌더링 기능(`useTransition`, `useDeferredValue` 등)은 애플리케이션의 실제 코드 실행 속도를 높이는 것이 아니라, 무거운 연산 중에도 긴급한 피드백을 방해하지 않도록 처리 순서를 조정함으로써 앱이 더 빠르게 "느껴지도록(feel faster)" 체감 성능을 향상시키는 역할을 합니다 [16].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/렌더링 차단 리소스(Render-blocking resources).md b/10_Wiki/Topics/Frontend_Mastery/렌더링 차단 리소스(Render-blocking resources).md
new file mode 100644
index 00000000..c6c1351f
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/렌더링 차단 리소스(Render-blocking resources).md	
@@ -0,0 +1,22 @@
+# [[렌더링 차단 리소스(Render-blocking resources)]]
+
+## 📌 Brief Summary
+렌더링 차단 리소스란 브라우저가 화면에 페이지를 그리는 렌더링 과정을 일시적으로 중단하게 만드는 핵심 웹 리소스를 뜻합니다 [1]. 대표적인 예인 CSS는 스타일이 적용되지 않은 화면(FOUC)이 사용자에게 노출되는 것을 막기 위해 CSSOM이 완전히 구성될 때까지 렌더링을 막습니다 [2, 3]. 동기적으로 실행되는 JavaScript 또한 HTML 파서를 멈추게 만들어 결과적으로 렌더링을 차단합니다 [4, 5]. 이러한 리소스들을 비동기 처리하거나 다운로드를 지연시키는 등 최적화하는 것은 초기 페이지 로드 속도와 웹 성능을 향상시키는 핵심 요소입니다 [6, 7].
+
+## 📖 Core Content
+- **CSS의 렌더링 차단 원리**: 브라우저가 문서 파싱 중 일부 외부 리소스 요청을 만나면 해당 에셋이 처리될 때까지 렌더링을 중단합니다 [8]. CSS는 기본적으로 렌더링 차단 리소스로 동작하는데, 그 이유는 나중에 로드된 스타일 규칙이 이전 규칙을 덮어씌울 수 있기 때문에 브라우저가 CSSOM(CSS Object Model)을 완성하기 전까지 화면 렌더링을 보류해야 하기 때문입니다 [3]. 이는 사용자가 스타일이 입혀지지 않은 HTML 원본을 보게 되는 '스타일 없는 콘텐츠의 번쩍임(FOUC)' 현상을 방지하기 위한 안전장치입니다 [2]. `<head>` 태그 내에 존재하는 렌더링 차단 리소스는 사실상 페이지 전체의 렌더링을 차단합니다 [9].
+- **파서 차단(Parser-blocking)과 JavaScript**: JavaScript는 기본적으로 파서를 차단하는 리소스입니다 [5]. 스크립트 실행 과정에서 DOM이나 CSSOM이 어떻게 변경될지 알 수 없으므로, 브라우저는 실행이 완료될 때까지 HTML 파싱을 중단합니다 [5, 10]. 파싱이 막히면 브라우저는 그 이후의 콘텐츠에 접근해 렌더링할 수 없기 때문에, 파서 차단 리소스는 결과적으로 렌더링도 차단하게 됩니다 [11].
+- **차단 우회 및 최적화 방법**:
+  - CSS의 경우 `<link>` 요소에 `media="print"`와 같이 현재 뷰포트 조건과 일치하지 않는 미디어 속성을 지정하면 렌더링을 차단하지 않도록 만들 수 있습니다 [12].
+  - JavaScript의 경우 `<script>` 태그에 `async` 또는 `defer` 속성을 추가하여 파서와 렌더링이 막히는 것을 방지할 수 있습니다 [5, 13].
+  - 중요하지 않은 리소스의 다운로드를 지연시키고, CSS 선택자 특이성을 최적화하거나 축소(minifying)하여 전체 차단 시간을 줄여야 합니다 [6, 14].
+  - 최신 기술로는 Chrome 105부터 도입된 `blocking=render` 속성을 통해 파서는 계속 진행하도록 두면서 명시적으로 렌더링만 차단하게 설정할 수도 있습니다 [5].
+- **측정 및 식별**: WebPageTest, Lighthouse 등과 같은 성능 감사 도구는 렌더링 차단 리소스를 식별하는 기능을 제공합니다. 이를 통해 어떤 리소스가 실제 페이지 렌더링을 지연시키고 있는지 찾아내어 최적화의 단서로 삼을 수 있습니다 [15].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[핵심 렌더링 경로(Critical rendering path)]], [[CSSOM(CSS Object Model)]], [[파서 차단 리소스(Parser-blocking resources)]], [[FOUC(Flash of Unstyled Content)]]
+- **Projects/Contexts:** [[웹 성능 최적화(Web Performance Optimization)]], [[Lighthouse 성능 감사]]
+- **Contradictions/Notes:** 소스에 따르면 CSS가 렌더링을 차단한다고 해서 브라우저의 모든 작업이 중지되는 것은 아닙니다. 브라우저는 CSS를 다운로드하고 렌더링을 일시 정지한 상태에서도 나머지 HTML을 계속 처리하며 할 수 있는 다른 작업(예: 리소스 탐색 등)을 수행하여 효율성을 높입니다 [12]. 또한, 과거에는 렌더링 차단 리소스가 페이지 전체 렌더링을 막았으나 최근 브라우저(Firefox, Chrome)는 렌더링 차단 리소스 아래에 있는 콘텐츠의 렌더링만 차단하도록 동작 방식이 개선되었습니다 [9].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/리플로우 및 리페인트(Reflow & Repaint).md b/10_Wiki/Topics/Frontend_Mastery/리플로우 및 리페인트(Reflow & Repaint).md
new file mode 100644
index 00000000..e001c569
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/리플로우 및 리페인트(Reflow & Repaint).md	
@@ -0,0 +1,27 @@
+# [[리플로우 및 리페인트(Reflow & Repaint)]]
+
+## 📌 Brief Summary
+리플로우(Reflow)는 요소의 너비, 높이 등 레이아웃이나 기하학적 구조가 변경될 때 브라우저가 문서의 구조를 재계산하는 과정이며, 리페인트(Repaint)는 레이아웃에 영향을 주지 않는 시각적 요소(색상, 배경 등)가 변경될 때 발생하여 화면을 다시 그리는 과정입니다 [1-3]. 두 과정 모두 연산 비용이 높고 렌더링 성능을 저하시켜 화면 끊김(Jank) 현상을 유발할 수 있으므로, CSS 및 애니메이션 구현 시 이들의 발생을 최소화하는 최적화 전략이 필수적입니다 [1, 4, 5].
+
+## 📖 Core Content
+**리플로우와 리페인트의 개념 및 비용**
+*   **리플로우(Reflow):** 요소의 레이아웃, 크기, 위치 등에 영향을 주는 변경 사항이 있을 때 발생합니다. 한 요소에서 리플로우가 발생하면 해당 요소의 자식, 부모 노드는 물론 DOM 트리에서 그 뒤에 오는 모든 요소까지 재계산되어야 하므로 성능 측면에서 매우 비쌉니다 [3, 5]. 심한 경우 페이지 전체를 다시 레이아웃하는 것과 같습니다 [5].
+*   **리페인트(Repaint):** 윤곽선(outline), 가시성(visibility), 배경색 등 레이아웃에는 영향을 주지 않지만 시각적인 스킨이 변경될 때 일어납니다 [3]. 브라우저는 시각적 변화를 반영하기 위해 다른 모든 노드의 가시성을 확인해야 하므로 이 또한 비용이 듭니다 [3]. 브라우저는 렌더 트리 생성 후 레이아웃을 계산하고 그 후에 페인트를 수행합니다 [6].
+
+**발생 원인**
+*   창 크기 조절, 폰트 변경, 스타일시트 추가/제거, 사용자의 입력(텍스트 타이핑 등), DOM 조작, `:hover`와 같은 가상 클래스 활성화, `offsetWidth` 및 `offsetHeight` 속성 계산, 인라인 스타일 설정 등이 리플로우를 유발합니다 [7, 8].
+*   애니메이션 적용 시 `width`, `height`, `margin`, `padding`, `top`, `left`, `box-shadow` 등의 속성을 변경하면 레이아웃 스래싱(Layout Thrashing)과 리페인트 주기를 촉발하여 성능이 급격히 저하됩니다 [4, 9, 10].
+
+**최적화 및 감소 기법**
+*   **DOM 및 스타일 조작 최소화:** 여러 개의 인라인 스타일을 각각 적용하는 것을 피하고, 변경 사항을 외부 클래스로 결합하여 한 번의 클래스 속성 조작으로 리플로우가 한 번만 발생하게 해야 합니다 [8, 11]. DOM 트리의 가능한 가장 낮은 계층(하위)에서 클래스를 변경하여 리플로우의 영향을 받는 노드 수를 줄이는 것이 좋습니다 [12]. DOM 변경 시에는 `documentFragment`를 사용하여 일괄 업데이트해야 합니다 [11, 13].
+*   **애니메이션 최적화:** 레이아웃을 건드리는 속성 대신 `transform`, `opacity`, `filter` 속성을 사용하여 애니메이션을 처리하면 리플로우를 방지하고 렌더링 성능을 높일 수 있습니다 [2, 10, 14]. 또한 `position: fixed` 또는 `absolute`인 요소에 애니메이션을 적용하면 전체 문서의 리플로우 대신 부분적인 리페인트만 유발할 수 있습니다 [15].
+*   **브라우저 힌팅(Hinting) 및 동기화:** 잦은 변경이 예상되는 요소에 `will-change` 속성을 부여하여 브라우저가 렌더링을 미리 최적화하도록 유도할 수 있습니다 [16-18]. 아울러 애니메이션은 브라우저의 리페인트 주기와 동기화되는 `requestAnimationFrame`을 사용하여 일괄 처리해야 합니다 [13, 18].
+*   **레이아웃 스래싱 방지 및 기타 주의사항:** DOM을 읽고 쓰는 작업을 명확히 분리하여(배칭) 브라우저가 강제로 동기식 리플로우를 발생시키는 레이아웃 스래싱을 방지해야 합니다 [13, 18]. 또한 렌더링을 지연시키고 작은 변경에도 모든 노드의 리플로우를 발생시키는 테이블(Table) 레이아웃 사용을 피하고 [19], 너무 복잡하고 깊게 중첩된 CSS 선택자를 사용하지 말아야 합니다 [11].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[CSS 애니메이션 최적화(CSS Animations Optimization)]], [[레이아웃 스래싱(Layout Thrashing)]], [[렌더링 파이프라인(Rendering Pipeline)]]
+- **Projects/Contexts:** [[대규모 프론트엔드 프로젝트(Large Frontend Projects)]], [[반응형 디자인 및 인터랙티브 UI(Responsive and Interactive UI)]]
+- **Contradictions/Notes:** 소스에 따르면 `will-change` 속성은 성능 향상에 도움이 되지만, 과도하게 사용할 경우 오히려 브라우저의 시스템 리소스를 많이 소모하여 성능 저하를 유발할 수 있으므로 꼭 필요한 요소(최후의 수단)에만 신중하게 사용해야 한다고 경고합니다 [16, 17].
+
+---
+*Last updated: 2026-04-26*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/리플로우 및 리페인트(Reflow and Repaint).md b/10_Wiki/Topics/Frontend_Mastery/리플로우 및 리페인트(Reflow and Repaint).md
new file mode 100644
index 00000000..a30d34cc
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/리플로우 및 리페인트(Reflow and Repaint).md	
@@ -0,0 +1,28 @@
+# [[리플로우 및 리페인트(Reflow and Repaint)]]
+
+## 📌 Brief Summary
+리플로우(Reflow)는 브라우저가 화면 내 요소들의 기하학적 위치와 크기를 재계산하는 과정을 의미하며 컴퓨팅 자원을 많이 소모합니다 [1-3]. 반면 리페인트(Repaint)는 레이아웃에 영향을 주지 않는 시각적 스타일 변화(색상, 그림자 등)를 픽셀로 변환하여 화면에 그리는 작업입니다 [1, 4]. 두 과정 모두 웹 페이지의 크리티컬 렌더링 패스(CRP)에서 화면을 업데이트하는 데 필수적이지만, 과도하게 발생할 경우 웹 페이지의 성능을 크게 저하시키므로 이를 최소화하는 것이 프론트엔드 성능 최적화의 핵심입니다 [5-7].
+
+## 📖 Core Content
+*   **리플로우(Reflow / Layout)의 메커니즘과 영향:**
+    *   브라우저가 뷰포트 크기와 박스 모델을 기반으로 렌더 트리 내 모든 가시적 요소의 정확한 위치와 크기(x, y, 너비, 높이)를 계산하는 과정입니다 [3, 8, 9].
+    *   주로 창 크기 조절(Resizing), DOM 요소의 추가 및 제거, 마진이나 패딩 등 레이아웃에 영향을 주는 속성이 변경될 때 트리거됩니다 [1, 4, 10].
+    *   문서 흐름(Document flow)의 특성상 단일 요소의 기하학적 변화가 렌더 트리 전체의 연쇄적인 재계산(Cascade of recalculations)을 유발할 수 있으므로, 리플로우는 연산 비용이 매우 높은 작업에 속합니다 [2, 7, 8].
+
+*   **리페인트(Repaint / Paint)의 메커니즘과 영향:**
+    *   기하학적 구조 계산이 완료된 후, 스타일 정보를 바탕으로 렌더 트리의 각 노드를 실제 화면의 픽셀로 래스터화(Rasterizing)하는 과정입니다 [1, 11, 12].
+    *   배경색, 텍스트 색상, 그림자(box-shadow), 가시성 등 레이아웃 수치를 변경하지 않는 시각적 속성 변화가 있을 때만 발생합니다 [1, 4, 10].
+    *   리플로우보다는 계산 비용이 상대적으로 적지만, 애니메이션 도중 과도하게 트리거되면 프레임 드랍이나 버벅거림(Jank)을 일으켜 CPU/GPU 사용량을 높이고 모바일 기기의 배터리를 소모시킬 수 있습니다 [2, 6, 11].
+
+*   **성능 최적화 전략 (Optimization Strategies):**
+    *   **CSS 속성 최적화:** 리플로우를 유발하는 속성(예: `top`, `left`, `width`, `height`) 대신 `transform` 속성을 활용하여 애니메이션을 구현하면, 새로운 레이아웃이나 페인트 사이클을 유발하지 않고 GPU 가속을 통해 처리할 수 있습니다 [6, 7, 11]. 
+    *   **가시성 제어 활용:** 요소를 화면에서 숨길 때 렌더 트리에서 완전히 제거하여 리플로우를 유발하는 `display: none` 대신, 시각적으로만 숨기고 공간을 유지해 리페인트만 유발하는 `visibility: hidden`을 사용하는 것이 유리할 수 있습니다 [13, 14].
+    *   **DOM 조작 최소화 및 배치(Batching) 처리:** 자바스크립트 반복문 내에서의 DOM 조작을 피하고 변경 사항을 일괄 처리해야 합니다 [6, 7]. 또한, React와 같이 가상 DOM(Virtual DOM)을 사용하는 프레임워크는 변경된 부분만을 계산하여 실제 DOM에 반영함으로써 불필요한 리플로우와 리페인트 횟수를 줄이는 데 도움을 줍니다 [6, 15].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Critical Rendering Path (CRP)]], [[Render Tree]], [[Virtual DOM]], [[Document Object Model (DOM)]], [[CSS Object Model (CSSOM)]], [[GPU Acceleration]]
+- **Projects/Contexts:** [[프론트엔드 웹 렌더링 성능 최적화]], [[React의 컴포넌트 아키텍처 및 렌더링 최적화(Reconciliation)]]
+- **Contradictions/Notes:** 소스에 관련 정보가 부족합니다. (제공된 모든 소스는 리플로우와 리페인트의 특성 및 이를 최소화해야 한다는 최적화 원칙에 대해 모순 없이 일치된 견해를 보입니다.)
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/마이크로서비스 아키텍처 (Microservices Architecture).md b/10_Wiki/Topics/Frontend_Mastery/마이크로서비스 아키텍처 (Microservices Architecture).md
new file mode 100644
index 00000000..4b69b11c
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/마이크로서비스 아키텍처 (Microservices Architecture).md	
@@ -0,0 +1,27 @@
+# [[마이크로서비스 아키텍처 (Microservices Architecture)]]
+
+## 📌 Brief Summary
+마이크로서비스 아키텍처(Microservices Architecture)는 애플리케이션을 API를 통해 통신하는 느슨하게 결합되고 독립적으로 배포 가능한 여러 개의 서비스로 분할하는 소프트웨어 아키텍처입니다 [1]. 이는 컴포넌트 기반 아키텍처(CBA)의 한 유형 혹은 연장선으로 볼 수 있으며, 높은 확장성과 결함 격리(fault isolation)를 제공합니다 [2, 3]. 전체적으로 제공된 문서가 프론트엔드 및 렌더링에 집중되어 있어, **소스에 관련 정보가 부족합니다.** 
+
+## 📖 Core Content
+제공된 소스에서 확인 가능한 마이크로서비스 아키텍처에 대한 핵심 내용은 다음과 같습니다. (그 외의 심층적인 백엔드 구조나 구체적인 설계 패턴에 대해서는 **소스에 관련 정보가 부족합니다.**)
+
+* **아키텍처의 정의 및 특징**
+  * 애플리케이션을 독립적으로 배포할 수 있는 서비스들로 나누며, 이들은 API를 통해 서로 통신합니다 [1].
+  * 컴포넌트 기반 아키텍처(CBA)의 한 유형으로도 분류되며, 컴포넌트들이 사용량에 따라 독립적으로 확장할 수 있는 클라우드 네이티브(cloud-native) 및 마이크로서비스 환경에 이상적인 구조입니다 [2, 4].
+* **주요 장점 (Pros)**
+  * 높은 확장성(High scalability)과 결함 격리(fault isolation) 기능을 제공합니다 [3].
+  * 서비스의 독립적인 개발 및 배포가 가능하여 민첩성을 높입니다 [3].
+* **주요 단점 (Cons)**
+  * 설정과 관리가 훨씬 복잡하며, 데브옵스(DevOps)에 대한 전문 지식이 요구됩니다 [3].
+  * 네트워크 지연(network latency)을 유발하거나 디버깅을 어렵게 만드는 원인이 될 수 있습니다 [3].
+* **적용 사례 (Use Case)**
+  * 다양한 팀이 병렬로 작업해야 하는 대규모(Large-scale) 애플리케이션 개발 환경에 가장 적합합니다 [3].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[컴포넌트 기반 아키텍처 (Component-Based Architecture)]], [[모놀리식 아키텍처 (Monolithic Architecture)]]
+- **Projects/Contexts:** 대규모 애플리케이션 개발, 클라우드 네이티브 환경, 그리고 여러 팀의 병렬 개발(Parallel development) 맥락 [3, 4]
+- **Contradictions/Notes:** 소스의 주요 주제가 'React 및 프론트엔드 최적화'이기 때문에 마이크로서비스에 대한 심층적인 기술 정보는 소스에 부족하며, 주로 '컴포넌트 기반 아키텍처'의 대안적 모델 및 활용 사례로서만 간략히 등장합니다 [1, 3].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/메인 스레드 (Main Thread).md b/10_Wiki/Topics/Frontend_Mastery/메인 스레드 (Main Thread).md
new file mode 100644
index 00000000..6be6daa9
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/메인 스레드 (Main Thread).md	
@@ -0,0 +1,25 @@
+# [[메인 스레드 (Main Thread)]]
+
+## 📌 Brief Summary
+메인 스레드는 브라우저가 HTML을 파싱하여 DOM 트리를 구축하고, 자바스크립트를 실행하며, 페이지의 레이아웃과 페인트를 포함한 렌더링을 처리하는 핵심 단일 스레드입니다 [1-4]. 브라우저는 기본적으로 단일 스레드 구조이므로, 메인 스레드가 작업을 진행 중일 때는 다른 요청이나 사용자 상호작용을 동시에 처리할 수 없습니다 [1, 5]. 따라서 메인 스레드의 점유 시간을 최소화하고 책임을 줄이는 것이 빠르고 반응성 높은 웹 성능을 확보하는 핵심 요건입니다 [1].
+
+## 📖 Core Content
+- **주요 역할 및 병목 현상**
+  메인 스레드는 DOM 트리 생성, 자바스크립트 컴파일 및 해석(웹 워커 등 일부 예외 제외), 화면 렌더링 등 브라우저의 대부분의 주요 작업을 전담합니다 [2-4]. 초기 로드 과정이나 무거운 자바스크립트 파싱 및 실행으로 인해 메인 스레드가 오랫동안 점유될 경우, 사용자의 클릭이나 스크롤과 같은 상호작용 이벤트에 50ms 이내로 반응하지 못하게 되어 UI가 지연(Jank)되거나 멈춘 것처럼 느껴지게 됩니다 [6, 7]. 특히 초기 로드 중 메인 스레드에서의 과도한 처리는 코어 웹 바이탈(Core Web Vitals) 수치 하락과 검색 순위(SEO) 페널티로 이어질 수 있습니다 [8].
+
+- **성능 예산(Frame Budget)과 반응성**
+  애니메이션과 스크롤을 60fps로 부드럽게 유지하려면, 메인 스레드를 차지하는 스타일 계산, 리플로우(Reflow), 페인트(Paint) 등의 작업이 16.67ms 이내에 완료되어야 합니다 [9, 10]. 규모가 큰 애플리케이션에서 렌더링이 이 16.6ms 프레임 예산을 초과하면 메인 스레드가 블로킹되어 UI가 사용자 입력에 반응할 수 없게 됩니다 [9].
+
+- **메인 스레드 부하 완화 및 최적화 전략**
+  - **React Fiber와 동시성 렌더링(Concurrent Rendering):** 기존의 동기적 렌더링이 메인 스레드를 장시간 차단하는 문제를 해결하기 위해, React는 렌더링 작업을 'Fiber 노드'라는 작은 작업 단위로 나누어 실행하고 우선순위가 높은 작업이 있을 때 브라우저에 제어권을 양보(Yield)하는 아키텍처를 도입했습니다 [9]. 
+  - **React 19 동시성 훅:** `useTransition`이나 `useDeferredValue`를 사용하여 무거운 상태 업데이트를 지연시킴으로써, 타이핑이나 클릭 등 긴급한 사용자 상호작용을 위해 메인 스레드를 비워두어 INP(Interaction to Next Paint) 점수를 향상시킵니다 [11, 12].
+  - **서버 컴포넌트(RSC):** 상호작용이 없는 컴포넌트를 서버에서 렌더링함으로써 클라이언트 브라우저로 전송되는 자바스크립트 번들 양을 줄이고, 결과적으로 상호작용 시 메인 스레드가 처리해야 할 자바스크립트의 양을 줄여줍니다 [13].
+  - **GPU 컴포지팅(Compositing):** 애니메이션이나 전환 효과 등을 브라우저가 개별 레이어로 분리하여 메인 스레드(CPU) 대신 GPU에서 그리도록(Paint) 승격시키면, 메인 스레드를 해방시키고 성능을 크게 향상할 수 있습니다 [4, 14].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[단일 스레드 (Single-threaded)]], [[React Fiber]], [[동시성 렌더링 (Concurrent Rendering)]]
+- **Projects/Contexts:** [[웹 성능 최적화 (Web Performance Optimization)]], [[Core Web Vitals (INP, TTI)]]
+- **Contradictions/Notes:** 소스에 관련 정보가 부족합니다.
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/메인 스레드 차단 문제 해결을 위한 React 16의 Fiber 엔진 교체 및 React 18, 19의 동시성 렌더링 적용 사례.md b/10_Wiki/Topics/Frontend_Mastery/메인 스레드 차단 문제 해결을 위한 React 16의 Fiber 엔진 교체 및 React 18, 19의 동시성 렌더링 적용 사례.md
new file mode 100644
index 00000000..4ef28a35
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/메인 스레드 차단 문제 해결을 위한 React 16의 Fiber 엔진 교체 및 React 18, 19의 동시성 렌더링 적용 사례.md	
@@ -0,0 +1,29 @@
+# [[메인 스레드 차단 문제 해결을 위한 React 16의 Fiber 엔진 교체 및 React 18, 19의 동시성 렌더링 적용 사례]]
+
+## 📌 Brief Summary
+React 16 이전의 동기적 렌더링 방식은 렌더링 작업이 길어질 경우 메인 스레드를 차단하여 UI 응답성을 떨어뜨리는 한계가 있었습니다. 이를 해결하기 위해 React 16은 렌더링 작업을 잘게 쪼개고 우선순위에 따라 작업을 중단, 재개할 수 있는 Fiber 아키텍처를 도입했습니다. 이를 기반으로 React 18에서는 자동 일괄 처리(Automatic Batching)와 `useTransition` 등을 활용한 동시성 렌더링 기능을 제공하였고, React 19에 이르러서는 React Compiler를 통한 자동 메모이제이션과 서버 컴포넌트(RSC)를 도입해 메인 스레드의 부하를 극적으로 줄이며 최적화를 자동화했습니다.
+
+## 📖 Core Content
+**메인 스레드 차단 문제와 한계**
+React 16 이전의 React는 컴포넌트 트리를 단일 재귀 호출로 동기적으로 처리하는 '스택 재조정자(Stack Reconciler)'를 사용했습니다 [1]. 대규모 애플리케이션의 경우, 이 과정이 16.6ms의 프레임 예산을 초과하면 메인 스레드를 차단하여 사용자 입력 및 애니메이션에 대한 애플리케이션의 응답성이 지연되는 문제가 발생했습니다 [1].
+
+**React 16의 Fiber 엔진 도입**
+*   **작업 분할 및 타임 슬라이싱 (Time-Slicing):** 동기적 차단 문제를 해결하기 위해 React 16은 동시성 렌더링을 지원하도록 재조정(Reconciliation) 엔진을 완전히 재작성한 'Fiber' 아키텍처를 도입했습니다 [2]. Fiber는 렌더링 작업을 'Fiber 노드'라는 작은 작업 단위(Unit of work)로 분할합니다 [1, 3]. 
+*   **중단 및 재개 가능한 렌더링:** 작업 루프(Work loop) 내에서 React는 각 작업을 처리한 후 우선순위가 높은 작업(예: 사용자 입력)을 위해 브라우저에 제어권을 양보(Yield)할 수 있습니다 [4]. 렌더링 단계(Render phase)는 중단 및 재개가 가능하며, 실제 DOM에 변경 사항을 적용하는 커밋 단계(Commit phase)는 동기적으로 실행됩니다 [5, 6].
+*   **우선순위 레인(Lanes):** 타이핑 및 클릭과 같은 긴급한 상호작용은 '동기(Sync) 레인'에 할당하고, 데이터 페칭은 '기본(Default) 레인'에 할당하는 방식으로 우선순위 기반 시스템을 운용하여 UI의 반응성을 향상시켰습니다 [7-9].
+
+**React 18의 동시성 렌더링 적용 사례**
+*   **긴급하지 않은 렌더링 지연:** React 18은 `useTransition` 및 `useDeferredValue` 훅을 통해 동시성 렌더링을 본격적으로 활용합니다 [10]. 긴급한 상호작용(예: 검색어 입력)을 먼저 처리하고, 무거운 연산(예: 수천 개의 목록 필터링)을 `startTransition`으로 감싸 지연시킴으로써 메인 스레드의 차단을 방지합니다 [10-12].
+*   **자동 일괄 처리 (Automatic Batching):** 이벤트 핸들러 내부뿐만 아니라 Promise, setTimeout, 기본 이벤트 등 비동기 작업에서 발생하는 여러 상태 업데이트를 단일 리렌더링으로 묶어 처리합니다 [13-15]. 이는 Virtual DOM의 Diffing 오버헤드를 줄여 데이터 집약적인 대시보드 환경에서 프레임 속도를 최대 25% 향상시키는 성과를 보였습니다 [12, 13, 16].
+
+**React 19의 성능 자동화 및 메인 스레드 부하 감소 사례**
+*   **React Compiler를 통한 자동 메모이제이션:** React 19는 수동으로 작성하던 `useMemo`나 `useCallback`의 인지적 부담을 덜기 위해, 빌드 시점에 AST(추상 구문 트리)를 분석하여 최적의 메모이제이션 경계를 자동으로 삽입하는 React Compiler를 도입했습니다 [17-19]. 이는 미세 조정된 반응성(Fine-Grained Reactivity)을 구현하여 불필요한 연쇄 리렌더링(Re-render cascade)을 획기적으로 방지합니다 [17, 20]. Meta의 내부 테스트에서는 상호작용 속도(INP)가 최대 2.5배 빨라졌습니다 [21].
+*   **React Server Components (RSC):** 번들 크기와 하이드레이션(Hydration) 비용을 근본적으로 제거하기 위해, 상호작용이 없는 컴포넌트를 서버에서만 실행하는 방식을 도입했습니다 [22-24]. 이 방식을 통해 브라우저로 전송되는 JavaScript를 0바이트로 줄여 메인 스레드가 파싱하고 실행해야 할 부담을 최소화했습니다 [22, 24, 25].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Virtual DOM]], [[Reconciliation]], [[Fiber Architecture]], [[Automatic Batching]], [[React Compiler]], [[React Server Components]], [[Time-Slicing]], [[Lane-Based Priority]]
+- **Projects/Contexts:** [[Next.js App Router]], [[Meta's Internal Testing (Quest Store)]], [[Sanity Studio]]
+- **Contradictions/Notes:** 컴포넌트의 렌더링 최적화와 관련해 React Compiler의 도입은 개발자가 `useMemo`나 `useCallback`을 사용하여 수동으로 최적화하던 기존 방식의 패러다임을 바꿉니다 [26]. 대부분의 자동 메모이제이션은 컴파일러가 처리하지만, `useEffect`의 의존성 관리나 타사 라이브러리 연동 등 세밀한 제어가 필요한 경우에는 여전히 수동 메모이제이션 방식이 "탈출구(Escape Hatch)"로 유효하다고 소스에서 지적하고 있습니다 [27-29].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/모놀리식 아키텍처 (Monolithic Architecture).md b/10_Wiki/Topics/Frontend_Mastery/모놀리식 아키텍처 (Monolithic Architecture).md
new file mode 100644
index 00000000..575a1289
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/모놀리식 아키텍처 (Monolithic Architecture).md	
@@ -0,0 +1,25 @@
+# [[모놀리식 아키텍처 (Monolithic Architecture)]]
+
+## 📌 Brief Summary
+모놀리식 아키텍처는 애플리케이션의 모든 기능과 서비스가 단일 코드베이스로 묶여 하나의 단위로 배포되는 전통적인 소프트웨어 설계 방식입니다 [1, 2]. 소규모 애플리케이션이나 최소 기능 제품(MVP)을 개발하고 배포하는 데에는 비교적 단순하고 유리하지만, 시스템이 커질수록 확장과 유지보수가 어렵다는 한계를 지닙니다 [2]. 구성 요소들이 강하게 결합되어 있어 아주 작은 변경 사항이라도 전체 애플리케이션의 재배포와 전체 시스템 테스트를 요구합니다 [1, 3].
+
+## 📖 일Core Content
+* **구조 및 배포 (Structure & Deployment)**
+  모놀리식 아키텍처는 모든 기능이 포함된 단일하고 통합된 코드베이스로 구성됩니다 [1, 2]. 이 구조로 인해 업데이트나 변경 사항을 적용할 때 전체 애플리케이션을 다시 배포해야 합니다 [1]. 소규모 애플리케이션의 경우 중앙 집중식 로깅을 통해 디버깅이 쉽고 개발 및 배포가 단순하다는 장점이 있습니다 [2].
+
+* **유지보수 및 테스트 (Maintenance & Testing)**
+  기능들이 긴밀하게 결합(tight coupling)되어 있기 때문에, 시스템 일부분의 작은 변경이 전체 시스템에 영향을 미치거나 버그와 지연의 도미노 효과를 일으킬 수 있습니다 [2, 3]. 따라서 유지보수가 복잡하며, 테스트 시에도 개별 요소가 아닌 전체 시스템 검증이 요구됩니다 [1]. 
+
+* **확장성 및 유연성 (Scalability & Flexibility)**
+  시스템 규모가 커짐에 따라 스파게티 코드(spaghetti code)가 될 위험이 증가하며 복잡성을 통제하기 어렵습니다 [1]. 또한, 특정 기능만 확장하는 것이 불가능하여 애플리케이션 전체를 확장해야 하므로 유연성이 떨어집니다 [1]. 외부 시스템 및 기술과의 통합이 더 까다로우며, 팀 간의 병렬 개발과 협업 역시 강한 의존성으로 인해 방해를 받을 수 있습니다 [1].
+
+* **성능 및 비용적 측면 (Performance & Cost)**
+  모놀리식 애플리케이션은 모듈화된 컴포넌트 기반 아키텍처가 겪을 수 있는 컴포넌트 간 통신(네트워크 호출 등) 오버헤드나 지연 시간(latency) 이슈가 없습니다 [4]. 따라서 경우에 따라서는 모놀리식 아키텍처가 더 간소화되어 추가적인 관리 리소스와 비용을 절감하는 효과를 낼 수도 있습니다 [4].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[컴포넌트 기반 아키텍처 (Component-Based Architecture)]], [[마이크로서비스 아키텍처 (Microservices Architecture)]]
+- **Projects/Contexts:** 제한된 기능만을 가지는 초기 스타트업 프로젝트 또는 [[최소 기능 제품 (MVP)]] 구축 [2], 유지보수 및 비용 효율성을 높이기 위해 모놀리식 시스템을 민첩하고 모듈화된 아키텍처로 변환하려는 [[레거시 시스템 현대화]] [5].
+- **Contradictions/Notes:** 모놀리식 아키텍처는 확장성과 유연성이 떨어져 현대의 대규모 개발에 불리하다는 것이 주된 시각이지만 [1, 2], 컴포넌트 간의 통신 오버헤드(네트워크 통신 등)가 발생하지 않기 때문에 고속 처리가 중요한 특정 시나리오에서는 오히려 컴포넌트 기반 접근보다 성능상 리소스와 비용이 덜 들고 간소화될 수 있다는 점이 소스에 언급되어 있습니다 [4].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/무거운 데이터 리스트 필터링 구현.md b/10_Wiki/Topics/Frontend_Mastery/무거운 데이터 리스트 필터링 구현.md
new file mode 100644
index 00000000..f730d4c8
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/무거운 데이터 리스트 필터링 구현.md	
@@ -0,0 +1,23 @@
+# [[무거운 데이터 리스트 필터링 구현]]
+
+## 📌 Brief Summary
+무거운 데이터 리스트 필터링 구현은 수백 개에서 수만 개의 항목을 포함하는 대규모 데이터셋을 화면에서 필터링할 때 발생하는 렌더링 지연 및 UI 멈춤 현상을 해결하는 기술입니다 [1-4]. React 19의 동시성 렌더링(Concurrent rendering) 훅을 사용하여 무거운 연산의 렌더링 우선순위를 낮추거나, 화면에 보이는 노드만 렌더링하는 가상화 기법을 적용함으로써 사용자의 입력 지연 없이 즉각적인 반응성을 유지하는 것을 목적으로 합니다 [3, 5, 6].
+
+## 📖 Core Content
+*   **동시성 기능(Concurrent Features)을 활용한 UI 응답성 유지**
+    *   `useTransition` 훅: 타이핑이나 클릭과 같은 긴급한 사용자 상호작용과 리스트 필터링이라는 비긴급 상태 업데이트를 분리합니다 [5]. 무거운 필터링 연산이 백그라운드에서 실행되는 동안 사용자의 키보드 입력이 즉각적으로 반응하도록 보장하며, `isPending` 플래그를 통해 진행 상태에 대한 시각적 피드백을 제공할 수 있습니다 [2].
+    *   `useDeferredValue` 훅: 부모 컴포넌트의 props나 외부 스토어 등 상태 업데이트 코드를 직접 제어할 수 없을 때 사용합니다 [2, 3]. 새로운 필터링 결과가 준비될 때까지 UI 프리징 없이 이전 결과를 유지하며, `useMemo`와 결합하면 10,000개 이상의 항목 리스트도 지연 느낌 없이 처리할 수 있습니다 [3].
+*   **리스트 가상화(Virtualization) 적용**
+    *   수백 또는 수천 개의 항목이 있는 리스트를 렌더링할 때 모든 DOM 노드를 생성하면 초기 렌더링 시간과 상호작용 반응성에 악영향을 미칩니다 [4].
+    *   가상화 기술(예: `react-window` 라이브러리)을 사용하면 현재 화면(Viewport)에 보이는 항목과 그 상하의 작은 버퍼 영역만을 DOM 노드로 렌더링할 수 있습니다 [6].
+    *   이 기법을 적용하면 10,000개의 리스트 항목이라 하더라도 한 번에 약 20개의 DOM 노드만 화면에 렌더링하여 렌더링 시간을 수 초에서 즉시 완료 수준으로 단축할 수 있습니다 [6]. 
+*   **디바운싱(Debouncing)을 통한 API 요청 최적화**
+    *   사용자가 타이핑하며 결과를 검색할 때마다 API 호출을 하면 불필요한 요청과 재렌더링이 발생합니다. 디바운싱(예: 300ms 지연)을 설정하면 타이핑이 멈춘 후에만 API를 호출하도록 제한하여 서버 부하를 줄일 수 있습니다 [7].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Concurrent Rendering]], [[useTransition]], [[useDeferredValue]], [[Virtualization]], [[Debouncing]]
+- **Projects/Contexts:** [[대규모 데이터 기반 대시보드]], [[사용자 검색/필터링 UI 최적화]]
+- **Contradictions/Notes:** 무거운 작업의 처리에 있어 디바운싱(Debouncing)과 `useTransition`을 비교했을 때, UI 업데이트를 지연시키는 목적이라면 React의 렌더링 모델에 더 잘 맞는 `useTransition`이 디바운싱보다 더 나은 선택입니다. 그러나 백엔드 API 호출 빈도를 낮추는 것이 목적일 경우에는 여전히 디바운싱이 최선의 방식입니다 [8].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/브라우저 렌더링 과정 (Critical Rendering Path).md b/10_Wiki/Topics/Frontend_Mastery/브라우저 렌더링 과정 (Critical Rendering Path).md
new file mode 100644
index 00000000..9a4fa531
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/브라우저 렌더링 과정 (Critical Rendering Path).md	
@@ -0,0 +1,20 @@
+# [[브라우저 렌더링 과정 (Critical Rendering Path)]]
+
+## 📌 Brief Summary
+브라우저 렌더링 과정(Critical Rendering Path)은 브라우저가 수신한 HTML, CSS, JavaScript 코드를 화면의 실제 픽셀로 변환하기 위해 거치는 일련의 순차적인 단계를 의미합니다 [1, 2]. 이 과정은 DOM과 CSSOM의 생성, 렌더 트리(Render Tree) 구축, 기하학적 형태를 계산하는 레이아웃(Layout), 그리고 픽셀을 그리는 페인트(Paint) 및 합성(Composite) 단계로 이루어집니다 [3, 4]. 렌더링 경로를 최적화하여 렌더링 차단 요소를 최소화하는 것은 웹 페이지의 초기 렌더링 속도를 높이고 사용자 경험(UX)을 향상시키는 프론트엔드 성능 최적화의 핵심입니다 [1, 5, 6].
+
+## 📖 Core Content
+*   **DOM (Document Object Model) 구축:** 브라우저가 HTML 데이터를 받으면 바이트를 문자, 토큰, 노드로 변환한 뒤 이를 기반으로 DOM 트리를 구축합니다 [1, 7]. 이 과정은 점진적(incremental)으로 이루어지기 때문에 브라우저는 네트워크 요청이 진행 중인 상태에서도 트리 구성을 시작할 수 있습니다 [1, 8]. 생성된 노드의 수가 많을수록 이후의 레이아웃과 페인트 단계에서 더 많은 시간이 소요됩니다 [1, 9].
+*   **CSSOM (CSS Object Model) 구축:** DOM과 달리 CSSOM 구성은 점진적이지 않으며 렌더링을 차단(Render-blocking)합니다 [8, 9]. 브라우저는 사용자가 스타일이 적용되지 않은 날것의 콘텐츠(FOUC)를 보는 것을 방지하기 위해, 연결된 모든 스타일시트를 다운로드하고 파싱할 때까지 렌더링을 중단합니다 [8, 9].
+*   **렌더 트리(Render Tree) 합성:** DOM과 CSSOM이 모두 준비되면 브라우저는 두 트리를 결합하여 화면에 렌더링되는 노드만 포함하는 렌더 트리를 생성합니다 [10, 11]. 이 과정에서 시각적 레이아웃에 영향을 주지 않는 `<script>`, `<meta>` 태그나 `display: none` 속성이 적용된 요소는 렌더 트리에서 완전히 제외됩니다 [10, 11]. 단, `visibility: hidden`이 적용된 요소는 눈에 보이지는 않지만 레이아웃 상에서 공간을 차지하므로 렌더 트리에 포함됩니다 [12, 13].
+*   **Layout(레이아웃) / Reflow(리플로우):** 렌더 트리가 완성되면 브라우저는 뷰포트(Viewport)의 크기와 박스 모델을 기반으로 렌더 트리 내 각 요소의 정확한 크기와 화면상 위치를 계산합니다 [14-16]. 창 크기 조절, DOM 요소의 추가 및 제거, 크기 속성 변경 등의 작업은 전체 혹은 부분적인 레이아웃의 재계산(Reflow)을 유발하며 이는 컴퓨팅 비용이 매우 높은 작업입니다 [17, 18].
+*   **Paint(페인트) 및 Compositing(합성):** 레이아웃 단계가 끝나면 브라우저는 계산된 기하학적 형태와 스타일을 바탕으로 화면에 실제 픽셀을 그리는 Paint 작업을 수행합니다 [19-21]. 요소의 색상이나 배경 등 시각적 스타일만 변경될 경우 레이아웃 계산을 생략하고 Repaint(리페인트)만 발생합니다 [18]. 페인트 이후 브라우저는 성능을 높이기 위해 요소들을 여러 레이어로 분리하여 그린 뒤, GPU 등을 활용해 이를 단일 이미지로 합치는 Compositing(합성) 과정을 거칩니다 [19, 22, 23].
+*   **크리티컬 렌더링 패스 최적화:** 브라우저는 `<head>` 태그 내부에 있는 렌더링 차단 CSS 및 파서 차단(Parser-blocking) 동기식 JavaScript가 모두 처리될 때까지 화면을 렌더링하지 않습니다 [24-26]. 반면 이미지, 폰트, 그리고 지연 로드(async/defer) 설정이 된 스크립트 등은 초기 렌더링을 차단하지 않습니다 [27]. 따라서 불필요한 리소스의 다운로드를 지연시키거나 파일 크기를 최적화하는 것이 렌더링 경로 최적화의 기본 원칙입니다 [28, 29].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[DOM]], [[CSSOM]], [[Render Tree]], [[Reflow 및 Repaint]]
+- **Projects/Contexts:** [[프론트엔드 렌더링 성능 최적화]], [[Core Web Vitals 최적화 (FCP, LCP 등)]]
+- **Contradictions/Notes:** 제공된 소스들은 브라우저 렌더링 과정에 대해 모순 없이 일관된 설명을 제공합니다. 특히 `display: none`(렌더 트리에서 제외됨)과 `visibility: hidden`(레이아웃 공간을 차지하므로 렌더 트리에 포함됨)의 처리 방식 차이를 명확히 대조하여 설명하고 있습니다 [13].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/브라우저 렌더링 파이프라인(Critical Rendering Path).md b/10_Wiki/Topics/Frontend_Mastery/브라우저 렌더링 파이프라인(Critical Rendering Path).md
new file mode 100644
index 00000000..fe8e1875
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/브라우저 렌더링 파이프라인(Critical Rendering Path).md	
@@ -0,0 +1,26 @@
+# [[브라우저 렌더링 파이프라인(Critical Rendering Path)]]
+
+## 📌 Brief Summary
+브라우저 렌더링 파이프라인(Critical Rendering Path, CRP)은 브라우저가 HTML, CSS, JavaScript 코드를 수신하여 화면의 픽셀로 변환하기 위해 거치는 일련의 핵심 단계입니다 [1, 2]. 이 파이프라인은 주로 DOM 및 CSSOM 생성, 렌더 트리 구축, 레이아웃, 페인트, 그리고 합성 단계로 이루어집니다 [3]. 이 경로를 최적화하는 것은 초기 렌더링 속도(Time to first render)를 높이고 60FPS의 부드러운 사용자 상호작용을 보장하기 위한 웹 성능 최적화의 핵심입니다 [4, 5].
+
+## 📖 Core Content
+브라우저 렌더링 파이프라인은 다음과 같은 세부적인 과정을 거쳐 실행됩니다.
+
+*   **DOM(Document Object Model) 구축**
+    브라우저가 서버로부터 HTML 데이터를 받으면, 이를 바이트 단위에서 문자, 토큰, 노드로 변환하여 점진적(incremental)으로 DOM 트리를 구성합니다 [1, 6]. 파싱 중 비차단(non-blocking) 리소스를 만나면 요청을 보내고 파싱을 계속하며, 프리로드 스캐너(Preload Scanner)가 백그라운드에서 CSS, 웹 폰트 등 우선순위가 높은 리소스를 미리 요청하여 병목을 줄입니다 [7].
+*   **CSSOM(CSS Object Model) 구축**
+    HTML과 별개로 브라우저는 CSS를 파싱하여 스타일 규칙과 계층 구조를 나타내는 CSSOM 트리를 생성합니다 [8, 9]. DOM 생성과 달리 CSSOM은 **렌더링을 차단(Render-blocking)**하는 속성을 지닙니다. 즉, 브라우저는 모든 CSS를 다운로드하고 파싱을 완료할 때까지 페이지 렌더링을 중단하여, 스타일이 입혀지지 않은 콘텐츠가 화면에 번쩍이는 현상(FOUC)을 방지합니다 [8, 10].
+*   **렌더 트리(Render Tree) 생성**
+    DOM과 CSSOM이 준비되면, 두 트리를 결합하여 **화면에 실제로 표시되는 노드들만 포함된 렌더 트리**를 구축합니다 [11, 12]. `<script>`, `<meta>` 같은 태그나 CSS의 `display: none`이 적용된 요소는 렌더 트리에서 완전히 제외되지만, 화면에 공간을 차지하는 `visibility: hidden`이 적용된 요소는 포함됩니다 [11-13].
+*   **레이아웃(Layout) 또는 리플로우(Reflow)**
+    렌더 트리가 완성되면, 브라우저는 뷰포트의 크기를 기준으로 각 요소가 화면의 어느 위치에, 어느 정도의 크기(기하학적 형태)로 배치될지 정확히 계산합니다 [14-16]. 창 크기가 조절되거나 JavaScript로 DOM 요소의 크기 및 위치를 조작할 때마다 이 계산이 다시 발생하며(**리플로우**), 이는 브라우저에 큰 계산 부담을 줍니다 [17-19].
+*   **페인트(Paint)와 합성(Compositing)**
+    레이아웃 계산이 끝나면 요소에 색상, 텍스트, 그림자, 테두리 등 시각적 속성을 적용하여 화면의 실제 픽셀로 변환하는 페인트(또는 리페인트) 단계가 진행됩니다 [17, 20]. 마지막으로, 성능 최적화를 위해 일부 요소(예: `<video>`, `<canvas>`, 특정 CSS 속성 적용 요소)가 별도의 레이어로 나뉘어 그려졌다면, 브라우저가 이들을 올바른 순서로 겹쳐서 최종 화면을 완성하는 **합성(Compositing)** 단계를 거칩니다 [21, 22]. GPU를 활용해 이 과정을 가속화할 수도 있습니다 [23, 24].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[DOM(Document Object Model)]], [[CSSOM(CSS Object Model)]], [[리플로우와 리페인트(Reflow and Repaint)]], [[가상 DOM(Virtual DOM)]], [[웹 성능 최적화(Web Performance Optimization)]]
+- **Projects/Contexts:** [[최초 렌더링 시간(Time to First Render) 단축]], [[단일 페이지 애플리케이션(SPA)의 CSR 및 SSR 전략]]
+- **Contradictions/Notes:** 동기식 JavaScript는 기본적으로 파서를 차단(Parser-blocking)하여 결과적으로 렌더링 파이프라인 전체를 지연시키므로, `async`나 `defer` 속성을 활용해 렌더링 경로를 방해하지 않도록 처리하는 것이 공통적인 모범 사례로 권장됩니다 [7, 25, 26].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/웹 렌더링 전략 (CSR, SSR, SSG, ISR).md b/10_Wiki/Topics/Frontend_Mastery/웹 렌더링 전략 (CSR, SSR, SSG, ISR).md
new file mode 100644
index 00000000..f86d666f
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/웹 렌더링 전략 (CSR, SSR, SSG, ISR).md	
@@ -0,0 +1,37 @@
+# [[웹 렌더링 전략 (CSR, SSR, SSG, ISR)]]
+
+## 📌 Brief Summary
+웹 렌더링 전략은 웹 애플리케이션의 HTML, CSS, JavaScript 코드를 브라우저가 화면에 표시하는 상호작용 가능한 형태(UI)로 변환하는 방식을 의미하며, 언제 어디서(클라이언트 혹은 서버) 렌더링을 수행할지에 대한 결정입니다 [1, 2]. 대표적인 방식으로 클라이언트 측에서 렌더링을 수행하는 CSR, 서버에서 HTML을 생성하는 SSR, 빌드 시점에 정적 파일을 생성하는 SSG, 그리고 이를 결합해 주기적으로 정적 페이지를 업데이트하는 ISR이 있습니다 [2-4]. 각 렌더링 전략은 초기 로드 속도, 검색 엔진 최적화(SEO), 상호작용 속도, 서버 부하 측면에서 명확한 장단점을 가지므로, 애플리케이션의 목적과 콘텐츠 업데이트 빈도에 따라 적절한 방식을 선택해야 합니다 [5-7].
+
+## 📖 Core Content
+*   **클라이언트 사이드 렌더링 (CSR, Client-Side Rendering)**
+    *   동작 원리: 서버는 뼈대만 있는 빈 HTML 파일과 애플리케이션 구동에 필요한 JavaScript 번들을 브라우저로 전송합니다 [8-11]. 이후 브라우저가 JavaScript를 다운로드하고 실행하여 동적으로 UI를 구축하고 필요한 데이터를 가져옵니다 [8-11].
+    *   장점: 초기 로딩 이후에는 전체 페이지 새로고침 없이 빠른 전환이 가능하여 부드럽고 상호작용이 풍부한 앱과 같은 사용자 경험을 제공합니다 [8, 12-15]. 렌더링 부하를 클라이언트로 분산시켜 서버 부하가 낮습니다 [12, 15, 16].
+    *   단점: JavaScript를 모두 다운로드하고 실행할 때까지 사용자는 빈 화면을 보게 되므로 초기 로드 속도(FCP 등)가 느립니다 [8, 12, 15, 17, 18]. 크롤러가 초기에 빈 화면을 마주하므로 검색 엔진 최적화(SEO)에 불리합니다 [8, 15, 19-21].
+    *   적합한 사용처: SEO가 중요하지 않은 내부 관리자 대시보드, SaaS 플랫폼, 사용자 인증이 필요한 고도의 상호작용 애플리케이션 [9, 11, 12, 22, 23].
+
+*   **서버 사이드 렌더링 (SSR, Server-Side Rendering)**
+    *   동작 원리: 사용자의 요청이 발생할 때마다 서버가 데이터를 가져와 완전하게 렌더링된 HTML 페이지를 생성하여 브라우저로 보냅니다 [24-28].
+    *   장점: 브라우저가 완전한 HTML을 즉시 수신하므로 사용자가 콘텐츠를 빠르게 볼 수 있으며(빠른 첫 콘텐츠풀 페인트, FCP), 크롤러가 내용을 완벽하게 읽을 수 있어 SEO에 매우 유리합니다 [25, 28-32].
+    *   단점: HTML이 표시된 후에도 JavaScript를 다운로드하여 이벤트 리스너를 연결하는 '하이드레이션(Hydration)' 과정이 끝나기 전까지는 페이지가 상호작용할 수 없어 대기 시간(TTI)이 길어질 수 있습니다 [25, 26, 33-35]. 매 요청마다 서버에서 렌더링을 처리해야 하므로 서버 리소스 소모가 큽니다 [25, 36-38].
+    *   적합한 사용처: 항상 최신 데이터가 유지되어야 하며 SEO가 매우 중요한 뉴스 사이트, 전자상거래 제품 페이지 등 [28, 29, 39, 40].
+
+*   **정적 사이트 생성 (SSG, Static Site Generation)**
+    *   동작 원리: 사용자의 요청 시점이 아닌 애플리케이션의 '빌드(Build) 타임'에 미리 전체 HTML 페이지를 생성해 두고, 이를 콘텐츠 전송 네트워크(CDN)를 통해 제공합니다 [24, 38, 41-43].
+    *   장점: 요청 시 서버에서의 추가 연산이 필요 없어 응답 속도가 압도적으로 빠르며 완벽한 SEO 성능을 제공합니다 [24, 41, 42, 44-46]. 정적 파일만 제공하므로 호스팅 비용이 저렴하고 확장성과 보안이 뛰어납니다 [16, 46-48].
+    *   단점: 콘텐츠가 변경되면 사이트 전체를 다시 빌드하고 배포해야 하므로, 실시간으로 데이터가 변하거나 개인화된 콘텐츠를 보여주기에는 한계가 있습니다 [46, 47, 49]. 
+    *   적합한 사용처: 내용이 자주 바뀌지 않는 공식 문서, 마케팅 랜딩 페이지, 기술 블로그 등 [24, 42, 46, 50].
+
+*   **점진적 정적 재생성 (ISR, Incremental Static Regeneration)**
+    *   동작 원리: SSG처럼 미리 빌드된 정적 페이지를 제공하지만, 설정된 일정 시간(예: 60초)이 지나거나 콘텐츠가 변경되었을 때 전체 사이트 재빌드 없이 백그라운드에서 개별 페이지 단위로 재생성 및 업데이트를 수행합니다 [4, 24, 41, 47, 51].
+    *   장점: SSG의 초고속 성능(CDN 캐싱)을 누리면서도 SSR처럼 최신 데이터를 반영할 수 있는 강력한 하이브리드 성능을 제공합니다 [41, 52, 53]. 대규모 사이트에서도 빌드 시간의 부담 없이 확장할 수 있습니다 [53, 54].
+    *   단점: 재검증 과정이나 백그라운드 재생성 설정 등 구성의 복잡성이 따르며, 재생성 주기 도중에는 일시적으로 예전 데이터(Stale data)가 노출될 위험이 존재합니다 [53, 55]. 
+    *   적합한 사용처: 방대한 카탈로그를 가진 대규모 전자상거래 플랫폼, 지속적인 최신화가 필요하지만 실시간 동기화까지는 불필요한 뉴스 포털 등 [4, 54, 56].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[하이드레이션 (Hydration)]], [[단일 페이지 애플리케이션 (SPA)]], [[검색 엔진 최적화 (SEO)]], [[Core Web Vitals]], [[렌더 트리 (Render Tree)]]
+- **Projects/Contexts:** [[Next.js의 하이브리드 렌더링 기능]], [[웹 성능 및 상호작용 최적화 프로젝트]]
+- **Contradictions/Notes:** SSR은 초기 화면 표시 속도를 높여(FCP 개선) 사용자 경험을 향상시킨다고 하지만, 이면의 하이드레이션(Hydration) 과정이 지연될 경우 눈에는 보이지만 클릭은 되지 않는 '불쾌한 골짜기' 경험을 초래하여 상호작용 지표(TTI)를 악화시킬 수 있다는 모순적인 특징을 가집니다 [25, 33, 35, 57].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/웹 성능 최적화(Web Performance Optimization).md b/10_Wiki/Topics/Frontend_Mastery/웹 성능 최적화(Web Performance Optimization).md
new file mode 100644
index 00000000..eac38288
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/웹 성능 최적화(Web Performance Optimization).md	
@@ -0,0 +1,25 @@
+# [[웹 성능 최적화(Web Performance Optimization)]]
+
+## 📌 Brief Summary
+웹 성능 최적화는 웹 페이지가 빠르게 로드되고, 원활하게 렌더링되며, 사용자의 상호작용에 즉각적으로 반응하도록 보장하기 위한 기술과 전략을 의미한다 [1-3]. 이는 중요 렌더링 경로(Critical Rendering Path)를 관리하여 리플로우(Reflow)와 리페인트(Repaint)를 최소화하고, 브라우저가 화면을 그리는 속도와 효율성을 극대화하는 과정을 포함한다 [4-7]. 현대의 프론트엔드 환경에서는 적절한 렌더링 전략(CSR, SSR, SSG 등)의 선택, 자바스크립트 번들 크기 축소, 그리고 컴포넌트 아키텍처를 통한 렌더링 횟수 통제가 핵심적인 최적화 목표로 다루어진다 [8-11].
+
+## 📖 Core Content
+* **중요 렌더링 경로(Critical Rendering Path, CRP) 최적화:** 브라우저는 네트워크를 통해 전달받은 HTML과 CSS를 파싱하여 DOM과 CSSOM 트리를 생성하고, 이를 결합해 렌더 트리(Render Tree)를 구축한 뒤, 요소의 위치와 크기를 계산(Layout)하고 화면의 픽셀로 변환(Paint)하는 단계를 거친다 [5, 12-14]. 초기 렌더링 시간을 줄이려면 렌더링을 차단하는 CSS나 파싱을 차단하는 자바스크립트(Render-blocking & Parser-blocking resources)의 수를 최소화하고 다운로드 순서를 최적화해야 한다 [15-18]. 또한 DOM 트리의 노드가 많아질수록 레이아웃과 페인트 단계의 연산 비용이 증가하므로 불필요한 DOM 노드 깊이를 줄여야 한다 [19-21].
+
+* **리플로우(Reflow) 및 리페인트(Repaint) 최소화:** DOM 구조의 변경, 창 크기 조절, 요소의 크기 및 위치 변경 등은 브라우저가 기하학적 구조를 다시 계산하게 만드는 비용이 큰 리플로우(또는 레이아웃)를 유발한다 [22-25]. 시각적 스타일(색상, 그림자 등)만 변경되는 리페인트의 경우 리플로우보다는 연산량이 적지만 과도하게 발생하면 애니메이션 프레임 속도를 저하시킨다 [7, 26, 27]. 성능을 유지하기 위해서는 DOM 업데이트를 일괄 처리하고, 요소 이동 시 위치 관련 속성 대신 GPU 가속을 활용할 수 있는 `transform` 속성을 사용하는 것이 좋다 [7, 26, 28-30].
+
+* **React 애플리케이션의 렌더링 최적화 기법:** React의 렌더링 특성상 부모의 상태가 변경되면 속성 변경 여부와 관계없이 하위 컴포넌트가 연쇄적으로 리렌더링되며 연산 비용을 낭비할 수 있다 [31, 32]. 이를 방지하기 위해 `React.memo`나 `useMemo` 등을 통한 메모이제이션, 대규모 목록에서 화면에 보이는 노드만 그리는 가상화(Virtualization), 그리고 상태 업데이트를 하나로 묶는 자동 일괄 처리(Automatic Batching)가 사용된다 [33-36]. 아울러 React 19의 동시성 렌더링 훅(`useTransition`, `useDeferredValue`)을 활용하면 무거운 연산 중에도 긴급한 상호작용의 응답성을 방해하지 않고 유지할 수 있다 [37-39].
+
+* **렌더링 전략 선택 및 하이드레이션(Hydration) 병목 관리:** 애플리케이션의 성격과 요구에 따라 클라이언트 사이드 렌더링(CSR), 서버 사이드 렌더링(SSR), 정적 사이트 생성(SSG), 점진적 정적 재생성(ISR) 등의 방식을 전략적으로 선택해야 한다 [9, 40-42]. SSR과 SSG는 서버에서 미리 완성된 HTML을 전달하여 빠른 초기 콘텐츠 표시(FCP)와 우수한 SEO를 보장하지만, SSR의 경우 브라우저가 자바스크립트를 다운로드하고 HTML에 이벤트 핸들러를 연결하는 '하이드레이션(Hydration)' 과정이 끝날 때까지 상호작용(TTI)이 지연되거나 메인 스레드를 차단(TBT)하는 단점이 있다 [43-47].
+
+* **React Server Components (RSC)의 도입과 자동화 도구:** 기존 렌더링 방식의 번들 크기 및 하이드레이션 문제를 근본적으로 해결하기 위해 컴포넌트를 서버에서만 실행하고 클라이언트에는 자바스크립트를 전송하지 않는 RSC 모델이 도입되었다 [48-51]. 이를 통해 클라이언트로 전송되는 JS 페이로드 크기를 대폭 줄이고 서버의 리소스를 직접 활용할 수 있다 [52-54]. 더 나아가 최신 React Compiler는 빌드 타임에 코드의 추상 구문 트리(AST)를 분석해 자동으로 세분화된 메모이제이션을 삽입해주어, 개발자가 수동으로 성능을 최적화해야 하는 부담을 대폭 감소시킨다 [55-58].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** `[[Critical Rendering Path]]`, `[[Reflow and Repaint]]`, `[[React Server Components]]`, `[[하이드레이션(Hydration)]]`, `[[동시성 렌더링(Concurrent Rendering)]]`, `[[React Compiler]]`
+- **Projects/Contexts:** `[[콘텐츠 기반의 SEO 최적화 웹사이트 및 이커머스(E-commerce) 플랫폼]]` (초기 화면의 빠른 렌더링과 검색엔진 최적화를 위해 SSR, SSG, ISR이 필수적으로 요구되는 맥락) [43, 59-62], `[[고도의 상호작용이 필요한 관리자 대시보드 및 SaaS]]` (초기 렌더링보다 실시간 상태 업데이트와 인터랙션 속도가 중시되어 CSR 또는 선택적 클라이언트 컴포넌트가 적합한 맥락) [63-67].
+- **Contradictions/Notes:** 
+  - **수동 메모이제이션의 유용성에 대한 관점 변화:** 기존 React 생태계에서는 불필요한 리렌더링을 막기 위해 `useMemo`나 `useCallback`과 같은 수동 메모이제이션이 권장되었으나, 얕은 비교 검사 자체의 오버헤드가 발생하거나 종속성 관리가 복잡해져 과도한 사용이 안티 패턴으로 지적되기도 했다 [68, 69]. 그러나 React 19의 React Compiler 등장 이후, 컴파일러가 정적 분석을 통해 최적의 위치에 자동으로 메모이제이션을 적용하게 되면서 개발자의 수동 개입 필요성이 크게 사라지는 패러다임 전환이 이루어지고 있다 [55, 58, 70-72].
+  - **SSR의 성능 지표 딜레마:** 서버 사이드 렌더링(SSR)은 클라이언트에게 완성된 HTML을 즉시 제공하여 초기 콘텐츠 표시(FCP)와 SEO를 개선하지만, 자바스크립트를 다운로드하여 정적 요소에 상호작용을 활성화하는 하이드레이션 과정이 완료될 때까지 상호작용 시작 시간(TTI)이 크게 지연되거나 메인 스레드 차단 시간(TBT)이 증가하는 역설적인 한계가 존재한다 [43, 45, 73-75].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/전자상거래 플랫폼 (E-commerce Platforms).md b/10_Wiki/Topics/Frontend_Mastery/전자상거래 플랫폼 (E-commerce Platforms).md
new file mode 100644
index 00000000..18a11cd5
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/전자상거래 플랫폼 (E-commerce Platforms).md	
@@ -0,0 +1,24 @@
+# [[전자상거래 플랫폼 (E-commerce Platforms)]]
+
+## 📌 Brief Summary
+전자상거래 플랫폼은 제품 카탈로그, 재고 관리, 결제 시스템 등을 처리하기 위해 고도의 확장성과 렌더링 최적화가 요구되는 복잡한 웹 시스템입니다 [1-3]. 검색 엔진 최적화(SEO)와 빠른 페이지 로딩 속도, 그리고 장바구니와 같은 동적 상호작용 간의 균형을 맞추는 것이 핵심 목표입니다 [1, 4, 5]. 이를 달성하기 위해 현대의 전자상거래 플랫폼은 SSR, ISR, SSG와 같은 다양한 렌더링 전략과 컴포넌트 기반 아키텍처(CBA)를 적극적으로 활용합니다 [6-8].
+
+## 📖 Core Content
+* **전자상거래를 위한 최적의 렌더링 전략:**
+  * **서버 사이드 렌더링 (SSR):** 제품 목록 페이지, 카테고리 탐색 및 개별 제품 상세 뷰에 이상적입니다. 강력한 검색 엔진 가시성(SEO)을 보장하고 클라이언트 측의 처리 지연 없이 제품의 가격과 재고 등을 즉각적으로 렌더링하여 사용자 경험과 전환율을 향상시킵니다 [1].
+  * **점진적 정적 재생성 (ISR):** 빠른 제품 페이지 로딩 속도를 제공하면서도 전체 사이트를 다시 빌드할 필요 없이 재고 정보 및 가격을 최신 상태로 유지할 수 있어 대규모 전자상거래 플랫폼에 완벽한 균형을 제공합니다 [4, 6, 7]. 
+  * **정적 사이트 생성 (SSG):** 실시간 재고 변경보다는 예약된 빌드 프로세스를 통해 제품 정보가 주로 업데이트되는 안정적인 제품 카탈로그 페이지에 유리합니다 [9, 10].
+  * **클라이언트 사이드 렌더링 (CSR):** 소셜 미디어나 전자상거래 웹사이트처럼 고도의 상호 작용이 필요한 애플리케이션에 부분적으로 사용됩니다 [5].
+
+* **전자상거래에서의 컴포넌트 기반 아키텍처 (CBA) 활용:**
+  * 전자상거래 플랫폼은 제품 목록, 결제 게이트웨이, 장바구니, 고객 리뷰 모듈과 같은 개별 기능을 독립적인 컴포넌트로 구축하여 아키텍처의 모듈화와 재사용성을 극대화합니다 [2, 3].
+  * 트래픽 급증 시 전체 애플리케이션이 아닌 쇼핑 카트 컴포넌트와 같은 특정 인스턴스만 추가하여 원활한 운영을 유지하는 등 뛰어난 확장성을 제공합니다 [8].
+  * 마케팅 캠페인이나 시즌별 프로모션에 맞춰 기본 비즈니스 기능을 손상시키지 않고 다양한 테마를 적용하여 사이트의 디자인을 신속하게 변경할 수 있습니다 [11].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Server-Side Rendering (SSR)]], [[Incremental Static Regeneration (ISR)]], [[Component-Based Architecture (CBA)]]
+- **Projects/Contexts:** [[제품 카탈로그 및 장바구니 시스템 (Product Catalogs and Shopping Carts)]]
+- **Contradictions/Notes:** 소스 [5]에서는 높은 수준의 상호작용이 필요한 전자상거래 웹사이트에 CSR이 흔히 사용된다고 언급합니다. 하지만 다른 소스들은 검색 엔진 최적화(SEO)와 최신 데이터 제공의 중요성 때문에 제품 탐색 및 세부 페이지에는 SSR 또는 ISR을 사용하는 것이 훨씬 이상적이고 필수적이라고 강조합니다 [1, 4, 7].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/점진적 정적 재생성 (ISR).md b/10_Wiki/Topics/Frontend_Mastery/점진적 정적 재생성 (ISR).md
new file mode 100644
index 00000000..c36d0bdf
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/점진적 정적 재생성 (ISR).md	
@@ -0,0 +1,27 @@
+# [[점진적 정적 재생성 (ISR)]]
+
+## 📌 Brief Summary
+점진적 정적 재생성(ISR, Incremental Static Regeneration)은 정적 사이트 생성(SSG)의 매우 빠른 로딩 속도와 서버 사이드 렌더링(SSR)의 데이터 최신화 능력을 결합한 하이브리드 웹 렌더링 전략입니다 [1, 2]. 전체 애플리케이션을 다시 빌드할 필요 없이 런타임에 백그라운드에서 특정 정적 페이지를 업데이트할 수 있도록 해줍니다 [1, 3, 4]. 주로 대규모 이커머스, 뉴스 포털, 문서 사이트 등 성능과 주기적인 콘텐츠 업데이트가 모두 중요한 플랫폼에서 효과적으로 활용됩니다 [5, 6].
+
+## 📖 Core Content
+- **기본 작동 원리**: 
+  초기 빌드 단계에서 페이지가 정적 HTML로 생성 및 캐시됩니다. 이후 사용자가 페이지를 요청하면 먼저 캐시된 정적 버전을 즉시 제공하여 빠른 응답 속도를 보장합니다 [6, 7]. 이때 콘텐츠가 지정된 재검증(revalidation) 시간을 초과한 상태라면, 브라우저에는 캐시된 구형 페이지를 먼저 보여주고 그와 동시에 백그라운드에서 페이지의 재생성 프로세스를 시작합니다 [6-8]. 새 버전이 성공적으로 생성되면 이후의 요청부터는 업데이트된 페이지가 제공됩니다 [7].
+
+- **주요 장점**:
+  - **성능과 데이터 최신의 조화**: 글로벌 CDN 캐싱을 통해 SSG와 같은 즉각적인 로딩 속도를 달성하면서도, SSR처럼 콘텐츠를 주기적으로 새롭게 유지할 수 있습니다 [8, 9].
+  - **대규모 확장성 및 서버 부하 감소**: 클라이언트의 요청 시마다 서버가 동적 렌더링을 수행하지 않고 백그라운드에서 업데이트를 처리하므로, 서버의 과부하 없이 막대한 트래픽을 처리하기 좋습니다 [5, 9].
+  - **주문형 재검증(On-demand Revalidation)**: 지정된 시간 주기에 의한 업데이트뿐만 아니라, 새로운 데이터가 발생했을 때 API 라우트를 통해 즉각적으로 특정 페이지의 재생성을 트리거할 수 있습니다 [8].
+  - **안정성 (Instant Rollback)**: 백그라운드 재생성 시도에 에러가 발생하더라도, 마지막으로 성공했던 정적 버전을 계속 제공하여 사이트의 가용성을 유지합니다 [9, 10].
+
+- **한계 및 기술적 고려사항**:
+  - **설정의 복잡성**: 재검증 주기를 너무 짧게 하면 서버 부하가 커지고, 너무 길게 하면 사용자에게 오래된 데이터(Stale data)를 보여줄 위험이 있어 성능과 최신성 사이의 균형을 맞추는 정밀한 구성이 필요합니다 [10].
+  - **프레임워크 종속성**: ISR은 Next.js나 Nuxt 3와 같이 의견이 강하게 반영된(opinionated) 특정 메타 프레임워크에 의존해야 하며, 백엔드 재생성 프로세스를 위해 주로 Node.js 런타임 환경을 필요로 합니다 [9, 10].
+  - 정적 파일 내보내기(Static exports) 방식과는 호환되지 않으며, 캐싱 및 배포 레이어를 관리하는 데 복잡성이 추가됩니다 [9, 10].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[정적 사이트 생성 (SSG)]], [[서버 사이드 렌더링 (SSR)]]
+- **Projects/Contexts:** [[Next.js]], [[Nuxt 3]], [[대규모 이커머스 및 콘텐츠 플랫폼]]
+- **Contradictions/Notes:** ISR은 실시간에 가까운 데이터(Near real-time)를 제공하며 안정성을 보장하지만, 백그라운드에서 재검증이 수행되기 전이거나 재생성 도중 백엔드 문제가 발생할 경우 사용자에게 필연적으로 이전의 오래된(Stale) 데이터가 지속해서 노출될 수 있다는 점을 유의해야 합니다 [8, 10, 11].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/차선 모델과 작업 우선순위 (Lane Model & Priorities).md b/10_Wiki/Topics/Frontend_Mastery/차선 모델과 작업 우선순위 (Lane Model & Priorities).md
new file mode 100644
index 00000000..30b0b4f4
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/차선 모델과 작업 우선순위 (Lane Model & Priorities).md	
@@ -0,0 +1,31 @@
+# [[차선 모델과 작업 우선순위 (Lane Model & Priorities)]]
+
+## 📌 Brief 동Summary
+React의 차선 모델(Lane Model)은 Concurrent 렌더링을 지원하기 위해 작업의 우선순위를 32비트 정수(비트마스크)로 관리하는 시스템입니다 [1, 2]. 이 시스템은 업데이트의 중요도에 따라 작업을 분류하고, 긴급한 사용자 상호작용을 먼저 처리하며 상대적으로 덜 중요한 작업은 지연시킵니다 [1, 3, 4]. 이를 통해 메인 스레드의 블로킹을 방지하고 애플리케이션의 반응성과 전반적인 사용자 경험을 크게 향상시킵니다 [4, 5].
+
+## 📖 Core Content
+**우선순위 레벨 및 차선(Lane)의 종류**
+스케줄러는 업데이트를 차선 우선순위에 따라 실행하며, 각 작업의 중요도에 따라 다음과 같이 분류합니다 [4, 6, 7].
+*   **Sync Lane (Immediate/Sync):** 타이핑이나 클릭과 같은 긴급한 개별 사용자 입력입니다 [4, 6, 7]. 이 작업은 애플리케이션의 즉각적인 반응성을 위해 다른 작업을 블로킹하지 않고 즉시 처리되어야 합니다 [4, 6].
+*   **InputContinuous Lane (User-blocking):** 스크롤이나 포인터 호버링과 같은 연속적인 사용자 입력입니다 [4, 6, 7]. 부드러운 화면 움직임을 보장하기 위해 높은 우선순위를 가지며 약간의 지연은 허용되지만 빠르게 완료되어야 합니다 [4, 6].
+*   **Default Lane (Normal):** 데이터 페칭(fetching) 결과나 사용자 입력에 의해 트리거되지 않은 애니메이션 등 대부분의 일반적인 상태 업데이트에 적용되는 표준 우선순위입니다 [4, 6, 7].
+*   **Low Lane:** 분석이나 로깅과 같이 지연 처리가 가능한 업데이트입니다 [6].
+*   **Idle Lane:** 화면 밖(offscreen) 렌더링 등 브라우저가 유휴(idle) 상태일 때만 처리되는 백그라운드 작업입니다 [4, 6, 7].
+
+**차선 모델의 설계 및 작동 원리**
+*   **비트마스크 시스템:** 차선 모델은 각 차선이 우선순위 수준이나 작업 범주를 나타내는 32비트 정수의 비트마스크 시스템을 사용합니다 [2]. 비트 연산(`lanes & otherLanes`)을 통해 겹치는 우선순위, 작업의 일괄 처리(batching) 가능 여부 등을 매우 효율적으로 판별합니다 [8].
+*   **다중 우선순위 관리:** 단일 렌더링 사이클은 여러 우선순위 레벨의 업데이트를 포함할 수 있으며, 스케줄러는 가장 우선순위가 높은 진행 중인 작업(WIP)을 먼저 실행합니다 [2, 9].
+*   **작업의 중단 및 재개:** 렌더링 페이즈 동안 React는 우선순위가 가장 높은 차선부터 작업을 처리하며, 더 높은 우선순위의 업데이트가 도착하면 기존의 낮은 우선순위 작업을 중단(Interrupt)하고 나중에 재개할 수 있습니다 [8, 9].
+*   **기아 상태 방지 (Starvation prevention):** 우선순위가 낮아 너무 오래 대기한 작업은 결국 실행될 수 있도록 더 높은 우선순위의 차선으로 승격됩니다 [8].
+*   **얽힘 (Entanglement):** 우선순위가 낮은 업데이트가 높은 우선순위의 업데이트에 의존해야 할 때, 두 차선을 얽어서 반드시 함께 렌더링되도록 보장합니다 [8].
+
+**Concurrent 기능과의 연관성**
+이러한 차선 모델은 React 18 및 19에서 무거운 연산 중에도 UI가 반응성을 유지하도록 돕는 `useTransition` 및 `useDeferredValue`와 같은 동시성(Concurrent) 기능을 가능하게 하는 핵심 기반 아키텍처입니다 [5].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[React Fiber Architecture]], [[Concurrent Rendering]], [[React Scheduler]], [[useTransition & useDeferredValue]]
+- **Projects/Contexts:** [[React 16, 18, 19 Rendering Updates]]
+- **Contradictions/Notes:** 소스 간의 모순된 주장은 없으며, 제공된 모든 소스는 React 스케줄러와 차선 모델이 사용자 경험을 저해하는 렌더링 블로킹을 해소하고 성능을 최적화하는 데 필수적인 역할을 한다는 점에 동의합니다.
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/초기 로드 시간 (Initial Load Time).md b/10_Wiki/Topics/Frontend_Mastery/초기 로드 시간 (Initial Load Time).md
new file mode 100644
index 00000000..81a95b89
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/초기 로드 시간 (Initial Load Time).md	
@@ -0,0 +1,28 @@
+# [[초기 로드 시간 (Initial Load Time)]]
+
+## 📌 Brief Summary
+초기 로드 시간은 사용자가 웹 페이지를 요청한 후 화면에 첫 콘텐츠가 표시되거나 사용자가 페이지와 상호작용할 수 있게 되기까지 걸리는 시간을 의미합니다 [1-3]. 이 시간은 네트워크 지연 시간(Latency), 자바스크립트 번들의 크기, 그리고 중요 렌더링 경로(Critical Rendering Path)의 최적화 수준에 따라 크게 달라집니다 [4-6]. 특히 웹 애플리케이션의 렌더링 전략(CSR, SSR, SSG)은 초기 로드 속도와 Time to First Byte(TTFB), First Contentful Paint(FCP), Time to Interactive(TTI) 등의 주요 성능 지표에 결정적인 영향을 미칩니다 [1, 7-9].
+
+## 📖 Core Content
+* **초기 로드의 기술적 단계 및 영향 요인**
+  * **네트워크 지연과 파싱:** 웹 페이지의 초기 로드는 DNS 조회, TCP 3방향 핸드셰이크, TLS 협상을 거쳐 서버로부터 첫 바이트(TTFB)를 수신하면서 시작됩니다 [2, 10-12]. 이후 브라우저는 HTML을 파싱하고 중요 렌더링 경로(DOM 및 CSSOM 생성, 렌더 트리 구축, 레이아웃, 페인트)를 실행하며, 첫 14KB의 데이터 패킷 안에 첫 렌더링에 필요한 핵심 HTML과 CSS가 포함되는 것이 성능에 매우 중요합니다 [13, 14].
+  * **렌더링 및 파서 차단 리소스:** `<head>` 태그 내의 CSS나 동기식 자바스크립트 파일은 렌더링 및 HTML 구문 분석을 차단(Render-blocking 및 Parser-blocking)하여 사용자가 화면을 보기까지 걸리는 초기 렌더링 시간을 크게 지연시킵니다 [15-18].
+  * **대용량 자바스크립트 번들:** React와 같은 프레임워크를 사용할 때 자바스크립트 번들의 크기가 커지면(예: 500KB 이상), 브라우저가 첫 상호작용 요소가 표시되기 전에 모든 코드를 다운로드하고 파싱, 실행해야 하므로 초기 로드 시간이 느려집니다 [1, 4, 19, 20].
+
+* **웹 렌더링 방식에 따른 초기 로드 시간 비교**
+  * **클라이언트 사이드 렌더링 (CSR):** 서버가 최소한의 빈 HTML 셸과 자바스크립트 번들을 전송하며, 브라우저가 스크립트를 다운로드해 UI를 구축할 때까지 사용자는 빈 화면(느린 초기 로드 및 FCP 지연)을 보게 됩니다 [1, 20-23].
+  * **서버 사이드 렌더링 (SSR):** 서버에서 완성된 HTML을 생성하여 전송하므로 초기 콘텐츠 표시(FCP)는 매우 빠릅니다 [7, 24, 25]. 하지만 사용자가 화면을 보더라도 자바스크립트 다운로드 및 하이드레이션(Hydration)이 완료될 때까지 상호작용(TTI)이 지연될 수 있으며, 서버 측 처리로 인해 TTFB가 증가하는 트레이드오프가 존재합니다 [7, 8, 26-28].
+  * **정적 사이트 생성 (SSG) 및 점진적 정적 재생성 (ISR):** 빌드 타임에 정적 HTML을 미리 생성하여 CDN을 통해 즉시 제공하므로 서버 연산 시간이 발생하지 않아 TTFB가 짧고 초기 로드 속도가 가장 빠릅니다 [29-34].
+
+* **초기 로드 시간 최적화 전략**
+  * **코드 분할(Code Splitting):** `React.lazy()` 등을 활용해 애플리케이션을 라우트 수준의 청크 단위로 나누면 초기 자바스크립트 번들 크기를 30~50%까지 줄일 수 있어 초기 로드 속도(LCP) 개선에 직접적인 도움을 줍니다 [35, 36].
+  * **최적화 도구 활용:** 최신 이미지 포맷(WebP, AVIF) 변환, 지연 로딩(Lazy Loading), 트리 쉐이킹(Tree Shaking)을 활용하여 로드되는 파일의 크기와 개수를 최소화해야 합니다 [37-39].
+  * **중요 렌더링 경로 단축:** 비판적인(Non-critical) 자바스크립트에 `async`나 `defer` 속성을 추가하고, 불필요한 DOM 조작을 줄여 브라우저의 파서 차단을 방지해야 합니다 [40-42].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[중요 렌더링 경로 (Critical Rendering Path)]], [[클라이언트 사이드 렌더링 (CSR)]], [[서버 사이드 렌더링 (SSR)]], [[정적 사이트 생성 (SSG)]], [[하이드레이션 (Hydration)]]
+- **Projects/Contexts:** [[웹 성능 최적화 (Web Performance Optimization)]], [[React 아키텍처 설계]]
+- **Contradictions/Notes:** SSR은 검색 엔진 최적화(SEO) 및 초기 콘텐츠 렌더링(FCP) 속도 개선에 뛰어나지만, 페이지마다 HTML을 동적으로 생성하므로 초기 TTFB(Time to First Byte)가 느려질 수 있으며 하이드레이션에 의해 상호작용 가능 시간(TTI)이 지연되는 단점이 있습니다 [8, 26, 43, 44]. 반면 CSR은 초기 콘텐츠 표시는 가장 느리지만(FCP 지연), 로드가 끝난 후의 인터랙션 반응성은 즉각적이고 부드러운 특징을 보입니다 [45, 46].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/컨테이너 쿼리(Container Queries).md b/10_Wiki/Topics/Frontend_Mastery/컨테이너 쿼리(Container Queries).md
new file mode 100644
index 00000000..aa2bef0b
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/컨테이너 쿼리(Container Queries).md	
@@ -0,0 +1,19 @@
+# [[컨테이너 쿼리(Container Queries)]]
+
+## 📌 Brief Summary
+컨테이너 쿼리는 브라우저의 전체 뷰포트(창) 크기가 아닌, 해당 컴포넌트를 감싸고 있는 **부모 컨테이너의 크기(사용 가능한 공간)**에 따라 스타일을 조정할 수 있게 해주는 모던 CSS 기능입니다 [1-3]. 이를 통해 페이지 레벨이 아닌 진정한 의미의 **컴포넌트 레벨 반응형 디자인**이 가능해지며, 2026년 현재 모듈식 UI 및 디자인 시스템 구축의 필수 표준 기술로 자리 잡았습니다 [1, 4].
+
+## 📖 Core Content
+
+*   **기존 미디어 쿼리의 근본적 한계 극복:** 전통적인 반응형 웹 디자인은 화면(뷰포트)의 너비에 의존하는 미디어 쿼리를 사용했습니다. 하지만 이 방식은 동일한 카드 컴포넌트가 좁은 사이드바에 있을 때와 넓은 메인 영역에 있을 때 각기 다르게 렌더링되어야 하는 상황을 효율적으로 처리하기 어렵다는 치명적인 한계가 있었습니다 [1, 3]. 컨테이너 쿼리는 화면 크기가 아니라 부모 요소의 크기에 반응함으로써 이 문제를 해결합니다 [1-3].
+*   **작동 방식 및 구현:** 컨테이너 쿼리를 사용하려면 먼저 부모 요소에 `container-type: inline-size;`와 같은 속성을 지정하여 쿼리의 기준이 될 컨테이너를 정의해야 합니다 [2, 3]. 그런 다음 `@container (min-width: 600px)`와 같은 구문을 사용하여 컨테이너의 크기 조건에 맞는 스타일을 하위 요소에 적용합니다 [1, 2].
+*   **모듈화 및 재사용성의 극대화:** 컨테이너 쿼리의 도입은 반응형 디자인의 패러다임이 '페이지 중심'에서 '컴포넌트 중심'으로 이동했음을 의미합니다 [1, 5]. 컴포넌트가 자신이 놓인 환경(Context)을 스스로 인식하고 독립적으로 레이아웃을 조정하게 되므로, 대규모 애플리케이션의 다양한 맥락에서 컴포넌트를 재사용할 때 유연성과 탄력성이 크게 향상되며 이는 디자인 시스템의 작동 방식과 완벽히 일치합니다 [1, 3, 6].
+*   **브라우저 지원 및 실무 적용 현황:** 2024년부터 모든 최신 브라우저에서 완벽히 지원되어 프로덕션 환경에 안전하게 사용할 수 있는 2026년의 반응형 웹 표준 기술입니다 [4, 7]. 실무에서는 복잡한 SaaS 대시보드나 이커머스에서 부모 너비가 좁아질 때 차트를 단순한 숫자 카드로 변경하거나, 데이터 테이블을 카드 스택 형식으로 자동 변환하는 등의 컨텍스트 기반 컴포넌트를 설계할 때 핵심적으로 활용됩니다 [6, 8].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[반응형 디자인(Responsive Design)]], [[미디어 쿼리(Media Queries)]], [[디자인 시스템(Design Systems)]], [[모듈식 CSS(Modular CSS)]]
+- **Projects/Contexts:** [[대규모 프론트엔드 아키텍처(Scalable Frontend Architecture)]], [[SaaS 대시보드 및 이커머스 UI 개발]]
+- **Contradictions/Notes:** 컨테이너 쿼리는 미디어 쿼리를 완전히 없애는 것이 아니라 그 한계를 보완하는 역할을 합니다. 반응형 디자인의 철학이 '뷰포트 중심'에서 '컴포넌트 중심'으로 진화하는 것을 보여주는 대표적인 기술 변화입니다 [5]. 
+
+---
+*Last updated: 2026-04-26*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/콘텐츠 기반의 이커머스 및 뉴스 웹사이트 성능 튜닝.md b/10_Wiki/Topics/Frontend_Mastery/콘텐츠 기반의 이커머스 및 뉴스 웹사이트 성능 튜닝.md
new file mode 100644
index 00000000..c84caf14
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/콘텐츠 기반의 이커머스 및 뉴스 웹사이트 성능 튜닝.md	
@@ -0,0 +1,18 @@
+# [[콘텐츠 기반의 이커머스 및 뉴스 웹사이트 성능 튜닝]]
+
+## 📌 Brief Summary
+콘텐츠 기반의 이커머스 및 뉴스 웹사이트는 빠른 초기 로딩 속도와 우수한 검색 엔진 최적화(SEO)가 필수적이므로, 주로 서버 사이드 렌더링(SSR)과 점진적 정적 재생성(ISR) 전략을 채택합니다 [1-3]. 이러한 웹사이트의 성능 튜닝은 초기 콘텐츠 표시 속도를 극대화하면서도 '하이드레이션(Hydration)' 지연으로 인한 상호작용 문제를 최소화하는 데 중점을 둡니다 [4, 5]. 이를 위해 이미지 및 대규모 리스트 최적화, 선택적 하이드레이션, 병렬 데이터 페칭 및 React 서버 컴포넌트(RSC) 활용 등의 기술이 포괄적으로 적용됩니다 [6-9].
+
+## 📖 Core Content
+*   **최적의 렌더링 전략 선택 (SSR 및 ISR):** 이커머스의 상품 목록 및 뉴스 기사와 같이 SEO와 신선한 데이터가 중요한 페이지에는 SSR이 적합합니다 [1-3]. SSR은 완전한 HTML을 서버에서 제공하여 검색 엔진 크롤러가 즉시 색인할 수 있게 하며, 매우 빠른 초기 콘텐츠 페인트(FCP)를 보장합니다 [1, 10]. 또한, ISR은 글로벌 CDN 캐싱을 통한 정적 사이트 생성(SSG)의 빠른 속도를 유지하면서 주기적으로 콘텐츠를 업데이트할 수 있어, 가격이나 재고가 빈번히 바뀌는 대규모 이커머스 및 뉴스 포털에 이상적입니다 [2, 11-13].
+*   **하이드레이션(Hydration) 병목 최적화:** SSR은 화면에 콘텐츠를 빨리 표시하지만, JavaScript가 다운로드 및 실행되어 페이지가 상호작용 가능해지기까지의 시간(TTI)이 지연되는 단점이 있습니다 [10, 14]. 이를 최적화하기 위해 뷰포트 상단(Above-the-fold)의 중요한 구성 요소부터 우선적으로 하이드레이션하는 선택적/점진적 하이드레이션(Selective Hydration) 기법을 사용하거나 [9, 15], 스크롤을 통해 화면에 보일 때만 하이드레이션을 수행하는 지연(Lazy) 하이드레이션을 적용할 수 있습니다 [16, 17].
+*   **React 서버 컴포넌트(RSC)를 통한 클라이언트 부하 감소:** 상품 카탈로그나 콘텐츠 페이지와 같은 읽기 전용 데이터 디스플레이의 경우, RSC를 도입하면 클라이언트 측 JavaScript 번들에 기여하는 용량을 0바이트로 만들어 INP(Interaction to Next Paint) 점수를 크게 개선할 수 있습니다 [7, 18]. 단, 서버에서 데이터 의존성이 직렬로 연결되어 '서버 사이드 폭포수(Waterfall)' 현상이 발생하지 않도록 컴포넌트의 데이터를 병렬로 페칭하도록 설계해야 합니다 [19-21].
+*   **이미지 및 대규모 리스트 렌더링 최적화:** 이커머스와 뉴스 사이트는 대량의 이미지를 포함합니다. WebP나 AVIF 같은 최신 포맷 사용, 기기 해상도에 맞춘 반응형 크기 제공, 네이티브 지연 로딩(`loading="lazy"`)을 통해 초기 페이지 로드 가중치를 줄이고 LCP(Largest Contentful Paint)를 개선해야 합니다 [6, 22]. 또한 뉴스 피드나 대규모 상품 리스트(100개 이상)를 렌더링할 때는 화면에 보이는 항목만 렌더링하는 '가상화(Virtualization)'를 적용하여 수천 개의 DOM 노드 생성으로 인한 렌더링 지연 및 버벅거림을 방지해야 합니다 [23, 24].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Server-Side Rendering (SSR)]], [[Incremental Static Regeneration (ISR)]], [[Hydration]], [[React Server Components]]
+- **Projects/Contexts:** [[대규모 상품 카탈로그 및 뉴스 포털 구축]], [[Next.js를 활용한 하이브리드 렌더링 최적화]]
+- **Contradictions/Notes:** SSR은 뛰어난 FCP와 SEO 이점을 제공하지만, 하이드레이션 과정이 완료될 때까지 페이지 상호작용이 지연(TTI 저하)되어 사용자가 클릭 시 반응하지 않는 등 체감 성능과 사용자 경험이 하락할 수 있다는 트레이드오프가 존재합니다 [5, 25, 26].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/크로스 플랫폼 디자인 시스템 연동.md b/10_Wiki/Topics/Frontend_Mastery/크로스 플랫폼 디자인 시스템 연동.md
new file mode 100644
index 00000000..e508607d
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/크로스 플랫폼 디자인 시스템 연동.md	
@@ -0,0 +1,17 @@
+# [[크로스 플랫폼 디자인 시스템 연동]]
+
+## 📌 Brief Summary
+크로스 플랫폼 디자인 시스템 연동은 디자인 토큰(Design Tokens)을 활용하여 웹, iOS, Android 등 여러 플랫폼에 걸쳐 일관된 시각적 디자인 값을 공유하고 관리하는 체계입니다 [1, 2]. 이 방식은 플랫폼에 구애받지 않는 단일 진실 공급원(Single source of truth)을 구성하여, 디자인 변경 사항이 자동 변환 도구를 통해 모든 플랫폼에 동시에 일관되게 반영되도록 돕습니다 [2, 3]. 결과적으로 디자이너와 개발자 간의 소통 오류를 줄이고 대규모 애플리케이션 환경에서 유지보수성과 확장성을 극대화합니다 [4, 5].
+
+## 📖 Core Content
+- **디자인 토큰 기반의 단일 진실 공급원 구축:** 디자인 토큰은 색상, 간격, 타이포그래피, 애니메이션 등의 시각적 디자인 속성을 저장하는 플랫폼 독립적인 명명된 엔티티입니다 [1, 6]. 이는 대규모 제품 배포 프로세스를 확장하기 위한 근본적인 빌딩 블록으로, JSON과 같은 중립적인 포맷으로 저장되어 전체 디자인 시스템 내에서 **단일 진실 공급원(Single source of truth)**의 역할을 수행합니다 [4, 5, 7].
+- **도구를 활용한 다중 플랫폼 자동 변환:** 크로스 플랫폼 환경에서 토큰의 진가는 하나의 디자인 값을 여러 플랫폼 형식으로 자동 변환할 때 발휘됩니다 [2]. **Style Dictionary**나 **Theo**와 같은 변환 도구 시스템을 활용하면, 원본 토큰 데이터를 기반으로 웹용 CSS 변수(Variables), iOS용 Swift, Android용 XML, React Native 환경의 코드 등으로 각각 변환해 생성할 수 있습니다 [1-3, 5].
+- **유지보수 가능한 설계와 워크플로우 파이프라인:** 현대적인 토큰 워크플로우는 Figma의 Tokens Studio 같은 디자인 도구에서 토큰을 내보내고, 이를 자동 변환하여 npm 패키지나 저장소를 통해 배포 및 소비하는 파이프라인 구조를 따릅니다 [8]. 이러한 구조를 통해, 디자인 시스템의 테마(예: 브랜드의 주요 색상)가 한 번 변경되면 수동 수정 없이 수많은 컴포넌트와 전체 플랫폼(Web, 모바일 앱 등)에 즉시 업데이트가 전파되어 유지보수가 매우 효율적입니다 [3, 5].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Design Tokens]], [[Style Dictionary]]
+- **Projects/Contexts:** [[디자인-개발 워크플로우(Design-to-Code Workflow)]], [[단일 진실 공급원(Single Source of Truth) 구축]]
+- **Contradictions/Notes:** 다중 플랫폼 디자인 시스템 연동을 위해 다양한 도구와 플러그인이 등장하고 있지만, 디자이너와 개발자 양측의 모든 디자인 토큰 관리 요구를 완벽하게 충족시키는 단일 솔루션은 아직 발견되지 않았으며 대부분 어느 정도의 수동 구성을 필요로 한다는 한계가 지적됩니다 [9, 10].
+
+---
+*Last updated: 2026-04-26*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/크리티컬 렌더링 패스 (Critical Rendering Path).md b/10_Wiki/Topics/Frontend_Mastery/크리티컬 렌더링 패스 (Critical Rendering Path).md
new file mode 100644
index 00000000..4f81342f
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/크리티컬 렌더링 패스 (Critical Rendering Path).md	
@@ -0,0 +1,26 @@
+# [[크리티컬 렌더링 패스 (Critical Rendering Path)]]
+
+## 📌 Brief Summary
+크리티컬 렌더링 패스(Critical Rendering Path, CRP)는 브라우저가 HTML, CSS, JavaScript 코드를 수신하여 화면의 픽셀로 변환하기 위해 거치는 일련의 단계를 의미합니다 [1, 2]. 브라우저는 DOM과 CSSOM을 생성하고, 이를 결합하여 렌더 트리를 구축한 뒤, 요소의 크기와 위치를 계산하는 레이아웃(Layout) 단계와 화면에 그리는 페인트(Paint) 단계를 수행합니다 [2, 3]. 이 경로를 최적화하는 것은 초기 렌더링 시간(Time to First Render)을 단축하고 사용자 상호작용의 유창함을 보장하기 위한 프론트엔드 성능 엔지니어링의 핵심 목표입니다 [1, 4].
+
+## 📖 Core Content
+**주요 진행 단계 (Sequential Progression of Steps)**
+*   **DOM 트리 생성 (DOM Construction)**: 브라우저가 HTML 바이트를 파싱하여 점진적(incremental)으로 DOM 트리를 구축합니다 [5, 6]. 노드의 수가 많을수록 이후 단계에서 소요되는 시간이 길어집니다 [1, 7].
+*   **CSSOM 트리 생성 (CSSOM Construction)**: CSS 규칙을 파싱하여 스타일 정보를 담은 CSSOM 트리를 생성합니다 [7, 8]. DOM과 달리 CSSOM 생성은 점진적이지 않으며, 브라우저는 모든 CSS를 처리할 때까지 페이지 렌더링을 차단(Render-blocking)합니다 [7, 9].
+*   **렌더 트리 합성 (Render Tree Synthesis)**: DOM과 CSSOM이 준비되면, 시각적으로 화면에 표시되어야 하는 노드와 그에 해당하는 계산된 스타일만 포함하는 렌더 트리를 구축합니다. `<script>` 요소나 `display: none` 스타일이 적용된 노드 등 화면에 보이지 않는 요소는 제외됩니다 [10-12].
+*   **레이아웃 (Layout / Reflow)**: 렌더 트리를 기반으로 기기의 뷰포트 크기를 고려하여 각 요소의 정확한 기하학적 형태(크기와 화면상 위치)를 계산합니다 [13-16].
+*   **페인트 및 합성 (Paint and Composite)**: 계산된 기하학적 형태와 스타일을 실제 픽셀로 변환(Paint)하여 화면에 그리고, 여러 레이어로 분리된 요소를 올바른 순서로 화면에 결합(Composite)합니다 [17-20].
+
+**성능 최적화 및 렌더링 차단 요소 (Performance Optimization and Blocking Resources)**
+*   초기 렌더링을 위해서는 HTML 일부와 `<head>` 태그 내에 있는 렌더링 차단 CSS 및 JavaScript 처리가 선행되어야 합니다 [21-23]. 
+*   브라우저의 파서(Parser)는 동기식 JavaScript를 만나면 DOM을 변경할 수 있기 때문에 HTML 파싱을 중단하며, 이는 렌더링 차단으로 이어져 큰 성능 비용을 발생시킵니다 [23, 24].
+*   CRP 최적화를 위해서는 이러한 렌더링 차단 리소스의 영향을 최소화하여 중요한 리소스의 로드 순서를 제어하고 다운로드해야 할 크기를 줄이는 것이 필수적입니다 [25, 26].
+*   이미지나 폰트는 일반적으로 초기 렌더링을 지연시키는 차단 리소스로 취급되지 않지만 [27], 요소의 치수를 미리 제공하지 않으면 이미지가 로드된 후 레이아웃이 다시 계산되는 리플로우(Reflow) 현상이 발생하여 성능이 저하될 수 있습니다 [19, 20, 27].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[DOM (Document Object Model)]], [[CSSOM (CSS Object Model)]], [[렌더 트리 (Render Tree)]], [[리플로우 (Reflow)]], [[리페인트 (Repaint)]]
+- **Projects/Contexts:** 프론트엔드 성능 최적화(Frontend Performance Optimization) 작업이나 Lighthouse, Chrome DevTools, WebPageTest와 같은 성능 감사 도구를 통해 렌더링 병목 현상을 파악하고 해결하는 맥락에서 빈번하게 다뤄집니다 [28-30].
+- **Contradictions/Notes:** 전통적으로 크리티컬 렌더링 패스는 '최초 렌더링(First Paint)'을 위해 필요한 최소한의 과정을 의미하지만, 최근의 웹 성능 측정은 첫 페인트를 넘어 실제 유의미한 콘텐츠가 사용자에게 보여지는 시점인 LCP(Largest Contentful Paint) 등을 포괄하는 '크리티컬 콘텐츠 렌더링 패스(Critical Contentful Rendering Path)'에 집중해야 한다는 관점도 대두되고 있습니다 [26, 31].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/클라이언트 사이드 렌더링 (CSR).md b/10_Wiki/Topics/Frontend_Mastery/클라이언트 사이드 렌더링 (CSR).md
new file mode 100644
index 00000000..aa32db32
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/클라이언트 사이드 렌더링 (CSR).md	
@@ -0,0 +1,29 @@
+# [[클라이언트 사이드 렌더링 (CSR)]]
+
+## 📌 Brief Summary
+클라이언트 사이드 렌더링(CSR)은 서버가 최소한의 빈 HTML 파일과 JavaScript 번들을 제공하고, 브라우저가 JavaScript를 실행하여 동적으로 UI를 생성 및 렌더링하는 웹 렌더링 방식입니다 [1-3]. 주로 싱글 페이지 애플리케이션(SPA)에서 사용되며, 페이지 전체를 새로고침하지 않고 필요한 콘텐츠만 변경하므로 매끄럽고 네이티브 앱과 같은 상호작용을 제공합니다 [4-6]. 하지만 큰 JavaScript 번들을 처리하느라 초기 로딩 속도가 느리고 검색 엔진 최적화(SEO)에 불리하다는 치명적인 단점이 있어, 주로 SEO보다 동적인 상호작용이 중요한 대시보드나 SaaS 플랫폼에 적합합니다 [7-9].
+
+## 📖 Core Content
+
+*   **작동 메커니즘 (How it Works)**
+    CSR 환경에서 브라우저는 처음에 거의 비어 있는 HTML 셸(Shell)과 JavaScript 파일에 대한 링크만을 서버로부터 전달받습니다 [2, 3, 9, 10]. 이후 브라우저가 JavaScript 번들을 다운로드, 파싱 및 실행하고, AJAX나 Fetch API를 통해 데이터를 가져온 뒤, DOM(문서 객체 모델)을 클라이언트 측에서 동적으로 구축하여 사용자 화면에 렌더링합니다 [2, 3]. 즉, 렌더링의 주체와 책임이 서버에서 브라우저로 완전히 이동한 형태입니다 [2].
+
+*   **주요 장점 (Advantages)**
+    *   **풍부한 상호작용 및 매끄러운 페이지 전환**: 초기 로드가 완료된 후에는 라우팅과 렌더링이 브라우저 내에서 동적으로 처리되므로 전체 페이지를 새로고침할 필요가 없습니다 [6, 9, 11, 12]. 이는 지연 없는 부드러운 앱 수준의 사용자 경험을 제공합니다 [4, 6].
+    *   **서버 부하 감소 및 비용 절감**: 서버는 정적 파일(HTML, CSS, JS)과 API 데이터만을 제공하면 되므로 서버의 연산 부담이 최소화됩니다 [9, 12-14]. 이로 인해 저렴한 정적 호스팅(Amazon S3, Netlify 등)을 활용할 수 있습니다 [14].
+
+*   **주요 단점 (Disadvantages)**
+    *   **느린 초기 로드 속도**: 브라우저가 모든 JavaScript 코드를 다운로드하고 실행하기 전까지 사용자는 빈 화면이나 로딩 스피너만 보게 됩니다 [7, 11-13]. 모바일 환경이나 느린 네트워크에서는 초기 렌더링에 수 초가 걸릴 수 있습니다 [7].
+    *   **기기 의존성 및 메모리 문제**: 렌더링 작업이 클라이언트의 컴퓨팅 파워에 의존하기 때문에, 사양이 낮은 기기에서는 성능 저하나 배터리 소모 문제가 발생할 수 있습니다 [15, 16].
+    *   **SEO(검색 엔진 최적화)의 한계**: 검색 엔진 크롤러가 초기에 빈 HTML 페이지만 수집하게 되어 콘텐츠의 색인을 생성하는 데 어려움을 겪을 수 있습니다 [9, 11, 12, 17, 18]. 또한, 소셜 미디어 플랫폼에서 링크를 공유할 때 메타 태그나 미리보기 이미지를 제대로 읽어가지 못하는 문제가 발생합니다 [17].
+
+*   **최적의 사용 사례 (Ideal Scenarios)**
+    CSR은 SEO가 중요하지 않고 고도의 상호작용이 요구되는 환경에 완벽하게 부합합니다 [8, 13]. 예를 들어 인증 벽(Login Wall) 뒤에 있는 내부 비즈니스 애플리케이션, 실시간 데이터 업데이트가 필요한 사용자 대시보드, 복잡한 상태 관리가 필요한 SaaS 플랫폼 등이 이에 해당합니다 [3, 8, 9, 13, 19].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[서버 사이드 렌더링 (SSR)]], [[정적 사이트 생성 (SSG)]], [[싱글 페이지 애플리케이션 (SPA)]], [[수화 (Hydration)]]
+- **Projects/Contexts:** [[React]], [[Vue.js]], [[SaaS 플랫폼 개발]]
+- **Contradictions/Notes:** 대부분의 소스는 CSR 환경에서 브라우저가 대규모 JavaScript를 실행해야 하므로 초기 로드 속도(First Contentful Paint 등)가 느리다고 설명합니다 [4, 7, 9, 12, 16]. 하지만 소스 [20]은 "서버 측 연산이 필요 없기 때문에 초기 렌더링(FCP)이 번개처럼 빠르다"고 주장하여 다른 자료들의 성능 평가와 명백한 모순을 보입니다.
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/타이핑에 즉각 반응해야 하는 검색창 (Search-as-you-type).md b/10_Wiki/Topics/Frontend_Mastery/타이핑에 즉각 반응해야 하는 검색창 (Search-as-you-type).md
new file mode 100644
index 00000000..d1565a32
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/타이핑에 즉각 반응해야 하는 검색창 (Search-as-you-type).md	
@@ -0,0 +1,18 @@
+# [[타이핑에 즉각 반응해야 하는 검색창 (Search-as-you-type)]]
+
+## 📌 Brief Summary
+'타이핑에 즉각 반응해야 하는 검색창 (Search-as-you-type)'은 사용자가 키보드를 입력할 때마다 실시간으로 검색 결과를 가져오거나 필터링을 수행하는 UI 패턴입니다 [1, 2]. 하지만 이 패턴은 매번 키를 입력할 때마다 무거운 연산이나 API 호출을 유발하여 메인 스레드를 점유하고 입력 지연(Input lag)을 초래할 수 있습니다 [2, 3]. 이를 해결하기 위해 React 개발 환경에서는 주로 디바운싱(Debouncing) 기술이나 동시성 렌더링 기능인 `useTransition` 훅을 활용하여 입력창의 즉각적인 반응성을 유지하고 성능을 최적화합니다 [1, 2, 4].
+
+## 📖 Core Content
+* **성능 저하의 원인:** 사용자가 타이핑할 때마다 결과를 가져오는 검색 입력창은 매 키입력마다 API 호출이나 데이터 필터링 작업을 촉발합니다 [2]. 이는 수십 개의 불필요한 네트워크 요청을 생성하거나 메인 스레드를 차단하여, 데이터 항목이 많은 경우 사용자가 심각한 입력 지연을 경험하게 만듭니다 [2, 3].
+* **디바운싱(Debouncing)을 통한 최적화:** 비용이 많이 드는 작업을 최적화하는 한 가지 방법은 디바운싱을 사용하는 것입니다 [2]. 이는 사용자가 타이핑을 멈출 때까지(예: 300ms) API 호출이나 상태 업데이트를 지연시키는 기법입니다 [2]. 300ms의 디바운스 창은 사용자에게 눈에 띄는 지연을 주지 않으면서도 타이핑 중단을 효과적으로 포착하여 API 부하와 불필요한 리렌더링을 줄여줍니다 [2].
+* **React 동시성 기능 (`useTransition`) 활용:** React 18 및 19에서 도입된 `useTransition` 훅은 이 패턴을 최적화하는 데 매우 효과적입니다 [1, 5]. 목록 필터링이나 자동완성 결과 로딩과 같은 무거운 상태 업데이트를 '비긴급(non-urgent)'으로 표시하고 `startTransition`으로 감싸면, React는 타이핑과 같은 '긴급한' 상호작용을 먼저 처리합니다 [1, 5]. 그 결과 무거운 필터링 연산이 백그라운드에서 실행되는 동안에도 입력 필드는 모든 키 입력에 대해 반응성을 유지합니다 [3].
+* **디바운싱 vs `useTransition`:** 두 방식 모두 불필요한 작업을 줄여주지만, React의 렌더링 모델 내에서 UI 업데이트를 컴포넌트 수준에서 지연시킬 때는 `useTransition`이 더 나은 선택입니다 [4]. 반면, 단순히 백엔드 API 호출 빈도 자체를 낮추는 것이 주된 목적이라면 여전히 디바운싱이 가장 좋은 방법으로 권장됩니다 [4].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Debouncing]], [[useTransition]], [[Concurrent Rendering]]
+- **Projects/Contexts:** [[데이터 집약적 애플리케이션의 필터링 및 자동완성 구현]], [[React 성능 최적화 (Performance Optimization)]]
+- **Contradictions/Notes:** 소스에서는 컴포넌트 수준에서 UI 업데이트를 지연시켜 앱이 더 빠르게 느껴지게 하는 데는 `useTransition`이 더 적합하다고 주장하지만, API 호출의 빈도 자체를 낮추는 목적에 있어서는 디바운싱이 여전히 최선의 선택이라고 구분하여 설명하고 있습니다 [4].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/프론트엔드 기초 구조 이해 핵심 목적.md b/10_Wiki/Topics/Frontend_Mastery/프론트엔드 기초 구조 이해 핵심 목적.md
new file mode 100644
index 00000000..79b50497
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/프론트엔드 기초 구조 이해 핵심 목적.md	
@@ -0,0 +1,25 @@
+# [[프론트엔드 기초 구조 이해 핵심 목적]]
+
+## 📌 Brief Summary
+현대 프론트엔드 기초 구조(React 프레임워크 및 최신 아키텍처)를 도입하고 이해하는 핵심 목적은 브라우저 렌더링 엔진의 본질적인 한계를 극복하고, 갈수록 복잡해지는 사용자 인터페이스 요구사항을 효율적으로 해결하기 위함입니다 [1]. 핵심 렌더링 경로(Critical Rendering Path, CRP)를 정밀하게 제어하여 연산 및 네트워크 부하를 최소화함으로써 빠르고 반응성 높은 사용자 경험을 제공하는 동시에 [2, 3], 선언적(declarative)이고 컴포넌트 기반인 패러다임을 통해 확장 가능하고 유지보수가 용이한 시스템을 구축하는 것이 궁극적인 목표입니다 [2, 3].
+
+## 📖 Core Content
+*   **핵심 렌더링 경로(CRP) 관리와 리플로우/리페인트 최소화**
+    프론트엔드 성능 최적화의 첫걸음은 브라우저가 코드를 화면에 그리는 과정인 '핵심 렌더링 경로'를 이해하는 것입니다 [1, 4]. 브라우저는 HTML과 CSS를 파싱하여 각각 DOM과 CSSOM 트리로 만들고, 이를 결합하여 시각적 요소만 포함하는 렌더 트리(Render Tree)를 생성합니다 [4-7]. 이후 요소의 크기와 위치를 계산하는 레이아웃(Reflow)과 화면의 픽셀을 채우는 페인트(Repaint) 과정을 거치게 됩니다 [8-11]. 특히 레이아웃 연산인 리플로우는 계산 비용이 매우 높고 연쇄적인 재계산을 유발하므로, 이러한 불필요한 렌더링 비용을 최소화하는 것이 프론트엔드 구조 최적화의 주요 목적 중 하나입니다 [9, 12-14].
+
+*   **DOM 조작의 한계 극복: 가상 DOM(Virtual DOM)과 재조정(Reconciliation)**
+    실제 DOM을 직접 수정하는 작업은 본질적으로 느리며 CRP의 레이아웃과 페인트 단계를 반복적으로 트리거하게 됩니다 [15]. 이러한 비효율성을 극복하기 위해 React는 메모리 내에 가벼운 가상 DOM을 유지하고, 상태 변경 전후의 트리를 비교(Diffing)하는 재조정 과정을 거칩니다 [15, 16]. 이는 O(n) 복잡도의 휴리스틱 알고리즘을 사용해 변경된 부분만을 실제 DOM에 최소한으로 반영하게 해주며, 개발자는 수동적인 DOM 조작 대신 선언적으로 UI 상태를 작성할 수 있게 됩니다 [15-21].
+
+*   **컴포넌트 기반 아키텍처(CBA)를 통한 확장성 확보**
+    성능 외에도 모듈화와 유지보수성 확보가 현대 프론트엔드 구조의 핵심 목적입니다 [22]. 애플리케이션을 기능적 책임을 가진 재사용 가능하고 독립적인 컴포넌트로 캡슐화함으로써 코드의 일관성과 재사용성을 높입니다 [22-25]. 이 방식은 독립적인 개발과 테스트를 가능하게 하여 여러 팀이 병렬적으로 협업할 수 있도록 돕고, 시스템의 규모가 커지더라도 손쉽게 확장하고 버그를 관리할 수 있는 애자일(Agile)한 환경을 제공합니다 [23, 24, 26].
+
+*   **사용자 중심의 전략적 렌더링 방식 채택 (CSR, SSR, SSG 등)**
+    초기 로딩 속도, 검색 엔진 최적화(SEO), 상호작용성의 균형을 맞추기 위해 다양한 웹 렌더링 전략을 적재적소에 활용하는 것도 중요한 구조적 접근입니다 [27-29]. 브라우저에서 동적으로 UI를 렌더링하는 CSR(Client-Side Rendering), 서버에서 매 요청마다 HTML을 완성하는 SSR(Server-Side Rendering), 빌드 타임에 정적 파일을 제공하는 SSG(Static Site Generation) 등을 이해해야 합니다 [27, 30-33]. 최근에는 클라이언트 측 자바스크립트 번들 사이즈를 줄이고 메인 스레드 부하를 낮추기 위해 서버에서만 실행되는 React Server Components(RSC) 모델로까지 발전하고 있습니다 [34-39].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Critical Rendering Path]], [[Virtual DOM]], [[Reflow and Repaint]], [[Component-Based Architecture]], [[Web Rendering Strategies (CSR, SSR, SSG, RSC)]]
+- **Projects/Contexts:** [[React Performance Optimization]]
+- **Contradictions/Notes:** 렌더링 방식 선택에 있어 SSR은 브라우저에 완성된 HTML을 빠르게 전송하여 초기 콘텐츠 노출(FCP)과 SEO에는 유리하지만, 자바스크립트를 다운로드하고 연결하는 '수화(Hydration)' 과정이 완료되기 전까지는 사용자와 상호작용할 수 없어 TTI(Time to Interactive)가 지연된다는 뚜렷한 한계가 존재합니다 [27, 30, 40-44]. 반면 CSR은 초기 로드 속도나 SEO 측면에서는 불리하지만 로딩 완료 후의 동적인 상호작용성은 훨씬 뛰어나므로, 서비스의 목적에 맞는 트레이드오프(Trade-off) 전략 수립이 필수적입니다 [27, 40, 44]. 
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/프론트엔드 렌더링 최적화(Rendering Optimization).md b/10_Wiki/Topics/Frontend_Mastery/프론트엔드 렌더링 최적화(Rendering Optimization).md
new file mode 100644
index 00000000..8e4e66c1
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/프론트엔드 렌더링 최적화(Rendering Optimization).md	
@@ -0,0 +1,41 @@
+# [[프론트엔드 렌더링 최적화(Rendering Optimization)]]
+
+## 📌 Brief Summary
+프론트엔드 렌더링 최적화는 브라우저가 HTML, CSS, JavaScript를 화면의 픽셀로 변환하는 과정인 중요 렌더링 경로(Critical Rendering Path)를 효율화하여 애플리케이션의 응답성과 화면 표시 속도를 향상시키는 작업입니다 [1-3]. DOM 조작 시 발생하는 비용이 큰 리플로우(Reflow)와 리페인트(Repaint) 연산을 최소화하는 것이 핵심이며, React와 같은 프레임워크에서는 가상 DOM(Virtual DOM)과 파이버(Fiber) 아키텍처를 통해 이를 추상화 및 최적화합니다 [4-6]. 또한, 서비스의 특성에 따라 CSR, SSR, SSG 등의 렌더링 전략을 선택하고 하이드레이션(Hydration) 및 번들 크기를 관리함으로써 사용자 경험(Core Web Vitals)을 극대화하는 데 그 목적이 있습니다 [7-9].
+
+## 📖 Core Content
+
+**1. 브라우저 렌더링 과정 (Critical Rendering Path)**
+브라우저는 서버로부터 HTML을 수신하면 점진적으로 문서를 파싱하여 DOM(Document Object Model) 트리를 생성하고, CSS를 파싱하여 렌더링 차단 리소스인 CSSOM(CSS Object Model) 트리를 구성합니다 [10-13]. DOM과 CSSOM이 준비되면 화면에 표시될 노드들만 포함하는 렌더 트리(Render Tree)를 합성합니다 [14, 15]. 이후 요소들의 정확한 위치와 크기를 계산하는 레이아웃(Layout 또는 Reflow) 단계를 거쳐, 픽셀을 화면에 그리는 페인트(Paint 또는 Repaint) 및 레이어들을 합성하는 컴포지팅(Compositing) 단계로 화면을 출력합니다 [16-19]. 
+
+**2. 리플로우(Reflow)와 리페인트(Repaint) 최소화**
+*   **리플로우 (Layout):** 창 크기 변경, 요소의 추가/제거, 크기나 여백(width, height, margin 등)의 변경은 DOM 트리의 위치나 크기 계산을 다시 하게 만드는 리플로우를 유발하며 이는 계산 비용이 매우 큽니다 [4, 6, 20].
+*   **리페인트 (Paint):** 배경색이나 그림자 등 시각적 속성만 변경될 때 발생하며, 리플로우보다 비용이 적지만 과도하면 프레임 드롭(Jank)을 유발합니다 [17, 20, 21].
+*   **최적화 전략:** 불필요한 DOM 깊이를 줄이고, 복잡한 CSS 선택자를 피해야 합니다 [22, 23]. 또한 화면을 강제로 재계산하게 하는 동기적 DOM 읽기/쓰기 작업을 분리하여 레이아웃 스래싱(Layout Thrashing)을 방지하고, 애니메이션 구현 시 `transform`과 `opacity`를 활용하여 GPU 가속(Compositing)을 사용하는 것이 유리합니다 [4, 17, 21, 24].
+
+**3. 가상 DOM(Virtual DOM)과 재조정(Reconciliation)**
+React는 실제 DOM 조작의 비효율성을 피하기 위해 가상 DOM이라는 경량화된 메모리 내 UI 표현을 사용합니다 [5, 25]. 렌더링 시 이전 가상 DOM과 새로운 가상 DOM을 비교(Diffing)하여 변경된 부분만 실제 DOM에 반영합니다 [5, 25]. 이론상 트리를 비교하는 알고리즘은 O(n^3)의 복잡도를 가지지만, React는 요소 타입이 다르면 하위 트리를 완전히 새로 구축하고 리스트 요소의 경우 고유한 `key` 속성을 통해 식별하는 O(n)의 휴리스틱 알고리즘을 사용해 성능을 최적화합니다 [26, 27].
+
+**4. React Fiber와 동시성 렌더링 (Concurrent Rendering)**
+React 16부터 도입된 파이버(Fiber) 아키텍처는 동기식으로 진행되어 메인 스레드를 블로킹하던 기존 렌더링 방식을 개선했습니다 [28-30]. 렌더링 작업을 잘게 쪼개어 중단, 일시 정지, 재개가 가능하게 만들었으며(Time-slicing) [29, 31], 우선순위 레인(Lanes) 시스템을 통해 사용자 입력 같은 긴급한 작업과 데이터 가져오기와 같은 비긴급 작업을 구분하여 동시성 렌더링을 처리합니다 [32-34].
+
+**5. 렌더링 전략: CSR, SSR, SSG, ISR**
+웹의 렌더링 방식은 언제 어디서 HTML을 생성하느냐에 따라 나뉘며 각각의 트레이드오프가 존재합니다.
+*   **CSR (Client-Side Rendering):** 브라우저가 자바스크립트를 다운로드하고 실행해 UI를 그립니다. 상호작용은 빠르고 부드러우나 초기 로딩(FCP)이 느리고 SEO에 불리합니다 [7, 35, 36].
+*   **SSR (Server-Side Rendering):** 서버에서 매 요청마다 HTML을 생성해 보내므로 초기 로딩과 SEO가 우수합니다. 하지만 클라이언트에서 JS를 다운로드하고 이벤트 리스너를 연결하는 하이드레이션(Hydration) 과정이 완료될 때까지 상호작용(TTI)이 지연되는 단점이 있습니다 [37-39].
+*   **SSG (Static Site Generation):** 빌드 시점에 정적 HTML을 생성해 CDN을 통해 배포하므로 로딩 속도가 가장 빠르지만 동적 데이터 업데이트에 취약합니다 [40-42].
+*   **ISR (Incremental Static Regeneration):** 정적 페이지를 캐싱해 빠르게 제공하면서, 백그라운드에서 점진적으로 HTML을 재생성하여 데이터 최신화를 보완하는 하이브리드 전략입니다 [40, 43].
+
+**6. React 성능 최적화 기법 (React 18 & 19)**
+*   **컴포넌트 리렌더링 제한 (Memoization):** 부모 컴포넌트의 렌더링이 자식으로 전파되는 계단식 리렌더링(Cascade)을 막기 위해 `React.memo`, `useMemo`, `useCallback`을 사용합니다 [44-46]. 최근 React Compiler(React 19)가 도입되면서 빌드 타임에 AST를 분석하여 정적/반응성 값을 구분하고 최적화 경계를 자동으로 추가함으로써 수동 메모이제이션의 필요성이 크게 줄어들었습니다 [47-49].
+*   **자동 배칭 (Automatic Batching):** React 18부터는 이벤트 핸들러뿐만 아니라 비동기 호출이나 타임아웃 내부의 다수 상태 업데이트도 하나의 리렌더링으로 자동 그룹화하여 DOM 업데이트 횟수를 줄입니다 [50-52].
+*   **React Server Components (RSC):** 서버에서 독점적으로 실행되고 브라우저로 JavaScript 번들을 전송하지 않는 컴포넌트 아키텍처입니다 [53, 54]. 정적 UI와 데이터 접근 로직을 서버에 두고 대규모 JS 번들 로드와 하이드레이션 단계를 생략하여 초기 성능(INP 등)을 크게 개선할 수 있습니다 [53, 55, 56].
+*   **기타 기법:** 화면에 보이지 않는 무거운 컴포넌트나 이미지의 지연 로딩(`React.lazy()`, Lazy Loading), 대규모 리스트의 가상화(Virtualization), 디바운싱(Debouncing) 등이 필수적으로 적용됩니다 [57-60].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Critical Rendering Path]], [[Reflow and Repaint]], [[Virtual DOM]], [[React Fiber Architecture]], [[Hydration]], [[Server-Side Rendering (SSR)]], [[Client-Side Rendering (CSR)]], [[React Compiler]], [[React Server Components (RSC)]]
+- **Projects/Contexts:** [[Next.js 기반 웹 성능 최적화 프로젝트]], [[대규모 데이터 대시보드 및 이커머스 플랫폼 렌더링 전략 구축]]
+- **Contradictions/Notes:** 소스에 따르면 CSR은 동적인 상호작용성(Interactive)에 강점이 있으나 초기 로딩 속도와 SEO에 한계가 있는 반면, SSR은 초기 콘텐츠 표시와 SEO에는 유리하지만 하이드레이션(Hydration)이 완료되기 전까지 사용자의 입력이 차단되는(TBT/TTI 지연) 상충 관계(Trade-off)를 갖습니다 [7, 37, 61-64]. 또한 최근 도입된 React Compiler는 자동으로 세분화된 수준(Fine-Grained)의 메모이제이션을 수행하지만, `useLocation`이나 `useMutation` 처럼 렌더링마다 새로운 객체를 반환하여 참조 안정성(Reference Equality)을 깨뜨리는 서드파티 라이브러리를 사용할 경우 자동 최적화가 무력화되어 수동 메모이제이션이 여전히 필요할 수 있습니다 [49, 65-67].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/프론트엔드 성능 최적화 및 SEO 개선 프로젝트.md b/10_Wiki/Topics/Frontend_Mastery/프론트엔드 성능 최적화 및 SEO 개선 프로젝트.md
new file mode 100644
index 00000000..71de0a1f
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/프론트엔드 성능 최적화 및 SEO 개선 프로젝트.md	
@@ -0,0 +1,29 @@
+# [[프론트엔드 성능 최적화 및 SEO 개선 프로젝트]]
+
+## 📌 Brief Summary
+프론트엔드 성능 최적화 및 SEO 개선은 브라우저의 중요 렌더링 경로(CRP)를 단축하고, 불필요한 리플로우(Reflow)와 리페인트(Repaint)를 줄여 쾌적한 사용자 경험을 제공하는 과정이다 [1-3]. 검색 엔진 최적화(SEO)를 달성하고 성능을 높이기 위해 콘텐츠의 특성에 맞춰 서버 사이드 렌더링(SSR), 정적 사이트 생성(SSG) 등 알맞은 렌더링 전략을 선택하는 것이 핵심이다 [4-7]. 또한, 현대적인 애플리케이션에서는 React의 Virtual DOM, Fiber 아키텍처, 서버 컴포넌트(RSC) 및 React Compiler를 활용하여 자바스크립트 실행 비용을 최소화하고 렌더링 성능을 극대화한다 [8-11].
+
+## 📖 Core Content
+- **브라우저 렌더링 과정(CRP)과 최적화 (Browser Rendering and CRP Optimization)**
+  - 브라우저의 중요 렌더링 경로(Critical Rendering Path)는 HTML, CSS, JavaScript를 화면의 픽셀로 변환하는 일련의 단계이다 [12]. 먼저 HTML 파싱으로 DOM(Document Object Model)을, CSS 파싱으로 CSSOM(CSS Object Model)을 생성한 후, 화면에 보일 요소들만을 결합해 렌더 트리(Render Tree)를 만든다 [13-15].
+  - 렌더 트리가 완성되면 요소의 정확한 위치와 크기를 계산하는 레이아웃(Layout, 또는 Reflow)이 발생하고, 이후 화면에 실제 픽셀과 색상을 그리는 페인트(Paint) 단계가 진행된다 [16-19].
+  - 리플로우(Reflow)는 많은 연산을 요구하여 병목 현상을 유발하는 무거운 작업이므로, DOM 트리의 깊이를 줄이고 레이아웃을 변경하는 속성(예: 너비, 높이 등)의 빈번한 조작을 피해야 한다 [20-23]. 성능 최적화를 위해서는 `transform` 등 GPU 가속이 가능한 속성을 활용하고, 렌더링 차단 리소스를 최소화해야 한다 [24-27].
+
+- **웹 렌더링 전략과 SEO (Web Rendering Strategies and SEO)**
+  - **CSR (Client-Side Rendering):** 클라이언트의 브라우저에서 JavaScript를 다운로드하고 실행하여 페이지를 동적으로 렌더링한다 [28, 29]. 사용자 상호작용과 페이지 전환 속도가 매우 뛰어나지만, 검색 엔진 크롤러가 초기에 빈 화면을 마주할 가능성이 커 SEO에 불리하며, 초기 로드 속도(FCP)가 느린 편이다 [30-33].
+  - **SSR (Server-Side Rendering):** 서버에서 사용자의 요청마다 완성된 HTML을 생성하여 브라우저에 전달한다 [34, 35]. 검색 엔진이 즉시 콘텐츠를 크롤링할 수 있어 SEO 최적화와 초기 렌더링 속도에 매우 유리하다 [36, 37]. 다만, 상호작용을 위해 자바스크립트가 연결되는 하이드레이션(Hydration) 단계가 완료될 때까지 버튼 클릭 등이 지연되는 현상(TTI 지연)이 발생할 수 있으며 서버 부하가 증가한다 [5, 38-40].
+  - **SSG (Static Site Generation) 및 ISR:** 빌드 단계에서 미리 HTML을 생성해두어 CDN을 통해 제공하므로 초고속 로딩과 뛰어난 SEO를 보장하지만 데이터 변경이 잦은 사이트에는 부적합하다 [41-44]. 이를 보완하기 위해 백그라운드 주기적 업데이트를 지원하는 ISR(Incremental Static Regeneration) 기법이 활용되기도 한다 [6, 45-47].
+
+- **React 기반 성능 최적화 기술 (React Performance Optimization)**
+  - **Virtual DOM과 Diffing:** React는 메모리 내에 가상 DOM을 유지하고 변경된 부분만 $O(n)$ 복잡도의 휴리스틱 알고리즘으로 비교하여 실제 DOM을 최소한으로 업데이트한다 [48-50].
+  - **Fiber 아키텍처와 자동 배칭(Automatic Batching):** React 16부터 도입된 Fiber는 렌더링 작업을 잘게 분할하여(Time-slicing) 우선순위가 높은 사용자 상호작용(예: 타이핑)을 먼저 처리하도록 지원한다 [8, 51-53]. 또한, React 18의 자동 배칭 기능은 동기 및 비동기 작업 내의 여러 상태 업데이트를 한 번의 렌더링으로 묶어 불필요한 리렌더링을 방지한다 [54-56].
+  - **React Server Components (RSC):** 서버에서만 실행되고 클라이언트로 자바스크립트 코드를 전송하지 않는 컴포넌트 구조다 [9, 57, 58]. 전송되는 번들 크기를 사실상 "제로(0)"로 만들고, 서버의 데이터베이스나 시스템에 직접 안전하게 접근할 수 있어 획기적인 성능 개선과 향상된 보안을 제공한다 [59-62].
+  - **React Compiler:** 2024년에 안정화된 이 도구는 `useMemo`, `useCallback` 등을 통한 개발자의 수동 메모이제이션 부담을 없앤다. 빌드 타임에 코드와 데이터 흐름을 정적으로 분석하여 필요한 부분에 자동으로 메모이제이션 경계를 삽입함으로써, 코드가 훨씬 간결해지고 렌더링 성능이 크게 향상된다 [10, 11, 63-65].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Critical Rendering Path]], [[Virtual DOM]], [[Server-Side Rendering]], [[Client-Side Rendering]], [[Hydration]], [[React Fiber]], [[React Compiler]], [[React Server Components]]
+- **Projects/Contexts:** [[단일 페이지 애플리케이션(SPA)]], [[Next.js를 활용한 하이브리드 렌더링]]
+- **Contradictions/Notes:** 소스 [66]과 [67]에 따르면, React Compiler가 적용된 후 React DevTools 프로파일러에 `Memo ✨` 배지가 표시된다고 해서 컴포넌트의 최적화가 반드시 성공했음을 의미하는 것은 아니다. props가 불안정한 참조를 계속 반환하는 일부 서드파티 라이브러리를 사용할 경우, 컴파일러가 이를 제어하지 못해 리렌더링이 발생할 수 있으므로 이러한 상황에서는 여전히 제한적인 수동 메모이제이션이 필요할 수 있다.
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/프론트엔드 성능 최적화(Frontend Performance Optimization).md b/10_Wiki/Topics/Frontend_Mastery/프론트엔드 성능 최적화(Frontend Performance Optimization).md
new file mode 100644
index 00000000..400110bf
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/프론트엔드 성능 최적화(Frontend Performance Optimization).md	
@@ -0,0 +1,28 @@
+# [[프론트엔드 성능 최적화(Frontend Performance Optimization)]]
+
+## 📌 Brief Summary
+프론트엔드 성능 최적화는 브라우저가 코드를 해석하여 화면에 렌더링하는 과정과 웹 애플리케이션의 작동 방식을 개선하여 사용자 경험을 극대화하는 과정입니다. 이는 브라우저의 중요 렌더링 경로(CRP) 최적화부터 불필요한 리플로우(Reflow)와 리페인트(Repaint) 최소화, 그리고 웹 렌더링 전략(CSR, SSR, SSG 등)의 올바른 선택을 아우릅니다. 최근에는 React의 Fiber 아키텍처, 상태 업데이트 자동 배칭, 컴파일러를 통한 자동 메모이제이션, 그리고 React 서버 컴포넌트(RSC) 도입을 통해 클라이언트 측 자바스크립트의 실행 및 번들 크기를 획기적으로 줄이는 방향으로 발전하고 있습니다.
+
+## 📖 Core 기Content
+**1. 브라우저 렌더링 과정 (Critical Rendering Path) 및 DOM 최적화**
+- **렌더 트리 구성:** 브라우저는 HTML을 파싱하여 DOM을 만들고, CSS를 파싱하여 CSSOM을 생성한 후, 화면에 표시될 가시적인 노드들만을 결합하여 렌더 트리(Render Tree)를 구축합니다 [1, 2]. 
+- **Reflow와 Repaint 최소화:** 렌더 트리가 변경되면 브라우저는 요소의 정확한 크기와 위치를 다시 계산하는 레이아웃(Reflow) 단계를 거친 후 픽셀을 화면에 그리는 페인트(Repaint) 작업을 수행합니다 [3-9]. Reflow는 연산 비용이 매우 높으므로 불필요한 DOM 깊이를 줄이고, 레이아웃에 영향을 주는 속성 변경을 피해야 합니다 [7, 8, 10-12]. 애니메이션의 경우 `transform` 속성이나 하드웨어(GPU) 가속을 활용해 Reflow를 피하고 컴포지팅(Compositing) 단계에서 처리되도록 최적화해야 합니다 [5, 12-14].
+- **렌더링 차단 리소스 최적화:** CSS와 동기식 자바스크립트는 초기 파싱 및 렌더링을 차단(Render-blocking)하므로, 자바스크립트에는 `async`나 `defer`를 사용하고 중요한 리소스는 Preload 스캐너를 통해 미리 로드하여 렌더링 지연을 방지해야 합니다 [15-23].
+
+**2. 프론트엔드 아키텍처 및 React 렌더링 최적화**
+- **가상 DOM (Virtual DOM) 및 재조정 (Reconciliation):** React는 메모리상에 가상 DOM을 두고 상태 변경 전후를 비교합니다. O(n) 복잡도의 Heuristic Diffing 알고리즘을 사용하며, 요소의 타입이 다르거나 리스트에 `key` 속성이 변경된 경우에만 실제 DOM 노드를 업데이트하여 연산을 최소화합니다 [24-37].
+- **Fiber 아키텍처:** React 16부터 도입된 Fiber는 렌더링 작업을 잘게 쪼개는 시간 분할(Time-slicing) 기술과 우선순위(Lanes) 시스템을 제공합니다. 클릭이나 타이핑 같은 긴급한 작업을 먼저 처리하고 무거운 렌더링은 중단 및 재개할 수 있어 동시성 렌더링(Concurrent Rendering)과 부드러운 UI 응답성을 달성합니다 [26, 38-51].
+- **자동 배칭 (Automatic Batching) 및 메모이제이션:** React 18은 Promise나 setTimeout 같은 비동기 환경 내의 상태 업데이트도 하나로 묶어서(Batching) 처리하여 불필요한 리렌더링을 줄입니다 [52-56]. 또한, React Compiler는 빌드 타임에 AST를 분석해 정적 값과 반응형 값을 식별하고 자동으로 메모이제이션 경계를 추가하여 개발자가 수동으로 `useMemo`나 `useCallback`을 작성해야 하는 부담과 오버헤드를 크게 줄여줍니다 [57-65].
+
+**3. 웹 렌더링 전략 (CSR, SSR, SSG) 및 하이드레이션**
+- **렌더링 전략의 장단점:** CSR(클라이언트 사이드 렌더링)은 동적 상호작용에 유리하지만 초기 로드가 느리고 SEO에 불리합니다 [66-70]. SSR(서버 사이드 렌더링)은 완성된 HTML을 바로 제공하여 초기 화면 표시(FCP)가 빠르고 SEO에 유리하지만 매 요청마다 서버 부하가 발생합니다 [71-76]. SSG(정적 사이트 생성)는 빌드 타임에 HTML을 미리 생성하여 가장 빠르고 CDN 캐싱이 가능하지만 동적 콘텐츠에는 한계가 있습니다 [77-82].
+- **하이드레이션 (Hydration) 병목 해결:** SSR 사용 시, 정적인 HTML이 사용자에게 표시된 후 자바스크립트를 다운로드하고 연결하여 상호작용을 활성화하는 하이드레이션 과정이 필수적입니다 [71, 83-85]. 이 과정은 메인 스레드를 차단하여 상호작용 지연 시간(TTI, TBT)을 악화시킬 수 있으므로, 사용자 뷰포트에 따라 렌더링을 지연시키는 선택적 하이드레이션(Selective Hydration)이나 지연 로딩 방식을 통해 최적화할 수 있습니다 [86-93].
+- **React 서버 컴포넌트 (React Server Components, RSC):** 상호작용이 필요 없는 정적 컴포넌트를 서버에서만 실행하고 결과 HTML과 직렬화된 지침(React Flight 프로토콜)만을 클라이언트에 스트리밍하는 아키텍처입니다. 클라이언트로 전송되는 자바스크립트 번들 크기를 0으로 만들어 하이드레이션 자체를 생략하므로, 성능(INP 등)이 대폭 향상되며 클라이언트와 서버 간의 데이터 폭포(Waterfall) 현상을 서버 수준에서 병렬로 해결할 수 있습니다 [94-109].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[브라우저 렌더링 과정(Critical Rendering Path)]], [[가상 DOM 및 재조정(Virtual DOM and Reconciliation)]], [[React Fiber 아키텍처]], [[하이드레이션(Hydration)]], [[웹 렌더링 전략(CSR, SSR, SSG, ISR)]], [[React 서버 컴포넌트(React Server Components)]], [[React Compiler]]
+- **Projects/Contexts:** [[Next.js를 활용한 웹 애플리케이션의 하이브리드 렌더링 구축]], [[Core Web Vitals (LCP, INP, CLS) 지표 측정 및 개선]]
+- **Contradictions/Notes:** 서버 사이드 렌더링(SSR)은 클라이언트 사이드 렌더링(CSR)에 비해 초기 화면 렌더링 속도(FCP)가 빠르고 검색 엔진 최적화(SEO)에 매우 유리하다는 강력한 이점을 지니지만 [71, 110], 자바스크립트를 로드하고 HTML 요소에 이벤트 리스너 등을 부착하는 하이드레이션(Hydration) 과정을 거쳐야 하므로 실제 사용자가 상호작용할 수 있는 시간(TTI)은 CSR의 로드 직후 반응성보다 다소 지연될 수 있다는 트레이드오프가 존재합니다 [71, 84, 111, 112].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/프론트엔드 프레임워크 (React, Angular, Vue).md b/10_Wiki/Topics/Frontend_Mastery/프론트엔드 프레임워크 (React, Angular, Vue).md
new file mode 100644
index 00000000..725bf7e0
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/프론트엔드 프레임워크 (React, Angular, Vue).md	
@@ -0,0 +1,29 @@
+# [[프론트엔드 프레임워크 (React, Angular, Vue)]]
+
+## 📌 Brief Summary
+프론트엔드 프레임워크는 사용자 인터페이스를 구축하기 위해 컴포넌트 기반 아키텍처(CBA)를 채택하는 모듈형 소프트웨어 도구입니다 [1, 2]. React, Angular, Vue와 같은 프레임워크는 기본적으로 클라이언트 측 렌더링(CSR)을 활용하여 상호작용이 풍부한 웹 애플리케이션을 구축하며, 필요에 따라 서버 측 렌더링(SSR) 및 정적 사이트 생성(SSG)을 혼합하여 성능을 최적화합니다 [3-5]. 제공된 소스에서는 프론트엔드 프레임워크의 아키텍처와 작동 원리가 주로 React를 중심으로 상세히 다뤄지고 있으며, Angular와 Vue의 내부 구조에 대한 구체적인 정보는 부족합니다.
+
+## 📖 Core Content
+*   **컴포넌트 기반 아키텍처 (Component-Based Architecture, CBA)**
+    *   현대 프론트엔드 프레임워크(React, Angular, Vue 등)는 시스템을 작고 독립적이며 재사용 가능한 '컴포넌트'로 나누어 설계하는 방식을 기반으로 합니다 [5-7].
+    *   각 컴포넌트는 자체적인 로직, 상태, UI를 캡슐화하여 제공하므로, 병렬 개발과 독립적인 테스트 및 배포가 가능해져 애플리케이션의 유지보수성과 확장성이 크게 향상됩니다 [1, 8, 9].
+
+*   **웹 렌더링 전략 (Web Rendering Strategies)**
+    *   **클라이언트 측 렌더링 (CSR):** React와 Vue는 기본적으로 CSR을 사용하며, 서버에서 빈 HTML 셸을 받은 뒤 브라우저에서 JavaScript를 실행하여 UI를 동적으로 생성합니다 [10]. 이는 상호작용이 부드럽지만 초기 로드 속도 지연과 SEO 약점을 가질 수 있습니다 [11, 12].
+    *   **하이브리드 렌더링:** 이러한 한계를 극복하기 위해 Next.js(React 기반), Nuxt.js(Vue 기반) 등의 프레임워크는 서버 측 렌더링(SSR) 및 정적 사이트 생성(SSG)을 혼합 지원하여 빠른 초기 페인팅(FCP)과 강력한 SEO 성능을 제공합니다 [4, 13].
+
+*   **프레임워크 핵심 아키텍처 (React 중심)**
+    *   **Virtual DOM 및 재조정 (Reconciliation):** 직접적인 DOM 조작의 성능 저하를 막기 위해, React는 UI를 메모리에 가상 DOM 객체로 유지합니다 [14, 15]. 상태가 변경되면 새로운 트리와 기존 트리를 비교(Diffing)하여 실제 DOM에 변경된 최소한의 부분만 업데이트합니다 [16, 17].
+    *   **Fiber 아키텍처:** 렌더링 작업을 동기적으로 한 번에 처리하던 기존 방식과 달리, Fiber는 렌더링을 중단 및 재개할 수 있는 작은 '작업 단위'로 나눕니다 [18, 19]. 이를 통해 사용자 입력과 같은 우선순위가 높은 작업을 먼저 처리하는 동시성 렌더링(Concurrent Rendering)이 가능해집니다 [20-22].
+    *   **성능 최적화의 자동화:** React 18은 비동기 작업이나 이벤트 핸들러 내의 여러 상태 업데이트를 묶어 한 번에 렌더링하는 '자동 일괄 처리(Automatic Batching)'를 도입했습니다 [23-25]. 또한, 최근의 React Compiler는 빌드 타임에 코드를 분석하여 불필요한 리렌더링을 막기 위한 메모이제이션을 자동으로 적용합니다 [26-28].
+    *   **React Server Components (RSC):** 클라이언트 번들 크기를 줄이기 위해 등장한 개념으로, 컴포넌트가 서버에서만 실행되고 클라이언트에는 직렬화된 UI 정보만 전달되어 JavaScript 번들 크기와 Hydration 과정의 부하를 없앱니다 [29, 30].
+
+*(소스에 관련 정보가 부족합니다: Angular와 Vue의 구체적인 내부 렌더링 엔진 작동 방식이나 상태 관리 최적화 기법 등 심층적인 프레임워크별 대조 정보는 제공된 소스에 포함되어 있지 않습니다.)*
+
+## 🔗 Knowledge Connections
+- **Related Topics:** `[[Component-Based Architecture]]`, `[[Client-Side Rendering (CSR)]]`, `[[Server-Side Rendering (SSR)]]`, `[[Virtual DOM]]`, `[[React Fiber]]`
+- **Projects/Contexts:** `[[Next.js 및 Nuxt.js를 활용한 하이브리드 웹 렌더링 최적화]]`, `[[Reflow 및 Repaint 최소화를 통한 브라우저 렌더링 개선]]`
+- **Contradictions/Notes:** 제공된 소스 데이터는 프론트엔드 프레임워크의 전반적인 개념(컴포넌트 구조, CSR/SSR)을 다루고 있으나, 기술적 작동 원리와 최적화 아키텍처(Virtual DOM, Fiber, Compiler, 자동 일괄 처리 등)에 대한 설명은 React에 압도적으로 편중되어 있습니다. Angular와 Vue는 개념을 설명하기 위한 예시로만 언급됩니다.
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/하이드레이션 (Hydration).md b/10_Wiki/Topics/Frontend_Mastery/하이드레이션 (Hydration).md
new file mode 100644
index 00000000..11526770
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/하이드레이션 (Hydration).md	
@@ -0,0 +1,28 @@
+# [[하이드레이션 (Hydration)]]
+
+## 📌 Brief Summary
+하이드레이션(Hydration)은 서버에서 사전 렌더링된 정적 HTML을 클라이언트가 전달받은 후, JavaScript를 실행하여 이벤트 리스너와 상태를 연결함으로써 완전한 상호작용이 가능한 애플리케이션으로 변환하는 과정입니다 [1]. SSR(Server-Side Rendering)의 빠른 콘텐츠 표시 장점과 CSR(Client-Side Rendering)의 상호작용성을 결합하지만, 하이드레이션이 완료되기 전까지는 사용자의 입력에 응답하지 않아 지연이 발생할 수 있습니다 [1-5]. 
+
+## 📖 Core Content
+*   **작동 방식 및 역할:**
+    *   서버는 데이터가 포함된 HTML을 생성하여 클라이언트(브라우저)로 전송합니다 [3, 5].
+    *   브라우저는 이 HTML을 즉시 표시하므로 사용자는 콘텐츠를 바로 볼 수 있지만, 이 시점에서는 상호작용할 수 없는 정적인 상태입니다 [2, 3].
+    *   이후 브라우저가 JavaScript 번들을 다운로드하고 실행하면, React가 가상 DOM을 렌더링된 HTML에 "연결(attach)"하여 버튼 클릭 등 각종 이벤트 핸들러와 상태 관리를 활성화합니다. 이 과정이 바로 하이드레이션입니다 [1, 2, 5].
+*   **성능에 미치는 영향 및 주요 과제:**
+    *   하이드레이션은 TBT(총 차단 시간), FID(최초 입력 지연), TTI(상호작용까지의 시간) 등 핵심 성능 지표(Core Web Vitals)에 직접적인 영향을 미칩니다 [6]. 
+    *   기본적으로 React는 전체 페이지를 한 번에 하이드레이션하려 하기 때문에 메인 스레드를 차단하는 불필요한 JavaScript 실행이 발생하고, 이로 인해 사용자가 클릭해도 즉각적으로 반응하지 않는 입력 지연(Input lag)을 초래할 수 있습니다 [5, 7]. 
+    *   서버 렌더링 결과와 클라이언트 측 렌더링이 일치하지 않을 때 발생하는 '하이드레이션 불일치 에러(Mismatch errors)'와 모든 컴포넌트의 JavaScript 번들을 로드해야 해서 발생하는 번들 크기 비대화(Bundle size bloat) 문제도 자주 겪는 과제입니다 [7-9].
+*   **하이드레이션 최적화 전략:**
+    *   **점진적/선택적 하이드레이션 (Selective Hydration):** 동적 임포트(`next/dynamic`)를 사용해 화면 상단(Above-the-fold)의 중요한 콘텐츠를 먼저 처리하고 나머지 덜 중요한 컴포넌트의 하이드레이션을 분산시킵니다 [8, 10, 11].
+    *   **가시성 기반 지연 하이드레이션 (Lazy Hydration):** `IntersectionObserver` API 등을 활용하여 컴포넌트가 뷰포트에 들어올 때만 하이드레이션을 실행합니다 [10, 11].
+    *   **부분 하이드레이션 (Partial Hydration) 및 아일랜드 아키텍처:** 상호작용이 필요한 특정 부분만 하이드레이션하고 나머지는 정적 HTML로 남겨둡니다 [12, 13].
+    *   **스트리밍 및 Suspense:** React의 Suspense API를 사용하여 서버에서 HTML을 점진적으로 스트리밍 처리합니다 [14].
+    *   **React Server Components (RSC):** 클라이언트 측으로 전송되는 JavaScript를 완전히 없애고 오직 서버에서만 실행되게 함으로써, 해당 컴포넌트들에 대해서는 하이드레이션 과정 자체를 생략합니다 [15-23].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Server-Side Rendering (SSR)]], [[Client-Side Rendering (CSR)]], [[React Server Components (RSC)]], [[Time to Interactive (TTI)]], [[Total Blocking Time (TBT)]]
+- **Projects/Contexts:** [[Next.js]], [[React 18]]
+- **Contradictions/Notes:** SSR은 초기 콘텐츠 렌더링(FCP)이 빠르고 SEO에 유리하다는 큰 장점이 있지만, 하이드레이션 단계가 완료되기 전까지 애플리케이션의 상호작용이 지연된다는 뚜렷한 한계(트레이드오프)가 있습니다 [4, 24, 25]. 이 문제를 근본적으로 해결하기 위해 React 18은 동시성 렌더링을 통한 하이드레이션 청크 분할 및 사용자가 상호작용하는 부분을 우선순위로 두는 선택적 하이드레이션을 도입하였고 [26], React Server Components는 하이드레이션 단계를 완전히 제거하는 구조를 제시합니다 [21, 23].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics/Skybound/2026-04-25-Skybound_Vampire_Survivors_Loop_and_Stage_Curve_Preparation.md b/10_Wiki/Topics/Skybound/2026-04-25-Skybound_Vampire_Survivors_Loop_and_Stage_Curve_Preparation.md
new file mode 100644
index 00000000..04f297a2
--- /dev/null
+++ b/10_Wiki/Topics/Skybound/2026-04-25-Skybound_Vampire_Survivors_Loop_and_Stage_Curve_Preparation.md
@@ -0,0 +1,116 @@
+# Skybound Vampire Survivors Loop and Stage Curve Preparation
+
+작성일: 2026-04-25 23:52 KST
+
+## 요청 요약
+
+- Skybound가 뱀파이어 서바이벌 계열 게임처럼 느껴지도록 재미 요소와 스테이지별 레벨 구조를 준비한다.
+- 단순히 적을 많이 내보내는 것이 아니라, 성장 선택, 밀도 상승, 진화 완성, 보스 체크포인트가 자연스럽게 이어지도록 만든다.
+
+## 핵심 방향
+
+Skybound는 탑다운 생존 슈터이지만, 기존 구조는 스테이지 시간이 짧고 보스 진입이 빨라 빌드가 완성되기 전에 전투가 끊기는 문제가 있었다. 뱀서류 재미를 만들려면 다음 루프가 안정적으로 반복되어야 한다.
+
+1. 초반: 첫 무기 선택 후 약한 적을 많이 처치하며 빠르게 1-2회 성장한다.
+2. 중반: 적 밀도와 엘리트 압박이 올라가며 광역/관통/방어 선택의 의미가 생긴다.
+3. 후반: 스웜과 미니보스가 들어오며 빌드 조합과 진화 무기가 필요해진다.
+4. 보스: 완성된 빌드가 제대로 작동하는지 검증한다.
+5. 다음 스테이지: 같은 빌드를 이어가되 적 밀도, 패턴, 보스 기믹이 상승한다.
+
+## 적용한 변경
+
+### 8스테이지 Survivor 프로필 추가
+
+`CombatTimeline.ts`에 `SURVIVOR_STAGE_PROFILES`를 추가했다. 각 스테이지는 아래 정보를 가진다.
+
+- 스테이지 이름
+- 스테이지 길이
+- 기본 난이도 배율
+- 동시 적 수 기준
+- 스폰 템포
+- 오프닝 웨이브
+- 압박 엘리트 웨이브
+- 스웜 웨이브
+- 클라이맥스 엘리트 웨이브
+- 미니보스 체크포인트
+
+### 스테이지별 구조
+
+- Stage 1 `First Contact`: 첫 무기와 기본 생존 학습
+- Stage 2 `Fast Lanes`: 빠른 적과 이동 압박
+- Stage 3 `Ruined Circuit`: 혼합 편대와 엘리트 압박
+- Stage 4 `Crossfire Grid`: 길막/라인 클리어 압박
+- Stage 5 `Magma Forge`: 고밀도 스웜 시작
+- Stage 6 `Storm Foundry`: 빌드 완성 요구
+- Stage 7 `Arcane Collapse`: 진화 무기 권장
+- Stage 8 `Final Singularity`: 완성 빌드 검증
+
+### 스테이지 시간 조정
+
+기존 Standard 스테이지는 약 165초부터 시작해 빌드업 시간이 부족했다. 새 구조에서는 Stage 1이 240초, Stage 8이 420초까지 증가한다.
+
+이렇게 하면 플레이어는 한 스테이지 안에서 다음 리듬을 경험할 수 있다.
+
+- 0-25%: 세팅과 첫 성장
+- 25-48%: 엘리트 압박
+- 48-72%: 스웜 압박
+- 72%-보스 전: 클라이맥스와 미니보스
+- 마지막 35초 전후: 보스전 진입
+
+### 스폰 밀도 조정
+
+- 적 하드캡을 56에서 76으로 올렸다.
+- 스웜 배치 단위를 6에서 8로 올렸다.
+- 기본 절차 스폰 간격을 96프레임에서 84프레임으로 줄였다.
+
+목표는 “가만히 있어도 클리어”가 아니라, 점점 밀려오는 압박을 움직임과 빌드 선택으로 해결하게 만드는 것이다.
+
+### Tac EXP 커브 조정
+
+바닥 EXP 젬을 다시 뿌리지는 않고, 처치 즉시 Tac EXP를 지급하는 현재 방향을 유지했다. 다만 뱀서류 성장 리듬을 만들기 위해 처치 경험치를 조정했다.
+
+- 일반 적: `+2 TAC`
+- 엘리트 적: `+10 TAC`
+- 미드보스: `+30 TAC`
+
+초기 요구 EXP는 `90`에서 `80`으로 낮췄다. 대신 레벨업 후 초과 EXP carryover는 25%만 유지해 연속 레벨업 폭주는 막는다.
+
+레벨 요구량 배율은 아래처럼 조정했다.
+
+- Level 1-4: `x1.34`
+- Level 5-8: `x1.42`
+- Level 9-14: `x1.52`
+- Level 15+: `x1.62`
+
+## 설계 의도
+
+이번 변경은 “Vampire Survivors의 재미”를 다음 요소로 해석했다.
+
+- 적은 점점 많아진다.
+- 플레이어는 더 자주 선택하고 강해진다.
+- 선택에는 빌드 방향성이 있다.
+- 중반 이후에는 광역, 관통, 방어, 기동 중 최소 하나가 부족하면 압박을 느낀다.
+- 보스는 단절된 엔딩이 아니라 빌드 검증 구간이다.
+- 다음 스테이지는 새 게임이 아니라 이전 빌드의 확장 시험이다.
+
+## 수정 파일
+
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/config/CombatTimeline.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/SpawnerSystem.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/CombatSystem.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/ProgressionSystem.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/types.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/store/useGameStore.ts`
+
+## 검증
+
+- `npm run build` 성공
+- Vite 경고: `/sprites/player.png referenced in /sprites/player.png didn't resolve at build time`
+- 위 경고는 기존 런타임 경로 경고이며 이번 변경으로 인한 빌드 실패는 아니다.
+
+## 후속 작업 제안
+
+- 각 스테이지별 고유 몬스터 역할 비중을 더 명확히 분리한다.
+- 스테이지별 보스 패턴을 현재보다 더 강하게 차별화한다.
+- 진화 무기별 화면 가독성과 성능을 플레이테스트로 검증한다.
+- 미니보스 처치 시 보물상자/카드 선택 보상을 확정 지급하는 구조를 추가하면 뱀서류 보상감이 더 강해진다.
diff --git a/10_Wiki/Topics/Skybound/2026-04-26-Skybound_Miniboss_Treasure_Cache_Reward_Loop.md b/10_Wiki/Topics/Skybound/2026-04-26-Skybound_Miniboss_Treasure_Cache_Reward_Loop.md
new file mode 100644
index 00000000..0bc19fac
--- /dev/null
+++ b/10_Wiki/Topics/Skybound/2026-04-26-Skybound_Miniboss_Treasure_Cache_Reward_Loop.md
@@ -0,0 +1,109 @@
+# Skybound Miniboss Treasure Cache Reward Loop
+
+작성일: 2026-04-26 09:32 KST
+
+## 요청 요약
+
+- 뱀파이어 서바이벌 계열의 재미를 더 강하게 만들기 위한 다음 단계로, 미니보스 처치 보상 루프를 추가한다.
+- 단순 EXP 성장만 반복되는 구조가 아니라, 중간 강적을 잡았을 때 빌드 방향을 강화하는 확정 보상을 제공한다.
+- 보상은 기존 Tac Level Up 화면을 재사용하되, 보물상자 성격의 `Emergency Supply` 카드 선택으로 연결한다.
+
+## 핵심 방향
+
+Skybound의 현재 전투 루프는 적을 처치하면 Tac EXP를 바로 얻고, 일정 EXP에 도달하면 업그레이드를 선택하는 구조다. 이 방식은 화면 가독성에는 좋지만, 플레이 중간에 “강적을 잡아서 특별한 보상을 얻었다”는 뱀서류 특유의 보상감이 부족했다.
+
+이번 변경의 목표는 미니보스를 다음 역할로 재정의하는 것이다.
+
+1. 전투 흐름 중간의 압박 체크포인트
+2. 플레이어 빌드가 충분히 강한지 확인하는 작은 검증 구간
+3. 처치하면 현재 빌드를 더 선명하게 만드는 확정 업그레이드 보상
+4. 보스 전 진화/EVO 경로를 완성할 기회를 주는 중간 보물상자
+
+## 적용한 변경
+
+### 미니보스 식별 플래그 추가
+
+기존 `MINI_BOSS` 스폰은 내부적으로 `ELITE` 적을 생성했기 때문에, 처치 시 일반 엘리트와 구분되는 보상 처리가 어려웠다. `SystemEnemy`에 아래 플래그를 추가했다.
+
+- `isMiniBoss`
+- `rewardClaimed`
+
+`SpawnerSystem`의 `MINI_BOSS` 스폰에서는 이제 `isMiniBoss: true`를 부여한다.
+
+### 미니보스 HP 스케일링
+
+미니보스가 후반 스테이지에서도 너무 빨리 녹지 않도록 스테이지와 난이도 배율을 반영했다.
+
+- 기본 HP: `620`
+- 스테이지당 증가: `+22%`
+- 현재 `difficultyMult` 반영
+
+의도는 미니보스가 보스만큼 길지는 않지만, 플레이어가 위치와 공격 방향을 신경 써야 하는 짧은 전투 목표가 되게 하는 것이다.
+
+### 처치 보상 인텐트 추가
+
+`EngineProtocol`에 `MINIBOSS_REWARD` 인텐트를 추가했다. `CombatSystem`은 미니보스 처치 시 직접 UI를 열지 않고, 엔진 인텐트를 통해 보상 처리를 요청한다.
+
+이렇게 한 이유는 다음과 같다.
+
+- 전투 시스템이 UI 상태를 직접 제어하지 않게 한다.
+- 기존 `LEVEL_UP` 이벤트와 `LevelUpModal` 흐름을 재사용한다.
+- 추후 보물상자 연출, 룰렛, 보상 티어를 추가하기 쉽다.
+
+### 빌드 우선 보상 카드 생성
+
+`ProgressionSystem`에 `generateMiniBossRewardCards`를 추가했다. 이 보상은 일반 레벨업 카드보다 더 전략적으로 구성된다.
+
+우선순위는 다음과 같다.
+
+1. 이미 보유한 무기/스킬의 레벨업
+2. Lv.3 이상 무기의 EVO에 필요한 서포트 패시브
+3. 스웜/압박 구간 대응용 `isSpikeCounter` 스킬
+4. 부족한 자리는 기존 3카드 생성 규칙으로 보충
+
+이 구조는 플레이어가 아무 카드나 고르는 것이 아니라, “내 빌드를 완성해가는 선택”을 하도록 유도한다.
+
+### 보상 UI 연결
+
+미니보스 처치 시 아래 흐름으로 동작한다.
+
+1. 미니보스 사망
+2. `CombatSystem`이 `MINIBOSS_REWARD` 인텐트 발행
+3. `useGameEngine`이 현재 스킬 상태를 기반으로 보상 카드 생성
+4. 게임 일시정지
+5. `LEVEL_UP` 이벤트를 `isChest: true`로 발행
+6. 기존 `Emergency Supply` 카드 선택 UI 표시
+7. `COMMAND CACHE UNLOCKED` 피드백 텍스트 출력
+
+## 설계 의도
+
+이 변경은 Skybound의 목적성을 더 명확하게 만들기 위한 작업이다.
+
+- 일반 적 처치: Tac EXP를 쌓는 기본 성장
+- 엘리트 처치: 더 많은 EXP와 재료/장비 가능성
+- 미니보스 처치: 확정 빌드 강화 선택
+- 스테이지 보스 처치: 다음 스테이지 진행과 영구 보상
+
+즉, 전투 중 목표가 “그냥 버티기”에서 “위험한 타이밍을 넘기고 빌드를 완성하기”로 바뀐다.
+
+## 수정 파일
+
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/hooks/useGameEngine.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/CombatSystem.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/EngineProtocol.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/ProgressionSystem.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/SpawnerSystem.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/types.ts`
+
+## 검증
+
+- `npm run build` 성공
+- Vite 경고: `/sprites/player.png referenced in /sprites/player.png didn't resolve at build time`
+- 위 경고는 기존 런타임 경로 경고이며 이번 변경으로 인한 빌드 실패는 아니다.
+
+## 후속 작업 제안
+
+- 미니보스 처치 순간에 실제 상자/코어가 열리는 0.6초 전용 연출을 추가한다.
+- 보상 카드에 `EVO READY`, `BUILD CORE`, `SURVIVAL PICK` 같은 태그를 붙여 선택 이유를 더 명확하게 보여준다.
+- 스테이지별 미니보스 외형과 탄막 패턴을 분리해 “이번 스테이지의 중간 위협” 정체성을 강화한다.
+- 보물상자 보상을 1장 선택에서 3장 순차 오픈 또는 희귀도 보상으로 확장할지 플레이테스트 후 결정한다.
diff --git a/10_Wiki/Topics/Skybound/2026-04-26-Skybound_Reward_Card_Clarity_and_Command_Cache_UI.md b/10_Wiki/Topics/Skybound/2026-04-26-Skybound_Reward_Card_Clarity_and_Command_Cache_UI.md
new file mode 100644
index 00000000..38aedfa3
--- /dev/null
+++ b/10_Wiki/Topics/Skybound/2026-04-26-Skybound_Reward_Card_Clarity_and_Command_Cache_UI.md
@@ -0,0 +1,104 @@
+# Skybound Reward Card Clarity and Command Cache UI
+
+작성일: 2026-04-26 09:40 KST
+
+## 요청 요약
+
+- 미니보스 보상 루프 다음 단계로, 보상 카드가 왜 좋은 선택인지 사용자가 즉시 이해할 수 있게 개선한다.
+- 미니보스 처치 보상과 위기 보급 보상을 같은 화면처럼 보이지 않게 구분한다.
+- Stylized Casual Magitech 톤앤매너 안에서 보상감 있는 카드 선택 UI를 강화한다.
+
+## 핵심 방향
+
+이전 단계에서 미니보스 처치 시 확정 업그레이드 선택 보상이 추가되었다. 하지만 카드 3장이 뜨는 것만으로는 사용자가 “왜 이 보상이 지금 내 빌드에 좋은지” 바로 이해하기 어렵다.
+
+이번 변경의 목표는 보상 화면을 단순 선택지가 아니라, 플레이어에게 다음 메시지를 전달하는 UI로 만드는 것이다.
+
+1. 이 카드는 현재 주력 빌드를 강화한다.
+2. 이 카드는 EVO 진화 경로에 필요하다.
+3. 이 카드는 스웜/압박 상황에서 생존에 도움이 된다.
+4. 이 카드는 새로운 공격 패턴을 열어준다.
+
+## 적용한 변경
+
+### 보상 출처 타입 추가
+
+`LEVEL_UP` 이벤트에 `rewardSource`를 추가했다.
+
+- `STARTER`
+- `LEVEL_UP`
+- `POWER_SPIKE`
+- `MINIBOSS`
+
+기존에는 `isChest`만 있어서 미니보스 보상과 위기 보급 보상이 모두 같은 `Emergency Supply`처럼 보였다. 이제 보상 출처에 따라 헤더, 문구, 카드 태그를 다르게 표시할 수 있다.
+
+### 미니보스 보상 헤더 차별화
+
+미니보스 보상은 이제 `Emergency Supply`가 아니라 `Command Cache`로 표시된다.
+
+- Badge: `Cache`
+- Title: `Command Cache`
+- Subtitle: `Choose one build-defining reward`
+
+위기 보급은 기존 의도대로 `Emergency Supply`를 유지한다.
+
+### 카드 선택 이유 태그 추가
+
+각 카드 상단에 보상 이유 태그를 추가했다.
+
+- `FIRST CORE`: 첫 무기 선택, 런의 시작 방향 결정
+- `CORE UPGRADE`: 현재 주력 무기 강화
+- `MODULE BOOST`: 보유 패시브/모듈 강화
+- `EVO LINK`: 현재 무기의 진화 조건을 지원
+- `EVO READY`: 진화 조건 완성
+- `SURVIVAL PICK`: 스웜/압박 구간 대응
+- `NEW WEAPON`: 새로운 공격 패턴 개방
+- `UTILITY MOD`: 기본 성능 강화
+
+이 태그는 단순 라벨이 아니라, 카드가 “왜 지금 의미 있는 선택인지”를 설명하는 짧은 문장과 함께 표시된다.
+
+### Command Cache 연출 추가
+
+보상 화면 상단에 작은 마법공학 캐시 코어를 추가했다.
+
+- 팝 인 애니메이션
+- 회전하는 점선 링
+- 미니보스 캐시는 청록/라임 계열 빛
+- 일반 보급은 오렌지/시안 계열 빛
+
+실제 게임 시간을 더 지연시키지는 않지만, 화면이 뜨는 순간 보상 상자가 열린다는 감각을 강화한다.
+
+## 설계 의도
+
+뱀파이어 서바이벌 계열의 재미는 단순히 레벨업을 많이 하는 것이 아니라, “내가 고른 선택 때문에 빌드가 강해지고 있다”는 확신에서 나온다.
+
+이번 변경은 그 확신을 UI로 보강한다.
+
+- 미니보스 처치: `Command Cache`
+- 위기 보급: `Emergency Supply`
+- 일반 레벨업: `Tactical Upgrade`
+- 시작 선택: `Choose First Weapon`
+
+이제 각 성장 이벤트는 같은 카드 선택이라도 서로 다른 의미를 가진다.
+
+## 수정 파일
+
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/hooks/useGameEngine.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/ProgressionSystem.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/types.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/ui/GameSceneRenderer.tsx`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/ui/LevelUpModal.tsx`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/ui/LevelUpModal.css`
+
+## 검증
+
+- `npm run build` 성공
+- Vite 경고: `/sprites/player.png referenced in /sprites/player.png didn't resolve at build time`
+- 위 경고는 기존 런타임 경로 경고이며 이번 변경으로 인한 빌드 실패는 아니다.
+
+## 후속 작업 제안
+
+- 스테이지별 미니보스 패턴을 분리해 `Command Cache`를 얻는 과정 자체를 더 재미있게 만든다.
+- 보상 카드에 실제 EVO 결과 미리보기 아이콘을 추가한다.
+- 보물상자 보상을 1장 선택에서 희귀도 기반 다중 보상으로 확장할지 플레이테스트한다.
+- Command Cache가 열리는 짧은 0.5초 전용 컷인/상자 오픈 애니메이션을 Canvas 위에 추가한다.
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/Core Web Vitals Optimization (INP, LCP 개선).md b/10_Wiki/Topics_Art/UI_UX_Assets/Core Web Vitals Optimization (INP, LCP 개선).md
new file mode 100644
index 00000000..a39e0ec0
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/Core Web Vitals Optimization (INP, LCP 개선).md	
@@ -0,0 +1,31 @@
+# [[Core Web Vitals Optimization (INP, LCP 개선)]]
+
+## 📌 Brief Summary
+Core Web Vitals는 구글이 웹 페이지의 검색 순위와 사용자 경험을 평가하기 위해 정의한 핵심 성능 지표입니다 [1]. 여기에는 화면의 주요 콘텐츠가 로드되는 속도를 측정하는 LCP(Largest Contentful Paint)와 페이지 세션 내내 애플리케이션이 사용자 상호작용에 얼마나 빠르게 응답하는지 측정하는 INP(Interaction to Next Paint)가 포함됩니다 [1, 2]. 이 지표들의 기준치(LCP 2.5초 미만, INP 200 밀리초 미만)를 달성하면 사용자 이탈률을 낮추고 유기적 검색(SEO) 성과를 직접적으로 높일 수 있습니다 [1-3].
+
+## 📖 Core Content
+
+- **Largest Contentful Paint (LCP) 최적화**
+  LCP는 브라우저 화면의 가장 큰 콘텐츠 요소가 렌더링되는 시간을 측정하며, 이를 2.5초 미만으로 유지하는 것이 목표입니다 [1]. 
+  - **코드 스플리팅(Code Splitting):** 기본적으로 번들러는 전체 애플리케이션을 하나의 큰 파일로 묶지만, `React.lazy()` 등을 통해 라우트 수준에서 코드를 분할하면 초기 번들 크기를 30~50%가량 줄여 LCP를 크게 개선할 수 있습니다 [4].
+  - **렌더링 전략 변경:** 클라이언트 측 렌더링(CSR)은 초기 로딩이 느리다는 단점이 있습니다 [5, 6]. 따라서 서버 사이드 렌더링(SSR)이나 정적 사이트 생성(SSG)을 도입해 자바스크립트 파싱 전에 완성된 HTML을 사용자에게 즉시 제공함으로써 LCP 병목 현상을 해소할 수 있습니다 [7-9].
+  - **이미지 최적화:** WebP나 AVIF 같은 현대적인 이미지 포맷을 사용하여 파일 크기를 줄이고, 화면에 보일 때만 이미지를 로드하는 `loading="lazy"` 지연 로딩을 도입해 초기 주요 리소스와의 대역폭 경쟁을 막습니다 [10, 11].
+
+- **Interaction to Next Paint (INP) 최적화**
+  INP는 기존의 First Input Delay(FID)를 대체한 지표로, 클릭이나 키보드 입력 같은 상호작용 지연 시간을 200ms 이내로 응답하게 만드는 것이 핵심입니다 [2].
+  - **동시성 렌더링(Concurrent Rendering):** React 19의 `useTransition` 및 `useDeferredValue` 훅을 통해 무거운 상태 업데이트(예: 대규모 목록 필터링)를 후순위로 미루고, 긴급한 사용자 입력(타이핑 등)을 먼저 처리하여 메인 스레드의 응답성을 유지합니다 [2, 12, 13].
+  - **메모이제이션과 연산 최적화:** 부모 컴포넌트의 상태가 변할 때 발생하는 불필요한 '리렌더링 폭포(Re-render Cascade)' 현상을 막기 위해 `React.memo`, `useMemo`, `useCallback`을 활용합니다 [14-16]. 더불어 키 입력마다 발생하는 과도한 API 호출을 줄이기 위해 디바운싱(Debouncing)을 적용합니다 [17].
+  - **목록 가상화(Virtualization):** 수백, 수천 개의 항목이 포함된 긴 목록을 렌더링할 때, 화면에 보이는 노드만 렌더링하는 가상화를 도입하면 레이아웃 및 페인트 작업 부하를 방지하여 상호작용 속도를 높입니다 [2, 18, 19].
+  - **React Server Components (RSC):** 읽기 전용 데이터 컴포넌트를 서버에서 전적으로 실행함으로써 클라이언트의 자바스크립트 크기를 40~60% 감소시키고, 상호작용 시 브라우저 메인 스레드가 처리할 코드를 줄여 INP를 직접적으로 낮출 수 있습니다 [20].
+
+- **Cumulative Layout Shift (CLS) 관리 및 성능 프로파일링**
+  - 시각적 안정성을 측정하는 CLS는 0.1 미만을 목표로 하며, 불필요한 DOM 노드를 줄이기 위한 React Fragment의 사용, 이미지의 명시적 크기 지정 등의 방법으로 개선합니다 [2, 21].
+  - 최적화를 적용하기 전에 항상 `React DevTools Profiler`나 `Lighthouse`를 사용하여 병목을 유발하는 컴포넌트를 찾고, 프로덕션 환경의 실측 데이터를 얻기 위해 `Web Vitals` 라이브러리로 필드 데이터를 모니터링해야 합니다 [22-26].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Largest Contentful Paint (LCP)]], [[Interaction to Next Paint (INP)]], [[Concurrent Rendering]], [[Server-Side Rendering (SSR)]], [[React Server Components (RSC)]]
+- **Projects/Contexts:** [[React Performance Optimization]], [[Search Engine Optimization (SEO) Strategy]]
+- **Contradictions/Notes:** Lighthouse와 같은 도구로 측정한 연구실 데이터(Lab measurements)는 다양한 기기 성능과 네트워크 조건을 겪는 실제 사용자들의 경험(Field data)과 항상 일치하지는 않으므로 프로덕션 상의 Web Vitals 데이터를 함께 수집해야 합니다 [23, 24].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/DOM (Document Object Model).md b/10_Wiki/Topics_Art/UI_UX_Assets/DOM (Document Object Model).md
new file mode 100644
index 00000000..b531a1b5
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/DOM (Document Object Model).md	
@@ -0,0 +1,25 @@
+# [[DOM (Document Object Model)]]
+
+## 📌 Brief Summary
+DOM(Document Object Model)은 브라우저가 수신한 HTML 문서 데이터를 파싱하여 생성하는 페이지 구조의 계층적 트리 표현입니다 [1-3]. 브라우저는 HTML 태그의 포함 관계를 바탕으로 부모 및 자식 노드의 트리를 형성하며, `<html>` 요소를 루트 노드로 갖습니다 [4, 5]. DOM은 페이지의 모든 콘텐츠 정보를 담고 있으며, 스타일 정보를 담은 CSSOM과 결합해 최종 화면 출력에 필요한 렌더 트리(Render Tree)를 형성하는 브라우저 렌더링 과정의 핵심 기반입니다 [6-8].
+
+## 📖 Core Content
+* **DOM 트리의 점진적 구축 (Incremental Construction)**
+  브라우저는 네트워크를 통해 HTML 문서의 전체 데이터를 다 받기 전부터 점진적으로 DOM 트리를 구축할 수 있습니다 [1, 4]. 초기 14KB의 데이터 패킷이 수신되면 바이트를 문자로, 문자를 토큰(startTag 및 endTag 등)으로 변환한 뒤, 최종적으로 노드(Node)로 변환하여 트리를 조립합니다 [1, 4]. 이 점진적 생성 메커니즘 덕분에 네트워크 요청이 진행 중인 상태에서도 브라우저는 렌더링 준비를 시작할 수 있습니다 [9].
+
+* **렌더링 파이프라인에서의 DOM과 CSSOM**
+  DOM은 문서의 '콘텐츠'를 표현하는 반면, CSSOM은 해당 콘텐츠의 '스타일'을 정의하는 독립적인 트리 구조입니다 [9, 10]. 이 두 모델은 브라우저에 의해 결합되어 화면에 시각적으로 출력되어야 하는 노드만을 포함하는 '렌더 트리(Render Tree)'로 합성됩니다 [6, 11, 12]. 이 과정에서 `<script>`, `<meta>` 또는 `display: none`이 적용된 요소처럼 시각적 영향을 주지 않는 DOM 노드는 렌더 트리에서 제외됩니다 [8, 11-13].
+
+* **크기와 복잡성이 성능에 미치는 영향**
+  DOM 트리의 깊이와 생성된 노드의 개수는 웹 성능과 직결됩니다 [5, 9]. 노드의 수가 많아질수록 렌더 트리 합성, 레이아웃(Reflow), 페인트 단계에서 브라우저가 처리해야 할 계산의 양과 시간이 증가하여 애플리케이션의 성능이 저하될 수 있습니다 [5, 7, 9, 14]. 불필요한 래퍼를 줄이고 React Fragment 등을 사용하여 DOM 노드 수를 최소화하는 것이 성능 향상에 도움이 됩니다 [15].
+
+* **DOM 조작의 비효율성과 최적화**
+  JavaScript를 사용해 DOM을 직접 조작하고 크기나 위치 등을 변경하면, 브라우저는 문서 전체의 레이아웃(Reflow)과 페인트(Repaint) 과정을 다시 실행해야 하므로 처리 비용이 매우 높습니다 [16-18]. 이를 최적화하기 위해서는 사용된 DOM 노드나 속성값을 캐싱하고, DOM의 읽기 및 쓰기 작업을 분리하여 레이아웃 스래싱(Layout thrashing)을 방지해야 합니다 [16, 19, 20]. React와 같은 프레임워크는 실제 DOM을 직접 수정하는 비효율성을 피하고자 메모리 내에 가벼운 사본인 가상 DOM(Virtual DOM)을 생성하여 조작을 추상화합니다 [17, 21, 22].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[CSSOM (CSS Object Model)]], [[Render Tree]], [[Virtual DOM]], [[Critical Rendering Path (CRP)]], [[Reflow (Layout)]], [[Repaint]]
+- **Projects/Contexts:** 프론트엔드 성능 최적화(DOM 접근 최소화 및 렌더링 파이프라인 관리), React의 렌더링 엔진 구조 및 재조정(Reconciliation) 과정 이해 [6, 17, 23, 24].
+- **Contradictions/Notes:** DOM 구축은 HTML을 파싱하면서 '점진적(incremental)'으로 이루어지지만, CSSOM 구축은 렌더링을 차단(render-blocking)하며 점진적으로 처리되지 않는다는 구조적 차이가 있습니다 [1, 7, 9].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/DOM 및 CSSOM.md b/10_Wiki/Topics_Art/UI_UX_Assets/DOM 및 CSSOM.md
new file mode 100644
index 00000000..df9a8011
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/DOM 및 CSSOM.md	
@@ -0,0 +1,31 @@
+# [[DOM 및 CSSOM]]
+
+## 📌 Brief Summary
+DOM(문서 객체 모델)과 CSSOM(CSS 객체 모델)은 브라우저의 핵심 렌더링 경로(Critical Rendering Path)에서 웹 페이지를 화면에 그리기 위해 생성되는 두 가지 독립적인 트리 구조 데이터입니다 [1, 2]. DOM은 HTML 마크업을 점진적으로 파싱하여 문서의 구조와 내용을 나타냅니다 [3, 4]. 반면, CSSOM은 문서에 적용될 스타일 규칙을 정의하며, 렌더링 시 스타일이 적용되지 않은 콘텐츠가 깜빡이는 현상(FOUC)을 방지하기 위해 렌더링 차단(render-blocking) 방식으로 생성됩니다 [5, 6]. 이 두 트리가 결합하여 화면에 표시될 시각적 요소들만 포함하는 렌더 트리(Render Tree)를 최종적으로 형성합니다 [7, 8].
+
+## 📖 Core Content
+**DOM(Document Object Model) 구축**
+- 브라우저는 HTML 응답을 받으면 데이터를 문자, 토큰(token)으로 변환하고, 이를 다시 노드(node)로 변환하여 계층적인 DOM 트리를 구축합니다 [3, 4, 9].
+- DOM 트리는 문서의 콘텐츠와 각 요소 간의 관계 및 계층 구조를 나타냅니다 [4, 8, 9].
+- DOM 구축은 점진적(incremental)으로 이루어지므로, 브라우저는 네트워크 요청이 진행 중인 상태에서도 파싱을 시작하여 트리를 구성할 수 있습니다 [3, 5, 6].
+- 단, DOM 노드의 수가 많아질수록 레이아웃 및 페인트 등 이후의 렌더링 단계에서 브라우저의 연산 부담이 커지고 처리 시간이 길어집니다 [5, 6, 9].
+
+**CSSOM(CSS Object Model) 구축**
+- CSSOM은 DOM이 어떻게 스타일링될지에 대한 모든 정보를 담고 있으며, 브라우저가 CSS 규칙을 이해하고 적용할 수 있도록 만든 트리 구조의 스타일 맵입니다 [2, 6, 8].
+- DOM과 달리 CSSOM 구축은 점진적이지 않으며, 문서의 렌더링을 차단(render-blocking)합니다 [5, 6].
+- 브라우저는 스타일이 적용되지 않은 원시 HTML이 사용자에게 노출되는 현상(FOUC)을 막기 위해 링크된 모든 스타일시트를 다운로드하고 파싱할 때까지 렌더링을 중단합니다 [5].
+- CSS 규칙은 하향식으로 종속(Cascade)되는 특성이 있어 파싱 도중 이전 규칙이 덮어써질 수 있으므로, 완전히 파싱이 끝나기 전까지는 렌더 트리를 구축하는 데 사용될 수 없습니다 [10, 11].
+- 브라우저는 CSS 선택자를 오른쪽에서 왼쪽으로 파싱합니다 [12]. 따라서 `.container.navigation.item`과 같이 구체적인 선택자는 단순히 `.item`을 찾는 것보다 DOM 트리를 거슬러 올라가며 조상 관계를 확인해야 하므로 연산 비용이 더 듭니다 [12, 13].
+
+**렌더 트리(Render Tree) 합성**
+- DOM과 CSSOM 구조가 모두 준비되면, 브라우저는 이 둘을 결합하여 화면에 그릴 렌더 트리를 생성합니다 [7, 14].
+- 렌더 트리는 시각적으로 렌더링되는 요소들만 캡처합니다 [7]. 따라서 시각적 레이아웃에 영향을 주지 않는 `<script>`, `<meta>` 요소나, CSS에 의해 `display: none`으로 처리된 요소는 렌더 트리에서 제외됩니다 [7, 8, 14, 15]. 
+- 하지만 `visibility: hidden`이 적용된 요소는 보이지 않더라도 레이아웃 상에서 공간을 차지하므로 렌더 트리에 포함됩니다 [15].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** `[[Critical Rendering Path]]`, `[[Render Tree]]`, `[[Reflow and Repaint]]`
+- **Projects/Contexts:** `[[프론트엔드 성능 최적화]]`, `[[브라우저 렌더링 파이프라인 이해]]`
+- **Contradictions/Notes:** CSS 선택자의 구체성이 CSSOM 생성 연산 속도에 영향을 미치지만, 최신 브라우저는 파싱 속도가 매우 빨라 이로 인한 지연은 마이크로초 단위에 불과합니다 [11, 13]. 따라서 과도하게 선택자 구체성 최적화에 집착하기보다는 미니파이(minification)나 렌더링 차단을 방지하는 다른 CSS 최적화 기법에 집중하는 것이 좋습니다 [13].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/DOM(Document Object Model).md b/10_Wiki/Topics_Art/UI_UX_Assets/DOM(Document Object Model).md
new file mode 100644
index 00000000..ad27a493
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/DOM(Document Object Model).md	
@@ -0,0 +1,25 @@
+# [[DOM(Document Object Model)]]
+
+## 📌 Brief Summary
+DOM(Document Object Model)은 브라우저가 HTML 마크업을 내부적으로 표현하기 위해 생성하는 계층적인 트리 구조의 객체 모델입니다 [1, 2]. 브라우저가 HTML 데이터를 수신하면서 점진적으로 생성하며, 웹 페이지의 모든 콘텐츠와 요소 간의 구조적 관계를 담고 있습니다 [1, 3, 4]. 자바스크립트(JavaScript) 내의 다양한 API를 통해 DOM에 접근하고 이를 동적으로 조작할 수 있습니다 [2].
+
+## 📖 Core Content
+- **DOM 생성 과정 (DOM Construction Process)**
+  브라우저는 서버로부터 HTML 문서를 수신하면 즉시 파싱(Parsing)을 시작합니다 [5]. 이 과정은 전체 문서가 도착하기를 기다리지 않고 점진적(incremental)으로 이루어집니다 [1]. 수신된 데이터(바이트)는 문자로 변환되고, 이후 토큰(tokens)으로 변환된 다음 최종적으로 노드(nodes)로 변환되어 계층적인 DOM 트리를 형성합니다 [1, 6]. 시작 태그(startTag)와 종료 태그(endTag) 사이에 다른 태그들이 포함되는 방식으로 노드 간의 계층 구조가 정의됩니다 [6].
+
+- **트리 구조와 구성 (Tree Structure and Composition)**
+  DOM 트리는 문서의 콘텐츠를 묘사하며, `<html>` 요소가 트리 구조의 첫 번째 요소이자 루트(root) 노드가 됩니다 [4]. 다른 요소 안에 중첩된 요소들은 자식 노드(child nodes)가 되어 트리 내부에서 각 요소의 관계와 계층을 반영합니다 [4]. 생성된 DOM 트리는 이후 스타일 정보를 담고 있는 CSSOM(CSS Object Model)과 결합하여 화면에 그려질 요소를 결정하는 렌더 트리(Render Tree)를 구축하는 데 사용됩니다 [7, 8].
+
+- **성능에 미치는 영향 (Performance Implications)**
+  DOM 트리의 깊이와 복잡성은 브라우저의 성능과 직결됩니다 [9]. DOM에 존재하는 노드의 수가 많아질수록 렌더 트리 생성, 레이아웃(Layout), 페인트(Paint)와 같은 중요 렌더링 경로(Critical Rendering Path)의 후속 작업에 소요되는 시간과 연산 부담이 커지게 됩니다 [3, 4, 9]. 
+
+- **직접적인 DOM 조작의 한계 (Limitations of Direct DOM Manipulation)**
+  자바스크립트 등을 통해 DOM을 직접 변경하는 작업은 브라우저의 레이아웃(Reflow)과 페인트 단계를 지속적으로 트리거하기 때문에 본질적으로 속도가 느리고 비용이 많이 듭니다 [10]. 애플리케이션이 복잡해질 경우 여러 노드를 개별적으로 업데이트하면 중복 연산이 발생하며, 이는 React와 같은 프레임워크가 가상 DOM(Virtual DOM)을 도입하게 된 핵심 배경이 되었습니다 [10].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[CSSOM(CSS Object Model)]], [[Critical Rendering Path(CRP)]], [[Render Tree]], [[Virtual DOM]], [[Reflow / Repaint]]
+- **Projects/Contexts:** 브라우저 렌더링 과정 (Browser Rendering Process), 프론트엔드 성능 최적화 및 React의 Virtual DOM 도입 배경 이해 [7, 10, 11]
+- **Contradictions/Notes:** 소스 간의 모순된 정보는 없습니다. 참고로 DOM의 생성은 점진적(incremental)으로 진행되어 문서를 파싱하는 동안에도 화면을 그리기 시작할 수 있지만, CSSOM의 생성은 렌더링을 차단(render-blocking)한다는 점에서 두 모델의 구축 방식에 차이가 있습니다 [3, 9].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/Next.js 기반의 Hybrid Rendering (SSR-CSR-RSC 혼합 적용).md b/10_Wiki/Topics_Art/UI_UX_Assets/Next.js 기반의 Hybrid Rendering (SSR-CSR-RSC 혼합 적용).md
new file mode 100644
index 00000000..e551737c
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/Next.js 기반의 Hybrid Rendering (SSR-CSR-RSC 혼합 적용).md	
@@ -0,0 +1,18 @@
+# [[Next.js 기반의 Hybrid Rendering (SSR/CSR/RSC 혼합 적용)]]
+
+## 📌 Brief Summary
+Next.js 기반의 Hybrid Rendering은 단일 애플리케이션 내에서 SSR, CSR, SSG 및 React Server Components(RSC) 등 다양한 렌더링 방식을 페이지나 컴포넌트 특성에 맞게 혼합하여 사용하는 아키텍처입니다 [1, 2]. 이 접근 방식은 각 렌더링 전략의 장점만을 결합하여 초기 로딩 속도, SEO, 그리고 상호작용성(Interactivity)을 동시에 최적화할 수 있도록 돕습니다 [1]. 특히 최신 Next.js 환경에서는 기본적으로 무거운 작업을 서버에서 처리하는 RSC를 사용하고, 상호작용이 필요한 영역에만 선택적으로 CSR을 적용하여 클라이언트의 자바스크립트 부담을 최소화합니다 [3-5].
+
+## 📖 Core Content
+- **페이지 단위의 유연한 렌더링 전략 선택:** Next.js와 같은 최신 프레임워크는 프로젝트의 요구사항에 따라 렌더링 방식을 유연하게 혼용할 수 있게 해줍니다 [1, 2]. 예를 들어, 내용이 변하지 않는 홈페이지나 마케팅 페이지에는 SSG(Static Site Generation)를 사용하고, 항상 최신 데이터를 반영해야 하는 상품 목록에는 SSR(Server-Side Rendering)을, 고도의 상호작용이 요구되는 유저 대시보드에는 CSR(Client-Side Rendering)을 개별적으로 적용할 수 있습니다 [1, 2].
+- **React Server Components (RSC)의 도입:** Next.js App Router 구조에서는 모든 컴포넌트가 기본적으로 서버 컴포넌트로 동작합니다 [5, 6]. 서버 컴포넌트는 오직 서버에서만 실행되어 렌더링된 HTML과 직렬화된 UI 표현(명령어)만 클라이언트로 전달하므로, 클라이언트 측 자바스크립트 번들에 어떠한 용량도 추가하지 않습니다(Zero Client-Side JavaScript) [3, 7, 8]. 이를 통해 브라우저에서의 하이드레이션(Hydration) 비용을 제거하고 데이터베이스에 직접 접근할 수 있습니다 [3, 8, 9].
+- **서버와 클라이언트 컴포넌트의 결합 원칙:** 모든 UI가 정적일 수는 없으므로 버튼 클릭이나 폼 입력과 같은 상호작용, 혹은 상태(State) 관리가 필요한 경우에는 파일 최상단에 `"use client"` 지시어를 선언하여 클라이언트 컴포넌트로 명시합니다 [3, 6]. 하이브리드 구조에서는 서버 컴포넌트가 데이터에 접근하고 클라이언트 컴포넌트를 렌더링(포함)하는 방식으로 혼합 구성됩니다 [3, 10]. 단, 클라이언트 컴포넌트가 서버 컴포넌트를 직접 임포트(import)할 수는 없으며, 의존성의 방향은 항상 서버에서 클라이언트로 흘러야 합니다 [11, 12].
+- **성능 최적화 및 부분 하이드레이션:** 이러한 혼합 아키텍처는 선택적 하이드레이션과 스트리밍(Streaming)을 가능하게 합니다 [10, 13, 14]. 상호작용이 필요 없는 영역은 서버에서 HTML로 완성되어 즉시 렌더링되며 자바스크립트 실행이 생략되지만, 클라이언트 컴포넌트가 위치한 조각에 대해서만 자바스크립트 번들이 전송되어 부분적으로 하이드레이션이 일어납니다 [10]. 이로 인해 초기 화면 표시 시간과 INP(Interaction to Next Paint) 지표가 극적으로 개선됩니다 [4, 7, 13].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[React Server Components (RSC)]], [[Client-Side Rendering (CSR)]], [[Server-Side Rendering (SSR)]], [[Static Site Generation (SSG)]], [[Hydration]]
+- **Projects/Contexts:** [[Next.js App Router]], [[React 19]]
+- **Contradictions/Notes:** 서버 컴포넌트를 도입하여 클라이언트의 번들 크기를 줄일 수는 있지만, 렌더링 및 데이터 호출 부하가 서버로 집중되므로 복잡한 스트리밍 인프라나 명확한 캐싱 전략이 부재할 경우 서버 병목 현상이라는 새로운 문제가 발생할 수 있습니다 [15-17]. 또한 클라이언트 컴포넌트에서 서버 컴포넌트를 직접 호출할 수 없는 등 엄격한 트리 구성 규칙을 지켜야 합니다 [11, 12].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/React 18 & 19 Performance Optimization.md b/10_Wiki/Topics_Art/UI_UX_Assets/React 18 & 19 Performance Optimization.md
new file mode 100644
index 00000000..21c40c22
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/React 18 & 19 Performance Optimization.md	
@@ -0,0 +1,28 @@
+# [[React 18 & 19 Performance Optimization]]
+
+## 📌 Brief Summary
+React 18 및 19의 성능 최적화는 동시성 렌더링, 자동 배칭(Automatic Batching), 그리고 빌드 타임 컴파일러를 통해 불필요한 렌더링을 최소화하고 UI 반응성을 극대화하는 기술적 진보를 의미합니다 [1-4]. React 18은 다양한 비동기 이벤트의 상태 업데이트를 한 번에 묶는 자동 배칭과 `useTransition`을 통한 동시성 훅을 도입했습니다 [3, 5, 6]. React 19는 React Compiler를 도입하여 수동 메모이제이션의 부담을 없애고, React Server Components(RSC) 아키텍처를 통해 클라이언트로 전송되는 JavaScript 번들 크기를 획기적으로 줄였습니다 [2, 4, 7, 8].
+
+## 📖 Core Content
+* **React 18 자동 배칭(Automatic Batching)**
+  React 18부터는 프로미스, `setTimeout`, 네이티브 이벤트 핸들러 내부에서 발생하는 상태 업데이트까지 모두 한 번의 리렌더링으로 묶어서 처리하는 자동 배칭이 기본으로 적용됩니다 [3, 9, 10]. 이를 통해 Virtual DOM 디핑(Diffing) 연산을 최소화하며, 특정 데이터 집약적인 대시보드 사례에서는 렌더링 횟수를 최대 40% 줄이고 프레임 속도를 25% 향상시키는 성과를 냈습니다 [1, 11, 12]. 만약 즉각적인 DOM 업데이트가 반드시 필요한 경우라면 `flushSync` API를 사용하여 자동 배칭을 우회할 수 있습니다 [12-14].
+
+* **동시성 렌더링 기능(Concurrent Features)**
+  React 18/19의 동시성 훅인 `useTransition`과 `useDeferredValue`는 메인 스레드가 차단되는 것을 방지합니다 [5, 12, 13]. 타이핑이나 클릭과 같은 긴급한 상호작용 업데이트와, 대용량 리스트 필터링 등 비긴급 상태 업데이트를 분리 처리하여 앱의 INP(Interaction to Next Paint) 지표를 크게 개선합니다 [5, 12, 15-17].
+
+* **React 19 Compiler와 자동 메모이제이션**
+  2025년 말 안정화된 React Compiler는 빌드 타임에 추상 구문 트리(AST)를 분석하여 데이터 흐름을 파악하고 최적의 위치에 자동으로 메모이제이션 경계를 삽입합니다 [2, 18-21]. 이 컴파일러는 참조 동일성 문제로 발생하는 연쇄적인 리렌더링(Re-render Cascade)을 근본적으로 방지하며, 개발자가 직접 `useMemo`, `useCallback`, `React.memo`를 수동으로 작성해야 하는 인지적 부담을 덜어줍니다 [2, 4, 22, 23]. 정밀한 자동 메모이제이션 덕분에 Meta 내부 테스트에서는 렌더링 횟수가 60% 감소하고 사용자 상호작용 속도가 2.5배 향상되었습니다 [24].
+
+* **React Server Components (RSC) 활용**
+  RSC는 렌더링과 컴포넌트 로직이 서버에서만 배타적으로 실행되는 새로운 아키텍처로, 클라이언트 JavaScript 번들 사이즈에 추가 바이트를 발생시키지 않습니다(0 바이트) [7, 8, 25, 26]. 클라이언트에서 여러 번 발생하는 데이터 페칭 왕복(waterfall)을 유발하는 대신, 서버에서 직접 데이터베이스나 로컬 시스템에 안전하게 접근하여 처리한 뒤, 직렬화된 React 명령(React Flight 프로토콜)과 HTML만을 클라이언트에 스트리밍하여 초기 로딩 속도와 보안을 개선합니다 [27-31].
+
+* **기본적인 성능 최적화 기법**
+  최신 렌더링 기능 외에도, 성능 확보를 위해서는 긴 목록 렌더링 시 가상화를 적용하는 `react-window` 라이브러리 사용, 라우트 단위의 `React.lazy()`를 이용한 코드 분할, 그리고 인라인 객체 및 함수의 불필요한 생성 방지 같은 원칙적인 최적화가 꾸준히 권장됩니다 [32-35].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** `[[Automatic Batching]]`, `[[React Compiler]]`, `[[Concurrent Rendering]]`, `[[React Server Components]]`
+- **Projects/Contexts:** `[[Next.js App Router]]`, `[[Virtual DOM]]`
+- **Contradictions/Notes:** 소스 자료에 따르면 React Compiler가 최적화의 90% 이상을 자동화하고 대부분의 경우 `useMemo`와 `useCallback`을 대체하지만, Effect 종속성을 명시적으로 제어해야 하거나 타사 라이브러리의 참조 안정성이 필수적인 밀리초 단위의 중요한 성능 경로(Critical performance path)에서는 여전히 수동 메모이제이션이 "이스케이프 해치(Escape Hatch)"로 작동해야 한다고 강조합니다 [36-39].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/React 18 Concurrent Features.md b/10_Wiki/Topics_Art/UI_UX_Assets/React 18 Concurrent Features.md
new file mode 100644
index 00000000..0855ae04
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/React 18 Concurrent Features.md	
@@ -0,0 +1,25 @@
+# [[React 18 Concurrent Features]]
+
+## 📌 Brief Summary
+React 18의 동시성 기능(Concurrent Features)은 렌더링 작업을 중단, 일시 중지 및 재개할 수 있도록 하여 애플리케이션의 반응성을 획기적으로 향상시키는 핵심 메커니즘입니다. 이 기능은 긴급한 사용자 상호작용(예: 타이핑, 클릭)과 덜 긴급한 작업(예: 무거운 데이터 필터링)을 분리하여 메인 스레드의 차단을 방지합니다. 결과적으로 연산량이 많은 상황에서도 UI가 멈추지 않고 부드럽게 작동하게 하여 사용자 경험을 개선하고 핵심 웹 지표(Core Web Vitals)를 최적화합니다.
+
+## 📖 Core Content
+
+*   **동시성 렌더링의 기반 (Fiber Architecture & Lane Model):** 
+    React의 동시성 기능은 Fiber 아키텍처의 작업 루프(Work loop)와 타임 슬라이싱(Time-slicing)을 기반으로 작동합니다. 렌더링 작업을 작은 단위로 쪼개어 처리하며, 긴급한 사용자 입력이 발생할 경우 작업을 멈추고 브라우저에 제어권을 양보(Yield)할 수 있습니다 [1-3]. 업데이트의 중요도는 비트마스크 시스템인 'Lane 모델'을 통해 동기적(Sync), 사용자 차단(User-blocking), 기본(Normal), 유휴(Idle) 등의 우선순위 레벨로 관리됩니다 [4-6].
+*   **`useTransition`과 `startTransition`:** 
+    긴급하지 않은 상태 업데이트의 우선순위를 낮추어 UI의 반응성을 유지하는 기능입니다. 타이핑과 동시에 검색 결과를 필터링하는 등의 무거운 연산을 `startTransition`으로 감싸면, React는 사용자의 긴급한 상호작용을 먼저 처리하고 메인 스레드가 여유로울 때 해당 업데이트를 백그라운드에서 처리합니다 [7-9]. 또한 `isPending` 플래그를 제공하여 무거운 작업이 진행되는 동안 사용자에게 시각적 피드백(로딩 상태 등)을 보여줄 수 있습니다 [10].
+*   **`useDeferredValue`:** 
+    상태를 업데이트하는 코드(setState)를 직접 제어할 수 없고 외부(예: Props)에서 값을 받아올 때 렌더링을 지연시키는 훅입니다 [10]. React는 새로운 필터링 결과 등 연산이 완료될 때까지 이전 렌더링 결과를 계속 화면에 표시하여 UI가 얼어붙는(Freezing) 현상을 방지합니다 [11].
+*   **`flushSync`를 통한 강제 동기화:** 
+    동시성 기능이 적용된 상태에서도 DOM 요소에 즉각적으로 포커싱을 하거나 레이아웃을 측정해야 하는 예외적인 상황을 위해 제공되는 API입니다. `flushSync`로 감싼 상태 업데이트는 React가 즉각적이고 동기적으로 렌더링하도록 강제합니다 [8, 9].
+*   **자동 일괄 처리 (Automatic Batching):** 
+    React 18은 Promise, setTimeout, 비동기 작업 및 네이티브 이벤트 핸들러 내에서 연속적으로 발생하는 여러 상태 업데이트를 하나로 묶어 단일 리렌더링으로 처리합니다 [12-14]. 이로 인해 불필요한 Virtual DOM 비교와 렌더링 횟수가 급감하여 애플리케이션 성능이 향상됩니다 [13, 15].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** `[[Fiber Architecture]]`, `[[Automatic Batching]]`, `[[Lane Priority Model]]`, `[[Virtual DOM]]`
+- **Projects/Contexts:** `[[React Performance Optimization]]`, `[[Interaction to Next Paint (INP)]]`
+- **Contradictions/Notes:** 동시성 훅(`useTransition`, `useDeferredValue`)은 코드의 실제 실행 속도를 높여주는 것이 아닙니다. 대신 무거운 연산이 즉각적인 사용자 피드백을 방해하지 않도록 처리 순서를 미뤄, 앱이 시각적으로 더 "빠르게 반응하는 것처럼(feel faster)" 느끼게 만드는 아키텍처적 접근입니다 [16]. 또한 `flushSync`는 남용할 경우 동시성 및 일괄 처리로 얻는 성능 이점을 무효화할 수 있으므로 주의해서 사용해야 합니다 [17].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/React 19.md b/10_Wiki/Topics_Art/UI_UX_Assets/React 19.md
new file mode 100644
index 00000000..0812ca64
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/React 19.md	
@@ -0,0 +1,18 @@
+# [[React 19]]
+
+## 📌 Brief Summary
+React 19는 UI의 반응성을 높이고 성능 최적화를 자동화하는 데 중점을 둔 React의 주요 업데이트 버전입니다 [1, 2]. 이 버전은 빌드 타임에 자동으로 메모이제이션을 수행하는 React Compiler를 도입하여 개발자의 수동 최적화 부담을 크게 줄여줍니다 [3, 4]. 또한, 모든 컴포넌트를 기본적으로 서버 컴포넌트(Server Components)로 처리하여 클라이언트 측 자바스크립트 번들 크기를 획기적으로 줄이고 렌더링 효율을 높이는 패러다임의 전환을 가져왔습니다 [5, 6].
+
+## 📖 Core Content
+- **React Compiler (자동 메모이제이션):** React 19 이상 환경에서 작동하는 React Compiler는 코드의 추상 구문 트리(AST)를 분석하여 데이터 흐름을 추적하고, 반응형 값과 정적 값을 스스로 구분합니다 [3, 4]. 결과적으로 `useMemo`, `useCallback`, `React.memo`와 같은 수동 메모이제이션 래퍼 없이도 자동으로 최적화 경계를 삽입해 불필요한 리렌더링 연쇄를 방지합니다 [3, 7, 8].
+- **동시성 렌더링(Concurrent Rendering) 강화:** `useTransition`과 `useDeferredValue` 같은 훅을 제공하여, 긴급한 UI 업데이트(사용자 입력 등)와 비긴급 업데이트(대용량 리스트 필터링 등)의 우선순위를 분리합니다 [2]. 이를 통해 무거운 연산이 메인 스레드를 블로킹하는 것을 방지하고 애플리케이션의 반응성(INP 등)을 최적의 상태로 유지합니다 [1, 9].
+- **서버 컴포넌트(RSC)의 기본화:** React 19에서는 모든 컴포넌트가 기본적으로 서버 컴포넌트로 동작합니다 [5]. 상호작용이 필요하여 브라우저에서 실행되어야 하는 경우에만 최상단에 `"use client"` 지시어를 명시해 클라이언트 컴포넌트로 선언합니다 [5]. 서버 컴포넌트는 클라이언트로 전송되는 JS 번들 크기를 없애고, 하이드레이션(Hydration) 단계를 생략하게 해 초기 로딩 속도와 성능을 대폭 향상시킵니다 [10-13].
+- **데이터 패칭 및 상태 관리의 진화:** 서버 컴포넌트는 브라우저를 거치지 않고 서버 환경에서 직접 데이터베이스나 파일 시스템에 접근하여 데이터를 가져올 수 있습니다 [14]. 또한 `useOptimistic`, `useActionState`, 프로미스를 직접 다루는 `use` 훅 등을 통해 데이터 패칭 및 비동기 상태 관리를 한층 더 효율적으로 수행할 수 있도록 지원합니다 [15].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[React Compiler]], [[React Server Components (RSC)]], [[Concurrent Rendering]], [[useTransition]], [[useDeferredValue]]
+- **Projects/Contexts:** [[Frontend Performance Optimization]], [[Next.js App Router]]
+- **Contradictions/Notes:** React 19의 React Compiler가 수동 메모이제이션 작업의 90% 이상을 자동으로 처리하지만, 타사 라이브러리와의 통합이나 명시적 제어가 필요한 이펙트 의존성 관리를 위해서는 여전히 `useMemo`나 `useCallback`을 수동으로 사용하는 예외 수단(Escape Hatch)이 필요할 수 있습니다 [16-18].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/React Fiber 아키텍처.md b/10_Wiki/Topics_Art/UI_UX_Assets/React Fiber 아키텍처.md
new file mode 100644
index 00000000..aea4c7c1
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/React Fiber 아키텍처.md	
@@ -0,0 +1,24 @@
+# [[React Fiber 아키텍처]]
+
+## 📌 Brief Summary
+React Fiber는 React 16에서 도입된 조정(reconciliation) 엔진의 완전한 재작성 버전으로, 동시성 렌더링(concurrent rendering)을 지원하기 위해 설계되었습니다 [1, 2]. 기존의 동기식 '스택 조정자(stack reconciler)'가 렌더링 중 메인 스레드를 차단하던 문제를 해결하기 위해, 렌더링 작업을 'Fiber 노드'라는 작은 작업 단위(units of work)로 분할하여 다수의 프레임에 걸쳐 처리합니다 [2, 3]. 이를 통해 우선순위에 따라 렌더링 작업을 일시 중지, 중단, 또는 재개할 수 있는 세밀한 제어와 타임 슬라이싱(time-slicing) 기능을 제공하여 UI의 응답성을 극대화합니다 [3-5].
+
+## 📖 Core Content
+**Fiber 노드와 작업 루프 (Work Loop)**
+React의 각 컴포넌트는 Fiber 노드로 표현되며, 해당 컴포넌트의 타입, 상태(state), 속성(props)뿐만 아니라 부모(return), 자식(child), 형제(sibling) 관계를 나타내는 포인터를 포함합니다 [6-8]. Fiber 아키텍처의 중심에는 작업 루프가 존재하며, 스케줄러를 통해 우선순위와 가용 시간에 따라 다음 작업 단위를 선택하여 순차적으로 처리합니다 [2, 9]. 작업을 수행(`beginWork`, `completeWork`)한 후에는 더 높은 우선순위의 작업(예: 사용자 입력)을 처리하기 위해 브라우저에 제어권을 넘겨야 하는지(yield)를 지속적으로 확인합니다 [6, 9, 10].
+
+**두 단계의 렌더링 프로세스 (Reconciliation Phases)**
+Fiber의 조정 과정은 작업을 중단하고 우선순위를 매기기 위해 두 가지 구별된 단계로 나뉩니다 [4].
+*   **렌더 단계 (Render Phase):** 이 단계는 중단 가능(interruptible)하며, 브라우저의 DOM을 직접 변경하지 않고 메모리 내의 Fiber 트리를 순회하여 순수 계산만을 수행합니다 [4, 11]. 이전 상태와 새로운 상태를 비교하여 DOM 삽입, 삭제, 업데이트 등의 부작용(side effects)이 필요한 노드들을 파악하고, 이를 모아 최적화된 '이펙트 리스트(Effect list)'를 구축합니다 [4, 12, 13]. 더 높은 우선순위 작업이 들어오면 기존 작업을 일시 중지하고, 진행 중이던 작업(WIP, Work-In-Progress)을 저장하거나 폐기 및 재시작할 수 있습니다 [11, 14].
+*   **커밋 단계 (Commit Phase):** 이 단계는 동기적으로 실행되며 중단할 수 없습니다(uninterruptible) [11, 15]. 렌더 단계에서 생성된 이펙트 리스트만을 순회하며 모든 변경 사항을 실제 DOM에 한 번에 적용합니다 [12, 15]. 이 과정에서 `useLayoutEffect`와 같은 동기적 레이아웃 효과와 비동기적인 `useEffect`가 함께 실행됩니다 [11, 15, 16].
+
+**우선순위와 레인 모델 (Priority Levels and Lane Model)**
+Fiber는 여러 동시 작업을 관리하기 위해 32비트 정수 비트마스크를 활용한 '레인(Lane)'이라는 정교한 우선순위 모델을 사용합니다 [13, 17]. 타이핑이나 클릭과 같은 이산적인 사용자 입력은 즉시 처리되어야 하는 가장 높은 우선순위(Sync Lane)를 부여받고, 스크롤이나 호버 등의 연속적 입력은 그 다음 높은 우선순위를 갖습니다 [18, 19]. 반면 화면에 보이지 않는 오프스크린 렌더링이나 데이터 로깅 작업은 유휴(Idle) 상태에 처리되도록 낮은 우선순위가 할당됩니다 [18, 19]. 이 모델을 통해 React는 여러 우선순위가 섞인 업데이트를 효율적으로 관리하고, 지연된 작업이 영원히 실행되지 않는 기아 상태(starvation)를 방지하며 항상 쾌적한 반응성을 유지할 수 있습니다 [17, 20].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Concurrent Rendering]], [[Reconciliation]], [[Virtual DOM]]
+- **Projects/Contexts:** [[React 16]], [[Time-Slicing]]
+- **Contradictions/Notes:** 소스에 관련 정보가 부족합니다.
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/React Flight Protocol.md b/10_Wiki/Topics_Art/UI_UX_Assets/React Flight Protocol.md
new file mode 100644
index 00000000..35251d59
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/React Flight Protocol.md	
@@ -0,0 +1,17 @@
+# [[React Flight Protocol]]
+
+## 📌 Brief Summary
+React Flight Protocol은 React Server Components(RSC)가 서버에서 렌더링된 결과를 클라이언트에게 전달할 때 사용하는 직렬화된 React 명령어 통신 규약입니다 [1]. 이 프로토콜은 무거운 전체 자바스크립트 코드를 전송하는 대신, 클라이언트의 React가 UI 조각들을 어떻게 결합해야 하는지 알려주는 가벼운 형태의 '청사진 언어(blueprint language)' 역할을 합니다 [1]. 비유하자면 브라우저에게 반쯤 조립된 가구와 함께, 빠진 상호작용 부품을 어떻게 끼워 넣는지 적힌 작은 조립 설명서를 보내는 것과 같습니다 [1].
+
+## 📖 Core Content
+- **직렬화된 명령어와 HTML의 결합**: React Server Components는 단순히 순수한 HTML만을 브라우저에 출력하지 않습니다. 정적인 부분을 위한 HTML과 함께, 클라이언트 측에서 각 요소들을 어떻게 꿰매어 연결할지(stitch together) 지시하는 직렬화된 React 명령어를 생성하는데, 이 과정이 바로 React Flight 프로토콜을 통해 이루어집니다 [1].
+- **클라이언트 자바스크립트 전송 최소화**: 브라우저에 컴포넌트를 위한 전체 자바스크립트 번들을 보내는 대신, React Flight 프로토콜은 브라우저 내의 React가 여러 UI 조각들을 어떻게 맞추고 조립해야 하는지 알려주는 매우 가벼운 지침(instructions)만을 전달하여 통신과 렌더링을 최적화합니다 [1].
+- **상세 원리 한계**: 제공된 소스 내에서는 React Flight Protocol이 어떤 데이터 포맷을 사용하는지 등의 더 깊은 기술적 명세에 대해서는 다루고 있지 않습니다. 따라서 소스에 관련 정보가 부족합니다.
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[React Server Components]], [[Serialized React Instructions]]
+- **Projects/Contexts:** [[Modern React Architecture]], [[React 19]]
+- **Contradictions/Notes:** 소스 간의 모순점은 발견되지 않았으나, React Flight Protocol 자체의 심층적인 구조나 동작 방식에 대해서는 소스에 관련 정보가 부족합니다.
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/React Frontend Development.md b/10_Wiki/Topics_Art/UI_UX_Assets/React Frontend Development.md
new file mode 100644
index 00000000..92306ca0
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/React Frontend Development.md	
@@ -0,0 +1,35 @@
+# [[React Frontend Development]]
+
+## 📌 Brief Summary
+React는 가상 DOM(Virtual DOM)과 컴포넌트 기반 아키텍처(CBA)를 활용하여 사용자 인터페이스를 효율적이고 선언적으로 구축하는 프론트엔드 라이브러리입니다 [1-3]. 브라우저의 비용이 많이 드는 Reflow와 Repaint 작업을 최소화하기 위해 '재조정(Reconciliation)' 알고리즘을 사용하며, 최신 버전에서는 Fiber 아키텍처와 자동 메모이제이션(React Compiler)을 통해 렌더링 성능을 극대화합니다 [1, 3-5]. 또한, 애플리케이션의 특성에 맞춰 CSR, SSR, SSG 및 React Server Components(RSC) 등 다양한 렌더링 전략을 지원하여 초기 로딩 속도, SEO, 상호작용(Interactivity)의 균형을 맞춥니다 [6-9].
+
+## 📖 Core Content
+*   **브라우저 렌더링 과정 (CRP) 및 비용 최소화**
+    브라우저의 중요 렌더링 경로(Critical Rendering Path)는 HTML과 CSS를 파싱하여 DOM과 CSSOM 트리를 생성하고, 이를 결합해 렌더 트리(Render Tree)를 만듭니다 [10, 11]. 이후 요소의 정확한 위치와 크기를 계산하는 레이아웃(Reflow) 단계와 화면에 픽셀을 그리는 페인트(Repaint) 단계를 거칩니다 [12, 13]. Reflow는 연산 비용이 매우 높으며, 잦은 Reflow와 Repaint는 성능 저하를 유발하므로 DOM 접근과 조작을 최소화하는 것이 필수적입니다 [14-16].
+
+*   **Virtual DOM 및 재조정 (Reconciliation)**
+    실제 DOM의 직접적인 조작으로 인한 성능 저하를 막기 위해, React는 메모리에 가벼운 UI 표현인 Virtual DOM을 유지합니다 [1, 3]. 상태가 변경되면 새로운 Virtual DOM을 생성하고 이전 트리와 비교(Diffing)하여 변경된 부분만 실제 DOM에 업데이트합니다 [1, 3]. 이 재조정 알고리즘은 요소의 타입 비교 및 리스트의 `key` 속성을 활용해 $O(n^3)$의 복잡도를 $O(n)$으로 최적화합니다 [17-20].
+
+*   **React Fiber 아키텍처와 동시성 렌더링 (Concurrent Rendering)**
+    React 16에 도입된 Fiber 아키텍처는 렌더링 작업을 'Fiber 노드'라는 작은 작업 단위로 분할하여 동시성 렌더링을 가능하게 합니다 [21-23]. 우선순위 기반 모델(Lane Model)과 시간 분할(Time-Slicing)을 적용하여, 사용자의 입력(타이핑, 클릭 등)과 같은 긴급한 작업이 들어오면 무거운 렌더링 작업을 잠시 중단(Yield)하고 메인 스레드를 비워두어 UI의 반응성을 유지합니다 [22, 24-26].
+
+*   **컴포넌트 기반 아키텍처 (Component-Based Architecture)**
+    애플리케이션을 독립적이고 재사용 가능한 컴포넌트 단위로 분할하여 구축합니다 [27-29]. 각 컴포넌트는 자체 로직과 UI 상태를 캡슐화하여 렌더링하므로 유지보수성과 확장성이 높으며, 다른 프로젝트에서도 재사용하기 쉽습니다 [30-32].
+
+*   **렌더링 전략: CSR vs SSR vs SSG vs RSC**
+    *   **CSR (Client-Side Rendering):** 서버에서 빈 HTML을 받고 브라우저가 JavaScript를 다운로드하여 UI를 그립니다. 동적 상호작용에 유리하지만, JS 다운로드 전까지 화면이 보이지 않아 초기 로딩과 SEO에 불리합니다 [6, 33-35].
+    *   **SSR (Server-Side Rendering):** 서버에서 HTML을 미리 렌더링하여 전송하므로 초기 콘텐츠 표시가 빠르고 SEO에 유리합니다 [7, 36, 37]. 이후 브라우저에서 JS를 연결해 상호작용을 가능하게 하는 수화(Hydration) 과정을 거칩니다 [7, 36, 38].
+    *   **SSG (Static Site Generation):** 빌드 타임에 HTML을 생성하여 CDN으로 배포하므로 로딩 속도가 가장 빠릅니다 [8, 39].
+    *   **React Server Components (RSC):** 서버에서만 렌더링되며 클라이언트로 JavaScript 번들을 전혀 보내지 않습니다 [9, 40]. 번들 크기를 줄이고 서버 데이터베이스에 직접 접근할 수 있으며, 상호작용이 필요한 곳에만 Client Component를 혼합해 사용할 수 있습니다 [41-43].
+
+*   **최신 렌더링 최적화 기법 (React 18 & 19)**
+    *   **자동 배칭 (Automatic Batching):** React 18부터는 이벤트 핸들러뿐만 아니라 Promise, setTimeout 등 비동기 작업 내의 여러 상태 업데이트를 하나로 묶어(Batching) 단일 리렌더링만 유발합니다 [44-46].
+    *   **React Compiler:** React 19에 도입된 빌드 타임 최적화 도구로, 개발자가 수동으로 작성하던 `useMemo`, `useCallback`을 제거하고 AST를 분석해 자동으로 메모이제이션 경계를 삽입합니다 [5, 47-49]. 이를 통해 불필요한 연산과 리렌더링을 지능적으로 방지합니다 [49, 50].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Virtual DOM]], [[Critical Rendering Path (CRP)]], [[React Fiber]], [[Component-Based Architecture]], [[Client-Side Rendering (CSR)]], [[Server-Side Rendering (SSR)]], [[React Server Components (RSC)]]
+- **Projects/Contexts:** [[Next.js]], [[Single-Page Applications (SPA)]]
+- **Contradictions/Notes:** React Compiler의 도입으로 `React.memo`, `useMemo`, `useCallback`과 같은 수동 메모이제이션이 90% 이상 불필요해졌으나, 서드파티 라이브러리의 불안정한 객체 참조를 다루거나 특정 Effect 의존성을 명시적으로 제어해야 하는 경우에는 여전히 탈출구(Escape Hatch)로써 수동 메모이제이션의 사용이 필요할 수 있습니다 [51-53].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/React 기반 대규모 웹 애플리케이션 최적화.md b/10_Wiki/Topics_Art/UI_UX_Assets/React 기반 대규모 웹 애플리케이션 최적화.md
new file mode 100644
index 00000000..b1c10ec8
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/React 기반 대규모 웹 애플리케이션 최적화.md	
@@ -0,0 +1,31 @@
+# [[React 기반 대규모 웹 애플리케이션 최적화]]
+
+## 📌 Brief Summary
+React 기반 대규모 웹 애플리케이션 최적화는 브라우저의 렌더링 과정(CRP)과 React의 가상 DOM(Virtual DOM) 및 재조정(Reconciliation) 메커니즘을 이해하여 불필요한 연산과 DOM 변경을 최소화하는 전략입니다 [1-3]. 이를 위해 메모이제이션, 코드 스플리팅, 가상화(Virtualization) 등의 클라이언트 측 기법과, Fiber 아키텍처를 통한 동시성 렌더링(Concurrent Rendering)을 활용하여 UI 응답성을 유지합니다 [4-7]. 또한, SSR, SSG와 같은 렌더링 방식과 React 서버 컴포넌트(RSC) 및 React Compiler를 결합하여 자바스크립트 번들 크기를 대폭 줄이고 초기 로딩 속도와 상호작용성을 극대화합니다 [8-11].
+
+## 📖 Core Content
+
+*   **브라우저 렌더링 과정과 Reflow/Repaint 최소화**
+    브라우저는 HTML과 CSS를 파싱하여 DOM과 CSSOM을 생성하고, 이를 결합하여 화면에 표시될 렌더 트리(Render Tree)를 구축합니다 [3, 12-14]. 이후 요소의 정확한 크기와 위치를 계산하는 레이아웃(Reflow) 단계와 화면에 픽셀을 그리는 페인트(Repaint) 단계를 거칩니다 [15-18]. 리플로우는 계산 비용이 매우 높아 성능 저하의 주원인이 되므로, 불필요한 DOM 깊이를 줄이고 DOM 상호작용을 최소화해야 합니다 [19-21]. 애니메이션 처리 시 `top`이나 `left` 대신 `transform`과 같이 GPU 가속을 지원하는 속성을 사용하면 리플로우와 리페인트를 최소화하여 프레임 드롭(Jank)을 방지할 수 있습니다 [16, 22, 23].
+
+*   **가상 DOM(Virtual DOM)과 재조정(Reconciliation)**
+    React는 실제 DOM을 직접 조작하는 대신, 가벼운 메모리 내 표현인 가상 DOM을 사용하여 UI 상태를 선언적으로 관리합니다 [2, 24, 25]. 상태가 변경되면 React는 이전 가상 DOM 트리와 새로운 트리를 비교(Diffing)하여 실제 DOM에 필요한 최소한의 업데이트만 반영합니다 [2, 26]. 이 과정에서 React는 O(n) 복잡도의 휴리스틱 알고리즘을 사용하며, 요소의 타입이 다르면 트리를 완전히 새로 구축하고, 동일한 타입의 리스트 컴포넌트는 고유한 `key` 속성을 통해 요소의 이동 여부를 식별하여 불필요한 재생성을 방지합니다 [27-29].
+
+*   **Fiber 아키텍처와 동시성 렌더링(Concurrent Rendering)**
+    기존의 동기식 렌더링은 대규모 컴포넌트 트리를 처리할 때 메인 스레드를 블로킹하여 UI 응답성을 떨어뜨렸습니다 [30]. 이를 해결하기 위해 도입된 Fiber 아키텍처는 렌더링 작업을 '작업 단위(Unit of Work)'로 나누어 타임 슬라이싱(Time-slicing)을 가능하게 합니다 [30, 31]. 렌더 단계는 중단 및 재개가 가능하며, 차선(Lane) 기반 우선순위 모델을 통해 사용자 입력과 같은 긴급한 작업을 렌더링 계산보다 먼저 처리할 수 있습니다 [32-34]. React 19의 `useTransition` 및 `useDeferredValue` 훅을 활용하면 무거운 계산 상태 업데이트의 우선순위를 낮추어 메인 스레드를 차단하지 않고 대규모 데이터를 부드럽게 처리할 수 있습니다 [5, 35, 36].
+
+*   **자동 일괄 처리(Automatic Batching)와 React Compiler**
+    React 18에 도입된 자동 일괄 처리는 Promise나 setTimeout 같은 비동기 콜백 내의 여러 상태 업데이트를 단일 리렌더링으로 묶어 렌더링 횟수를 대폭 줄입니다 [37-39]. 나아가 React 19부터 안정화된 React Compiler는 빌드 타임에 AST(추상 구문 트리)를 분석하여 컴포넌트와 값의 의존성을 파악하고, `useMemo`, `useCallback`, `React.memo`와 같은 수동 메모이제이션을 자동으로 삽입합니다 [10, 11, 40]. 이를 통해 불필요한 렌더링 전파(Re-render Cascade)를 차단하고, 수동 최적화의 복잡성과 오류를 근본적으로 제거합니다 [10, 41, 42].
+
+*   **컴포넌트 렌더링 전략 (CSR, SSR, SSG) 및 서버 컴포넌트(RSC)**
+    대규모 애플리케이션에서는 페이지의 특성에 따라 렌더링 전략을 혼합(Hybrid)하여 사용합니다 [43, 44].
+    *   **CSR/SSR/SSG:** 클라이언트 사이드 렌더링(CSR)은 로드 후 상호작용성이 좋으나 초기 속도가 느리고 SEO에 불리하며, 서버 사이드 렌더링(SSR)과 정적 사이트 생성(SSG)은 초기 로딩(FCP)과 SEO에 유리하지만 SSR의 경우 하이드레이션(Hydration) 완료 전까지 상호작용(TTI)이 지연되는 단점이 있습니다 [8, 45-48].
+    *   **React 서버 컴포넌트 (RSC):** RSC는 서버에서 독점적으로 렌더링되며 클라이언트로 자바스크립트 번들을 전혀 보내지 않습니다 [9, 49, 50]. 데이터베이스나 파일 시스템에 직접 접근할 수 있어 클라이언트-서버 간 불필요한 API 호출을 줄입니다 [51-53]. 대규모 앱에서는 읽기 전용 UI를 서버 컴포넌트로 처리하고, 상태나 이벤트 핸들러가 필요한 요소만 `use client` 지시어를 통해 클라이언트 컴포넌트로 분리함으로써 번들 크기를 극적으로 줄이고 성능을 최적화할 수 있습니다 [51, 54, 55].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Critical Rendering Path]], [[Virtual DOM]], [[Reconciliation]], [[Fiber Architecture]], [[React Server Components]], [[React Compiler]], [[Automatic Batching]]
+- **Projects/Contexts:** [[초기 로딩 및 SEO 최적화가 필수적인 대규모 이커머스 및 콘텐츠 플랫폼]], [[수천 개의 리스트와 실시간 데이터 처리가 필요한 대형 SaaS 대시보드 애플리케이션]]
+- **Contradictions/Notes:** 수동 메모이제이션(`React.memo`, `useMemo`)은 리렌더링을 방지할 수 있지만 참조 객체 저장 및 비교 연산에 따른 자체적인 오버헤드가 발생하므로 모든 컴포넌트에 무분별하게 적용하는 것은 오히려 성능을 저하시키는 안티 패턴입니다 [42, 56]. 그러나 최신 React Compiler가 적용된 환경에서는 이러한 최적화 판단과 메모이제이션 삽입이 빌드 타임에 자동으로 이루어지므로 개발자가 수동으로 제어할 필요성이 크게 줄어들었습니다 [11, 57]. 또한, SSR은 빠른 초기 화면(FCP)을 제공하지만 하이드레이션 병목 현상으로 인해 상호작용(TTI)까지 지연 시간이 발생할 수 있으므로 주의가 필요합니다 [45, 48].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/React 동시성 훅 (useTransition, useDeferredValue).md b/10_Wiki/Topics_Art/UI_UX_Assets/React 동시성 훅 (useTransition, useDeferredValue).md
new file mode 100644
index 00000000..9b823cf4
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/React 동시성 훅 (useTransition, useDeferredValue).md	
@@ -0,0 +1,25 @@
+# [[React 동시성 훅 (useTransition, useDeferredValue)]]
+
+## 📌 Brief Summary
+React의 동시성 훅(Concurrent Hooks)인 `useTransition`과 `useDeferredValue`는 긴급한 업데이트와 비긴급 업데이트를 분리하여 UI의 응답성을 유지하는 데 사용되는 도구입니다 [1]. 이 훅들은 연산 속도 자체를 높이는 것이 아니라 무거운 연산이 메인 스레드를 차단하는 것을 방지함으로써 애플리케이션의 체감 속도를 높여줍니다 [2]. 결과적으로 사용자 피드백을 즉각적으로 처리하게 하여 INP(Interaction to Next Paint)와 같은 성능 지표를 개선하는 데 핵심적인 역할을 합니다 [3].
+
+## 📖 Core Content
+* **동시성 렌더링의 원리 및 효과:**
+  React의 동시성 기능은 타이핑이나 클릭 같은 '긴급한 상호작용'과 대규모 리스트 필터링이나 차트 재계산 같은 '비긴급 업데이트'를 분리합니다 [1]. 이 기능은 React의 우선순위 시스템인 'Lane 모델'을 기반으로 작동하며, 특정 업데이트를 낮은 우선순위로 표시하여 UI의 응답성을 유지할 수 있게 합니다 [4]. 이 훅들을 사용하면 메인 스레드가 긴급한 사용자 상호작용에 즉시 대응할 수 있으므로, INP 점수를 낮추는 데 직접적으로 기여합니다 [3].
+
+* **useTransition (비차단 상태 업데이트):**
+  `useTransition`은 개발자가 상태 업데이트 코드를 직접 제어할 수 있을 때 사용합니다 [3]. 상태 변경 함수(`setState` 등)를 `startTransition`으로 감싸면, 해당 업데이트를 낮은 우선순위로 처리하여 메인 스레드가 여유로워질 때까지 연산을 지연시킵니다 [1, 3].
+  * 주로 사용자가 타이핑할 때마다 검색 결과를 필터링하는 패턴이나, 데이터가 많은 애플리케이션에서의 탭 전환 등에 매우 효과적입니다 [1].
+  * `isPending`이라는 플래그를 함께 제공하여, 무거운 연산이 백그라운드에서 실행되는 동안 사용자에게 즉각적인 시각적 피드백(예: 로딩 상태)을 줄 수 있습니다 [5].
+
+* **useDeferredValue (무거운 렌더링 지연):**
+  `useDeferredValue`는 외부 스토어나 부모 컴포넌트에서 props로 전달받는 등 상태 업데이트 코드를 직접 제어할 수 없을 때 상태 값 자체를 감싸기 위해 사용합니다 [3, 5].
+  * 무거운 렌더링을 처리하는 동안 UI가 멈추는(freezing) 현상을 방지하기 위해, React는 새로운 결과가 준비될 때까지 화면에 이전 결과를 계속 표시합니다 [3].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[React Fiber Architecture]], [[Lane Model]], [[INP (Interaction to Next Paint)]]
+- **Projects/Contexts:** [[검색어 입력 필터링 (Search-as-you-type)]], [[데이터 집약적 대시보드의 탭 전환]]
+- **Contradictions/Notes:** 동시성 훅(`useTransition`)과 디바운싱(Debouncing)은 불필요한 작업을 줄여준다는 공통점이 있지만 목적이 다릅니다. 컴포넌트 수준에서 UI 업데이트를 지연시키는 데는 React 네이티브 방식인 `useTransition`이 더 적합한 반면, 잦은 API 호출 빈도를 낮추는 데는 여전히 디바운싱 기법을 사용하는 것이 최선입니다 [6].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/React 성능 최적화 (React Performance Optimization).md b/10_Wiki/Topics_Art/UI_UX_Assets/React 성능 최적화 (React Performance Optimization).md
new file mode 100644
index 00000000..7ed0e48a
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/React 성능 최적화 (React Performance Optimization).md	
@@ -0,0 +1,29 @@
+# [[React 성능 최적화 (React Performance Optimization)]]
+
+## 📌 Brief Summary
+React 성능 최적화는 불필요한 연산과 재렌더링을 최소화하고 브라우저의 중요 렌더링 경로(Critical Rendering Path)를 효율적으로 관리하여 애플리케이션의 속도 및 응답성을 극대화하는 과정이다 [1, 2]. 이는 렌더링 계단식(Re-render Cascade) 문제 해결, 초기 번들 크기 감소, 리플로우(Reflow) 및 리페인트(Repaint) 제어를 주요 목표로 삼는다 [3-6]. 최근에는 React 18의 자동 배칭(Automatic Batching)과 React 19 컴파일러의 자동 메모이제이션 도입으로 인해, 개발자의 수동 최적화 부담이 크게 줄어들고 프레임워크 및 빌드 타임 레벨에서 성능 향상이 이루어지는 추세이다 [7-9].
+
+## 📖 Core Content
+
+*   **불필요한 재렌더링 방지 및 가상 DOM 최적화**
+    부모 컴포넌트의 상태가 변경될 때 모든 자식 컴포넌트가 재렌더링되는 '렌더링 계단식' 문제는 성능 저하의 주된 원인이다 [3, 10]. 이를 방지하기 위해 기존에는 `React.memo`, `useMemo`, `useCallback`과 같은 수동 메모이제이션 기법을 사용하여 참조(Reference)의 동등성을 유지하고 불필요한 비교(Diffing) 연산을 차단했다 [11-13]. 또한, React 18에 도입된 자동 배칭(Automatic Batching)은 이벤트 핸들러뿐만 아니라 Promise나 `setTimeout` 같은 비동기 작업 내의 여러 상태 업데이트를 단일 렌더링으로 묶어주어 가상 DOM 작업과 렌더링 횟수를 획기적으로 줄여준다 [7, 14, 15].
+
+*   **빌드 타임 최적화: React 컴파일러(React Compiler)**
+    React 19 컴파일러는 애플리케이션 코드를 구문 분석(AST)하여 정적 값과 반응형 값을 자동으로 식별하고, 최적의 위치에 메모이제이션 경계를 삽입하는 빌드 타임 도구이다 [8, 9, 16, 17]. 이를 통해 개발자가 수동으로 의존성 배열을 관리하며 겪는 과도한 메모이제이션(Over-memoization)이나 누락 문제를 해결하고, 값이 변경된 특정 부분만 렌더링하는 세밀한 반응성(Fine-Grained Reactivity)을 달성하여 성능 최적화 작업의 90%를 제거한다 [18-20].
+
+*   **동시성 렌더링과 파이버(Fiber) 아키텍처**
+    React 16부터 도입된 파이버 아키텍처는 동기적으로 블로킹되던 기존 렌더링 방식을 벗어나, 렌더링 작업을 작은 단위로 나누고(Time-slicing) 우선순위(Lane model)를 부여하여 중단 및 재개가 가능하도록 만들었다 [21-24]. 이를 기반으로 하는 `useTransition` 및 `useDeferredValue` 훅을 사용하면, 무거운 데이터 필터링이나 화면 전환 같은 비긴급 업데이트의 우선순위를 낮춤으로써 타이핑과 같은 긴급한 상호작용이 지연 없이 처리되도록 하여 UI의 응답성(INP 개선)을 높일 수 있다 [25-28].
+
+*   **브라우저 렌더링 최적화: Reflow와 Repaint 최소화**
+    React가 가상 DOM을 업데이트한 후, 브라우저가 화면을 그리는 과정에서 레이아웃 계산(Reflow)과 시각적 업데이트(Repaint)는 큰 비용을 수반한다 [5, 6, 29]. 렌더링 성능을 개선하려면 React Fragment를 사용해 불필요한 DOM 노드 래퍼를 줄이고 DOM의 깊이를 얕게 유지해야 한다 [30, 31]. 100개가 넘어가는 긴 리스트의 경우 화면에 보이는 노드만 렌더링하는 가상화(Virtualization) 라이브러리를 도입하여 다중 노드 생성 비용을 극적으로 줄일 수 있다 [32, 33]. 더불어 애니메이션 구현 시 레이아웃을 다시 계산하는 속성 대신 `transform` 속성 등을 활용해 GPU 가속을 적용하면 리플로우를 피할 수 있다 [34-36].
+
+*   **번들 사이즈 제어 및 렌더링 전략 고도화**
+    초기 로딩 속도(LCP)를 개선하려면 다운로드해야 할 JavaScript 번들 크기를 최소화해야 한다. `React.lazy()`를 활용한 라우트 레벨의 코드 스플리팅을 적용하면 초기 번들 크기를 30~50%가량 줄일 수 있다 [37]. 한 걸음 더 나아가 서버에서만 실행되는 React Server Components(RSC)를 활용하면 무거운 라이브러리나 정적 데이터 페칭 로직이 브라우저로 전송되지 않아 JavaScript 번들 크기를 '0 바이트'에 가깝게 줄이고 수화(Hydration) 비용을 완전히 제거할 수 있다 [38-40].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Virtual DOM (가상 DOM)]], [[Critical Rendering Path (중요 렌더링 경로)]], [[React Compiler (React 컴파일러)]], [[React Server Components (RSC)]], [[Concurrent Rendering (동시성 렌더링)]]
+- **Projects/Contexts:** [[코어 웹 바이탈(Core Web Vitals) 개선 프로젝트]], [[프론트엔드 컴포넌트 기반 아키텍처(CBA) 구축]]
+- **Contradictions/Notes:** React 18의 자동 배칭(Automatic Batching) 기능은 기본적으로 활성화되어 렌더링 최적화에 기여하지만, 사용자가 즉각적인 시각적 피드백(예: 입력 포커스, 폼 값 즉각 업데이트)을 필요로 하는 경우에는 `flushSync` API를 사용하여 의도적으로 배칭을 우회하고 동기적 렌더링을 강제해야 한다 [28, 41, 42]. 한편 기존 React 생태계에서는 `useMemo`와 같은 수동 최적화가 필수적이었으나, React 컴파일러 도입 이후에는 이들이 불필요해지며 의도적인 제어나 서드파티 라이브러리 대응과 같은 예외적 상황에서만 사용하는(Escape Hatch) 방식으로 패러다임이 바뀌고 있다 [19, 43-45].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/React 컴파일러 (React Compiler).md b/10_Wiki/Topics_Art/UI_UX_Assets/React 컴파일러 (React Compiler).md
new file mode 100644
index 00000000..2374ab18
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/React 컴파일러 (React Compiler).md	
@@ -0,0 +1,19 @@
+# [[React 컴파일러 (React Compiler)]]
+
+## 📌 Brief Summary
+React 컴파일러(React Compiler, 이전 명칭 'React Forget')는 빌드 타임에 React 애플리케이션을 자동으로 최적화해주는 도구이다 [1-4]. 개발자가 수동으로 작성하던 `useMemo`, `useCallback`, `React.memo` 등의 메모이제이션 작업을 컴파일러가 코드를 분석하여 필요한 곳에 자동으로 삽입한다 [2, 3]. 이를 통해 불필요한 리렌더링을 방지하고 코드의 가독성을 높이며, 메모이제이션 누락이나 오용으로 인한 성능 저하를 효과적으로 해결한다 [4-6].
+
+## 📖 Core Content
+- **작동 원리**: React 컴파일러는 Babel 또는 SWC 플러그인 형태로 동작하며 빌드 단계에서 코드를 변환한다 [7-9]. Abstract Syntax Tree(AST)를 분석하여 데이터 흐름을 추적하고, 각 값을 정적(Static), 반응형(Reactive), 파생(Derived)으로 분류한 뒤 최적의 위치에 메모이제이션 경계를 자동으로 삽입한다 [1, 10, 11]. 단순히 전체 컴포넌트를 캐싱하는 것을 넘어, 개별 JSX 요소와 내부 계산 작업까지 세밀하게(granular) 최적화하는 것이 특징이다 [12, 13].
+- **주요 장점**: 수동 메모이제이션이 유발하는 개발자의 인지적 부담과 '의존성 배열 지옥(Dependency Array Hell)'을 제거하여 코드를 깔끔하게 유지할 수 있다 [2, 6, 13]. 실제 프로덕션 환경(Meta, Sanity Studio, Wakelet 등)에서 적용한 결과 초기 로드 시간 단축, 상호작용 지연 시간(INP) 개선, 리렌더링 횟수 60% 감소 등의 괄목할 만한 성능 향상이 입증되었다 [14-16].
+- **단점 및 한계**: 일부 서드파티 라이브러리(예: TanStack Query 등 렌더링마다 의도적으로 새로운 객체를 반환하는 훅)와 호환성 문제가 발생하여 컴파일러의 최적화가 무력화될 수 있다 [17]. 또한, 내부 동작이 블랙박스처럼 처리되어 예기치 않은 리렌더링 발생 시 원인 규명과 디버깅이 더 까다로워질 수 있으며, React의 기본 원칙(Rules of React)을 다수 위반한 레거시 코드베이스에서는 곧바로 도입하기 어렵다 [18-20].
+- **도입 및 마이그레이션 전략**: 모든 코드에 일괄 적용할 필요 없이 특정 디렉터리부터 시작하거나 `'use compiler'` 지시어를 사용하여 파일 단위로 점진적인 도입이 가능하다 [21, 22]. 컴파일러 적용 전 ESLint 플러그인을 사용하여 React 규칙 위반 사항을 식별하고 수정하는 것이 적극 권장된다 [18, 22].
+- **수동 메모이제이션의 잔존 필요성**: 컴파일러가 대부분의 최적화를 자동으로 처리하지만, 이펙트(Effect)의 의존성 제어나 안정적인 참조가 필수적인 서드파티 라이브러리 연동 등 명시적인 제어가 필요한 상황(Escape Hatch)에서는 여전히 `useMemo` 및 `useCallback`을 사용해야 한다 [23-26]. 
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[메모이제이션 (Memoization)]], [[빌드 타임 최적화 (Build-Time Optimization)]], [[리렌더링 (Re-rendering)]]
+- **Projects/Contexts:** [[Meta 프로덕션 앱 (Instagram, Quest Store)]], [[Sanity Studio]], [[Next.js 및 Vite 통합]]
+- **Contradictions/Notes:** 소스에 따르면 React 컴파일러가 적용된 컴포넌트는 React DevTools에서 `Memo ✨` 배지가 표시되지만, 이것이 항상 최적화의 성공을 의미하는 것은 아니다 [17, 27]. 속성에 인라인 객체나 함수 등 불안정한 참조가 전달될 경우, 배지가 있더라도 부모 컴포넌트 업데이트 시 여전히 리렌더링이 발생할 수 있으므로 주의해야 한다 [17].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/Virtual DOM과 Reconciliation.md b/10_Wiki/Topics_Art/UI_UX_Assets/Virtual DOM과 Reconciliation.md
new file mode 100644
index 00000000..39a02a9d
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/Virtual DOM과 Reconciliation.md	
@@ -0,0 +1,37 @@
+# [[Virtual DOM과 Reconciliation]]
+
+## 📌 Brief Summary
+Virtual DOM은 UI의 이상적인 가상 표현을 메모리에 유지하는 프로그래밍 개념입니다 [1]. Reconciliation(재조정)은 이 Virtual DOM을 실제 DOM과 동기화하여 변경된 부분만 파악하고 효율적으로 업데이트하는 React의 핵심 프로세스입니다 [1, 2]. React는 O(n) 복잡도를 가진 휴리스틱 Diffing 알고리즘을 사용하여 실제 DOM 조작으로 인해 발생하는 비싼 렌더링 비용과 성능 저하를 최소화합니다 [3-5].
+
+## 📖 Core Content
+**Virtual DOM의 개념과 도입 배경**
+*   브라우저의 실제 DOM을 직접 수정하는 작업은 레이아웃(Reflow)과 페인트(Repaint) 단계를 반복적으로 트리거하기 때문에 본질적으로 매우 느립니다 [2]. 
+*   React는 이 문제를 추상화하기 위해 가볍고 메모리 내에 존재하는 UI 표현인 Virtual DOM을 도입했습니다 [2]. 
+*   이를 통해 개발자는 원하는 UI 상태를 선언적으로 명시하기만 하면 되며, React의 ReactDOM과 같은 라이브러리가 내부적으로 속성 조작, 이벤트 처리 및 수동 DOM 업데이트를 알아서 관리하게 됩니다 [1, 2]. 
+*   React 세계에서 Virtual DOM은 일반적으로 사용자 인터페이스를 나타내는 객체인 'React Elements'를 의미하며, 컴포넌트 트리에 대한 추가 정보를 담고 있는 내부 객체인 'Fiber' 역시 그 구현의 일부로 간주될 수 있습니다 [6].
+
+**Reconciliation과 휴리스틱 Diffing 알고리즘**
+*   상태(State)나 속성(Props)이 업데이트되면 `render()` 함수는 새로운 React Element 트리를 반환하며, React는 이를 가장 최근의 트리와 비교하여 UI를 어떻게 효율적으로 업데이트할지 계산합니다 [4].
+*   두 트리를 비교하여 변환하기 위한 최소한의 연산을 찾는 일반적인 알고리즘은 O(n^3)의 복잡도를 가지므로 실제 애플리케이션에 적용하기에는 비용이 너무 높습니다 [4].
+*   따라서 React는 다음 두 가지 가정에 기반한 **O(n) 휴리스틱 알고리즘**을 구현했습니다 [3-5]:
+    1. 서로 다른 타입의 요소(Elements)는 본질적으로 다른 트리를 생성한다 [3, 5].
+    2. 개발자가 `key` 속성을 제공하여 여러 렌더링 간에 어떤 자식 요소가 안정적인지 힌트를 줄 수 있다 [3, 5].
+
+**비교(Diffing) 프로세스 상세 처리**
+*   **다른 타입의 요소:** 루트 요소의 타입이 다르면(예: `<a>`에서 `<img>`로, 혹은 `<div>`에서 `<span>`으로 변경), React는 기존 트리를 완전히 파괴하고 처음부터 새 트리를 구축합니다 [3, 7]. 이 과정에서 이전 DOM 노드는 파괴되며 연관된 모든 컴포넌트의 상태(State)가 유실됩니다 [7].
+*   **같은 타입의 DOM 요소:** 동일한 타입의 React DOM 요소를 비교할 때는 기본 DOM 노드를 유지한 채, `className`이나 `style` 등 변경된 속성(Attributes)만을 업데이트합니다 [8, 9].
+*   **같은 타입의 컴포넌트 요소:** 컴포넌트가 업데이트될 때 인스턴스는 동일하게 유지되어 렌더링 간에 상태가 보존됩니다. React는 새 요소와 일치하도록 기본 컴포넌트 인스턴스의 props를 업데이트하고 수명 주기(Lifecycle) 메서드를 호출한 뒤, 자식 노드에 대해 재귀적으로 처리합니다 [9, 10].
+*   **자식 노드 처리와 Key 속성:** 자식 노드를 순회할 때 리스트의 맨 앞에 요소를 추가하면 전체 트리가 변경된 것으로 인식해 매우 비효율적으로 작동할 수 있습니다 [10, 11]. 이를 해결하기 위해 `key` 속성을 사용하여 원본 트리와 후속 트리의 자식을 정확히 매칭시킵니다 [3, 11]. `key`는 형제 노드 사이에서 안정적이고 예측 가능하며 고유해야 성능 저하와 상태 유실을 방지할 수 있습니다 [12].
+
+**React Fiber 아키텍처를 통한 렌더링 최적화**
+*   과거 동기적인 스택 재조정자(Stack reconciler)는 대규모 애플리케이션 처리 시 메인 스레드를 차단(Blocking)하여 UI의 반응성을 떨어뜨리는 문제가 있었습니다 [13, 14].
+*   React 16은 이를 해결하기 위해 동시성 렌더링(Concurrent rendering)을 지원하는 **Fiber 아키텍처**로 재조정 엔진을 완전히 재작성했습니다 [15-17].
+*   Fiber는 렌더링 작업을 '작업 단위(Unit of work)'로 나누고, 우선순위(Lanes) 시스템을 통해 긴급한 상호작용(클릭, 타이핑 등)을 위해 작업을 일시 중단, 양보(Yield), 및 재개할 수 있도록 지원합니다 [14, 16, 18, 19]. 이로 인해 Virtual DOM의 재조정 과정 중에도 UI 반응성을 유지할 수 있습니다 [16, 18].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[React Fiber Architecture]], [[Critical Rendering Path (CRP)]], [[Concurrent Rendering]]
+- **Projects/Contexts:** [[React Application Performance Optimization]]
+- **Contradictions/Notes:** 소스에 따르면 Virtual DOM 트리는 설계상 불변(immutable)으로 취급되지만, 단일 자식 노드를 여러 위치에서 사용하는 경우 복사 비용 문제가 발생할 수 있습니다. 이를 해결하기 위해 React는 현재 설치된 상태를 나타내는 가변적인 형태의 "Augmented DOM" 구조를 구축하며, 이것이 바로 React의 Fiber 데이터 구조가 수행하는 역할입니다 [20]. 
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/가상 DOM (Virtual DOM) 및 Fiber.md b/10_Wiki/Topics_Art/UI_UX_Assets/가상 DOM (Virtual DOM) 및 Fiber.md
new file mode 100644
index 00000000..cbc5fef4
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/가상 DOM (Virtual DOM) 및 Fiber.md	
@@ -0,0 +1,27 @@
+# [[가상 DOM (Virtual DOM) 및 Fiber]]
+
+## 📌 Brief Summary
+가상 DOM(Virtual DOM)은 사용자 인터페이스(UI)의 이상적인 상태를 메모리에 저장하고 가볍게 표현한 자바스크립트 객체로, 실제 DOM과의 동기화(재조정, Reconciliation)를 통해 직접적인 DOM 조작의 비효율성을 추상화하는 개념입니다 [1-3]. React Fiber는 이러한 재조정 엔진을 완전히 재작성하여 React 16에 도입된 아키텍처로, 동기식 렌더링의 한계를 극복하고 렌더링 작업을 중단 및 재개할 수 있는 동시성 렌더링(Concurrent Rendering)을 지원합니다 [4, 5]. Fiber 아키텍처는 렌더링 작업을 '작업 단위(Fiber node)'로 분할하여 우선순위에 따라 스케줄링함으로써 애플리케이션의 반응성을 극대화합니다 [6-8].
+
+## 📖 Core Content
+* **가상 DOM과 휴리스틱 재조정 알고리즘**
+  실제 DOM을 직접 수정하는 것은 브라우저의 레이아웃 및 페인트 단계를 유발하므로 계산 비용이 많이 듭니다 [1]. React는 가상 DOM을 도입하여 이전 가상 DOM 트리와 새롭게 계산된 가상 DOM 트리를 비교(Diffing)하여 변경 사항을 감지합니다 [2]. 이론적인 트리 비교 알고리즘의 복잡도는 $O(n^3)$이지만, React는 두 가지 가정(다른 타입의 요소는 다른 트리를 생성하며, 개발자가 부여한 'key'를 통해 안정적인 요소를 식별함)을 바탕으로 $O(n)$의 휴리스틱 알고리즘을 구현하여 성능을 최적화합니다 [9-11].
+
+* **스택 재조정자(Stack Reconciler)의 한계와 Fiber의 도입**
+  Fiber 도입 이전의 React는 컴포넌트 트리를 단일 재귀 호출로 처리하는 동기식 스택 재조정자를 사용했습니다 [6]. 이 방식은 작업이 길어질 경우 16.6ms의 프레임 예산을 초과하여 메인 스레드를 차단하고 UI를 멈추게 하는 한계가 있었습니다 [6]. 이를 해결하기 위해 등장한 Fiber는 컴포넌트를 나타내는 변경 가능한 인메모리 구조(Fiber 데이터 구조)를 통해 렌더링 작업을 관리합니다 [12].
+
+* **Fiber의 렌더링 단계 (Render & Commit Phases)**
+  Fiber는 재조정 과정을 두 가지 명확한 단계로 분리하여 실행합니다 [13].
+  1. **렌더 단계(Render Phase):** 이 단계는 비동기적이며 중단 가능합니다 [13]. React는 Fiber 트리를 순회하며 변경 사항을 계산하고 실제 DOM을 변형하지 않은 채로 부작용(Effect) 목록을 작성합니다 [13, 14]. 처리 도중 우선순위가 높은 작업(예: 사용자 입력)이 발생하면 브라우저에 제어권을 양보(Yield)할 수 있습니다 [6, 15].
+  2. **커밋 단계(Commit Phase):** 이 단계는 동기적이며 중단할 수 없습니다 [16]. 렌더 단계에서 생성된 부작용 목록(DOM 삽입, 업데이트, 삭제 등)을 실제 DOM에 한 번에 적용하고, 동기식 레이아웃 효과(`useLayoutEffect`)를 실행합니다 [16, 17].
+
+* **우선순위 레인(Lane) 모델과 스케줄링**
+  React의 스케줄러는 비트마스크(Bitmask) 시스템을 사용하는 'Lane 모델'을 통해 동시성 작업을 관리합니다 [18, 19]. 업데이트의 성격에 따라 Sync Lane(사용자 타이핑, 클릭 등 즉시 처리), InputContinuous Lane(스크롤 등), Default Lane, Idle Lane(백그라운드 작업) 등으로 우선순위를 분류합니다 [20, 21]. 이를 통해 무거운 연산이 진행 중이더라도 메인 스레드를 차단하지 않고 긴급한 사용자 상호작용에 즉각적으로 반응할 수 있습니다 [20, 22].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[재조정 (Reconciliation)]], [[동시성 렌더링 (Concurrent Rendering)]], [[Critical Rendering Path (CRP)]], [[레이아웃 스래싱 (Layout Thrashing)]]
+- **Projects/Contexts:** [[React 16]], [[React 18 Concurrent Features (useTransition, useDeferredValue)]]
+- **Contradictions/Notes:** 가상 DOM 트리는 설계상 불변(Immutable)으로 취급되지만, React 내부적으로는 현재 설치된 상태(설치된 DOM 노드에 대한 참조 등)를 추적하기 위해 변경 가능한(Mutable) "증강된 DOM(Augmented DOM)" 형태인 Fiber 데이터 구조를 사용합니다 [12].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/가상 DOM과 재조정 (Virtual DOM and Reconciliation).md b/10_Wiki/Topics_Art/UI_UX_Assets/가상 DOM과 재조정 (Virtual DOM and Reconciliation).md
new file mode 100644
index 00000000..3fc18d45
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/가상 DOM과 재조정 (Virtual DOM and Reconciliation).md	
@@ -0,0 +1,33 @@
+# [[가상 DOM과 재조정 (Virtual DOM and Reconciliation)]]
+
+## 📌 Brief 시 Summary
+가상 DOM(Virtual DOM)은 실제 DOM과 동기화되는 사용자 인터페이스(UI)의 가벼운 인메모리(in-memory) 표현입니다 [1, 2]. React는 이 가상 DOM을 사용하여 이전 상태와 새로운 상태를 비교(Diffing)한 뒤, 가장 효율적인 방식으로 실제 DOM을 업데이트하는 '재조정(Reconciliation)' 과정을 수행합니다 [2, 3]. 이 메커니즘은 수동적인 DOM 조작의 비효율성을 추상화하고 선언적인 API를 가능하게 하여 애플리케이션의 렌더링 성능을 최적화합니다 [1, 2].
+
+## 📖 Core Content
+*   **가상 DOM의 도입 배경 및 개념**
+    *   웹 브라우저에서 DOM을 직접 수정하는 것은 브라우저의 중요 렌더링 경로(Critical Rendering Path)에 있는 레이아웃(Layout) 및 페인트(Paint) 단계를 트리거하기 때문에 본질적으로 속도가 느립니다 [1].
+    *   React는 평범한 JavaScript 객체 형태인 가상 DOM을 도입하여 UI 엘리먼트를 표현함으로써 이 문제를 해결합니다 [3]. 이는 일시적인 프레젠테이션 상태를 지속적인 애플리케이션 상태에서 분리하여 불필요한 렌더링 작업을 줄입니다 [3].
+
+*   **휴리스틱 기반의 비교 알고리즘 (Heuristic Diffing Algorithm)**
+    *   일반적으로 두 트리를 비교하는 알고리즘은 $O(n^3)$의 시간 복잡도를 가지며, 이는 실제 애플리케이션에 적용하기에는 너무 무겁습니다 [4, 5].
+    *   React는 두 가지 가정을 바탕으로 $O(n)$의 시간 복잡도를 갖는 휴리스틱 알고리즘을 사용합니다 [4, 6].
+        1.  서로 다른 타입의 엘리먼트는 완전히 다른 트리를 생성합니다 [4, 6].
+        2.  개발자는 `key` prop을 통해 여러 렌더링 사이에서 어떤 자식 엘리먼트가 안정적으로 유지되는지 React에 힌트를 제공할 수 있습니다 [4, 6].
+
+*   **엘리먼트 타입에 따른 업데이트 방식**
+    *   **다른 타입의 엘리먼트:** 루트 엘리먼트의 타입이 다르면(예: `<a>`에서 `<img>`로 변경), React는 이전 트리를 완전히 파괴하고 새로운 트리를 처음부터 다시 구축하며, 이때 이전 트리와 연관된 상태(State)는 모두 소실됩니다 [4, 7].
+    *   **동일한 타입의 DOM 엘리먼트:** 동일한 타입일 경우 기반이 되는 DOM 노드를 그대로 유지하고, 변경된 속성이나 스타일(예: `className`, `color`)만 업데이트합니다 [8, 9].
+    *   **동일한 타입의 컴포넌트 엘리먼트:** 컴포넌트 인스턴스가 동일하게 유지되어 렌더링 간에 상태가 보존됩니다 [9]. 새로운 엘리먼트에 맞춰 props를 업데이트한 후 `render()` 메서드를 호출하고, 그 결과에 대해 비교 알고리즘을 재귀적으로 수행합니다 [9, 10].
+
+*   **자식 노드 재귀 처리와 `key`의 역할**
+    *   React가 자식 노드들을 순회할 때, 기본적으로 두 리스트를 동시에 순회하며 차이가 있을 때마다 변이(mutation)를 생성합니다 [10].
+    *   목록의 맨 앞에 새로운 엘리먼트가 추가되는 경우, 순서가 밀린 모든 자식 노드를 변경해야 하므로 성능이 크게 저하될 수 있습니다 [11].
+    *   이를 해결하기 위해 `key` 속성을 부여하면, React는 원래 트리의 자식과 새로운 트리의 자식을 효율적으로 매치하여 기존 엘리먼트를 그대로 이동시킬 수 있습니다 [11, 12]. 단, 배열의 인덱스를 키로 사용하면 항목이 재정렬될 때 컴포넌트의 상태가 꼬이는 등의 문제가 발생할 수 있습니다 [12, 13].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Fiber Architecture]], [[DOM (Document Object Model)]], [[Critical Rendering Path]]
+- **Projects/Contexts:** [[React]]
+- **Contradictions/Notes:** 초기 구현이나 단순화된 개념에서는 '새롭게 계산된 가상 DOM'과 '이전 가상 DOM'을 직접 비교한다고 설명하지만, React는 단일 자식 노드가 여러 곳에서 공유되는 문제를 해결하기 위해 현재 설치된 상태를 나타내는 변경 가능한(mutable) "증강된 DOM(augmented DOM)"인 Fiber 데이터 구조를 생성하여 활용합니다 [14, 15].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/동시성 렌더링 (Concurrent Rendering).md b/10_Wiki/Topics_Art/UI_UX_Assets/동시성 렌더링 (Concurrent Rendering).md
new file mode 100644
index 00000000..24f54c6f
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/동시성 렌더링 (Concurrent Rendering).md	
@@ -0,0 +1,25 @@
+# [[동시성 렌더링 (Concurrent Rendering)]]
+
+## 📌 Brief Summary
+동시성 렌더링(Concurrent Rendering)은 React의 Fiber 아키텍처를 기반으로 메인 스레드를 동기적으로 차단하지 않고 렌더링 작업을 중단 및 재개할 수 있도록 하는 렌더링 방식입니다 [1, 2]. 이 기술은 전체 렌더링 작업을 작은 단위로 쪼개어 처리하는 타임 슬라이싱(Time-Slicing)을 통해, 긴급한 사용자 상호작용을 우선적으로 처리할 수 있도록 브라우저에 제어권을 양보합니다 [2-4]. 이를 통해 무거운 연산이 백그라운드에서 진행되는 동안에도 UI의 반응성을 부드럽게 유지할 수 있습니다 [4, 5].
+
+## 📖 Core Content
+- **Fiber 아키텍처와 작업 분할 (Time-Slicing)**
+  기존의 동기식 스택 리컨실러(Stack Reconciler)가 메인 스레드를 길게 차단하여 UI가 멈추는 문제를 해결하기 위해, React 16부터 도입된 Fiber 아키텍처는 동시성 렌더링을 지원합니다 [1, 2]. 전체 렌더링 작업을 '작업 단위(unit of work)'인 Fiber 노드로 나누어 처리하며, 각 작업 후 브라우저에 제어권을 양보(yield)하여 더 높은 우선순위의 작업(예: 사용자 입력)이 있는지 확인합니다 [3, 6]. 렌더링 단계는 이렇게 중단과 재개가 가능하지만, 실제 DOM을 변경하는 커밋 단계는 동기적으로 처리됩니다 [7, 8].
+
+- **우선순위 기반의 레인(Lane) 모델**
+  동시성 렌더링은 '레인(Lane)'이라는 비트마스크 시스템을 통해 렌더링 작업의 우선순위를 관리합니다 [9, 10]. 클릭이나 타이핑 같은 사용자 상호작용은 가장 높은 우선순위(Sync Lane)로 즉시 처리되고, 화면에 보이지 않는 요소의 렌더링이나 무거운 데이터 업데이트는 낮은 우선순위(Idle 또는 Default Lane)로 미루어집니다 [9, 11].
+
+- **React 18/19의 동시성 훅 (Concurrent Features)**
+  `useTransition`과 `useDeferredValue` 훅은 이 동시성 렌더링 모델을 직접적으로 활용합니다 [5]. `useTransition`은 대규모 목록 필터링과 같은 비긴급 상태 업데이트의 우선순위를 낮춰 입력 지연을 방지하며 [5, 12], `useDeferredValue`는 무거운 렌더링 계산이 필요한 값의 적용을 지연시킵니다 [12, 13]. 
+
+- **동시성 하이드레이션 (Concurrent Hydration)**
+  React 18부터는 하이드레이션 과정에도 동시성 렌더링이 적용됩니다 [14]. 거대한 덩어리의 하이드레이션 작업을 작은 조각으로 나누어 브라우저의 상호작용 처리를 방해하지 않게 하며, Suspense와 결합할 경우 사용자가 상호작용하는 UI 컴포넌트부터 우선적으로 하이드레이션하여 초기 로딩 성능(Total Blocking Time)을 크게 개선합니다 [14, 15].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[React Fiber Architecture]], [[Time-Slicing]], [[Lane Model]], [[Reconciliation]]
+- **Projects/Contexts:** [[React 18/19 Performance Optimization]], [[Concurrent Hydration]]
+- **Contradictions/Notes:** 동시성 렌더링 기능(`useTransition`, `useDeferredValue` 등)은 애플리케이션의 실제 코드 실행 속도를 높이는 것이 아니라, 무거운 연산 중에도 긴급한 피드백을 방해하지 않도록 처리 순서를 조정함으로써 앱이 더 빠르게 "느껴지도록(feel faster)" 체감 성능을 향상시키는 역할을 합니다 [16].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/렌더링 차단 리소스(Render-blocking resources).md b/10_Wiki/Topics_Art/UI_UX_Assets/렌더링 차단 리소스(Render-blocking resources).md
new file mode 100644
index 00000000..c6c1351f
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/렌더링 차단 리소스(Render-blocking resources).md	
@@ -0,0 +1,22 @@
+# [[렌더링 차단 리소스(Render-blocking resources)]]
+
+## 📌 Brief Summary
+렌더링 차단 리소스란 브라우저가 화면에 페이지를 그리는 렌더링 과정을 일시적으로 중단하게 만드는 핵심 웹 리소스를 뜻합니다 [1]. 대표적인 예인 CSS는 스타일이 적용되지 않은 화면(FOUC)이 사용자에게 노출되는 것을 막기 위해 CSSOM이 완전히 구성될 때까지 렌더링을 막습니다 [2, 3]. 동기적으로 실행되는 JavaScript 또한 HTML 파서를 멈추게 만들어 결과적으로 렌더링을 차단합니다 [4, 5]. 이러한 리소스들을 비동기 처리하거나 다운로드를 지연시키는 등 최적화하는 것은 초기 페이지 로드 속도와 웹 성능을 향상시키는 핵심 요소입니다 [6, 7].
+
+## 📖 Core Content
+- **CSS의 렌더링 차단 원리**: 브라우저가 문서 파싱 중 일부 외부 리소스 요청을 만나면 해당 에셋이 처리될 때까지 렌더링을 중단합니다 [8]. CSS는 기본적으로 렌더링 차단 리소스로 동작하는데, 그 이유는 나중에 로드된 스타일 규칙이 이전 규칙을 덮어씌울 수 있기 때문에 브라우저가 CSSOM(CSS Object Model)을 완성하기 전까지 화면 렌더링을 보류해야 하기 때문입니다 [3]. 이는 사용자가 스타일이 입혀지지 않은 HTML 원본을 보게 되는 '스타일 없는 콘텐츠의 번쩍임(FOUC)' 현상을 방지하기 위한 안전장치입니다 [2]. `<head>` 태그 내에 존재하는 렌더링 차단 리소스는 사실상 페이지 전체의 렌더링을 차단합니다 [9].
+- **파서 차단(Parser-blocking)과 JavaScript**: JavaScript는 기본적으로 파서를 차단하는 리소스입니다 [5]. 스크립트 실행 과정에서 DOM이나 CSSOM이 어떻게 변경될지 알 수 없으므로, 브라우저는 실행이 완료될 때까지 HTML 파싱을 중단합니다 [5, 10]. 파싱이 막히면 브라우저는 그 이후의 콘텐츠에 접근해 렌더링할 수 없기 때문에, 파서 차단 리소스는 결과적으로 렌더링도 차단하게 됩니다 [11].
+- **차단 우회 및 최적화 방법**:
+  - CSS의 경우 `<link>` 요소에 `media="print"`와 같이 현재 뷰포트 조건과 일치하지 않는 미디어 속성을 지정하면 렌더링을 차단하지 않도록 만들 수 있습니다 [12].
+  - JavaScript의 경우 `<script>` 태그에 `async` 또는 `defer` 속성을 추가하여 파서와 렌더링이 막히는 것을 방지할 수 있습니다 [5, 13].
+  - 중요하지 않은 리소스의 다운로드를 지연시키고, CSS 선택자 특이성을 최적화하거나 축소(minifying)하여 전체 차단 시간을 줄여야 합니다 [6, 14].
+  - 최신 기술로는 Chrome 105부터 도입된 `blocking=render` 속성을 통해 파서는 계속 진행하도록 두면서 명시적으로 렌더링만 차단하게 설정할 수도 있습니다 [5].
+- **측정 및 식별**: WebPageTest, Lighthouse 등과 같은 성능 감사 도구는 렌더링 차단 리소스를 식별하는 기능을 제공합니다. 이를 통해 어떤 리소스가 실제 페이지 렌더링을 지연시키고 있는지 찾아내어 최적화의 단서로 삼을 수 있습니다 [15].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[핵심 렌더링 경로(Critical rendering path)]], [[CSSOM(CSS Object Model)]], [[파서 차단 리소스(Parser-blocking resources)]], [[FOUC(Flash of Unstyled Content)]]
+- **Projects/Contexts:** [[웹 성능 최적화(Web Performance Optimization)]], [[Lighthouse 성능 감사]]
+- **Contradictions/Notes:** 소스에 따르면 CSS가 렌더링을 차단한다고 해서 브라우저의 모든 작업이 중지되는 것은 아닙니다. 브라우저는 CSS를 다운로드하고 렌더링을 일시 정지한 상태에서도 나머지 HTML을 계속 처리하며 할 수 있는 다른 작업(예: 리소스 탐색 등)을 수행하여 효율성을 높입니다 [12]. 또한, 과거에는 렌더링 차단 리소스가 페이지 전체 렌더링을 막았으나 최근 브라우저(Firefox, Chrome)는 렌더링 차단 리소스 아래에 있는 콘텐츠의 렌더링만 차단하도록 동작 방식이 개선되었습니다 [9].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/메인 스레드 차단 문제 해결을 위한 React 16의 Fiber 엔진 교체 및 React 18, 19의 동시성 렌더링 적용 사례.md b/10_Wiki/Topics_Art/UI_UX_Assets/메인 스레드 차단 문제 해결을 위한 React 16의 Fiber 엔진 교체 및 React 18, 19의 동시성 렌더링 적용 사례.md
new file mode 100644
index 00000000..4ef28a35
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/메인 스레드 차단 문제 해결을 위한 React 16의 Fiber 엔진 교체 및 React 18, 19의 동시성 렌더링 적용 사례.md	
@@ -0,0 +1,29 @@
+# [[메인 스레드 차단 문제 해결을 위한 React 16의 Fiber 엔진 교체 및 React 18, 19의 동시성 렌더링 적용 사례]]
+
+## 📌 Brief Summary
+React 16 이전의 동기적 렌더링 방식은 렌더링 작업이 길어질 경우 메인 스레드를 차단하여 UI 응답성을 떨어뜨리는 한계가 있었습니다. 이를 해결하기 위해 React 16은 렌더링 작업을 잘게 쪼개고 우선순위에 따라 작업을 중단, 재개할 수 있는 Fiber 아키텍처를 도입했습니다. 이를 기반으로 React 18에서는 자동 일괄 처리(Automatic Batching)와 `useTransition` 등을 활용한 동시성 렌더링 기능을 제공하였고, React 19에 이르러서는 React Compiler를 통한 자동 메모이제이션과 서버 컴포넌트(RSC)를 도입해 메인 스레드의 부하를 극적으로 줄이며 최적화를 자동화했습니다.
+
+## 📖 Core Content
+**메인 스레드 차단 문제와 한계**
+React 16 이전의 React는 컴포넌트 트리를 단일 재귀 호출로 동기적으로 처리하는 '스택 재조정자(Stack Reconciler)'를 사용했습니다 [1]. 대규모 애플리케이션의 경우, 이 과정이 16.6ms의 프레임 예산을 초과하면 메인 스레드를 차단하여 사용자 입력 및 애니메이션에 대한 애플리케이션의 응답성이 지연되는 문제가 발생했습니다 [1].
+
+**React 16의 Fiber 엔진 도입**
+*   **작업 분할 및 타임 슬라이싱 (Time-Slicing):** 동기적 차단 문제를 해결하기 위해 React 16은 동시성 렌더링을 지원하도록 재조정(Reconciliation) 엔진을 완전히 재작성한 'Fiber' 아키텍처를 도입했습니다 [2]. Fiber는 렌더링 작업을 'Fiber 노드'라는 작은 작업 단위(Unit of work)로 분할합니다 [1, 3]. 
+*   **중단 및 재개 가능한 렌더링:** 작업 루프(Work loop) 내에서 React는 각 작업을 처리한 후 우선순위가 높은 작업(예: 사용자 입력)을 위해 브라우저에 제어권을 양보(Yield)할 수 있습니다 [4]. 렌더링 단계(Render phase)는 중단 및 재개가 가능하며, 실제 DOM에 변경 사항을 적용하는 커밋 단계(Commit phase)는 동기적으로 실행됩니다 [5, 6].
+*   **우선순위 레인(Lanes):** 타이핑 및 클릭과 같은 긴급한 상호작용은 '동기(Sync) 레인'에 할당하고, 데이터 페칭은 '기본(Default) 레인'에 할당하는 방식으로 우선순위 기반 시스템을 운용하여 UI의 반응성을 향상시켰습니다 [7-9].
+
+**React 18의 동시성 렌더링 적용 사례**
+*   **긴급하지 않은 렌더링 지연:** React 18은 `useTransition` 및 `useDeferredValue` 훅을 통해 동시성 렌더링을 본격적으로 활용합니다 [10]. 긴급한 상호작용(예: 검색어 입력)을 먼저 처리하고, 무거운 연산(예: 수천 개의 목록 필터링)을 `startTransition`으로 감싸 지연시킴으로써 메인 스레드의 차단을 방지합니다 [10-12].
+*   **자동 일괄 처리 (Automatic Batching):** 이벤트 핸들러 내부뿐만 아니라 Promise, setTimeout, 기본 이벤트 등 비동기 작업에서 발생하는 여러 상태 업데이트를 단일 리렌더링으로 묶어 처리합니다 [13-15]. 이는 Virtual DOM의 Diffing 오버헤드를 줄여 데이터 집약적인 대시보드 환경에서 프레임 속도를 최대 25% 향상시키는 성과를 보였습니다 [12, 13, 16].
+
+**React 19의 성능 자동화 및 메인 스레드 부하 감소 사례**
+*   **React Compiler를 통한 자동 메모이제이션:** React 19는 수동으로 작성하던 `useMemo`나 `useCallback`의 인지적 부담을 덜기 위해, 빌드 시점에 AST(추상 구문 트리)를 분석하여 최적의 메모이제이션 경계를 자동으로 삽입하는 React Compiler를 도입했습니다 [17-19]. 이는 미세 조정된 반응성(Fine-Grained Reactivity)을 구현하여 불필요한 연쇄 리렌더링(Re-render cascade)을 획기적으로 방지합니다 [17, 20]. Meta의 내부 테스트에서는 상호작용 속도(INP)가 최대 2.5배 빨라졌습니다 [21].
+*   **React Server Components (RSC):** 번들 크기와 하이드레이션(Hydration) 비용을 근본적으로 제거하기 위해, 상호작용이 없는 컴포넌트를 서버에서만 실행하는 방식을 도입했습니다 [22-24]. 이 방식을 통해 브라우저로 전송되는 JavaScript를 0바이트로 줄여 메인 스레드가 파싱하고 실행해야 할 부담을 최소화했습니다 [22, 24, 25].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Virtual DOM]], [[Reconciliation]], [[Fiber Architecture]], [[Automatic Batching]], [[React Compiler]], [[React Server Components]], [[Time-Slicing]], [[Lane-Based Priority]]
+- **Projects/Contexts:** [[Next.js App Router]], [[Meta's Internal Testing (Quest Store)]], [[Sanity Studio]]
+- **Contradictions/Notes:** 컴포넌트의 렌더링 최적화와 관련해 React Compiler의 도입은 개발자가 `useMemo`나 `useCallback`을 사용하여 수동으로 최적화하던 기존 방식의 패러다임을 바꿉니다 [26]. 대부분의 자동 메모이제이션은 컴파일러가 처리하지만, `useEffect`의 의존성 관리나 타사 라이브러리 연동 등 세밀한 제어가 필요한 경우에는 여전히 수동 메모이제이션 방식이 "탈출구(Escape Hatch)"로 유효하다고 소스에서 지적하고 있습니다 [27-29].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/브라우저 렌더링 과정 (Critical Rendering Path).md b/10_Wiki/Topics_Art/UI_UX_Assets/브라우저 렌더링 과정 (Critical Rendering Path).md
new file mode 100644
index 00000000..9a4fa531
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/브라우저 렌더링 과정 (Critical Rendering Path).md	
@@ -0,0 +1,20 @@
+# [[브라우저 렌더링 과정 (Critical Rendering Path)]]
+
+## 📌 Brief Summary
+브라우저 렌더링 과정(Critical Rendering Path)은 브라우저가 수신한 HTML, CSS, JavaScript 코드를 화면의 실제 픽셀로 변환하기 위해 거치는 일련의 순차적인 단계를 의미합니다 [1, 2]. 이 과정은 DOM과 CSSOM의 생성, 렌더 트리(Render Tree) 구축, 기하학적 형태를 계산하는 레이아웃(Layout), 그리고 픽셀을 그리는 페인트(Paint) 및 합성(Composite) 단계로 이루어집니다 [3, 4]. 렌더링 경로를 최적화하여 렌더링 차단 요소를 최소화하는 것은 웹 페이지의 초기 렌더링 속도를 높이고 사용자 경험(UX)을 향상시키는 프론트엔드 성능 최적화의 핵심입니다 [1, 5, 6].
+
+## 📖 Core Content
+*   **DOM (Document Object Model) 구축:** 브라우저가 HTML 데이터를 받으면 바이트를 문자, 토큰, 노드로 변환한 뒤 이를 기반으로 DOM 트리를 구축합니다 [1, 7]. 이 과정은 점진적(incremental)으로 이루어지기 때문에 브라우저는 네트워크 요청이 진행 중인 상태에서도 트리 구성을 시작할 수 있습니다 [1, 8]. 생성된 노드의 수가 많을수록 이후의 레이아웃과 페인트 단계에서 더 많은 시간이 소요됩니다 [1, 9].
+*   **CSSOM (CSS Object Model) 구축:** DOM과 달리 CSSOM 구성은 점진적이지 않으며 렌더링을 차단(Render-blocking)합니다 [8, 9]. 브라우저는 사용자가 스타일이 적용되지 않은 날것의 콘텐츠(FOUC)를 보는 것을 방지하기 위해, 연결된 모든 스타일시트를 다운로드하고 파싱할 때까지 렌더링을 중단합니다 [8, 9].
+*   **렌더 트리(Render Tree) 합성:** DOM과 CSSOM이 모두 준비되면 브라우저는 두 트리를 결합하여 화면에 렌더링되는 노드만 포함하는 렌더 트리를 생성합니다 [10, 11]. 이 과정에서 시각적 레이아웃에 영향을 주지 않는 `<script>`, `<meta>` 태그나 `display: none` 속성이 적용된 요소는 렌더 트리에서 완전히 제외됩니다 [10, 11]. 단, `visibility: hidden`이 적용된 요소는 눈에 보이지는 않지만 레이아웃 상에서 공간을 차지하므로 렌더 트리에 포함됩니다 [12, 13].
+*   **Layout(레이아웃) / Reflow(리플로우):** 렌더 트리가 완성되면 브라우저는 뷰포트(Viewport)의 크기와 박스 모델을 기반으로 렌더 트리 내 각 요소의 정확한 크기와 화면상 위치를 계산합니다 [14-16]. 창 크기 조절, DOM 요소의 추가 및 제거, 크기 속성 변경 등의 작업은 전체 혹은 부분적인 레이아웃의 재계산(Reflow)을 유발하며 이는 컴퓨팅 비용이 매우 높은 작업입니다 [17, 18].
+*   **Paint(페인트) 및 Compositing(합성):** 레이아웃 단계가 끝나면 브라우저는 계산된 기하학적 형태와 스타일을 바탕으로 화면에 실제 픽셀을 그리는 Paint 작업을 수행합니다 [19-21]. 요소의 색상이나 배경 등 시각적 스타일만 변경될 경우 레이아웃 계산을 생략하고 Repaint(리페인트)만 발생합니다 [18]. 페인트 이후 브라우저는 성능을 높이기 위해 요소들을 여러 레이어로 분리하여 그린 뒤, GPU 등을 활용해 이를 단일 이미지로 합치는 Compositing(합성) 과정을 거칩니다 [19, 22, 23].
+*   **크리티컬 렌더링 패스 최적화:** 브라우저는 `<head>` 태그 내부에 있는 렌더링 차단 CSS 및 파서 차단(Parser-blocking) 동기식 JavaScript가 모두 처리될 때까지 화면을 렌더링하지 않습니다 [24-26]. 반면 이미지, 폰트, 그리고 지연 로드(async/defer) 설정이 된 스크립트 등은 초기 렌더링을 차단하지 않습니다 [27]. 따라서 불필요한 리소스의 다운로드를 지연시키거나 파일 크기를 최적화하는 것이 렌더링 경로 최적화의 기본 원칙입니다 [28, 29].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[DOM]], [[CSSOM]], [[Render Tree]], [[Reflow 및 Repaint]]
+- **Projects/Contexts:** [[프론트엔드 렌더링 성능 최적화]], [[Core Web Vitals 최적화 (FCP, LCP 등)]]
+- **Contradictions/Notes:** 제공된 소스들은 브라우저 렌더링 과정에 대해 모순 없이 일관된 설명을 제공합니다. 특히 `display: none`(렌더 트리에서 제외됨)과 `visibility: hidden`(레이아웃 공간을 차지하므로 렌더 트리에 포함됨)의 처리 방식 차이를 명확히 대조하여 설명하고 있습니다 [13].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/브라우저 렌더링 파이프라인(Critical Rendering Path).md b/10_Wiki/Topics_Art/UI_UX_Assets/브라우저 렌더링 파이프라인(Critical Rendering Path).md
new file mode 100644
index 00000000..fe8e1875
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/브라우저 렌더링 파이프라인(Critical Rendering Path).md	
@@ -0,0 +1,26 @@
+# [[브라우저 렌더링 파이프라인(Critical Rendering Path)]]
+
+## 📌 Brief Summary
+브라우저 렌더링 파이프라인(Critical Rendering Path, CRP)은 브라우저가 HTML, CSS, JavaScript 코드를 수신하여 화면의 픽셀로 변환하기 위해 거치는 일련의 핵심 단계입니다 [1, 2]. 이 파이프라인은 주로 DOM 및 CSSOM 생성, 렌더 트리 구축, 레이아웃, 페인트, 그리고 합성 단계로 이루어집니다 [3]. 이 경로를 최적화하는 것은 초기 렌더링 속도(Time to first render)를 높이고 60FPS의 부드러운 사용자 상호작용을 보장하기 위한 웹 성능 최적화의 핵심입니다 [4, 5].
+
+## 📖 Core Content
+브라우저 렌더링 파이프라인은 다음과 같은 세부적인 과정을 거쳐 실행됩니다.
+
+*   **DOM(Document Object Model) 구축**
+    브라우저가 서버로부터 HTML 데이터를 받으면, 이를 바이트 단위에서 문자, 토큰, 노드로 변환하여 점진적(incremental)으로 DOM 트리를 구성합니다 [1, 6]. 파싱 중 비차단(non-blocking) 리소스를 만나면 요청을 보내고 파싱을 계속하며, 프리로드 스캐너(Preload Scanner)가 백그라운드에서 CSS, 웹 폰트 등 우선순위가 높은 리소스를 미리 요청하여 병목을 줄입니다 [7].
+*   **CSSOM(CSS Object Model) 구축**
+    HTML과 별개로 브라우저는 CSS를 파싱하여 스타일 규칙과 계층 구조를 나타내는 CSSOM 트리를 생성합니다 [8, 9]. DOM 생성과 달리 CSSOM은 **렌더링을 차단(Render-blocking)**하는 속성을 지닙니다. 즉, 브라우저는 모든 CSS를 다운로드하고 파싱을 완료할 때까지 페이지 렌더링을 중단하여, 스타일이 입혀지지 않은 콘텐츠가 화면에 번쩍이는 현상(FOUC)을 방지합니다 [8, 10].
+*   **렌더 트리(Render Tree) 생성**
+    DOM과 CSSOM이 준비되면, 두 트리를 결합하여 **화면에 실제로 표시되는 노드들만 포함된 렌더 트리**를 구축합니다 [11, 12]. `<script>`, `<meta>` 같은 태그나 CSS의 `display: none`이 적용된 요소는 렌더 트리에서 완전히 제외되지만, 화면에 공간을 차지하는 `visibility: hidden`이 적용된 요소는 포함됩니다 [11-13].
+*   **레이아웃(Layout) 또는 리플로우(Reflow)**
+    렌더 트리가 완성되면, 브라우저는 뷰포트의 크기를 기준으로 각 요소가 화면의 어느 위치에, 어느 정도의 크기(기하학적 형태)로 배치될지 정확히 계산합니다 [14-16]. 창 크기가 조절되거나 JavaScript로 DOM 요소의 크기 및 위치를 조작할 때마다 이 계산이 다시 발생하며(**리플로우**), 이는 브라우저에 큰 계산 부담을 줍니다 [17-19].
+*   **페인트(Paint)와 합성(Compositing)**
+    레이아웃 계산이 끝나면 요소에 색상, 텍스트, 그림자, 테두리 등 시각적 속성을 적용하여 화면의 실제 픽셀로 변환하는 페인트(또는 리페인트) 단계가 진행됩니다 [17, 20]. 마지막으로, 성능 최적화를 위해 일부 요소(예: `<video>`, `<canvas>`, 특정 CSS 속성 적용 요소)가 별도의 레이어로 나뉘어 그려졌다면, 브라우저가 이들을 올바른 순서로 겹쳐서 최종 화면을 완성하는 **합성(Compositing)** 단계를 거칩니다 [21, 22]. GPU를 활용해 이 과정을 가속화할 수도 있습니다 [23, 24].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[DOM(Document Object Model)]], [[CSSOM(CSS Object Model)]], [[리플로우와 리페인트(Reflow and Repaint)]], [[가상 DOM(Virtual DOM)]], [[웹 성능 최적화(Web Performance Optimization)]]
+- **Projects/Contexts:** [[최초 렌더링 시간(Time to First Render) 단축]], [[단일 페이지 애플리케이션(SPA)의 CSR 및 SSR 전략]]
+- **Contradictions/Notes:** 동기식 JavaScript는 기본적으로 파서를 차단(Parser-blocking)하여 결과적으로 렌더링 파이프라인 전체를 지연시키므로, `async`나 `defer` 속성을 활용해 렌더링 경로를 방해하지 않도록 처리하는 것이 공통적인 모범 사례로 권장됩니다 [7, 25, 26].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/웹 성능 최적화(Web Performance Optimization).md b/10_Wiki/Topics_Art/UI_UX_Assets/웹 성능 최적화(Web Performance Optimization).md
new file mode 100644
index 00000000..eac38288
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/웹 성능 최적화(Web Performance Optimization).md	
@@ -0,0 +1,25 @@
+# [[웹 성능 최적화(Web Performance Optimization)]]
+
+## 📌 Brief Summary
+웹 성능 최적화는 웹 페이지가 빠르게 로드되고, 원활하게 렌더링되며, 사용자의 상호작용에 즉각적으로 반응하도록 보장하기 위한 기술과 전략을 의미한다 [1-3]. 이는 중요 렌더링 경로(Critical Rendering Path)를 관리하여 리플로우(Reflow)와 리페인트(Repaint)를 최소화하고, 브라우저가 화면을 그리는 속도와 효율성을 극대화하는 과정을 포함한다 [4-7]. 현대의 프론트엔드 환경에서는 적절한 렌더링 전략(CSR, SSR, SSG 등)의 선택, 자바스크립트 번들 크기 축소, 그리고 컴포넌트 아키텍처를 통한 렌더링 횟수 통제가 핵심적인 최적화 목표로 다루어진다 [8-11].
+
+## 📖 Core Content
+* **중요 렌더링 경로(Critical Rendering Path, CRP) 최적화:** 브라우저는 네트워크를 통해 전달받은 HTML과 CSS를 파싱하여 DOM과 CSSOM 트리를 생성하고, 이를 결합해 렌더 트리(Render Tree)를 구축한 뒤, 요소의 위치와 크기를 계산(Layout)하고 화면의 픽셀로 변환(Paint)하는 단계를 거친다 [5, 12-14]. 초기 렌더링 시간을 줄이려면 렌더링을 차단하는 CSS나 파싱을 차단하는 자바스크립트(Render-blocking & Parser-blocking resources)의 수를 최소화하고 다운로드 순서를 최적화해야 한다 [15-18]. 또한 DOM 트리의 노드가 많아질수록 레이아웃과 페인트 단계의 연산 비용이 증가하므로 불필요한 DOM 노드 깊이를 줄여야 한다 [19-21].
+
+* **리플로우(Reflow) 및 리페인트(Repaint) 최소화:** DOM 구조의 변경, 창 크기 조절, 요소의 크기 및 위치 변경 등은 브라우저가 기하학적 구조를 다시 계산하게 만드는 비용이 큰 리플로우(또는 레이아웃)를 유발한다 [22-25]. 시각적 스타일(색상, 그림자 등)만 변경되는 리페인트의 경우 리플로우보다는 연산량이 적지만 과도하게 발생하면 애니메이션 프레임 속도를 저하시킨다 [7, 26, 27]. 성능을 유지하기 위해서는 DOM 업데이트를 일괄 처리하고, 요소 이동 시 위치 관련 속성 대신 GPU 가속을 활용할 수 있는 `transform` 속성을 사용하는 것이 좋다 [7, 26, 28-30].
+
+* **React 애플리케이션의 렌더링 최적화 기법:** React의 렌더링 특성상 부모의 상태가 변경되면 속성 변경 여부와 관계없이 하위 컴포넌트가 연쇄적으로 리렌더링되며 연산 비용을 낭비할 수 있다 [31, 32]. 이를 방지하기 위해 `React.memo`나 `useMemo` 등을 통한 메모이제이션, 대규모 목록에서 화면에 보이는 노드만 그리는 가상화(Virtualization), 그리고 상태 업데이트를 하나로 묶는 자동 일괄 처리(Automatic Batching)가 사용된다 [33-36]. 아울러 React 19의 동시성 렌더링 훅(`useTransition`, `useDeferredValue`)을 활용하면 무거운 연산 중에도 긴급한 상호작용의 응답성을 방해하지 않고 유지할 수 있다 [37-39].
+
+* **렌더링 전략 선택 및 하이드레이션(Hydration) 병목 관리:** 애플리케이션의 성격과 요구에 따라 클라이언트 사이드 렌더링(CSR), 서버 사이드 렌더링(SSR), 정적 사이트 생성(SSG), 점진적 정적 재생성(ISR) 등의 방식을 전략적으로 선택해야 한다 [9, 40-42]. SSR과 SSG는 서버에서 미리 완성된 HTML을 전달하여 빠른 초기 콘텐츠 표시(FCP)와 우수한 SEO를 보장하지만, SSR의 경우 브라우저가 자바스크립트를 다운로드하고 HTML에 이벤트 핸들러를 연결하는 '하이드레이션(Hydration)' 과정이 끝날 때까지 상호작용(TTI)이 지연되거나 메인 스레드를 차단(TBT)하는 단점이 있다 [43-47].
+
+* **React Server Components (RSC)의 도입과 자동화 도구:** 기존 렌더링 방식의 번들 크기 및 하이드레이션 문제를 근본적으로 해결하기 위해 컴포넌트를 서버에서만 실행하고 클라이언트에는 자바스크립트를 전송하지 않는 RSC 모델이 도입되었다 [48-51]. 이를 통해 클라이언트로 전송되는 JS 페이로드 크기를 대폭 줄이고 서버의 리소스를 직접 활용할 수 있다 [52-54]. 더 나아가 최신 React Compiler는 빌드 타임에 코드의 추상 구문 트리(AST)를 분석해 자동으로 세분화된 메모이제이션을 삽입해주어, 개발자가 수동으로 성능을 최적화해야 하는 부담을 대폭 감소시킨다 [55-58].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** `[[Critical Rendering Path]]`, `[[Reflow and Repaint]]`, `[[React Server Components]]`, `[[하이드레이션(Hydration)]]`, `[[동시성 렌더링(Concurrent Rendering)]]`, `[[React Compiler]]`
+- **Projects/Contexts:** `[[콘텐츠 기반의 SEO 최적화 웹사이트 및 이커머스(E-commerce) 플랫폼]]` (초기 화면의 빠른 렌더링과 검색엔진 최적화를 위해 SSR, SSG, ISR이 필수적으로 요구되는 맥락) [43, 59-62], `[[고도의 상호작용이 필요한 관리자 대시보드 및 SaaS]]` (초기 렌더링보다 실시간 상태 업데이트와 인터랙션 속도가 중시되어 CSR 또는 선택적 클라이언트 컴포넌트가 적합한 맥락) [63-67].
+- **Contradictions/Notes:** 
+  - **수동 메모이제이션의 유용성에 대한 관점 변화:** 기존 React 생태계에서는 불필요한 리렌더링을 막기 위해 `useMemo`나 `useCallback`과 같은 수동 메모이제이션이 권장되었으나, 얕은 비교 검사 자체의 오버헤드가 발생하거나 종속성 관리가 복잡해져 과도한 사용이 안티 패턴으로 지적되기도 했다 [68, 69]. 그러나 React 19의 React Compiler 등장 이후, 컴파일러가 정적 분석을 통해 최적의 위치에 자동으로 메모이제이션을 적용하게 되면서 개발자의 수동 개입 필요성이 크게 사라지는 패러다임 전환이 이루어지고 있다 [55, 58, 70-72].
+  - **SSR의 성능 지표 딜레마:** 서버 사이드 렌더링(SSR)은 클라이언트에게 완성된 HTML을 즉시 제공하여 초기 콘텐츠 표시(FCP)와 SEO를 개선하지만, 자바스크립트를 다운로드하여 정적 요소에 상호작용을 활성화하는 하이드레이션 과정이 완료될 때까지 상호작용 시작 시간(TTI)이 크게 지연되거나 메인 스레드 차단 시간(TBT)이 증가하는 역설적인 한계가 존재한다 [43, 45, 73-75].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/크리티컬 렌더링 패스 (Critical Rendering Path).md b/10_Wiki/Topics_Art/UI_UX_Assets/크리티컬 렌더링 패스 (Critical Rendering Path).md
new file mode 100644
index 00000000..4f81342f
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/크리티컬 렌더링 패스 (Critical Rendering Path).md	
@@ -0,0 +1,26 @@
+# [[크리티컬 렌더링 패스 (Critical Rendering Path)]]
+
+## 📌 Brief Summary
+크리티컬 렌더링 패스(Critical Rendering Path, CRP)는 브라우저가 HTML, CSS, JavaScript 코드를 수신하여 화면의 픽셀로 변환하기 위해 거치는 일련의 단계를 의미합니다 [1, 2]. 브라우저는 DOM과 CSSOM을 생성하고, 이를 결합하여 렌더 트리를 구축한 뒤, 요소의 크기와 위치를 계산하는 레이아웃(Layout) 단계와 화면에 그리는 페인트(Paint) 단계를 수행합니다 [2, 3]. 이 경로를 최적화하는 것은 초기 렌더링 시간(Time to First Render)을 단축하고 사용자 상호작용의 유창함을 보장하기 위한 프론트엔드 성능 엔지니어링의 핵심 목표입니다 [1, 4].
+
+## 📖 Core Content
+**주요 진행 단계 (Sequential Progression of Steps)**
+*   **DOM 트리 생성 (DOM Construction)**: 브라우저가 HTML 바이트를 파싱하여 점진적(incremental)으로 DOM 트리를 구축합니다 [5, 6]. 노드의 수가 많을수록 이후 단계에서 소요되는 시간이 길어집니다 [1, 7].
+*   **CSSOM 트리 생성 (CSSOM Construction)**: CSS 규칙을 파싱하여 스타일 정보를 담은 CSSOM 트리를 생성합니다 [7, 8]. DOM과 달리 CSSOM 생성은 점진적이지 않으며, 브라우저는 모든 CSS를 처리할 때까지 페이지 렌더링을 차단(Render-blocking)합니다 [7, 9].
+*   **렌더 트리 합성 (Render Tree Synthesis)**: DOM과 CSSOM이 준비되면, 시각적으로 화면에 표시되어야 하는 노드와 그에 해당하는 계산된 스타일만 포함하는 렌더 트리를 구축합니다. `<script>` 요소나 `display: none` 스타일이 적용된 노드 등 화면에 보이지 않는 요소는 제외됩니다 [10-12].
+*   **레이아웃 (Layout / Reflow)**: 렌더 트리를 기반으로 기기의 뷰포트 크기를 고려하여 각 요소의 정확한 기하학적 형태(크기와 화면상 위치)를 계산합니다 [13-16].
+*   **페인트 및 합성 (Paint and Composite)**: 계산된 기하학적 형태와 스타일을 실제 픽셀로 변환(Paint)하여 화면에 그리고, 여러 레이어로 분리된 요소를 올바른 순서로 화면에 결합(Composite)합니다 [17-20].
+
+**성능 최적화 및 렌더링 차단 요소 (Performance Optimization and Blocking Resources)**
+*   초기 렌더링을 위해서는 HTML 일부와 `<head>` 태그 내에 있는 렌더링 차단 CSS 및 JavaScript 처리가 선행되어야 합니다 [21-23]. 
+*   브라우저의 파서(Parser)는 동기식 JavaScript를 만나면 DOM을 변경할 수 있기 때문에 HTML 파싱을 중단하며, 이는 렌더링 차단으로 이어져 큰 성능 비용을 발생시킵니다 [23, 24].
+*   CRP 최적화를 위해서는 이러한 렌더링 차단 리소스의 영향을 최소화하여 중요한 리소스의 로드 순서를 제어하고 다운로드해야 할 크기를 줄이는 것이 필수적입니다 [25, 26].
+*   이미지나 폰트는 일반적으로 초기 렌더링을 지연시키는 차단 리소스로 취급되지 않지만 [27], 요소의 치수를 미리 제공하지 않으면 이미지가 로드된 후 레이아웃이 다시 계산되는 리플로우(Reflow) 현상이 발생하여 성능이 저하될 수 있습니다 [19, 20, 27].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[DOM (Document Object Model)]], [[CSSOM (CSS Object Model)]], [[렌더 트리 (Render Tree)]], [[리플로우 (Reflow)]], [[리페인트 (Repaint)]]
+- **Projects/Contexts:** 프론트엔드 성능 최적화(Frontend Performance Optimization) 작업이나 Lighthouse, Chrome DevTools, WebPageTest와 같은 성능 감사 도구를 통해 렌더링 병목 현상을 파악하고 해결하는 맥락에서 빈번하게 다뤄집니다 [28-30].
+- **Contradictions/Notes:** 전통적으로 크리티컬 렌더링 패스는 '최초 렌더링(First Paint)'을 위해 필요한 최소한의 과정을 의미하지만, 최근의 웹 성능 측정은 첫 페인트를 넘어 실제 유의미한 콘텐츠가 사용자에게 보여지는 시점인 LCP(Largest Contentful Paint) 등을 포괄하는 '크리티컬 콘텐츠 렌더링 패스(Critical Contentful Rendering Path)'에 집중해야 한다는 관점도 대두되고 있습니다 [26, 31].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/프론트엔드 렌더링 최적화(Rendering Optimization).md b/10_Wiki/Topics_Art/UI_UX_Assets/프론트엔드 렌더링 최적화(Rendering Optimization).md
new file mode 100644
index 00000000..8e4e66c1
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/프론트엔드 렌더링 최적화(Rendering Optimization).md	
@@ -0,0 +1,41 @@
+# [[프론트엔드 렌더링 최적화(Rendering Optimization)]]
+
+## 📌 Brief Summary
+프론트엔드 렌더링 최적화는 브라우저가 HTML, CSS, JavaScript를 화면의 픽셀로 변환하는 과정인 중요 렌더링 경로(Critical Rendering Path)를 효율화하여 애플리케이션의 응답성과 화면 표시 속도를 향상시키는 작업입니다 [1-3]. DOM 조작 시 발생하는 비용이 큰 리플로우(Reflow)와 리페인트(Repaint) 연산을 최소화하는 것이 핵심이며, React와 같은 프레임워크에서는 가상 DOM(Virtual DOM)과 파이버(Fiber) 아키텍처를 통해 이를 추상화 및 최적화합니다 [4-6]. 또한, 서비스의 특성에 따라 CSR, SSR, SSG 등의 렌더링 전략을 선택하고 하이드레이션(Hydration) 및 번들 크기를 관리함으로써 사용자 경험(Core Web Vitals)을 극대화하는 데 그 목적이 있습니다 [7-9].
+
+## 📖 Core Content
+
+**1. 브라우저 렌더링 과정 (Critical Rendering Path)**
+브라우저는 서버로부터 HTML을 수신하면 점진적으로 문서를 파싱하여 DOM(Document Object Model) 트리를 생성하고, CSS를 파싱하여 렌더링 차단 리소스인 CSSOM(CSS Object Model) 트리를 구성합니다 [10-13]. DOM과 CSSOM이 준비되면 화면에 표시될 노드들만 포함하는 렌더 트리(Render Tree)를 합성합니다 [14, 15]. 이후 요소들의 정확한 위치와 크기를 계산하는 레이아웃(Layout 또는 Reflow) 단계를 거쳐, 픽셀을 화면에 그리는 페인트(Paint 또는 Repaint) 및 레이어들을 합성하는 컴포지팅(Compositing) 단계로 화면을 출력합니다 [16-19]. 
+
+**2. 리플로우(Reflow)와 리페인트(Repaint) 최소화**
+*   **리플로우 (Layout):** 창 크기 변경, 요소의 추가/제거, 크기나 여백(width, height, margin 등)의 변경은 DOM 트리의 위치나 크기 계산을 다시 하게 만드는 리플로우를 유발하며 이는 계산 비용이 매우 큽니다 [4, 6, 20].
+*   **리페인트 (Paint):** 배경색이나 그림자 등 시각적 속성만 변경될 때 발생하며, 리플로우보다 비용이 적지만 과도하면 프레임 드롭(Jank)을 유발합니다 [17, 20, 21].
+*   **최적화 전략:** 불필요한 DOM 깊이를 줄이고, 복잡한 CSS 선택자를 피해야 합니다 [22, 23]. 또한 화면을 강제로 재계산하게 하는 동기적 DOM 읽기/쓰기 작업을 분리하여 레이아웃 스래싱(Layout Thrashing)을 방지하고, 애니메이션 구현 시 `transform`과 `opacity`를 활용하여 GPU 가속(Compositing)을 사용하는 것이 유리합니다 [4, 17, 21, 24].
+
+**3. 가상 DOM(Virtual DOM)과 재조정(Reconciliation)**
+React는 실제 DOM 조작의 비효율성을 피하기 위해 가상 DOM이라는 경량화된 메모리 내 UI 표현을 사용합니다 [5, 25]. 렌더링 시 이전 가상 DOM과 새로운 가상 DOM을 비교(Diffing)하여 변경된 부분만 실제 DOM에 반영합니다 [5, 25]. 이론상 트리를 비교하는 알고리즘은 O(n^3)의 복잡도를 가지지만, React는 요소 타입이 다르면 하위 트리를 완전히 새로 구축하고 리스트 요소의 경우 고유한 `key` 속성을 통해 식별하는 O(n)의 휴리스틱 알고리즘을 사용해 성능을 최적화합니다 [26, 27].
+
+**4. React Fiber와 동시성 렌더링 (Concurrent Rendering)**
+React 16부터 도입된 파이버(Fiber) 아키텍처는 동기식으로 진행되어 메인 스레드를 블로킹하던 기존 렌더링 방식을 개선했습니다 [28-30]. 렌더링 작업을 잘게 쪼개어 중단, 일시 정지, 재개가 가능하게 만들었으며(Time-slicing) [29, 31], 우선순위 레인(Lanes) 시스템을 통해 사용자 입력 같은 긴급한 작업과 데이터 가져오기와 같은 비긴급 작업을 구분하여 동시성 렌더링을 처리합니다 [32-34].
+
+**5. 렌더링 전략: CSR, SSR, SSG, ISR**
+웹의 렌더링 방식은 언제 어디서 HTML을 생성하느냐에 따라 나뉘며 각각의 트레이드오프가 존재합니다.
+*   **CSR (Client-Side Rendering):** 브라우저가 자바스크립트를 다운로드하고 실행해 UI를 그립니다. 상호작용은 빠르고 부드러우나 초기 로딩(FCP)이 느리고 SEO에 불리합니다 [7, 35, 36].
+*   **SSR (Server-Side Rendering):** 서버에서 매 요청마다 HTML을 생성해 보내므로 초기 로딩과 SEO가 우수합니다. 하지만 클라이언트에서 JS를 다운로드하고 이벤트 리스너를 연결하는 하이드레이션(Hydration) 과정이 완료될 때까지 상호작용(TTI)이 지연되는 단점이 있습니다 [37-39].
+*   **SSG (Static Site Generation):** 빌드 시점에 정적 HTML을 생성해 CDN을 통해 배포하므로 로딩 속도가 가장 빠르지만 동적 데이터 업데이트에 취약합니다 [40-42].
+*   **ISR (Incremental Static Regeneration):** 정적 페이지를 캐싱해 빠르게 제공하면서, 백그라운드에서 점진적으로 HTML을 재생성하여 데이터 최신화를 보완하는 하이브리드 전략입니다 [40, 43].
+
+**6. React 성능 최적화 기법 (React 18 & 19)**
+*   **컴포넌트 리렌더링 제한 (Memoization):** 부모 컴포넌트의 렌더링이 자식으로 전파되는 계단식 리렌더링(Cascade)을 막기 위해 `React.memo`, `useMemo`, `useCallback`을 사용합니다 [44-46]. 최근 React Compiler(React 19)가 도입되면서 빌드 타임에 AST를 분석하여 정적/반응성 값을 구분하고 최적화 경계를 자동으로 추가함으로써 수동 메모이제이션의 필요성이 크게 줄어들었습니다 [47-49].
+*   **자동 배칭 (Automatic Batching):** React 18부터는 이벤트 핸들러뿐만 아니라 비동기 호출이나 타임아웃 내부의 다수 상태 업데이트도 하나의 리렌더링으로 자동 그룹화하여 DOM 업데이트 횟수를 줄입니다 [50-52].
+*   **React Server Components (RSC):** 서버에서 독점적으로 실행되고 브라우저로 JavaScript 번들을 전송하지 않는 컴포넌트 아키텍처입니다 [53, 54]. 정적 UI와 데이터 접근 로직을 서버에 두고 대규모 JS 번들 로드와 하이드레이션 단계를 생략하여 초기 성능(INP 등)을 크게 개선할 수 있습니다 [53, 55, 56].
+*   **기타 기법:** 화면에 보이지 않는 무거운 컴포넌트나 이미지의 지연 로딩(`React.lazy()`, Lazy Loading), 대규모 리스트의 가상화(Virtualization), 디바운싱(Debouncing) 등이 필수적으로 적용됩니다 [57-60].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Critical Rendering Path]], [[Reflow and Repaint]], [[Virtual DOM]], [[React Fiber Architecture]], [[Hydration]], [[Server-Side Rendering (SSR)]], [[Client-Side Rendering (CSR)]], [[React Compiler]], [[React Server Components (RSC)]]
+- **Projects/Contexts:** [[Next.js 기반 웹 성능 최적화 프로젝트]], [[대규모 데이터 대시보드 및 이커머스 플랫폼 렌더링 전략 구축]]
+- **Contradictions/Notes:** 소스에 따르면 CSR은 동적인 상호작용성(Interactive)에 강점이 있으나 초기 로딩 속도와 SEO에 한계가 있는 반면, SSR은 초기 콘텐츠 표시와 SEO에는 유리하지만 하이드레이션(Hydration)이 완료되기 전까지 사용자의 입력이 차단되는(TBT/TTI 지연) 상충 관계(Trade-off)를 갖습니다 [7, 37, 61-64]. 또한 최근 도입된 React Compiler는 자동으로 세분화된 수준(Fine-Grained)의 메모이제이션을 수행하지만, `useLocation`이나 `useMutation` 처럼 렌더링마다 새로운 객체를 반환하여 참조 안정성(Reference Equality)을 깨뜨리는 서드파티 라이브러리를 사용할 경우 자동 최적화가 무력화되어 수동 메모이제이션이 여전히 필요할 수 있습니다 [49, 65-67].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/프론트엔드 성능 최적화(Frontend Performance Optimization).md b/10_Wiki/Topics_Art/UI_UX_Assets/프론트엔드 성능 최적화(Frontend Performance Optimization).md
new file mode 100644
index 00000000..400110bf
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/프론트엔드 성능 최적화(Frontend Performance Optimization).md	
@@ -0,0 +1,28 @@
+# [[프론트엔드 성능 최적화(Frontend Performance Optimization)]]
+
+## 📌 Brief Summary
+프론트엔드 성능 최적화는 브라우저가 코드를 해석하여 화면에 렌더링하는 과정과 웹 애플리케이션의 작동 방식을 개선하여 사용자 경험을 극대화하는 과정입니다. 이는 브라우저의 중요 렌더링 경로(CRP) 최적화부터 불필요한 리플로우(Reflow)와 리페인트(Repaint) 최소화, 그리고 웹 렌더링 전략(CSR, SSR, SSG 등)의 올바른 선택을 아우릅니다. 최근에는 React의 Fiber 아키텍처, 상태 업데이트 자동 배칭, 컴파일러를 통한 자동 메모이제이션, 그리고 React 서버 컴포넌트(RSC) 도입을 통해 클라이언트 측 자바스크립트의 실행 및 번들 크기를 획기적으로 줄이는 방향으로 발전하고 있습니다.
+
+## 📖 Core 기Content
+**1. 브라우저 렌더링 과정 (Critical Rendering Path) 및 DOM 최적화**
+- **렌더 트리 구성:** 브라우저는 HTML을 파싱하여 DOM을 만들고, CSS를 파싱하여 CSSOM을 생성한 후, 화면에 표시될 가시적인 노드들만을 결합하여 렌더 트리(Render Tree)를 구축합니다 [1, 2]. 
+- **Reflow와 Repaint 최소화:** 렌더 트리가 변경되면 브라우저는 요소의 정확한 크기와 위치를 다시 계산하는 레이아웃(Reflow) 단계를 거친 후 픽셀을 화면에 그리는 페인트(Repaint) 작업을 수행합니다 [3-9]. Reflow는 연산 비용이 매우 높으므로 불필요한 DOM 깊이를 줄이고, 레이아웃에 영향을 주는 속성 변경을 피해야 합니다 [7, 8, 10-12]. 애니메이션의 경우 `transform` 속성이나 하드웨어(GPU) 가속을 활용해 Reflow를 피하고 컴포지팅(Compositing) 단계에서 처리되도록 최적화해야 합니다 [5, 12-14].
+- **렌더링 차단 리소스 최적화:** CSS와 동기식 자바스크립트는 초기 파싱 및 렌더링을 차단(Render-blocking)하므로, 자바스크립트에는 `async`나 `defer`를 사용하고 중요한 리소스는 Preload 스캐너를 통해 미리 로드하여 렌더링 지연을 방지해야 합니다 [15-23].
+
+**2. 프론트엔드 아키텍처 및 React 렌더링 최적화**
+- **가상 DOM (Virtual DOM) 및 재조정 (Reconciliation):** React는 메모리상에 가상 DOM을 두고 상태 변경 전후를 비교합니다. O(n) 복잡도의 Heuristic Diffing 알고리즘을 사용하며, 요소의 타입이 다르거나 리스트에 `key` 속성이 변경된 경우에만 실제 DOM 노드를 업데이트하여 연산을 최소화합니다 [24-37].
+- **Fiber 아키텍처:** React 16부터 도입된 Fiber는 렌더링 작업을 잘게 쪼개는 시간 분할(Time-slicing) 기술과 우선순위(Lanes) 시스템을 제공합니다. 클릭이나 타이핑 같은 긴급한 작업을 먼저 처리하고 무거운 렌더링은 중단 및 재개할 수 있어 동시성 렌더링(Concurrent Rendering)과 부드러운 UI 응답성을 달성합니다 [26, 38-51].
+- **자동 배칭 (Automatic Batching) 및 메모이제이션:** React 18은 Promise나 setTimeout 같은 비동기 환경 내의 상태 업데이트도 하나로 묶어서(Batching) 처리하여 불필요한 리렌더링을 줄입니다 [52-56]. 또한, React Compiler는 빌드 타임에 AST를 분석해 정적 값과 반응형 값을 식별하고 자동으로 메모이제이션 경계를 추가하여 개발자가 수동으로 `useMemo`나 `useCallback`을 작성해야 하는 부담과 오버헤드를 크게 줄여줍니다 [57-65].
+
+**3. 웹 렌더링 전략 (CSR, SSR, SSG) 및 하이드레이션**
+- **렌더링 전략의 장단점:** CSR(클라이언트 사이드 렌더링)은 동적 상호작용에 유리하지만 초기 로드가 느리고 SEO에 불리합니다 [66-70]. SSR(서버 사이드 렌더링)은 완성된 HTML을 바로 제공하여 초기 화면 표시(FCP)가 빠르고 SEO에 유리하지만 매 요청마다 서버 부하가 발생합니다 [71-76]. SSG(정적 사이트 생성)는 빌드 타임에 HTML을 미리 생성하여 가장 빠르고 CDN 캐싱이 가능하지만 동적 콘텐츠에는 한계가 있습니다 [77-82].
+- **하이드레이션 (Hydration) 병목 해결:** SSR 사용 시, 정적인 HTML이 사용자에게 표시된 후 자바스크립트를 다운로드하고 연결하여 상호작용을 활성화하는 하이드레이션 과정이 필수적입니다 [71, 83-85]. 이 과정은 메인 스레드를 차단하여 상호작용 지연 시간(TTI, TBT)을 악화시킬 수 있으므로, 사용자 뷰포트에 따라 렌더링을 지연시키는 선택적 하이드레이션(Selective Hydration)이나 지연 로딩 방식을 통해 최적화할 수 있습니다 [86-93].
+- **React 서버 컴포넌트 (React Server Components, RSC):** 상호작용이 필요 없는 정적 컴포넌트를 서버에서만 실행하고 결과 HTML과 직렬화된 지침(React Flight 프로토콜)만을 클라이언트에 스트리밍하는 아키텍처입니다. 클라이언트로 전송되는 자바스크립트 번들 크기를 0으로 만들어 하이드레이션 자체를 생략하므로, 성능(INP 등)이 대폭 향상되며 클라이언트와 서버 간의 데이터 폭포(Waterfall) 현상을 서버 수준에서 병렬로 해결할 수 있습니다 [94-109].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[브라우저 렌더링 과정(Critical Rendering Path)]], [[가상 DOM 및 재조정(Virtual DOM and Reconciliation)]], [[React Fiber 아키텍처]], [[하이드레이션(Hydration)]], [[웹 렌더링 전략(CSR, SSR, SSG, ISR)]], [[React 서버 컴포넌트(React Server Components)]], [[React Compiler]]
+- **Projects/Contexts:** [[Next.js를 활용한 웹 애플리케이션의 하이브리드 렌더링 구축]], [[Core Web Vitals (LCP, INP, CLS) 지표 측정 및 개선]]
+- **Contradictions/Notes:** 서버 사이드 렌더링(SSR)은 클라이언트 사이드 렌더링(CSR)에 비해 초기 화면 렌더링 속도(FCP)가 빠르고 검색 엔진 최적화(SEO)에 매우 유리하다는 강력한 이점을 지니지만 [71, 110], 자바스크립트를 로드하고 HTML 요소에 이벤트 리스너 등을 부착하는 하이드레이션(Hydration) 과정을 거쳐야 하므로 실제 사용자가 상호작용할 수 있는 시간(TTI)은 CSR의 로드 직후 반응성보다 다소 지연될 수 있다는 트레이드오프가 존재합니다 [71, 84, 111, 112].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Art/UI_UX_Assets/프론트엔드 프레임워크 (React, Angular, Vue).md b/10_Wiki/Topics_Art/UI_UX_Assets/프론트엔드 프레임워크 (React, Angular, Vue).md
new file mode 100644
index 00000000..725bf7e0
--- /dev/null
+++ b/10_Wiki/Topics_Art/UI_UX_Assets/프론트엔드 프레임워크 (React, Angular, Vue).md	
@@ -0,0 +1,29 @@
+# [[프론트엔드 프레임워크 (React, Angular, Vue)]]
+
+## 📌 Brief Summary
+프론트엔드 프레임워크는 사용자 인터페이스를 구축하기 위해 컴포넌트 기반 아키텍처(CBA)를 채택하는 모듈형 소프트웨어 도구입니다 [1, 2]. React, Angular, Vue와 같은 프레임워크는 기본적으로 클라이언트 측 렌더링(CSR)을 활용하여 상호작용이 풍부한 웹 애플리케이션을 구축하며, 필요에 따라 서버 측 렌더링(SSR) 및 정적 사이트 생성(SSG)을 혼합하여 성능을 최적화합니다 [3-5]. 제공된 소스에서는 프론트엔드 프레임워크의 아키텍처와 작동 원리가 주로 React를 중심으로 상세히 다뤄지고 있으며, Angular와 Vue의 내부 구조에 대한 구체적인 정보는 부족합니다.
+
+## 📖 Core Content
+*   **컴포넌트 기반 아키텍처 (Component-Based Architecture, CBA)**
+    *   현대 프론트엔드 프레임워크(React, Angular, Vue 등)는 시스템을 작고 독립적이며 재사용 가능한 '컴포넌트'로 나누어 설계하는 방식을 기반으로 합니다 [5-7].
+    *   각 컴포넌트는 자체적인 로직, 상태, UI를 캡슐화하여 제공하므로, 병렬 개발과 독립적인 테스트 및 배포가 가능해져 애플리케이션의 유지보수성과 확장성이 크게 향상됩니다 [1, 8, 9].
+
+*   **웹 렌더링 전략 (Web Rendering Strategies)**
+    *   **클라이언트 측 렌더링 (CSR):** React와 Vue는 기본적으로 CSR을 사용하며, 서버에서 빈 HTML 셸을 받은 뒤 브라우저에서 JavaScript를 실행하여 UI를 동적으로 생성합니다 [10]. 이는 상호작용이 부드럽지만 초기 로드 속도 지연과 SEO 약점을 가질 수 있습니다 [11, 12].
+    *   **하이브리드 렌더링:** 이러한 한계를 극복하기 위해 Next.js(React 기반), Nuxt.js(Vue 기반) 등의 프레임워크는 서버 측 렌더링(SSR) 및 정적 사이트 생성(SSG)을 혼합 지원하여 빠른 초기 페인팅(FCP)과 강력한 SEO 성능을 제공합니다 [4, 13].
+
+*   **프레임워크 핵심 아키텍처 (React 중심)**
+    *   **Virtual DOM 및 재조정 (Reconciliation):** 직접적인 DOM 조작의 성능 저하를 막기 위해, React는 UI를 메모리에 가상 DOM 객체로 유지합니다 [14, 15]. 상태가 변경되면 새로운 트리와 기존 트리를 비교(Diffing)하여 실제 DOM에 변경된 최소한의 부분만 업데이트합니다 [16, 17].
+    *   **Fiber 아키텍처:** 렌더링 작업을 동기적으로 한 번에 처리하던 기존 방식과 달리, Fiber는 렌더링을 중단 및 재개할 수 있는 작은 '작업 단위'로 나눕니다 [18, 19]. 이를 통해 사용자 입력과 같은 우선순위가 높은 작업을 먼저 처리하는 동시성 렌더링(Concurrent Rendering)이 가능해집니다 [20-22].
+    *   **성능 최적화의 자동화:** React 18은 비동기 작업이나 이벤트 핸들러 내의 여러 상태 업데이트를 묶어 한 번에 렌더링하는 '자동 일괄 처리(Automatic Batching)'를 도입했습니다 [23-25]. 또한, 최근의 React Compiler는 빌드 타임에 코드를 분석하여 불필요한 리렌더링을 막기 위한 메모이제이션을 자동으로 적용합니다 [26-28].
+    *   **React Server Components (RSC):** 클라이언트 번들 크기를 줄이기 위해 등장한 개념으로, 컴포넌트가 서버에서만 실행되고 클라이언트에는 직렬화된 UI 정보만 전달되어 JavaScript 번들 크기와 Hydration 과정의 부하를 없앱니다 [29, 30].
+
+*(소스에 관련 정보가 부족합니다: Angular와 Vue의 구체적인 내부 렌더링 엔진 작동 방식이나 상태 관리 최적화 기법 등 심층적인 프레임워크별 대조 정보는 제공된 소스에 포함되어 있지 않습니다.)*
+
+## 🔗 Knowledge Connections
+- **Related Topics:** `[[Component-Based Architecture]]`, `[[Client-Side Rendering (CSR)]]`, `[[Server-Side Rendering (SSR)]]`, `[[Virtual DOM]]`, `[[React Fiber]]`
+- **Projects/Contexts:** `[[Next.js 및 Nuxt.js를 활용한 하이브리드 웹 렌더링 최적화]]`, `[[Reflow 및 Repaint 최소화를 통한 브라우저 렌더링 개선]]`
+- **Contradictions/Notes:** 제공된 소스 데이터는 프론트엔드 프레임워크의 전반적인 개념(컴포넌트 구조, CSR/SSR)을 다루고 있으나, 기술적 작동 원리와 최적화 아키텍처(Virtual DOM, Fiber, Compiler, 자동 일괄 처리 등)에 대한 설명은 React에 압도적으로 편중되어 있습니다. Angular와 Vue는 개념을 설명하기 위한 예시로만 언급됩니다.
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Biz/Business_Strategy/E-commerce Platforms.md b/10_Wiki/Topics_Biz/Business_Strategy/E-commerce Platforms.md
new file mode 100644
index 00000000..b3ff3f19
--- /dev/null
+++ b/10_Wiki/Topics_Biz/Business_Strategy/E-commerce Platforms.md	
@@ -0,0 +1,22 @@
+# [[E-commerce Platforms]]
+
+## 📌 Brief Summary
+E-commerce Platforms(이커머스 플랫폼)은 제품 카탈로그, 장바구니, 결제 처리 등의 기능을 제공하여 온라인 상거래를 지원하는 시스템입니다 [1, 2]. 이 시스템의 핵심은 검색 엔진 최적화(SEO)를 통한 제품 발견, 빠른 페이지 로딩을 통한 구매 전환율 향상, 그리고 재고 및 가격 변동을 반영하는 최신 데이터의 유지입니다 [3-5]. 소스 자료에 따르면, 이커머스 플랫폼은 성능과 확장성을 극대화하기 위해 SSR(서버 사이드 렌더링), ISR(점진적 정적 재생성)과 같은 최적화된 웹 렌더링 전략과 컴포넌트 기반 아키텍처(CBA)를 적극적으로 채택합니다 [2, 6].
+
+## 📖 Core Content
+* **이커머스 플랫폼을 위한 웹 렌더링 전략 (Web Rendering Strategies):**
+  * **SSR (Server-Side Rendering):** 이커머스 플랫폼의 제품 목록 페이지, 카테고리 탐색 및 개별 제품 상세 페이지에 가장 이상적인 렌더링 방식 중 하나입니다 [3]. 서버에서 제품의 세부 정보, 가격, 구매 버튼이 포함된 완전한 HTML을 즉시 제공하므로, 자바스크립트 로딩을 기다릴 필요 없이 사용자에게 콘텐츠를 보여주어 구매 전환율을 크게 향상시킵니다 [5]. 또한 훌륭한 SEO를 제공하여 제품 검색 노출에 유리하며, 항상 최신의 실시간 데이터를 요구하는 결제(Checkout) 페이지에 적합합니다 [3, 7].
+  * **SSG (Static Site Generation):** 제품 라인이 변동 없이 안정적이고 콘텐츠 업데이트 주기가 규칙적인 제품 카탈로그 페이지에 적용될 수 있습니다 [8]. 
+  * **ISR (Incremental Static Regeneration):** 이커머스 플랫폼에 최적의 균형(성능과 최신성)을 제공하는 고도화된 접근 방식입니다 [4, 6]. 대규모 제품 카탈로그를 초고속으로 로딩하는 동시에, 전체 사이트를 다시 빌드하는 오버헤드 없이 백그라운드에서 재고 정보와 가격을 주기적으로 업데이트하여 최신 상태로 유지할 수 있습니다 [4, 6, 9].
+
+* **컴포넌트 기반 아키텍처 적용 (Component-Based Architecture):**
+  * 이커머스 플랫폼은 제품 목록(Product listings), 결제 게이트웨이(Payment gateways), 장바구니(Shopping carts), 고객 리뷰 모듈 등 명확히 분리된 기능을 가진 재사용 가능한 소프트웨어 컴포넌트들의 조립으로 구축됩니다 [2].
+  * 이러한 모듈식 접근 방식을 통해 비즈니스가 확장됨에 따라 새로운 결제 옵션을 추가하거나 제품 추천 기능을 갱신해야 할 때, 플랫폼 전체에 중단을 일으키지 않고 특정 컴포넌트만 쉽게 교체하거나 확장할 수 있는 유연성을 확보합니다 [2, 10].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Server-Side Rendering (SSR)]], [[Incremental Static Regeneration (ISR)]], [[Component-Based Architecture]], [[Search Engine Optimization (SEO)]]
+- **Projects/Contexts:** 대규모 트래픽을 처리하면서도 검색 엔진 노출을 극대화하고 실시간 재고/가격 변동을 반영해야 하는 프론트엔드 웹 성능 최적화 및 렌더링 아키텍처 구축 맥락 [3, 4, 7].
+- **Contradictions/Notes:** 제공된 소스는 이커머스 플랫폼의 백엔드 비즈니스 로직이나 운영 모델보다는 주로 프론트엔드의 화면 렌더링 최적화(SSR/ISR)와 아키텍처(컴포넌트화) 측면에 초점을 맞추고 있어, 결제 시스템의 내부 동작 원리 등에 대해서는 소스에 관련 정보가 부족합니다.
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Biz/Business_Strategy/Meta Quest Store.md b/10_Wiki/Topics_Biz/Business_Strategy/Meta Quest Store.md
new file mode 100644
index 00000000..04477daf
--- /dev/null
+++ b/10_Wiki/Topics_Biz/Business_Strategy/Meta Quest Store.md	
@@ -0,0 +1,18 @@
+# [[Meta Quest Store]]
+
+## 📌 Brief Summary
+Meta Quest Store는 Meta에서 운영하는 플랫폼으로, 제공된 문서 내에서는 프론트엔드 성능 최적화 도구인 React Compiler를 실제 프로덕션 환경에 성공적으로 도입한 대표적인 사례로만 짧게 등장합니다 [1, 2]. 해당 스토어의 구체적인 서비스 목적, 판매 항목, 혹은 전반적인 아키텍처에 대해서는 소스에 관련 정보가 부족합니다.
+
+## 📖 Core Content
+- **React Compiler의 성공적 배포**: Meta는 대중에게 공개하기 전 자사 애플리케이션 생태계 전반에 걸쳐 React Compiler를 내부적으로 테스트했으며, Instagram과 함께 Meta Quest Store에 성공적으로 배포했습니다 [1, 2].
+- **로딩 속도 지표 개선**: 수동 메모이제이션(Manual Memoization) 문제를 해결하는 React Compiler 적용 결과, Quest Store의 로딩 속도는 최소 4% 이상 향상되었으며, 초기 로딩(initial loads) 시간은 최대 12%까지 개선되었습니다 [2].
+- **상호작용(Interaction)의 즉각성**: 최적화의 결과로 Quest Store 내의 복잡한 제품 페이지(complex product pages)들이 눈에 띄게 빠르게 로드되었습니다 [1]. 특히 일부 상호작용은 2배 이상 빨라져 사용자들이 거의 즉각적(instantaneous)이라고 느낄 수 있는 수준의 개선이 이루어졌습니다 [1, 2].
+- 이외에 플랫폼 자체의 상업적 기능이나 비즈니스 로직 등에 대해서는 소스에 관련 정보가 부족합니다.
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[React Compiler]], [[Performance Optimization]]
+- **Projects/Contexts:** [[Meta's Internal Testing (React Compiler 성능 검증)]]
+- **Contradictions/Notes:** Meta Quest Store에 대한 독립적이고 포괄적인 설명은 제공된 소스에 관련 정보가 부족합니다. 오직 React Compiler의 적용으로 인한 성능 최적화 지표를 보여주는 단편적인 사례(Case Study)로만 활용되었습니다.
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Biz/Business_Strategy/SaaS 플랫폼 및 인터랙티브 대시보드 개발.md b/10_Wiki/Topics_Biz/Business_Strategy/SaaS 플랫폼 및 인터랙티브 대시보드 개발.md
new file mode 100644
index 00000000..6a68f440
--- /dev/null
+++ b/10_Wiki/Topics_Biz/Business_Strategy/SaaS 플랫폼 및 인터랙티브 대시보드 개발.md	
@@ -0,0 +1,23 @@
+# [[SaaS 플랫폼 및 인터랙티브 대시보드 개발]]
+
+## 📌 Brief Summary
+SaaS 플랫폼과 인터랙티브 대시보드는 실시간 데이터 업데이트, 풍부한 사용자 상호작용, 그리고 매끄러운 화면 전환이 필수적인 웹 애플리케이션입니다 [1, 2]. 이러한 시스템은 대부분 로그인 벽(Authentication wall) 뒤에서 작동하므로 검색 엔진 최적화(SEO)의 중요성이 낮아 클라이언트 사이드 렌더링(CSR)이 가장 이상적인 렌더링 방식으로 평가받습니다 [1, 3, 4]. 또한 대규모 데이터 처리와 복잡한 UI 업데이트 시 성능 병목 현상을 방지하기 위해 컴포넌트 기반 아키텍처와 동시성 렌더링(Concurrent Rendering) 같은 최적화 기술이 적극적으로 활용됩니다 [5, 6].
+
+## 📖 Core Content
+- **최적의 렌더링 전략 (CSR의 활용):**
+  SaaS 플랫폼 및 사용자 대시보드 구축 시에는 클라이언트 사이드 렌더링(CSR)이 주로 권장됩니다 [1, 2]. 대시보드 특성상 검색 엔진 인덱싱이 필요하지 않고 동적인 상호작용이 가장 중요하기 때문입니다 [1, 3]. 초기 로딩 속도는 다소 느릴 수 있으나, 브라우저에서 동적으로 라우팅과 데이터를 처리하므로 사용자가 여러 애플리케이션 섹션을 부드럽게 탐색할 수 있고 인터랙티브한 앱과 같은 경험을 제공합니다 [2, 3, 7]. 일부 프레임워크에서는 실시간 상호작용이 중요한 대시보드에는 CSR을, 그 외 문서나 블로그 페이지에는 SSG나 SSR을 사용하는 하이브리드 방식을 적용하기도 합니다 [8, 9].
+
+- **데이터 집약적 대시보드의 렌더링 성능 최적화:**
+  - **자동 배칭(Automatic Batching):** 데이터가 많은 대시보드에서 React 18의 자동 배칭 기능을 활성화하면 여러 상태 업데이트가 단일 리렌더링으로 묶여 처리됩니다 [10, 11]. 내부 사례 연구에 따르면, 이를 통해 최대 부하 시 총 렌더링 횟수를 약 40% 줄이고 프레임 속도를 25% 향상시킬 수 있습니다 [12, 13].
+  - **동시성 기능(Concurrent Features):** 대시보드에서 10,000개 이상의 대규모 데이터 리스트를 필터링하거나 차트를 다시 계산하는 등 비용이 많이 드는 작업 시 UI가 멈추는 현상을 방지해야 합니다 [5, 14]. `useTransition`이나 `useDeferredValue` 훅을 사용해 무거운 상태 업데이트를 지연시키면 메인 스레드를 차단하지 않고 UI의 즉각적인 반응성(예: 타이핑 시 입력 지연 방지)을 유지할 수 있습니다 [5, 14, 15].
+
+- **컴포넌트 기반 아키텍처(CBA)의 적용:**
+  인터랙티브 대시보드는 차트, 데이터 테이블, 그래프 등 독립적이고 재사용 가능한 컴포넌트들을 조합하여 구축하는 컴포넌트 기반 아키텍처가 적합합니다 [6, 16]. 이를 통해 기능별 모듈화가 이루어져 일부 기능(예: 결제 프로세서 교체, 특정 위젯 업데이트)만 안전하게 수정하거나 확장할 수 있어 유지보수와 확장이 용이해집니다 [17, 18]. 
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Client-Side Rendering (CSR)]], [[Component-Based Architecture]], [[Automatic Batching]], [[Concurrent Rendering]]
+- **Projects/Contexts:** [[데이터 집약적 대시보드 성능 최적화 사례]], [[Sanity Studio]]
+- **Contradictions/Notes:** React 서버 컴포넌트(RSC) 적용과 관련하여 소스 간 시각 차이가 존재합니다. 일부 소스는 읽기 전용 데이터 디스플레이(제품 카탈로그, 단순 대시보드)에 RSC를 사용하면 클라이언트 JavaScript 번들을 40-60%까지 줄일 수 있다고 주장하지만 [19], 다른 소스에서는 빈번한 리렌더링과 로컬 상태, 직접적인 브라우저 API에 크게 의존하는 '복잡한 대시보드 및 고도의 상호작용이 필요한 인터페이스'에는 RSC가 부적합(Poor fit)하며 클라이언트 컴포넌트를 사용해야 한다고 경고합니다 [20].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Biz/Business_Strategy/전자상거래 플랫폼 (E-commerce Platforms).md b/10_Wiki/Topics_Biz/Business_Strategy/전자상거래 플랫폼 (E-commerce Platforms).md
new file mode 100644
index 00000000..18a11cd5
--- /dev/null
+++ b/10_Wiki/Topics_Biz/Business_Strategy/전자상거래 플랫폼 (E-commerce Platforms).md	
@@ -0,0 +1,24 @@
+# [[전자상거래 플랫폼 (E-commerce Platforms)]]
+
+## 📌 Brief Summary
+전자상거래 플랫폼은 제품 카탈로그, 재고 관리, 결제 시스템 등을 처리하기 위해 고도의 확장성과 렌더링 최적화가 요구되는 복잡한 웹 시스템입니다 [1-3]. 검색 엔진 최적화(SEO)와 빠른 페이지 로딩 속도, 그리고 장바구니와 같은 동적 상호작용 간의 균형을 맞추는 것이 핵심 목표입니다 [1, 4, 5]. 이를 달성하기 위해 현대의 전자상거래 플랫폼은 SSR, ISR, SSG와 같은 다양한 렌더링 전략과 컴포넌트 기반 아키텍처(CBA)를 적극적으로 활용합니다 [6-8].
+
+## 📖 Core Content
+* **전자상거래를 위한 최적의 렌더링 전략:**
+  * **서버 사이드 렌더링 (SSR):** 제품 목록 페이지, 카테고리 탐색 및 개별 제품 상세 뷰에 이상적입니다. 강력한 검색 엔진 가시성(SEO)을 보장하고 클라이언트 측의 처리 지연 없이 제품의 가격과 재고 등을 즉각적으로 렌더링하여 사용자 경험과 전환율을 향상시킵니다 [1].
+  * **점진적 정적 재생성 (ISR):** 빠른 제품 페이지 로딩 속도를 제공하면서도 전체 사이트를 다시 빌드할 필요 없이 재고 정보 및 가격을 최신 상태로 유지할 수 있어 대규모 전자상거래 플랫폼에 완벽한 균형을 제공합니다 [4, 6, 7]. 
+  * **정적 사이트 생성 (SSG):** 실시간 재고 변경보다는 예약된 빌드 프로세스를 통해 제품 정보가 주로 업데이트되는 안정적인 제품 카탈로그 페이지에 유리합니다 [9, 10].
+  * **클라이언트 사이드 렌더링 (CSR):** 소셜 미디어나 전자상거래 웹사이트처럼 고도의 상호 작용이 필요한 애플리케이션에 부분적으로 사용됩니다 [5].
+
+* **전자상거래에서의 컴포넌트 기반 아키텍처 (CBA) 활용:**
+  * 전자상거래 플랫폼은 제품 목록, 결제 게이트웨이, 장바구니, 고객 리뷰 모듈과 같은 개별 기능을 독립적인 컴포넌트로 구축하여 아키텍처의 모듈화와 재사용성을 극대화합니다 [2, 3].
+  * 트래픽 급증 시 전체 애플리케이션이 아닌 쇼핑 카트 컴포넌트와 같은 특정 인스턴스만 추가하여 원활한 운영을 유지하는 등 뛰어난 확장성을 제공합니다 [8].
+  * 마케팅 캠페인이나 시즌별 프로모션에 맞춰 기본 비즈니스 기능을 손상시키지 않고 다양한 테마를 적용하여 사이트의 디자인을 신속하게 변경할 수 있습니다 [11].
+
+## 🔗 Knowledge Connections
+- **Related Topics:** [[Server-Side Rendering (SSR)]], [[Incremental Static Regeneration (ISR)]], [[Component-Based Architecture (CBA)]]
+- **Projects/Contexts:** [[제품 카탈로그 및 장바구니 시스템 (Product Catalogs and Shopping Carts)]]
+- **Contradictions/Notes:** 소스 [5]에서는 높은 수준의 상호작용이 필요한 전자상거래 웹사이트에 CSR이 흔히 사용된다고 언급합니다. 하지만 다른 소스들은 검색 엔진 최적화(SEO)와 최신 데이터 제공의 중요성 때문에 제품 탐색 및 세부 페이지에는 SSR 또는 ISR을 사용하는 것이 훨씬 이상적이고 필수적이라고 강조합니다 [1, 4, 7].
+
+---
+*Last updated: 2026-04-25*
\ No newline at end of file
diff --git a/10_Wiki/Topics_GD/Balancing/2026-04-25-Skybound_Vampire_Survivors_Loop_and_Stage_Curve_Preparation.md b/10_Wiki/Topics_GD/Balancing/2026-04-25-Skybound_Vampire_Survivors_Loop_and_Stage_Curve_Preparation.md
new file mode 100644
index 00000000..04f297a2
--- /dev/null
+++ b/10_Wiki/Topics_GD/Balancing/2026-04-25-Skybound_Vampire_Survivors_Loop_and_Stage_Curve_Preparation.md
@@ -0,0 +1,116 @@
+# Skybound Vampire Survivors Loop and Stage Curve Preparation
+
+작성일: 2026-04-25 23:52 KST
+
+## 요청 요약
+
+- Skybound가 뱀파이어 서바이벌 계열 게임처럼 느껴지도록 재미 요소와 스테이지별 레벨 구조를 준비한다.
+- 단순히 적을 많이 내보내는 것이 아니라, 성장 선택, 밀도 상승, 진화 완성, 보스 체크포인트가 자연스럽게 이어지도록 만든다.
+
+## 핵심 방향
+
+Skybound는 탑다운 생존 슈터이지만, 기존 구조는 스테이지 시간이 짧고 보스 진입이 빨라 빌드가 완성되기 전에 전투가 끊기는 문제가 있었다. 뱀서류 재미를 만들려면 다음 루프가 안정적으로 반복되어야 한다.
+
+1. 초반: 첫 무기 선택 후 약한 적을 많이 처치하며 빠르게 1-2회 성장한다.
+2. 중반: 적 밀도와 엘리트 압박이 올라가며 광역/관통/방어 선택의 의미가 생긴다.
+3. 후반: 스웜과 미니보스가 들어오며 빌드 조합과 진화 무기가 필요해진다.
+4. 보스: 완성된 빌드가 제대로 작동하는지 검증한다.
+5. 다음 스테이지: 같은 빌드를 이어가되 적 밀도, 패턴, 보스 기믹이 상승한다.
+
+## 적용한 변경
+
+### 8스테이지 Survivor 프로필 추가
+
+`CombatTimeline.ts`에 `SURVIVOR_STAGE_PROFILES`를 추가했다. 각 스테이지는 아래 정보를 가진다.
+
+- 스테이지 이름
+- 스테이지 길이
+- 기본 난이도 배율
+- 동시 적 수 기준
+- 스폰 템포
+- 오프닝 웨이브
+- 압박 엘리트 웨이브
+- 스웜 웨이브
+- 클라이맥스 엘리트 웨이브
+- 미니보스 체크포인트
+
+### 스테이지별 구조
+
+- Stage 1 `First Contact`: 첫 무기와 기본 생존 학습
+- Stage 2 `Fast Lanes`: 빠른 적과 이동 압박
+- Stage 3 `Ruined Circuit`: 혼합 편대와 엘리트 압박
+- Stage 4 `Crossfire Grid`: 길막/라인 클리어 압박
+- Stage 5 `Magma Forge`: 고밀도 스웜 시작
+- Stage 6 `Storm Foundry`: 빌드 완성 요구
+- Stage 7 `Arcane Collapse`: 진화 무기 권장
+- Stage 8 `Final Singularity`: 완성 빌드 검증
+
+### 스테이지 시간 조정
+
+기존 Standard 스테이지는 약 165초부터 시작해 빌드업 시간이 부족했다. 새 구조에서는 Stage 1이 240초, Stage 8이 420초까지 증가한다.
+
+이렇게 하면 플레이어는 한 스테이지 안에서 다음 리듬을 경험할 수 있다.
+
+- 0-25%: 세팅과 첫 성장
+- 25-48%: 엘리트 압박
+- 48-72%: 스웜 압박
+- 72%-보스 전: 클라이맥스와 미니보스
+- 마지막 35초 전후: 보스전 진입
+
+### 스폰 밀도 조정
+
+- 적 하드캡을 56에서 76으로 올렸다.
+- 스웜 배치 단위를 6에서 8로 올렸다.
+- 기본 절차 스폰 간격을 96프레임에서 84프레임으로 줄였다.
+
+목표는 “가만히 있어도 클리어”가 아니라, 점점 밀려오는 압박을 움직임과 빌드 선택으로 해결하게 만드는 것이다.
+
+### Tac EXP 커브 조정
+
+바닥 EXP 젬을 다시 뿌리지는 않고, 처치 즉시 Tac EXP를 지급하는 현재 방향을 유지했다. 다만 뱀서류 성장 리듬을 만들기 위해 처치 경험치를 조정했다.
+
+- 일반 적: `+2 TAC`
+- 엘리트 적: `+10 TAC`
+- 미드보스: `+30 TAC`
+
+초기 요구 EXP는 `90`에서 `80`으로 낮췄다. 대신 레벨업 후 초과 EXP carryover는 25%만 유지해 연속 레벨업 폭주는 막는다.
+
+레벨 요구량 배율은 아래처럼 조정했다.
+
+- Level 1-4: `x1.34`
+- Level 5-8: `x1.42`
+- Level 9-14: `x1.52`
+- Level 15+: `x1.62`
+
+## 설계 의도
+
+이번 변경은 “Vampire Survivors의 재미”를 다음 요소로 해석했다.
+
+- 적은 점점 많아진다.
+- 플레이어는 더 자주 선택하고 강해진다.
+- 선택에는 빌드 방향성이 있다.
+- 중반 이후에는 광역, 관통, 방어, 기동 중 최소 하나가 부족하면 압박을 느낀다.
+- 보스는 단절된 엔딩이 아니라 빌드 검증 구간이다.
+- 다음 스테이지는 새 게임이 아니라 이전 빌드의 확장 시험이다.
+
+## 수정 파일
+
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/config/CombatTimeline.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/SpawnerSystem.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/CombatSystem.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/ProgressionSystem.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/types.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/store/useGameStore.ts`
+
+## 검증
+
+- `npm run build` 성공
+- Vite 경고: `/sprites/player.png referenced in /sprites/player.png didn't resolve at build time`
+- 위 경고는 기존 런타임 경로 경고이며 이번 변경으로 인한 빌드 실패는 아니다.
+
+## 후속 작업 제안
+
+- 각 스테이지별 고유 몬스터 역할 비중을 더 명확히 분리한다.
+- 스테이지별 보스 패턴을 현재보다 더 강하게 차별화한다.
+- 진화 무기별 화면 가독성과 성능을 플레이테스트로 검증한다.
+- 미니보스 처치 시 보물상자/카드 선택 보상을 확정 지급하는 구조를 추가하면 뱀서류 보상감이 더 강해진다.
diff --git a/10_Wiki/Topics_GD/Balancing/2026-04-26-Skybound_Miniboss_Treasure_Cache_Reward_Loop.md b/10_Wiki/Topics_GD/Balancing/2026-04-26-Skybound_Miniboss_Treasure_Cache_Reward_Loop.md
new file mode 100644
index 00000000..0bc19fac
--- /dev/null
+++ b/10_Wiki/Topics_GD/Balancing/2026-04-26-Skybound_Miniboss_Treasure_Cache_Reward_Loop.md
@@ -0,0 +1,109 @@
+# Skybound Miniboss Treasure Cache Reward Loop
+
+작성일: 2026-04-26 09:32 KST
+
+## 요청 요약
+
+- 뱀파이어 서바이벌 계열의 재미를 더 강하게 만들기 위한 다음 단계로, 미니보스 처치 보상 루프를 추가한다.
+- 단순 EXP 성장만 반복되는 구조가 아니라, 중간 강적을 잡았을 때 빌드 방향을 강화하는 확정 보상을 제공한다.
+- 보상은 기존 Tac Level Up 화면을 재사용하되, 보물상자 성격의 `Emergency Supply` 카드 선택으로 연결한다.
+
+## 핵심 방향
+
+Skybound의 현재 전투 루프는 적을 처치하면 Tac EXP를 바로 얻고, 일정 EXP에 도달하면 업그레이드를 선택하는 구조다. 이 방식은 화면 가독성에는 좋지만, 플레이 중간에 “강적을 잡아서 특별한 보상을 얻었다”는 뱀서류 특유의 보상감이 부족했다.
+
+이번 변경의 목표는 미니보스를 다음 역할로 재정의하는 것이다.
+
+1. 전투 흐름 중간의 압박 체크포인트
+2. 플레이어 빌드가 충분히 강한지 확인하는 작은 검증 구간
+3. 처치하면 현재 빌드를 더 선명하게 만드는 확정 업그레이드 보상
+4. 보스 전 진화/EVO 경로를 완성할 기회를 주는 중간 보물상자
+
+## 적용한 변경
+
+### 미니보스 식별 플래그 추가
+
+기존 `MINI_BOSS` 스폰은 내부적으로 `ELITE` 적을 생성했기 때문에, 처치 시 일반 엘리트와 구분되는 보상 처리가 어려웠다. `SystemEnemy`에 아래 플래그를 추가했다.
+
+- `isMiniBoss`
+- `rewardClaimed`
+
+`SpawnerSystem`의 `MINI_BOSS` 스폰에서는 이제 `isMiniBoss: true`를 부여한다.
+
+### 미니보스 HP 스케일링
+
+미니보스가 후반 스테이지에서도 너무 빨리 녹지 않도록 스테이지와 난이도 배율을 반영했다.
+
+- 기본 HP: `620`
+- 스테이지당 증가: `+22%`
+- 현재 `difficultyMult` 반영
+
+의도는 미니보스가 보스만큼 길지는 않지만, 플레이어가 위치와 공격 방향을 신경 써야 하는 짧은 전투 목표가 되게 하는 것이다.
+
+### 처치 보상 인텐트 추가
+
+`EngineProtocol`에 `MINIBOSS_REWARD` 인텐트를 추가했다. `CombatSystem`은 미니보스 처치 시 직접 UI를 열지 않고, 엔진 인텐트를 통해 보상 처리를 요청한다.
+
+이렇게 한 이유는 다음과 같다.
+
+- 전투 시스템이 UI 상태를 직접 제어하지 않게 한다.
+- 기존 `LEVEL_UP` 이벤트와 `LevelUpModal` 흐름을 재사용한다.
+- 추후 보물상자 연출, 룰렛, 보상 티어를 추가하기 쉽다.
+
+### 빌드 우선 보상 카드 생성
+
+`ProgressionSystem`에 `generateMiniBossRewardCards`를 추가했다. 이 보상은 일반 레벨업 카드보다 더 전략적으로 구성된다.
+
+우선순위는 다음과 같다.
+
+1. 이미 보유한 무기/스킬의 레벨업
+2. Lv.3 이상 무기의 EVO에 필요한 서포트 패시브
+3. 스웜/압박 구간 대응용 `isSpikeCounter` 스킬
+4. 부족한 자리는 기존 3카드 생성 규칙으로 보충
+
+이 구조는 플레이어가 아무 카드나 고르는 것이 아니라, “내 빌드를 완성해가는 선택”을 하도록 유도한다.
+
+### 보상 UI 연결
+
+미니보스 처치 시 아래 흐름으로 동작한다.
+
+1. 미니보스 사망
+2. `CombatSystem`이 `MINIBOSS_REWARD` 인텐트 발행
+3. `useGameEngine`이 현재 스킬 상태를 기반으로 보상 카드 생성
+4. 게임 일시정지
+5. `LEVEL_UP` 이벤트를 `isChest: true`로 발행
+6. 기존 `Emergency Supply` 카드 선택 UI 표시
+7. `COMMAND CACHE UNLOCKED` 피드백 텍스트 출력
+
+## 설계 의도
+
+이 변경은 Skybound의 목적성을 더 명확하게 만들기 위한 작업이다.
+
+- 일반 적 처치: Tac EXP를 쌓는 기본 성장
+- 엘리트 처치: 더 많은 EXP와 재료/장비 가능성
+- 미니보스 처치: 확정 빌드 강화 선택
+- 스테이지 보스 처치: 다음 스테이지 진행과 영구 보상
+
+즉, 전투 중 목표가 “그냥 버티기”에서 “위험한 타이밍을 넘기고 빌드를 완성하기”로 바뀐다.
+
+## 수정 파일
+
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/hooks/useGameEngine.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/CombatSystem.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/EngineProtocol.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/ProgressionSystem.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/SpawnerSystem.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/types.ts`
+
+## 검증
+
+- `npm run build` 성공
+- Vite 경고: `/sprites/player.png referenced in /sprites/player.png didn't resolve at build time`
+- 위 경고는 기존 런타임 경로 경고이며 이번 변경으로 인한 빌드 실패는 아니다.
+
+## 후속 작업 제안
+
+- 미니보스 처치 순간에 실제 상자/코어가 열리는 0.6초 전용 연출을 추가한다.
+- 보상 카드에 `EVO READY`, `BUILD CORE`, `SURVIVAL PICK` 같은 태그를 붙여 선택 이유를 더 명확하게 보여준다.
+- 스테이지별 미니보스 외형과 탄막 패턴을 분리해 “이번 스테이지의 중간 위협” 정체성을 강화한다.
+- 보물상자 보상을 1장 선택에서 3장 순차 오픈 또는 희귀도 보상으로 확장할지 플레이테스트 후 결정한다.
diff --git a/10_Wiki/Topics_GD/Balancing/2026-04-26-Skybound_Reward_Card_Clarity_and_Command_Cache_UI.md b/10_Wiki/Topics_GD/Balancing/2026-04-26-Skybound_Reward_Card_Clarity_and_Command_Cache_UI.md
new file mode 100644
index 00000000..38aedfa3
--- /dev/null
+++ b/10_Wiki/Topics_GD/Balancing/2026-04-26-Skybound_Reward_Card_Clarity_and_Command_Cache_UI.md
@@ -0,0 +1,104 @@
+# Skybound Reward Card Clarity and Command Cache UI
+
+작성일: 2026-04-26 09:40 KST
+
+## 요청 요약
+
+- 미니보스 보상 루프 다음 단계로, 보상 카드가 왜 좋은 선택인지 사용자가 즉시 이해할 수 있게 개선한다.
+- 미니보스 처치 보상과 위기 보급 보상을 같은 화면처럼 보이지 않게 구분한다.
+- Stylized Casual Magitech 톤앤매너 안에서 보상감 있는 카드 선택 UI를 강화한다.
+
+## 핵심 방향
+
+이전 단계에서 미니보스 처치 시 확정 업그레이드 선택 보상이 추가되었다. 하지만 카드 3장이 뜨는 것만으로는 사용자가 “왜 이 보상이 지금 내 빌드에 좋은지” 바로 이해하기 어렵다.
+
+이번 변경의 목표는 보상 화면을 단순 선택지가 아니라, 플레이어에게 다음 메시지를 전달하는 UI로 만드는 것이다.
+
+1. 이 카드는 현재 주력 빌드를 강화한다.
+2. 이 카드는 EVO 진화 경로에 필요하다.
+3. 이 카드는 스웜/압박 상황에서 생존에 도움이 된다.
+4. 이 카드는 새로운 공격 패턴을 열어준다.
+
+## 적용한 변경
+
+### 보상 출처 타입 추가
+
+`LEVEL_UP` 이벤트에 `rewardSource`를 추가했다.
+
+- `STARTER`
+- `LEVEL_UP`
+- `POWER_SPIKE`
+- `MINIBOSS`
+
+기존에는 `isChest`만 있어서 미니보스 보상과 위기 보급 보상이 모두 같은 `Emergency Supply`처럼 보였다. 이제 보상 출처에 따라 헤더, 문구, 카드 태그를 다르게 표시할 수 있다.
+
+### 미니보스 보상 헤더 차별화
+
+미니보스 보상은 이제 `Emergency Supply`가 아니라 `Command Cache`로 표시된다.
+
+- Badge: `Cache`
+- Title: `Command Cache`
+- Subtitle: `Choose one build-defining reward`
+
+위기 보급은 기존 의도대로 `Emergency Supply`를 유지한다.
+
+### 카드 선택 이유 태그 추가
+
+각 카드 상단에 보상 이유 태그를 추가했다.
+
+- `FIRST CORE`: 첫 무기 선택, 런의 시작 방향 결정
+- `CORE UPGRADE`: 현재 주력 무기 강화
+- `MODULE BOOST`: 보유 패시브/모듈 강화
+- `EVO LINK`: 현재 무기의 진화 조건을 지원
+- `EVO READY`: 진화 조건 완성
+- `SURVIVAL PICK`: 스웜/압박 구간 대응
+- `NEW WEAPON`: 새로운 공격 패턴 개방
+- `UTILITY MOD`: 기본 성능 강화
+
+이 태그는 단순 라벨이 아니라, 카드가 “왜 지금 의미 있는 선택인지”를 설명하는 짧은 문장과 함께 표시된다.
+
+### Command Cache 연출 추가
+
+보상 화면 상단에 작은 마법공학 캐시 코어를 추가했다.
+
+- 팝 인 애니메이션
+- 회전하는 점선 링
+- 미니보스 캐시는 청록/라임 계열 빛
+- 일반 보급은 오렌지/시안 계열 빛
+
+실제 게임 시간을 더 지연시키지는 않지만, 화면이 뜨는 순간 보상 상자가 열린다는 감각을 강화한다.
+
+## 설계 의도
+
+뱀파이어 서바이벌 계열의 재미는 단순히 레벨업을 많이 하는 것이 아니라, “내가 고른 선택 때문에 빌드가 강해지고 있다”는 확신에서 나온다.
+
+이번 변경은 그 확신을 UI로 보강한다.
+
+- 미니보스 처치: `Command Cache`
+- 위기 보급: `Emergency Supply`
+- 일반 레벨업: `Tactical Upgrade`
+- 시작 선택: `Choose First Weapon`
+
+이제 각 성장 이벤트는 같은 카드 선택이라도 서로 다른 의미를 가진다.
+
+## 수정 파일
+
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/hooks/useGameEngine.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/ProgressionSystem.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/systems/types.ts`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/ui/GameSceneRenderer.tsx`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/ui/LevelUpModal.tsx`
+- `/Volumes/Data/project/Antigravity/Skybound/src/features/game/ui/LevelUpModal.css`
+
+## 검증
+
+- `npm run build` 성공
+- Vite 경고: `/sprites/player.png referenced in /sprites/player.png didn't resolve at build time`
+- 위 경고는 기존 런타임 경로 경고이며 이번 변경으로 인한 빌드 실패는 아니다.
+
+## 후속 작업 제안
+
+- 스테이지별 미니보스 패턴을 분리해 `Command Cache`를 얻는 과정 자체를 더 재미있게 만든다.
+- 보상 카드에 실제 EVO 결과 미리보기 아이콘을 추가한다.
+- 보물상자 보상을 1장 선택에서 희귀도 기반 다중 보상으로 확장할지 플레이테스트한다.
+- Command Cache가 열리는 짧은 0.5초 전용 컷인/상자 오픈 애니메이션을 Canvas 위에 추가한다.