From 87e27e27d73bd4633c66ef14e0b1009fb1369cbd Mon Sep 17 00:00:00 2001
From: ikae <ikaesujeel@gmail.com>
Date: Tue, 1 Sep 2026 20:45:01 +0900
Subject: [PATCH 1/6] =?UTF-8?q?feat:=20=EB=8C=93=EA=B8=80=20=EC=82=AD?=
 =?UTF-8?q?=EC=A0=9C(Soft=20Delete)=EA=B8=B0=EB=8A=A5=20=EA=B0=9C=EB=B0=9C?=
 =?UTF-8?q?=20=EB=B0=8F=20=EB=8B=A8=EC=9C=84/=ED=86=B5=ED=95=A9=20?=
 =?UTF-8?q?=ED=85=8C=EC=8A=A4=ED=8A=B8=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../comment/service/CommentService.java       |  30 +-
 .../comment/service/CommentDeleteTest.java    | 325 ++++++++++++++++++
 docs/project/work.md                          |  61 ++++
 3 files changed, 395 insertions(+), 21 deletions(-)
 create mode 100644 backend/src/test/java/com/ikae/snowthing/domain/comment/service/CommentDeleteTest.java

diff --git a/backend/src/main/java/com/ikae/snowthing/domain/comment/service/CommentService.java b/backend/src/main/java/com/ikae/snowthing/domain/comment/service/CommentService.java
index 58c1c24..20ca1a3 100644
--- a/backend/src/main/java/com/ikae/snowthing/domain/comment/service/CommentService.java
+++ b/backend/src/main/java/com/ikae/snowthing/domain/comment/service/CommentService.java
@@ -240,31 +240,19 @@ private void validateDeletePermission(
             return;
         }
 
-        if (comment.isAnonymous()) {
-            if (userDetails != null
-                    && comment.getMember() != null
-                    && comment.getMember().getPublicId().equals(userDetails.getPublicId())) {
-                return;
-            }
-
-            if (anonymousPassword == null
-                    || !passwordEncoder.matches(
-                            anonymousPassword, comment.getAnonymousPassword())) {
-                throw new CustomAuthException(ErrorCode.INVALID_ANON_PASSWORD);
+        if (comment.getMember() != null) {
+            boolean isWriter =
+                    userDetails != null
+                            && comment.getMember().getPublicId().equals(userDetails.getPublicId());
+            if (!isWriter) {
+                throw new CustomAuthException(ErrorCode.ACCESS_DENIED);
             }
             return;
         }
 
-        if (userDetails == null) {
-            throw new CustomAuthException(ErrorCode.ACCESS_DENIED);
-        }
-
-        boolean isWriter =
-                comment.getMember() != null
-                        && comment.getMember().getPublicId().equals(userDetails.getPublicId());
-
-        if (!isWriter) {
-            throw new CustomAuthException(ErrorCode.ACCESS_DENIED);
+        if (anonymousPassword == null
+                || !passwordEncoder.matches(anonymousPassword, comment.getAnonymousPassword())) {
+            throw new CustomAuthException(ErrorCode.INVALID_ANON_PASSWORD);
         }
     }
 }
diff --git a/backend/src/test/java/com/ikae/snowthing/domain/comment/service/CommentDeleteTest.java b/backend/src/test/java/com/ikae/snowthing/domain/comment/service/CommentDeleteTest.java
new file mode 100644
index 0000000..e750e8a
--- /dev/null
+++ b/backend/src/test/java/com/ikae/snowthing/domain/comment/service/CommentDeleteTest.java
@@ -0,0 +1,325 @@
+package com.ikae.snowthing.domain.comment.service;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import java.util.List;
+import java.util.UUID;
+
+import jakarta.persistence.EntityManager;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.test.context.DynamicPropertyRegistry;
+import org.springframework.test.context.DynamicPropertySource;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.ikae.snowthing.domain.comment.dto.CommentCreateRequest;
+import com.ikae.snowthing.domain.comment.dto.CommentResponse;
+import com.ikae.snowthing.domain.comment.entity.Comment;
+import com.ikae.snowthing.domain.comment.repository.CommentRepository;
+import com.ikae.snowthing.domain.member.entity.Member;
+import com.ikae.snowthing.domain.member.entity.MemberStatus;
+import com.ikae.snowthing.domain.member.entity.Role;
+import com.ikae.snowthing.domain.member.repository.MemberRepository;
+import com.ikae.snowthing.domain.post.dto.PostCreateRequest;
+import com.ikae.snowthing.domain.post.dto.PostResponse;
+import com.ikae.snowthing.domain.post.entity.Post;
+import com.ikae.snowthing.domain.post.entity.PostCategory;
+import com.ikae.snowthing.domain.post.repository.PostCategoryRepository;
+import com.ikae.snowthing.domain.post.repository.PostRepository;
+import com.ikae.snowthing.domain.post.service.PostService;
+import com.ikae.snowthing.global.error.ErrorCode;
+import com.ikae.snowthing.global.exception.CustomAuthException;
+import com.ikae.snowthing.global.security.CustomUserDetails;
+
+@SpringBootTest
+@Transactional
+class CommentDeleteTest {
+
+    @DynamicPropertySource
+    static void useRealMySql(DynamicPropertyRegistry registry) {
+        String testDbUrl = System.getenv("SNOWTHING_TEST_DB_URL");
+        if (testDbUrl == null || testDbUrl.isBlank()) {
+            return;
+        }
+        registry.add("spring.datasource.url", () -> testDbUrl);
+        registry.add(
+                "spring.datasource.username",
+                () -> requiredEnvironmentVariable("SNOWTHING_TEST_DB_USERNAME"));
+        registry.add(
+                "spring.datasource.password",
+                () -> requiredEnvironmentVariable("SNOWTHING_TEST_DB_PASSWORD"));
+        registry.add("spring.datasource.driver-class-name", () -> "com.mysql.cj.jdbc.Driver");
+        registry.add("spring.jpa.hibernate.ddl-auto", () -> "create-drop");
+        registry.add("spring.jpa.database-platform", () -> "org.hibernate.dialect.MySQLDialect");
+        registry.add(
+                "spring.jpa.properties.hibernate.dialect",
+                () -> "org.hibernate.dialect.MySQLDialect");
+    }
+
+    private static String requiredEnvironmentVariable(String name) {
+        String value = System.getenv(name);
+        if (value == null || value.isBlank()) {
+            throw new CustomAuthException(ErrorCode.INVALID_INPUT);
+        }
+        return value;
+    }
+
+    @Autowired private CommentService commentService;
+    @Autowired private CommentRepository commentRepository;
+    @Autowired private PostService postService;
+    @Autowired private PostRepository postRepository;
+    @Autowired private MemberRepository memberRepository;
+    @Autowired private PostCategoryRepository categoryRepository;
+    @Autowired private PasswordEncoder passwordEncoder;
+    @Autowired private EntityManager entityManager;
+
+    private CustomUserDetails writerDetails;
+    private CustomUserDetails otherDetails;
+    private CustomUserDetails adminDetails;
+    private PostResponse postResponse;
+
+    @BeforeEach
+    void setUp() {
+        String fixtureId = UUID.randomUUID().toString().substring(0, 8);
+        categoryRepository
+                .findByCode("FREE")
+                .orElseGet(() -> categoryRepository.save(new PostCategory("자유게시판", "FREE")));
+
+        Member writer =
+                memberRepository.save(
+                        new Member(
+                                null,
+                                "delete-writer-" + fixtureId + "@example.com",
+                                passwordEncoder.encode("Password123!"),
+                                "삭제작성자-" + fixtureId,
+                                null,
+                                null,
+                                null,
+                                null,
+                                null,
+                                Role.ROLE_USER,
+                                MemberStatus.ACTIVE));
+        writerDetails = new CustomUserDetails(writer);
+
+        Member other =
+                memberRepository.save(
+                        new Member(
+                                null,
+                                "delete-other-" + fixtureId + "@example.com",
+                                passwordEncoder.encode("Password123!"),
+                                "타인회원-" + fixtureId,
+                                null,
+                                null,
+                                null,
+                                null,
+                                null,
+                                Role.ROLE_USER,
+                                MemberStatus.ACTIVE));
+        otherDetails = new CustomUserDetails(other);
+
+        Member admin =
+                memberRepository.save(
+                        new Member(
+                                null,
+                                "delete-admin-" + fixtureId + "@example.com",
+                                passwordEncoder.encode("Password123!"),
+                                "최고관리자-" + fixtureId,
+                                null,
+                                null,
+                                null,
+                                null,
+                                null,
+                                Role.ROLE_ADMIN,
+                                MemberStatus.ACTIVE));
+        adminDetails = new CustomUserDetails(admin);
+
+        postResponse =
+                postService.createPost(
+                        new PostCreateRequest(
+                                "FREE", "삭제 테스트 게시글", "게시글 본문", false, null, List.of()),
+                        writerDetails,
+                        "127.0.0.1");
+    }
+
+    @Nested
+    @DisplayName("성공 케이스")
+    class SuccessCase {
+
+        @Test
+        @DisplayName("[성공 1] 일반 회원 본인 댓글 삭제 성공 (is_deleted = true, post.commentCount 1 차감 확인)")
+        void deleteOwnCommentAsMember() {
+            CommentResponse created = createMemberComment("본인 작성 댓글");
+
+            commentService.deleteComment(created.commentId(), null, writerDetails);
+
+            entityManager.flush();
+            entityManager.clear();
+            Comment deletedComment = commentRepository.findById(created.commentId()).orElseThrow();
+            assertThat(deletedComment.isDeleted()).isTrue();
+            assertThat(deletedComment.getDeletedAt()).isNotNull();
+
+            Post post = postRepository.findByPublicId(postResponse.publicId()).orElseThrow();
+            assertThat(post.getCommentCount()).isEqualTo(0);
+        }
+
+        @Test
+        @DisplayName("[성공 2] 비회원 익명 댓글 올바른 비밀번호 입력 시 삭제 성공")
+        void deleteAnonymousCommentWithCorrectPassword() {
+            CommentResponse created = createGuestAnonymousComment("익명 작성 댓글", "anonPass1234");
+
+            commentService.deleteComment(created.commentId(), "anonPass1234", null);
+
+            entityManager.flush();
+            entityManager.clear();
+            Comment deletedComment = commentRepository.findById(created.commentId()).orElseThrow();
+            assertThat(deletedComment.isDeleted()).isTrue();
+            assertThat(deletedComment.getDeletedAt()).isNotNull();
+
+            Post post = postRepository.findByPublicId(postResponse.publicId()).orElseThrow();
+            assertThat(post.getCommentCount()).isEqualTo(0);
+        }
+
+        @Test
+        @DisplayName("[성공 3] 최고 관리자(ROLE_ADMIN)가 타인/익명 댓글을 비밀번호 없이 강제 삭제 성공")
+        void deleteCommentAsAdmin() {
+            CommentResponse memberComment = createMemberComment("일반 회원 댓글");
+            CommentResponse anonComment = createGuestAnonymousComment("비회원 익명 댓글", "anonPass1234");
+
+            // 관리자는 회원 댓글을 비밀번호 없이 삭제 가능
+            commentService.deleteComment(memberComment.commentId(), null, adminDetails);
+            // 관리자는 익명 댓글도 비밀번호 없이 삭제 가능
+            commentService.deleteComment(anonComment.commentId(), null, adminDetails);
+
+            entityManager.flush();
+            entityManager.clear();
+            Comment deletedMemberComment =
+                    commentRepository.findById(memberComment.commentId()).orElseThrow();
+            Comment deletedAnonComment =
+                    commentRepository.findById(anonComment.commentId()).orElseThrow();
+
+            assertThat(deletedMemberComment.isDeleted()).isTrue();
+            assertThat(deletedAnonComment.isDeleted()).isTrue();
+
+            Post post = postRepository.findByPublicId(postResponse.publicId()).orElseThrow();
+            assertThat(post.getCommentCount()).isEqualTo(0);
+        }
+
+        @Test
+        @DisplayName("[성공 4] 대댓글이 존재하는 부모 댓글 삭제 시 부모만 is_deleted = true 처리되고 하위 대댓글 정상 보존 확인")
+        void deleteParentCommentPreservesReplies() {
+            CommentResponse parent = createMemberComment("부모 댓글");
+            CommentResponse reply1 = createReply(parent.commentId(), "대댓글 1");
+            CommentResponse reply2 = createReply(parent.commentId(), "대댓글 2");
+
+            Post postBeforeDelete =
+                    postRepository.findByPublicId(postResponse.publicId()).orElseThrow();
+            assertThat(postBeforeDelete.getCommentCount()).isEqualTo(3);
+
+            // 부모 댓글만 삭제
+            commentService.deleteComment(parent.commentId(), null, writerDetails);
+
+            entityManager.flush();
+            entityManager.clear();
+            Comment deletedParent = commentRepository.findById(parent.commentId()).orElseThrow();
+            Comment activeReply1 = commentRepository.findById(reply1.commentId()).orElseThrow();
+            Comment activeReply2 = commentRepository.findById(reply2.commentId()).orElseThrow();
+
+            assertThat(deletedParent.isDeleted()).isTrue();
+            assertThat(activeReply1.isDeleted()).isFalse();
+            assertThat(activeReply2.isDeleted()).isFalse();
+
+            Post postAfterDelete =
+                    postRepository.findByPublicId(postResponse.publicId()).orElseThrow();
+            assertThat(postAfterDelete.getCommentCount()).isEqualTo(2);
+        }
+    }
+
+    @Nested
+    @DisplayName("실패 케이스")
+    class FailureCase {
+
+        @Test
+        @DisplayName("[실패 1] 로그인 회원이 타인의 댓글 삭제 시도 시 AUTH_002 (403 Forbidden) 검증")
+        void rejectDeleteByOtherMember() {
+            CommentResponse created = createMemberComment("타인이 삭제할 원본 댓글");
+
+            assertThatThrownBy(
+                            () ->
+                                    commentService.deleteComment(
+                                            created.commentId(), null, otherDetails))
+                    .isInstanceOf(CustomAuthException.class)
+                    .extracting("errorCode")
+                    .isEqualTo(ErrorCode.ACCESS_DENIED);
+        }
+
+        @Test
+        @DisplayName("[실패 2] 비회원 익명 댓글에 틀린 비밀번호 입력 시 POST_004 (403 Forbidden) 검증")
+        void rejectDeleteWithWrongPassword() {
+            CommentResponse created = createGuestAnonymousComment("익명 댓글", "correctPass1234");
+
+            assertThatThrownBy(
+                            () ->
+                                    commentService.deleteComment(
+                                            created.commentId(), "wrongPass9999", null))
+                    .isInstanceOf(CustomAuthException.class)
+                    .extracting("errorCode")
+                    .isEqualTo(ErrorCode.INVALID_ANON_PASSWORD);
+        }
+
+        @Test
+        @DisplayName("[실패 3] 이미 Soft Delete된 댓글 재삭제 시도 시 COMMENT_001 (404 Not Found) 검증")
+        void rejectDeleteOnAlreadyDeletedComment() {
+            CommentResponse created = createMemberComment("이미 삭제될 댓글");
+            commentService.deleteComment(created.commentId(), null, writerDetails);
+
+            assertThatThrownBy(
+                            () ->
+                                    commentService.deleteComment(
+                                            created.commentId(), null, writerDetails))
+                    .isInstanceOf(CustomAuthException.class)
+                    .extracting("errorCode")
+                    .isEqualTo(ErrorCode.COMMENT_NOT_FOUND);
+        }
+
+        @Test
+        @DisplayName("[실패 4] 존재하지 않는 댓글 ID 삭제 시도 시 COMMENT_001 (404 Not Found) 검증")
+        void rejectDeleteOnNonExistentComment() {
+            assertThatThrownBy(
+                            () -> commentService.deleteComment(Long.MAX_VALUE, null, writerDetails))
+                    .isInstanceOf(CustomAuthException.class)
+                    .extracting("errorCode")
+                    .isEqualTo(ErrorCode.COMMENT_NOT_FOUND);
+        }
+    }
+
+    private CommentResponse createMemberComment(String content) {
+        return commentService.createComment(
+                postResponse.publicId(),
+                new CommentCreateRequest(null, content, false, null),
+                writerDetails,
+                "127.0.0.1");
+    }
+
+    private CommentResponse createGuestAnonymousComment(String content, String password) {
+        return commentService.createComment(
+                postResponse.publicId(),
+                new CommentCreateRequest(null, content, true, password),
+                null,
+                "127.0.0.1");
+    }
+
+    private CommentResponse createReply(Long parentId, String content) {
+        return commentService.createComment(
+                postResponse.publicId(),
+                new CommentCreateRequest(parentId, content, false, null),
+                writerDetails,
+                "127.0.0.1");
+    }
+}
diff --git a/docs/project/work.md b/docs/project/work.md
index c481049..111100f 100644
--- a/docs/project/work.md
+++ b/docs/project/work.md
@@ -1,3 +1,29 @@
+- **Sprint 03 댓글 삭제(DELETE /api/v1/comments/{commentId}) 및 4대 권한 매트릭스 전담 개발 완결 (2026-09-01)**:
+  1. **작업명**: 댓글 삭제(Soft Delete & 권한 매트릭스) 기능 보강 및 단위/통합 테스트
+  2. **현재 상태**: 완료
+  3. **완료된 항목**:
+     - `CommentService.java` 내 `validateDeletePermission` 권한 매트릭스 리팩토링:
+       * 1) 최고 관리자(`ROLE_ADMIN`): 비밀번호 없이 즉시 삭제 권한 통과
+       * 2) 일반 회원 및 로그인 익명(`comment.getMember() != null`): 본인 세션(`publicId`) 일치 시 통과, 타인 접근 시 `AUTH_002` (403 Forbidden) 반환
+       * 3) 비회원 익명(`comment.getMember() == null`): 비밀번호 불일치/누락 시 `POST_004` (403 Forbidden) 반환, 일치 시 통과
+     - Soft Delete 및 활성 댓글 수 원자적 차감 유지: `comment.softDelete()`, `postRepository.decreaseCommentCount(...)`
+     - `CommentDeleteTest.java` 단위/통합 테스트 8건 신설 (성공 4건 + 실패 4건).
+  4. **남은 항목**: 없음 (Delete 전담 완료)
+  5. **발견된 이슈 및 해결**:
+     - 기존 `validateDeletePermission`에서 로그인 회원이 작성한 익명 댓글(`isAnonymous = true, member != null`)을 타인이 삭제 시도 시 비밀번호 검사로 넘어가 `POST_004`가 발생하던 결함 발견.
+     - `comment.getMember() != null` 조건으로 통합하여 로그인 익명 글도 본인 세션이 아니면 정확히 `AUTH_002`가 발생하도록 인가 로직 일원화 완료.
+  6. **검증 결과**:
+     - `spotlessApply` 서식 포맷팅 완료.
+     - `gradle test --tests "*CommentDeleteTest*"` 총 8개 테스트 케이스 100% PASS (BUILD SUCCESSFUL in 16s).
+       - [성공 1] 일반 회원 본인 댓글 삭제 성공 (`is_deleted = true`, `post.commentCount` 1 차감 확인)
+       - [성공 2] 비회원 익명 댓글 올바른 비밀번호 입력 시 삭제 성공
+       - [성공 3] 최고 관리자(`ROLE_ADMIN`)가 타인/익명 댓글을 비밀번호 없이 강제 삭제 성공
+       - [성공 4] 대댓글이 존재하는 부모 댓글 삭제 시 부모만 `is_deleted = true` 처리되고 하위 대댓글 정상 보존 확인
+       - [실패 1] 로그인 회원이 타인의 댓글 삭제 시도 시 `AUTH_002` (403 Forbidden) 검증
+       - [실패 2] 비회원 익명 댓글에 틀린 비밀번호 입력 시 `POST_004` (403 Forbidden) 검증
+       - [실패 3] 이미 Soft Delete된 댓글 재삭제 시도 시 `COMMENT_001` (404 Not Found) 검증
+       - [실패 4] 존재하지 않는 댓글 ID 삭제 시도 시 `COMMENT_001` (404 Not Found) 검증
+
 - **Sprint 03 댓글 도메인 공식 API 명세서(comment_api_spec.md) 작성 (2026-09-01)**:
   1. **5대 CRUD 엔드포인트 계약 명세화**: `docs/conception/sprint03/comment_api_spec.md`에 댓글 작성(`POST`), 루트 댓글 Batch+Top-5 프리뷰 조회(`GET`), 대댓글 분리 페이징 조회(`GET`), 댓글 수정(`PUT`), Soft Delete 삭제(`DELETE`)의 Request/Response DTO, Header, 에러 코드 매핑을 100% 명세화.
 
@@ -727,3 +753,38 @@
   6. 댓글·대댓글 응답 병합 시 `commentId` 중복을 방어하고, 삭제된 루트 placeholder 아래의 대댓글과 답글 작성 기능은 유지.
   7. 검증 결과: 변경 파일 대상 ESLint 오류 0건(기존 `<img>` 최적화 경고 1건), `npm run build` 및 TypeScript 검사 통과.
   8. 확인 이슈: 전체 `npm run lint`는 이번 변경과 무관한 기존 `ToastEditor.tsx`, `ToastViewer.tsx`, 게시글 작성·목록 페이지의 오류 6건 때문에 실패. 브라우저 수동 검증은 백엔드와 테스트 데이터가 실행된 환경에서 추가 확인 필요.
+
+## Sprint 03 댓글 수정·삭제 프론트엔드 UI
+
+- 상태: DONE
+- 시작일: 2026-09-01
+
+### 계획
+- 댓글과 대댓글에 한 번에 하나만 열리는 인라인 수정 폼을 적용한다.
+- 일반 회원은 `writer.publicId`가 현재 사용자와 같은 댓글에만 수정·삭제 버튼을 노출한다.
+- 익명 댓글은 현재 DTO에 소유권 필드가 없어 버튼을 노출한 뒤 세션 또는 비밀번호를 서버에서 최종 검증하는 방안 A를 적용한다.
+- 댓글 삭제의 `prompt`/`confirm`을 제거하고 기존 `DeleteConfirmModal`을 재사용한다.
+- 변경 파일 대상 ESLint와 `npm run build`로 검증한다.
+
+### 완료
+- 구현 전 설계 문서, 프론트엔드 스킬, 현재 댓글 UI와 공용 삭제 모달 대조 완료.
+- 루트 댓글과 대댓글에 공통 인라인 수정 폼을 적용하고 공백, 1,000자 제한, 변경 없음, 익명 비밀번호를 검증하도록 구현.
+- 수정 성공 시 전체 목록 재조회 없이 해당 `commentId`의 본문만 불변 업데이트하도록 구현.
+- 댓글 삭제의 브라우저 `prompt`/`confirm`을 제거하고 게시글 삭제와 분리된 `DeleteConfirmModal` 인스턴스로 연결.
+- 공용 모달에 동적 확인 문구, 제출 중 닫기 방지, dialog ARIA 속성, 입력 label 연결을 추가.
+- 삭제 성공 후 댓글 목록을 재조회하고 게시글의 `commentCount`를 1 차감하도록 구현.
+
+### 남은 작업
+- 백엔드 PUT 구현 완료 후 실제 수정·권한 실패 응답을 브라우저에서 통합 검증.
+- 모달의 완전한 focus trap과 Escape 닫기 동작은 후속 접근성 개선 대상으로 남김.
+
+### 이슈
+- 현재 프론트가 참조하는 백엔드 브랜치에는 PUT 엔드포인트가 아직 없으며 백엔드에서 병행 구현 중이다.
+- 익명 댓글 응답에 `canEdit`, `canDelete`, `requiresPassword`가 없어 버튼 노출 권한은 완전히 판별할 수 없다.
+
+### 결정 필요
+- 방안 A 적용을 사용자 승인받음. 서버를 최종 권한 검증 주체로 사용한다.
+
+### 검증
+- 변경 파일 대상 ESLint 오류 0건. 기존 게시글 이미지 `<img>` 최적화 경고 1건만 확인.
+- `npm run build` 성공 및 TypeScript 오류 0건 확인.

From 3992f72a76527dee6ecef86526f59b23edce36cb Mon Sep 17 00:00:00 2001
From: ikae <ikaesujeel@gmail.com>
Date: Tue, 1 Sep 2026 20:49:32 +0900
Subject: [PATCH 2/6] =?UTF-8?q?feat(comment):=20=EB=8C=93=EA=B8=80=20?=
 =?UTF-8?q?=EC=82=AD=EC=A0=9C=20=EB=AA=A8=EB=8B=AC=20UI=20=EC=97=B0?=
 =?UTF-8?q?=EB=8F=99?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/project/work.md                          |  13 +--
 .../app/components/DeleteConfirmModal.tsx     |  29 +++--
 frontend/app/posts/[publicId]/page.tsx        | 101 +++++++++++-------
 3 files changed, 92 insertions(+), 51 deletions(-)

diff --git a/docs/project/work.md b/docs/project/work.md
index 111100f..de80a0f 100644
--- a/docs/project/work.md
+++ b/docs/project/work.md
@@ -754,33 +754,28 @@
   7. 검증 결과: 변경 파일 대상 ESLint 오류 0건(기존 `<img>` 최적화 경고 1건), `npm run build` 및 TypeScript 검사 통과.
   8. 확인 이슈: 전체 `npm run lint`는 이번 변경과 무관한 기존 `ToastEditor.tsx`, `ToastViewer.tsx`, 게시글 작성·목록 페이지의 오류 6건 때문에 실패. 브라우저 수동 검증은 백엔드와 테스트 데이터가 실행된 환경에서 추가 확인 필요.
 
-## Sprint 03 댓글 수정·삭제 프론트엔드 UI
+## Sprint 03 댓글 삭제 프론트엔드 UI
 
 - 상태: DONE
 - 시작일: 2026-09-01
 
 ### 계획
-- 댓글과 대댓글에 한 번에 하나만 열리는 인라인 수정 폼을 적용한다.
-- 일반 회원은 `writer.publicId`가 현재 사용자와 같은 댓글에만 수정·삭제 버튼을 노출한다.
-- 익명 댓글은 현재 DTO에 소유권 필드가 없어 버튼을 노출한 뒤 세션 또는 비밀번호를 서버에서 최종 검증하는 방안 A를 적용한다.
+- 일반 회원은 `writer.publicId`가 현재 사용자와 같은 댓글에만 삭제 버튼을 노출한다.
+- 익명 댓글은 현재 DTO에 소유권 필드가 없어 삭제 버튼을 노출한 뒤 세션 또는 비밀번호를 서버에서 최종 검증하는 방안 A를 적용한다.
 - 댓글 삭제의 `prompt`/`confirm`을 제거하고 기존 `DeleteConfirmModal`을 재사용한다.
 - 변경 파일 대상 ESLint와 `npm run build`로 검증한다.
 
 ### 완료
 - 구현 전 설계 문서, 프론트엔드 스킬, 현재 댓글 UI와 공용 삭제 모달 대조 완료.
-- 루트 댓글과 대댓글에 공통 인라인 수정 폼을 적용하고 공백, 1,000자 제한, 변경 없음, 익명 비밀번호를 검증하도록 구현.
-- 수정 성공 시 전체 목록 재조회 없이 해당 `commentId`의 본문만 불변 업데이트하도록 구현.
 - 댓글 삭제의 브라우저 `prompt`/`confirm`을 제거하고 게시글 삭제와 분리된 `DeleteConfirmModal` 인스턴스로 연결.
 - 공용 모달에 동적 확인 문구, 제출 중 닫기 방지, dialog ARIA 속성, 입력 label 연결을 추가.
 - 삭제 성공 후 댓글 목록을 재조회하고 게시글의 `commentCount`를 1 차감하도록 구현.
 
 ### 남은 작업
-- 백엔드 PUT 구현 완료 후 실제 수정·권한 실패 응답을 브라우저에서 통합 검증.
 - 모달의 완전한 focus trap과 Escape 닫기 동작은 후속 접근성 개선 대상으로 남김.
 
 ### 이슈
-- 현재 프론트가 참조하는 백엔드 브랜치에는 PUT 엔드포인트가 아직 없으며 백엔드에서 병행 구현 중이다.
-- 익명 댓글 응답에 `canEdit`, `canDelete`, `requiresPassword`가 없어 버튼 노출 권한은 완전히 판별할 수 없다.
+- 익명 댓글 응답에 `canDelete`, `requiresPassword`가 없어 버튼 노출 권한은 완전히 판별할 수 없다.
 
 ### 결정 필요
 - 방안 A 적용을 사용자 승인받음. 서버를 최종 권한 검증 주체로 사용한다.
diff --git a/frontend/app/components/DeleteConfirmModal.tsx b/frontend/app/components/DeleteConfirmModal.tsx
index 628e348..5447944 100644
--- a/frontend/app/components/DeleteConfirmModal.tsx
+++ b/frontend/app/components/DeleteConfirmModal.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import { useState } from "react";
+import { useId, useState } from "react";
 
 interface DeleteConfirmModalProps {
   isOpen: boolean;
@@ -9,6 +9,8 @@ interface DeleteConfirmModalProps {
   title?: string;
   description?: string;
   requirePassword?: boolean;
+  confirmLabel?: string;
+  submittingLabel?: string;
 }
 
 export function DeleteConfirmModal({
@@ -18,7 +20,11 @@ export function DeleteConfirmModal({
   title = "게시글 삭제 확인",
   description = "이 게시글을 삭제하시겠습니까?",
   requirePassword = true,
+  confirmLabel = "삭제",
+  submittingLabel = "삭제 중...",
 }: DeleteConfirmModalProps) {
+  const titleId = useId();
+  const passwordId = useId();
   const [password, setPassword] = useState("");
   const [errorMsg, setErrorMsg] = useState("");
   const [submitting, setSubmitting] = useState(false);
@@ -49,6 +55,7 @@ export function DeleteConfirmModal({
   };
 
   const handleClose = () => {
+    if (submitting) return;
     setPassword("");
     setErrorMsg("");
     onClose();
@@ -56,11 +63,19 @@ export function DeleteConfirmModal({
 
   return (
     <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/60 backdrop-blur-xs p-4">
-      <div className="w-full max-w-md rounded-lg border-2 border-black bg-white p-6 shadow-[8px_8px_0px_0px_rgba(0,0,0,1)]">
+      <div
+        role="dialog"
+        aria-modal="true"
+        aria-labelledby={titleId}
+        className="w-full max-w-md rounded-lg border-2 border-black bg-white p-6 shadow-[8px_8px_0px_0px_rgba(0,0,0,1)]"
+      >
         <div className="flex items-center justify-between border-b-2 border-black pb-3">
-          <h3 className="text-xl font-extrabold italic text-black">{title}</h3>
+          <h3 id={titleId} className="text-xl font-extrabold italic text-black">{title}</h3>
           <button
+            type="button"
             onClick={handleClose}
+            disabled={submitting}
+            aria-label="삭제 확인 모달 닫기"
             className="text-gray-400 hover:text-black font-bold text-lg"
           >
             ✕
@@ -71,13 +86,14 @@ export function DeleteConfirmModal({
 
         <form onSubmit={handleSubmit} className="mt-5 grid gap-4">
           {requirePassword && (
-            <label className="grid gap-2">
+            <label htmlFor={passwordId} className="grid gap-2">
               <span className="font-mono text-xs font-bold uppercase tracking-wider text-[var(--snow-muted)]">
                 익명 비밀번호 (Password)
               </span>
               <input
+                id={passwordId}
                 type="password"
-                placeholder="작성 당시 등록한 비밀번호"
+                placeholder="●●●●"
                 value={password}
                 onChange={(e) => setPassword(e.target.value)}
                 autoFocus
@@ -96,6 +112,7 @@ export function DeleteConfirmModal({
             <button
               type="button"
               onClick={handleClose}
+              disabled={submitting}
               className="px-4 py-2 text-xs font-mono uppercase tracking-wider text-gray-500 hover:text-black"
             >
               Cancel
@@ -105,7 +122,7 @@ export function DeleteConfirmModal({
               disabled={submitting}
               className="bg-[#dc2626] text-white px-5 py-2 text-xs font-mono uppercase tracking-wider hover:bg-black transition border-2 border-black disabled:opacity-50"
             >
-              {submitting ? "Deleting..." : "Delete"}
+              {submitting ? submittingLabel : confirmLabel}
             </button>
           </div>
         </form>
diff --git a/frontend/app/posts/[publicId]/page.tsx b/frontend/app/posts/[publicId]/page.tsx
index 3fecf1a..df689d2 100644
--- a/frontend/app/posts/[publicId]/page.tsx
+++ b/frontend/app/posts/[publicId]/page.tsx
@@ -73,6 +73,11 @@ interface ReplyPagingState {
   loading: boolean;
 }
 
+interface CommentDeleteTarget {
+  commentId: number;
+  requiresPassword: boolean;
+}
+
 export default function PostDetailPage({ params }: { params: Promise<{ publicId: string }> }) {
   const router = useRouter();
   const { publicId } = use(params);
@@ -93,6 +98,7 @@ export default function PostDetailPage({ params }: { params: Promise<{ publicId:
   const [replyMentionName, setReplyMentionName] = useState<string | null>(null);
   const [replyText, setReplyText] = useState("");
   const [replyAnonPassword, setReplyAnonPassword] = useState("");
+  const [commentDeleteTarget, setCommentDeleteTarget] = useState<CommentDeleteTarget | null>(null);
   const [currentUserPublicId, setCurrentUserPublicId] = useState<string | null>(null);
   const [isAdmin, setIsAdmin] = useState(false);
   const [isDeleteModalOpen, setIsDeleteModalOpen] = useState(false);
@@ -389,35 +395,29 @@ export default function PostDetailPage({ params }: { params: Promise<{ publicId:
     }
   };
 
-  const handleDeleteComment = async (commentId: number, isAnonymousWriter: boolean) => {
-    let anonymousPassword = "";
-    if (isAnonymousWriter) {
-      const input = prompt("익명 댓글 삭제 비밀번호를 입력하세요.");
-      if (!input) return;
-      anonymousPassword = input;
-    } else if (!confirm("댓글을 삭제하시겠습니까?")) {
-      return;
-    }
+  const handleOpenCommentDeleteModal = (comment: CommentItem) => {
+    setCommentDeleteTarget({
+      commentId: comment.commentId,
+      requiresPassword: comment.isAnonymous && !currentUserPublicId,
+    });
+  };
 
-    try {
-      const res = await csrfFetch(API_ENDPOINTS.comments.delete(commentId), {
-        method: "DELETE",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          anonymousPassword: anonymousPassword || null,
-        }),
-      });
-      if (res.ok) {
-        await fetchComments();
-        setPost((current) => (current ? { ...current, commentCount: Math.max(0, current.commentCount - 1) } : current));
-        return;
-      }
+  const handleConfirmCommentDelete = async (password: string) => {
+    if (!commentDeleteTarget) return;
 
+    const res = await csrfFetch(API_ENDPOINTS.comments.delete(commentDeleteTarget.commentId), {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ anonymousPassword: password || null }),
+    });
+    if (!res.ok) {
       const errorData = await res.json();
-      alert(`삭제 실패: ${errorData.message || "요청을 처리하지 못했습니다."}`);
-    } catch {
-      alert("서버 통신 중 오류가 발생했습니다.");
+      throw new Error(errorData.message || "댓글 삭제에 실패했습니다.");
     }
+
+    setCommentDeleteTarget(null);
+    await fetchComments();
+    setPost((current) => (current ? { ...current, commentCount: Math.max(0, current.commentCount - 1) } : current));
   };
 
   if (loading) {
@@ -575,7 +575,8 @@ export default function PostDetailPage({ params }: { params: Promise<{ publicId:
                     replyAnonPassword={replyAnonPassword}
                     setReplyAnonPassword={setReplyAnonPassword}
                     handleCreateComment={handleCreateComment}
-                    handleDeleteComment={handleDeleteComment}
+                    handleOpenCommentDeleteModal={handleOpenCommentDeleteModal}
+                    isAdmin={isAdmin}
                     handleLoadMoreReplies={handleLoadMoreReplies}
                     isLoadingReplies={Boolean(replyPagingByRootId[comment.commentId]?.loading)}
                   />
@@ -605,6 +606,16 @@ export default function PostDetailPage({ params }: { params: Promise<{ publicId:
         description={deleteModalConfig.description}
         requirePassword={deleteModalConfig.requirePassword}
       />
+      <DeleteConfirmModal
+        isOpen={commentDeleteTarget !== null}
+        onClose={() => setCommentDeleteTarget(null)}
+        onConfirm={handleConfirmCommentDelete}
+        title="댓글 삭제 확인"
+        description="정말 삭제하시겠습니까?"
+        requirePassword={commentDeleteTarget?.requiresPassword ?? false}
+        confirmLabel="댓글 삭제"
+        submittingLabel="삭제 중..."
+      />
       <Footer />
     </div>
   );
@@ -623,7 +634,8 @@ function CommentRow({
   replyAnonPassword,
   setReplyAnonPassword,
   handleCreateComment,
-  handleDeleteComment,
+  handleOpenCommentDeleteModal,
+  isAdmin,
   handleLoadMoreReplies,
   isLoadingReplies,
 }: {
@@ -639,10 +651,12 @@ function CommentRow({
   replyAnonPassword: string;
   setReplyAnonPassword: (value: string) => void;
   handleCreateComment: (parentId: number | null) => Promise<void>;
-  handleDeleteComment: (commentId: number, isAnonymousWriter: boolean) => Promise<void>;
+  handleOpenCommentDeleteModal: (comment: CommentItem) => void;
+  isAdmin: boolean;
   handleLoadMoreReplies: (rootCommentId: number) => Promise<void>;
   isLoadingReplies: boolean;
 }) {
+  const canDelete = canDeleteComment(item, currentUserPublicId, isAdmin);
   const openReplyEditor = (target: CommentItem) => {
     if (activeReplyParentId === item.commentId && replyMentionName === getWriterName(target)) {
       setActiveReplyParentId(null);
@@ -666,8 +680,8 @@ function CommentRow({
           <button onClick={() => openReplyEditor(item)} className="text-black">
             {activeReplyParentId === item.commentId ? "답글 취소" : "답글 쓰기"}
           </button>
-          {!item.isDeleted && (
-            <button onClick={() => void handleDeleteComment(item.commentId, item.isAnonymous)} className="text-[var(--snow-error)]">
+          {canDelete && (
+            <button type="button" onClick={() => handleOpenCommentDeleteModal(item)} className="text-[var(--snow-error)]">
               삭제
             </button>
           )}
@@ -680,7 +694,9 @@ function CommentRow({
                 key={reply.commentId}
                 item={reply}
                 onReply={() => openReplyEditor(reply)}
-                handleDeleteComment={handleDeleteComment}
+                currentUserPublicId={currentUserPublicId}
+                isAdmin={isAdmin}
+                handleOpenCommentDeleteModal={handleOpenCommentDeleteModal}
               />
             ))}
           </div>
@@ -748,12 +764,17 @@ function CommentRow({
 function ReplyRow({
   item,
   onReply,
-  handleDeleteComment,
+  currentUserPublicId,
+  isAdmin,
+  handleOpenCommentDeleteModal,
 }: {
   item: CommentItem;
   onReply: () => void;
-  handleDeleteComment: (commentId: number, isAnonymousWriter: boolean) => Promise<void>;
+  currentUserPublicId: string | null;
+  isAdmin: boolean;
+  handleOpenCommentDeleteModal: (comment: CommentItem) => void;
 }) {
+  const canDelete = canDeleteComment(item, currentUserPublicId, isAdmin);
   return (
     <div className="ml-5 border-l-2 border-black pl-5">
       <div className="flex items-center justify-between gap-3">
@@ -768,9 +789,11 @@ function ReplyRow({
           <button type="button" onClick={onReply} className="text-black">
             답글 쓰기
           </button>
-          <button onClick={() => void handleDeleteComment(item.commentId, item.isAnonymous)} className="text-[var(--snow-error)]">
-            삭제
-          </button>
+          {canDelete && (
+            <button type="button" onClick={() => handleOpenCommentDeleteModal(item)} className="text-[var(--snow-error)]">
+              삭제
+            </button>
+          )}
         </div>
       )}
     </div>
@@ -781,3 +804,9 @@ function getWriterName(comment: CommentItem) {
   if (comment.isAnonymous) return `익명 (${comment.writerIp})`;
   return comment.writer?.nickname || "알 수 없음";
 }
+
+function canDeleteComment(comment: CommentItem, currentUserPublicId: string | null, isAdmin: boolean) {
+  if (comment.isDeleted) return false;
+  if (isAdmin || comment.isAnonymous) return true;
+  return Boolean(currentUserPublicId && comment.writer?.publicId === currentUserPublicId);
+}

From 0e48e4cdcfa0640cbd22e4a141b77b8751139d7e Mon Sep 17 00:00:00 2001
From: ikae <ikaesujeel@gmail.com>
Date: Thu, 3 Sep 2026 17:36:22 +0900
Subject: [PATCH 3/6] =?UTF-8?q?docs(comment):=20=EB=8C=93=EA=B8=80=20?=
 =?UTF-8?q?=EC=95=84=ED=82=A4=ED=85=8D=EC=B2=98=20=EB=AC=B8=EC=84=9C=20?=
 =?UTF-8?q?=EB=B0=8F=20README=20=EC=A0=95=EB=A6=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 README.md                                     | 186 +++++++-
 ...04\355\202\244\355\205\215\354\262\230.md" |   0
 ...04\354\262\264\353\260\260\354\271\230.md" |  89 ++++
 ...70\353\246\254\354\241\260\353\246\275.md" |  73 ++++
 ...53\267\260_\353\266\204\353\246\254API.md" | 167 ++++++++
 ...354\261\204 \355\225\264\352\262\260_4.md" | 401 ++++++++++++++++++
 docs/project/work.md                          |  66 +++
 7 files changed, 976 insertions(+), 6 deletions(-)
 rename docs/conception/sprint03/ADR-001-comment-hierarchy-and-retrieval-architecture.md => "docs/conception/sprint03/ADR-001-\353\214\223\352\270\200\354\225\204\355\202\244\355\205\215\354\262\230.md" (100%)
 create mode 100644 "docs/conception/sprint03/spike_\353\243\250\355\212\270\354\273\244\354\204\234_\353\214\200\353\214\223\352\270\200\354\240\204\354\262\264\353\260\260\354\271\230.md"
 create mode 100644 "docs/conception/sprint03/spike_\353\251\224\353\252\250\353\246\254\354\240\204\354\262\264\355\212\270\353\246\254\354\241\260\353\246\275.md"
 create mode 100644 "docs/conception/sprint03/spike_\355\225\230\354\235\264\353\270\214\353\246\254\353\223\234\355\224\204\353\246\254\353\267\260_\353\266\204\353\246\254API.md"
 create mode 100644 "docs/conception/sprint03/\352\270\260\354\210\240\353\266\200\354\261\204 \355\225\264\352\262\260_4.md"

diff --git a/README.md b/README.md
index 19ebdc9..96e0cb6 100644
--- a/README.md
+++ b/README.md
@@ -55,7 +55,7 @@ sequenceDiagram
     Server->>Session: request.changeSessionId() 호출! (세션 식별자 교체)
     Session-->>Server: 신규 32자리 JSESSIONID 발급 (기존 스키장/성향 검색 필터 세션 데이터 유지)
     
-    Server-->>Client: Set-Cookie: JSESSIONID=A1B2...; Path=/; HttpOnly; SameSite=Lax
+    Server-->>Client: 신규 세션 쿠키 발급 (JSESSIONID, HttpOnly, SameSite=Lax)
     Client-->>User: 로그인 성공 (메인 프로필 대시보드 전환)
 
     Note over User, Server: 4. 인증된 API 요청 (프로필 조회/수정)
@@ -69,12 +69,12 @@ sequenceDiagram
     Client->>Server: POST /api/auth/logout
     Server->>Server: 1) ThreadLocal.clearContext() 청소
     Server->>Session: 2) session.invalidate() 톰캣 세션 파기
-    Server-->>Client: 3) Set-Cookie: JSESSIONID=; Max-Age=0 (쿠키 즉시 만료)
+    Server-->>Client: 3) JSESSIONID 쿠키 만료 응답 (Max-Age=0)
 ```
 
 ---
 
-### 핵심 아키텍처 고민 및 기술적 의사결정 
+### 아키텍처 고민 및 기술적 의사결정
 
 #### 1. 공통 엔티티와 JPA Auditing (`@EnableJpaAuditing`) 도입
 
@@ -111,7 +111,7 @@ sequenceDiagram
 
 ---
 
-## 4. 게시판(Post) 도메인 설계 & 핵심 기술적 의사결정 (Board Architecture & Decisions)
+## 4. 게시판(Post) 도메인 설계 & 기술적 의사결정 (Board Architecture & Decisions)
 
 게시판은 Snowthing에서 가장 자주 읽히는 도메인이다. 그래서 단순 CRUD로만 만들지 않고, 목록 조회 비용, 익명 글 권한, 삭제 정책, 이미지 첨부 상태까지 같이 맞춰서 설계했다.
 
@@ -268,13 +268,187 @@ Page<Post> findByCategoryCodeWithMemberAndCategory(@Param("categoryCode") String
 - `INVALID_PAGE_LIMIT (400)`: offset page 제한을 넘긴 요청
 
 ### 11) CSRF
+
 게시글 생성, 수정, 삭제 같은 CUD 요청은 CSRF 공격 표적이 되기 쉽다.
 Spring Security의 `CookieCsrfTokenRepository.withHttpOnlyFalse()`를 적용했다.
 이 방식은 Double Submit Cookie 패턴으로 동작한다. 백엔드가 `XSRF-TOKEN` 쿠키를 발급하면, 프론트엔드가 자원 변경 요청(POST, PUT, DELETE)을 보낼 때 쿠키 값을 읽어 `X-XSRF-TOKEN` HTTP 헤더에 담아서 보낸다. 서버의 `CsrfFilter`는 쿠키의 토큰 값과 헤더의 토큰 값이 일치하는지 비교하여 검증한다.
 외부 해킹 사이트는 동일 출처 정책(SOP) 제약으로 인해 사용자의 `XSRF-TOKEN` 쿠키를 자바스크립트로 읽을 수 없어 `X-XSRF-TOKEN` 헤더를 생성하지 못하므로 위조된 요청은 403 Forbidden으로 차단된다.
+
+---
+
+## 5. 댓글(Comment) 도메인 설계 & 기술적 의사결정
+
+댓글은 게시글 상세 화면에서 가장 자주 읽히는 데이터다. 그래서 단순히 `post_id`로 전체 댓글을 가져오는 방식 대신, 루트 댓글과 대댓글을 나누고 초기 응답 크기를 제한하는 구조로 설계했다.
+
+자세한 후보 비교와 실행계획은 [ADR-001 댓글 아키텍처](docs/conception/sprint03/ADR-001-댓글아키텍처.md), [댓글 API 명세](docs/conception/sprint03/comment_api_spec.md), [기술부채 해결 기록](docs/conception/sprint03/기술부채%20해결_4.md)에 정리했다.
+
+### 1) 댓글 도메인 구조
+
+댓글 엔티티는 `Comment` 하나로 둔다. 별도의 대댓글 `Reply` 엔티티를 만들지 않고, 하나의 `comment` 테이블에서 `parent_id`로 루트 댓글과 대댓글을 표현한다.
+
+- 루트 댓글: `parent_id = null`
+- 대댓글: `parent_id = 루트 댓글 ID`
+- 대댓글의 대댓글: 서버에서 최상위 루트 댓글 ID로 평탄화
+
+무한 계층을 허용하지 않은 이유는 화면과 쿼리 비용 때문이다. 댓글 깊이가 3단계 이상으로 늘어나면 모바일 화면에서 들여쓰기와 접힘 처리가 복잡해지고, DB 조회도 재귀 구조나 별도 계층 테이블을 고민해야 한다.
+
+현재의 프로젝트에서는 댓글과 대댓글 2단계면 대화 흐름을 표현하기에 충분하다고 판단했다.
+
+### 2) 게시글과 댓글의 관계
+
+게시글과 댓글은 `Post 1 : N Comment` 관계. 댓글은 반드시 하나의 게시글에 속하고, 게시글은 여러 댓글을 가질 수 있다.
+
+```text
+Post
+ └─ Comment(parent_id = null)
+     └─ Comment(parent_id = root_comment_id)
+```
+
+`post.comment_count`는 매번 댓글 테이블을 `COUNT(*)` 하지 않기 위한 역정규화 필드.
+
+댓글 생성과 삭제 시 같은 트랜잭션에서 증감시켜 목록 화면에서 댓글 수를 빠르게 보여준다.
+
+이 선택은 읽기 성능을 얻는 대신, 댓글 저장/삭제 실패와 카운트 갱신 실패의 경계를 반드시 같은 트랜잭션 안에 묶어야 하는 트레이드오프가 있다.
+
+### 3) 댓글 상태와 유형
+
+댓글 상태는 크게 정상 댓글과 Soft Delete 댓글로 나뉜다.
+
+- 정상 댓글: 목록과 상세 화면에 그대로 노출된다.
+- 삭제된 댓글: DB row는 남기고 `is_deleted = true`, `deleted_at`을 기록한다.
+
+작성 유형은 세 가지다.
+
+- 로그인 일반 댓글: 회원 ID를 남기고 닉네임 표시
+- 로그인 익명 댓글: 회원 ID는 서버에 남기되 화면에서는 익명 표시
+- 비로그인 익명 댓글: 작성 IP와 익명 비밀번호 해시로 삭제 권한을 검증한다.
+
+삭제된 루트 댓글은 활성 대댓글 유무에 따라 다르게 처리한다.
+
+```text
+삭제된 루트댓글 + 활성 대댓글 없음 -> 목록에서 숨김
+삭제된 루트댓글 + 활성 대댓글 있음 -> 루트 댓글은 "삭제된 댓글입니다."로 표시하고 활성 대댓글은 그대로 표시
+```
+
+### 4) 댓글 조회 페이지네이션 방식
+
+댓글 조회는 cursor pagination을 사용한다.
+
+```http
+GET /api/v1/posts/{publicId}/comments?cursor={commentId}&size=20
+GET /api/v1/comments/{commentId}/replies?cursor={commentId}&size=20
+```
+
+게시글 댓글 목록은 루트 댓글 20개를 먼저 조회하고, 각 루트 댓글의 대댓글은 5개까지만 같이 보여준다. 대댓글이 5개를 넘으면 사용자가 더보기를 눌렀을 때 대댓글 전용 API로 20개씩 추가 조회한다.
+
+정렬 기준은 루트 댓글과 대댓글 모두 같다.
+
+```sql
+ORDER BY created_at ASC, comment_id ASC
+```
+
+
+### 5) 조회 아키텍처 후보 비교
+
+댓글 조회 구조는 같은 데이터셋과 같은 정책으로 후보 1, 2, 3을 Spike 실험한 뒤 결정했다.
+
+| 후보 | 방식 | 장점 | 단점 및 트레이드오프 | 판단 |
+| :--- | :--- | :--- | :--- | :--- |
+| 후보 1 | 전체 댓글을 한 번에 조회하고 메모리에서 트리 조립 | 쿼리 1회로 끝나 구현이 단순함 | 댓글 수가 늘수록 응답 크기와 메모리 사용량이 같이 증가함 | 기각 |
+| 후보 2 | 루트 댓글 20개 조회 후 해당 루트의 대댓글 전체를 Batch 조회 | 루트 댓글 수를 제한하고 N+1을 피할 수 있음 | 특정 루트에 대댓글이 몰리면 초기 응답이 다시 커짐 | 기각 |
+| 후보 3 | 루트 댓글 20개 + 루트별 대댓글 5개 프리뷰 + 대댓글 분리 API | 초기 응답 크기를 제한하고 핫스팟 댓글에도 대응 가능 | 대댓글 전용 API와 부모별 Top-N 쿼리가 필요함 | 채택 |
+
+실측 결과도 후보 3이 가장 안정적이었다.
+
+| 시나리오 | 후보 1 | 후보 2 | 후보 3 |
+| :--- | :---: | :---: | :---: |
+| 분산 데이터(Post 998) 응답 크기 | 210.44 KB | 39.87 KB | 22.03 KB |
+| 핫스팟 데이터(Post 999) 응답 크기 | 205.84 KB | 103.70 KB | 5.55 KB |
+| 핫스팟 데이터 읽은 행 수 | 1,000행 | 520행 | 25행 |
+
+후보 3은 API가 하나 늘어나지만 댓글 조회 시 대댓글 500개를 한 번에 읽어오는 상황을 피할 수 있었다.
+
+커뮤니티 서비스에서는 댓글이 많은 글도 빠르게 보여줘야 한다고 생각해서, 초기 응답 크기를 제한하는 방식을 생각했다.
+
+### 6) 선택한 방식의 기술부채
+
+해당 방식을 선택하면서 다음 기술부채가 남았다.
+
+1. 부모별 Top-5 조회를 위한 MySQL 8.0 `ROW_NUMBER() OVER (PARTITION BY parent_id)`.
+2. 게시글 댓글 조회 API 외에 대댓글 전용 페이징 API의 별도 관리.
+3. `ORDER BY created_at ASC, comment_id ASC` 정렬을 안정적으로 처리하기 위한 복합 인덱스.
+4. MySQL 실행계획에서 윈도우 함수 처리로 `Using temporary`, `Using filesort`가 일부 남을 수 있다.
+
+
+### 7) 기술부채 개선 내용
+
+부모별 Top-5 프리뷰는 MySQL 8.0 윈도우 함수로 구현했다.
+
+```sql
+ROW_NUMBER() OVER (
+    PARTITION BY c.parent_id
+    ORDER BY c.created_at ASC, c.comment_id ASC
+) AS rn
+```
+
+대댓글 전용 API는 `GET /api/v1/comments/{commentId}/replies`로 분리했고, `size + 1`개를 조회해 `hasNext`를 판단한다.
+
+읽기 성능을 위해 복합 인덱스도 보강했다.
+
+```text
+(post_id, parent_id, created_at, comment_id)
+(parent_id, is_deleted, created_at, comment_id)
+```
+
+두 번째 인덱스에서 `is_deleted`는 `parent_id` 다음에 둔다. 특정 루트의 대댓글 범위를 먼저 좁힌 뒤, 활성 댓글만 필터링하고, 그 안에서 생성 시각과 PK 순서로 읽기 위한 구조다.
+
+```sql
+WHERE parent_id = ?
+  AND is_deleted = false
+ORDER BY created_at ASC, comment_id ASC
+```
+
+### 8) 개선 후 결과
+
+| post_id | 데이터셋 | 전체 댓글 | 루트 댓글 | 대댓글 |
+| :---: | :--- | :---: | :---: | :---: |
+| 998 | 분산 데이터 | 1,000개 | 100개 | 900개 |
+| 999 | 핫스팟 데이터 | 1,000개 | 500개 | 500개 |
+
+실행계획에서는 복합 인덱스가 사용되는 것을 확인했는데, `ROW_NUMBER()` 기반 Top-5 쿼리와 삭제 루트 노출 정책이 포함된 쿼리에서는 `Using temporary`, `Using filesort`가 남는다.
+
+목적은 DB 내부 정렬 비용을 완전히 없애는 것이 아니라, 초기 응답 크기와 서버 메모리 사용량을 제한하는 것.
+
+
+### 9) 테스트 및 검증 결과
+개선 후의 테스트 결과
+
+```bash
+./gradlew.bat test --tests "*CommentReadTest*"
+```
+
+| 항목 | 결과 |
+| :--- | :--- |
+| 테스트 수 | 10 |
+| 실패 | 0 |
+| 에러 | 0 |
+| 스킵 | 0 |
+
+댓글 도메인 전체 테스트는 42건 중 1건이 실패하고 1건이 스킵됐다.
+
+```bash
+./gradlew.bat test --tests "*Comment*"
+```
+
+실패한 테스트는 후보 3 구조나 현재 조회 구현 문제가 아니다.
+
+기존 `CommentServiceTest` 일부가 "삭제된 루트 댓글은 활성 대댓글이 없어도 목록에 남는다"는 예전 정책을 기대하고 있어서 현재 정책과 충돌한다.
+
+현재 정책은 활성 대댓글이 없는 삭제 루트를 숨기는 방식이다.
+
 ---
 
-## 5. 프로젝트 물리 디렉토리 구조 (Project Structure)
+## 6. 프로젝트 물리 디렉토리 구조 (Project Structure)
 
 ```
 snowthing/ (프로젝트 최상위 루트)
@@ -296,7 +470,7 @@ snowthing/ (프로젝트 최상위 루트)
 
 ---
 
-## 6. 실행 및 테스트 (Build & Run)
+## 7. 실행 및 테스트 (Build & Run)
 
 ### Backend (Spring Boot)
 ```bash
diff --git a/docs/conception/sprint03/ADR-001-comment-hierarchy-and-retrieval-architecture.md "b/docs/conception/sprint03/ADR-001-\353\214\223\352\270\200\354\225\204\355\202\244\355\205\215\354\262\230.md"
similarity index 100%
rename from docs/conception/sprint03/ADR-001-comment-hierarchy-and-retrieval-architecture.md
rename to "docs/conception/sprint03/ADR-001-\353\214\223\352\270\200\354\225\204\355\202\244\355\205\215\354\262\230.md"
diff --git "a/docs/conception/sprint03/spike_\353\243\250\355\212\270\354\273\244\354\204\234_\353\214\200\353\214\223\352\270\200\354\240\204\354\262\264\353\260\260\354\271\230.md" "b/docs/conception/sprint03/spike_\353\243\250\355\212\270\354\273\244\354\204\234_\353\214\200\353\214\223\352\270\200\354\240\204\354\262\264\353\260\260\354\271\230.md"
new file mode 100644
index 0000000..332bd43
--- /dev/null
+++ "b/docs/conception/sprint03/spike_\353\243\250\355\212\270\354\273\244\354\204\234_\353\214\200\353\214\223\352\270\200\354\240\204\354\262\264\353\260\260\354\271\230.md"
@@ -0,0 +1,89 @@
+# [Spike 결과 보고서] 후보 2: 루트 커서 페이징 + 대댓글 전체 Batch
+
+- **브랜치명**: `sprint03-spikeTest-02-Cursor/Batch`
+- **측정 일시**: 2026-08-29
+- **작성자**: devikae (자동 생성)
+
+---
+
+## 1. 구현 요약 (PoC Implementation)
+- 루트 댓글을 `(created_at, comment_id)` 복합 커서로 20개 조회합니다.
+- 선택된 루트 ID를 `parent_id IN (...)`에 전달해 모든 대댓글을 한 번에 조회합니다.
+- 두 쿼리 모두 작성자 정보를 LEFT JOIN하고, DTO 컬렉션은 방어적으로 복사합니다.
+
+---
+
+## 2. 측정 결과 데이터 매트릭스
+
+| 시나리오 | 쿼리 수 (Count) | 읽은 Row 수 (Rows) | 응답 크기 (Bytes / KB) | 실행 시간 (Elapsed ms) |
+| :--- | :---: | :---: | :---: | :---: |
+| **[시나리오 A] 분산 1,000건** | 2회 | 200행 | 40830 B (39.87 KB) | 10.308 ms |
+| **[시나리오 B] 집중 핫스팟 1,000건** | 2회 | 520행 | 106186 B (103.70 KB) | 14.988 ms |
+
+---
+
+## 3. 실행된 실제 SQL 및 MySQL EXPLAIN
+
+### 1) [시나리오 A] 분산 1,000건
+
+#### [Query 1]
+```sql
+SELECT c.comment_id, c.parent_id, c.content, c.is_deleted, c.created_at, m.nickname, c.is_anonymous, c.writer_ip FROM comment c LEFT JOIN member m ON m.member_id = c.member_id WHERE c.post_id = 998 AND c.parent_id IS NULL ORDER BY c.created_at ASC, c.comment_id ASC LIMIT 20
+```
+
+**EXPLAIN 분석**:
+
+| table | type | key | rows | Extra |
+| :--- | :--- | :--- | :--- | :--- |
+| c | ref | fk_comment_parent | 603 | Using index condition; Using where; Using filesort |
+| m | eq_ref | PRIMARY | 1 | null |
+
+#### [Query 2]
+```sql
+SELECT c.comment_id, c.parent_id, c.content, c.is_deleted, c.created_at, m.nickname, c.is_anonymous, c.writer_ip FROM comment c LEFT JOIN member m ON m.member_id = c.member_id WHERE c.parent_id IN (4004, 4014, 4024, 4034, 4044, 4054, 4064, 4074, 4084, 4094, 4104, 4114, 4124, 4134, 4144, 4154, 4164, 4174, 4184, 4194) ORDER BY c.parent_id ASC, c.created_at ASC, c.comment_id ASC
+```
+
+**EXPLAIN 분석**:
+
+| table | type | key | rows | Extra |
+| :--- | :--- | :--- | :--- | :--- |
+| c | range | fk_comment_parent | 180 | Using index condition; Using filesort |
+| m | eq_ref | PRIMARY | 1 | null |
+
+### 2) [시나리오 B] 집중 핫스팟 1,000건
+
+#### [Query 1]
+```sql
+SELECT c.comment_id, c.parent_id, c.content, c.is_deleted, c.created_at, m.nickname, c.is_anonymous, c.writer_ip FROM comment c LEFT JOIN member m ON m.member_id = c.member_id WHERE c.post_id = 999 AND c.parent_id IS NULL ORDER BY c.created_at ASC, c.comment_id ASC LIMIT 20
+```
+
+**EXPLAIN 분석**:
+
+| table | type | key | rows | Extra |
+| :--- | :--- | :--- | :--- | :--- |
+| c | ref | fk_comment_parent | 603 | Using index condition; Using where; Using filesort |
+| m | eq_ref | PRIMARY | 1 | null |
+
+#### [Query 2]
+```sql
+SELECT c.comment_id, c.parent_id, c.content, c.is_deleted, c.created_at, m.nickname, c.is_anonymous, c.writer_ip FROM comment c LEFT JOIN member m ON m.member_id = c.member_id WHERE c.parent_id IN (5004, 5005, 5006, 5007, 5008, 5009, 5010, 5011, 5012, 5013, 5014, 5015, 5016, 5017, 5018, 5019, 5020, 5021, 5022, 5023) ORDER BY c.parent_id ASC, c.created_at ASC, c.comment_id ASC
+```
+
+**EXPLAIN 분석**:
+
+| table | type | key | rows | Extra |
+| :--- | :--- | :--- | :--- | :--- |
+| c | range | fk_comment_parent | 519 | Using index condition; Using filesort |
+| m | eq_ref | PRIMARY | 1 | null |
+
+---
+
+## 4. 발견된 결함 및 한계점 (Issues & Bottlenecks)
+- 응답 쿼리 수는 2회로 고정되지만 선택된 루트에 대댓글이 집중되면 응답 행과 페이로드는 제한되지 않습니다.
+- 현재 스키마에는 `(post_id, parent_id, created_at, comment_id)` 복합 인덱스가 없어 EXPLAIN상 추가 정렬이나 넓은 스캔이 발생할 수 있습니다.
+- 실행 시간은 로컬 단일 실행값이므로 반복 측정의 평균·백분위 지표가 아닙니다.
+
+---
+
+## 5. 최종 평가 및 소견
+후보 2는 루트 수를 20개로 제한하면서 N+1 없이 2회 조회를 유지합니다. 다만 핫스팟 루트가 페이지에 포함되면 대댓글 전체가 반환되어 페이로드 상한을 보장하지 못하므로, 운영안에서는 대댓글 별도 커서 또는 프리뷰 제한을 함께 검토해야 합니다.
diff --git "a/docs/conception/sprint03/spike_\353\251\224\353\252\250\353\246\254\354\240\204\354\262\264\355\212\270\353\246\254\354\241\260\353\246\275.md" "b/docs/conception/sprint03/spike_\353\251\224\353\252\250\353\246\254\354\240\204\354\262\264\355\212\270\353\246\254\354\241\260\353\246\275.md"
new file mode 100644
index 0000000..14fa9c4
--- /dev/null
+++ "b/docs/conception/sprint03/spike_\353\251\224\353\252\250\353\246\254\354\240\204\354\262\264\355\212\270\353\246\254\354\241\260\353\246\275.md"
@@ -0,0 +1,73 @@
+# [Spike 결과 보고서] 후보 1: 메모리 전체 트리 조립
+
+- **브랜치명**: `devikae/sprint03-spikeTest-01-메모리-조립`
+- **측정 일시**: 2026-08-29
+- **작성자**: devikae (자동 생성)
+
+---
+
+## 1. 구현 요약 (PoC Implementation)
+- `findByPostIdWithMember` 한 번으로 게시글별 댓글 1,000건과 작성자를 조회
+- `LinkedHashMap<Long, MutableCommentNode>`에서 루트/대댓글을 연결한 뒤 불변 2-Depth DTO로 변환
+- Hibernate Statistics로 각 시나리오의 JPQL 실행 횟수가 1회인지 검증
+
+---
+
+## 2. 측정 결과 데이터 매트릭스
+
+| 시나리오 | 쿼리 수 (Count) | 읽은 Row 수 (Rows) | 응답 크기 (Bytes / KB) | 실행 시간 (Elapsed ms) |
+| :--- | :---: | :---: | :---: | :---: |
+| **[시나리오 A] 분산 1,000건** | 1회 | 1000행 | 215490 B (210.44 KB) | 83.468 ms |
+| **[시나리오 B] 집중 핫스팟 1,000건** | 1회 | 1000행 | 210784 B (205.84 KB) | 35.401 ms |
+
+---
+
+## 3. 실행된 실제 SQL 및 MySQL EXPLAIN
+
+### 1) [시나리오 A] 분산 1,000건
+
+#### [Query 1]
+```sql
+SELECT c.*, m.*
+FROM comment c
+LEFT JOIN member m ON m.member_id = c.member_id
+WHERE c.post_id = 998
+ORDER BY c.created_at ASC, c.comment_id ASC
+```
+
+**EXPLAIN 분석**:
+
+| table | type | key | rows | Extra |
+| :--- | :--- | :--- | :--- | :--- |
+| c | ref | fk_comment_post | 1000 | Using temporary; Using filesort |
+| m | ALL | null | 3 | Using where; Using join buffer (hash join) |
+
+### 2) [시나리오 B] 집중 핫스팟 1,000건
+
+#### [Query 1]
+```sql
+SELECT c.*, m.*
+FROM comment c
+LEFT JOIN member m ON m.member_id = c.member_id
+WHERE c.post_id = 999
+ORDER BY c.created_at ASC, c.comment_id ASC
+```
+
+**EXPLAIN 분석**:
+
+| table | type | key | rows | Extra |
+| :--- | :--- | :--- | :--- | :--- |
+| c | ref | fk_comment_post | 1000 | Using temporary; Using filesort |
+| m | ALL | null | 3 | Using where; Using join buffer (hash join) |
+
+---
+
+## 4. 발견된 결함 및 한계점 (Issues & Bottlenecks)
+- 댓글 총량에 비례해 엔티티와 DTO가 동시에 메모리에 존재합니다.
+- 핫스팟 시나리오는 한 루트 DTO가 대댓글 500개를 한 응답에 포함합니다.
+- 전체 응답 방식이라 루트 페이징이나 대댓글 더보기로 페이로드 상한을 통제할 수 없습니다.
+
+---
+
+## 5. 최종 평가 및 소견
+단일 JPQL로 N+1 없이 2-Depth 트리를 조립할 수 있다는 가설은 확인했습니다. 다만 댓글 증가량이 DB 조회 행, JVM 메모리, 직렬화 크기에 그대로 반영되므로 운영 기본안으로 채택하기 전 후보 2·3과 응답 상한 및 핫스팟 안정성을 비교해야 합니다.
diff --git "a/docs/conception/sprint03/spike_\355\225\230\354\235\264\353\270\214\353\246\254\353\223\234\355\224\204\353\246\254\353\267\260_\353\266\204\353\246\254API.md" "b/docs/conception/sprint03/spike_\355\225\230\354\235\264\353\270\214\353\246\254\353\223\234\355\224\204\353\246\254\353\267\260_\353\266\204\353\246\254API.md"
new file mode 100644
index 0000000..edca094
--- /dev/null
+++ "b/docs/conception/sprint03/spike_\355\225\230\354\235\264\353\270\214\353\246\254\353\223\234\355\224\204\353\246\254\353\267\260_\353\266\204\353\246\254API.md"
@@ -0,0 +1,167 @@
+# [Spike 결과 보고서] 후보 3: 루트 Batch + 대댓글 5개 프리뷰 & 분리 API
+
+- **브랜치명**: `devikae/sprint03-spikeTest-03-Batch/API`
+- **측정 일시**: 2026-08-29
+- **작성자**: devikae (자동 생성)
+
+---
+
+## 1. 구현 요약 (PoC Implementation)
+- 루트 댓글 20개 조회 후 MySQL 8 `ROW_NUMBER() OVER (PARTITION BY parent_id)`로 각 루트당 대댓글 5개만 일괄 조회합니다.
+- 프리뷰는 총 2회 쿼리이며, 대댓글 더보기는 `comment_id` 커서와 `LIMIT 20`을 사용하는 분리 조회입니다.
+- Spike 코드는 `src/test`에 격리했고 응답 컬렉션은 `List.copyOf()`로 방어적 복사했습니다.
+
+---
+
+## 2. 측정 결과 데이터 매트릭스
+
+| 시나리오 | 쿼리 수 (Count) | 읽은 Row 수 (Rows) | 응답 크기 (Bytes / KB) | 실행 시간 (Elapsed ms) |
+| :--- | :---: | :---: | :---: | :---: |
+| **[분산] Post 998** | 2회 | 120행 | 22560 B (22.03 KB) | 14.594 ms |
+| **[집중] Post 999** | 2회 | 25행 | 5685 B (5.55 KB) | 5.603 ms |
+| **[더보기 호출 시] Post 999 핫스팟 루트** | 1회 | 20행 | 3582 B (3.50 KB) | 2.357 ms |
+
+---
+
+## 3. 실행된 실제 SQL 및 MySQL EXPLAIN
+
+### 1) [분산] Post 998
+
+#### [Query 1]
+```sql
+SELECT c.comment_id, c.parent_id, c.content, m.nickname, c.created_at, 0 AS reply_count
+FROM comment c
+LEFT JOIN member m ON m.member_id = c.member_id
+WHERE c.post_id = 998
+  AND c.parent_id IS NULL
+  AND c.is_deleted = FALSE
+  AND c.comment_id > 0
+ORDER BY c.comment_id ASC
+LIMIT 20
+```
+
+**EXPLAIN 분석**:
+
+| table | type | key | rows | Extra |
+| :--- | :--- | :--- | :--- | :--- |
+| c | range | PRIMARY | 1001 | Using where |
+| m | eq_ref | PRIMARY | 1 | null |
+
+#### [Query 2]
+```sql
+WITH ranked_replies AS (
+    SELECT c.comment_id,
+           c.parent_id,
+           c.content,
+           m.nickname,
+           c.created_at,
+           ROW_NUMBER() OVER (
+               PARTITION BY c.parent_id
+               ORDER BY c.comment_id ASC
+           ) AS reply_rank,
+           COUNT(*) OVER (PARTITION BY c.parent_id) AS reply_count
+    FROM comment c
+    LEFT JOIN member m ON m.member_id = c.member_id
+    WHERE c.parent_id IN (4004, 4014, 4024, 4034, 4044, 4054, 4064, 4074, 4084, 4094, 4104, 4114, 4124, 4134, 4144, 4154, 4164, 4174, 4184, 4194)
+      AND c.is_deleted = FALSE
+)
+SELECT comment_id, parent_id, content, nickname, created_at, reply_count
+FROM ranked_replies
+WHERE reply_rank <= 5
+ORDER BY parent_id ASC, comment_id ASC
+```
+
+**EXPLAIN 분석**:
+
+| table | type | key | rows | Extra |
+| :--- | :--- | :--- | :--- | :--- |
+| <derived2> | ALL | null | 18 | Using where; Using filesort |
+| c | range | fk_comment_parent | 180 | Using index condition; Using where; Using temporary; Using filesort |
+| m | eq_ref | PRIMARY | 1 | null |
+
+### 2) [집중] Post 999
+
+#### [Query 1]
+```sql
+SELECT c.comment_id, c.parent_id, c.content, m.nickname, c.created_at, 0 AS reply_count
+FROM comment c
+LEFT JOIN member m ON m.member_id = c.member_id
+WHERE c.post_id = 999
+  AND c.parent_id IS NULL
+  AND c.is_deleted = FALSE
+  AND c.comment_id > 0
+ORDER BY c.comment_id ASC
+LIMIT 20
+```
+
+**EXPLAIN 분석**:
+
+| table | type | key | rows | Extra |
+| :--- | :--- | :--- | :--- | :--- |
+| c | range | PRIMARY | 1001 | Using where |
+| m | eq_ref | PRIMARY | 1 | null |
+
+#### [Query 2]
+```sql
+WITH ranked_replies AS (
+    SELECT c.comment_id,
+           c.parent_id,
+           c.content,
+           m.nickname,
+           c.created_at,
+           ROW_NUMBER() OVER (
+               PARTITION BY c.parent_id
+               ORDER BY c.comment_id ASC
+           ) AS reply_rank,
+           COUNT(*) OVER (PARTITION BY c.parent_id) AS reply_count
+    FROM comment c
+    LEFT JOIN member m ON m.member_id = c.member_id
+    WHERE c.parent_id IN (5004, 5005, 5006, 5007, 5008, 5009, 5010, 5011, 5012, 5013, 5014, 5015, 5016, 5017, 5018, 5019, 5020, 5021, 5022, 5023)
+      AND c.is_deleted = FALSE
+)
+SELECT comment_id, parent_id, content, nickname, created_at, reply_count
+FROM ranked_replies
+WHERE reply_rank <= 5
+ORDER BY parent_id ASC, comment_id ASC
+```
+
+**EXPLAIN 분석**:
+
+| table | type | key | rows | Extra |
+| :--- | :--- | :--- | :--- | :--- |
+| <derived2> | ALL | null | 51 | Using where; Using filesort |
+| c | range | fk_comment_parent | 519 | Using index condition; Using where; Using temporary; Using filesort |
+| m | eq_ref | PRIMARY | 1 | null |
+
+### 3) [더보기 호출 시] Post 999 핫스팟 루트
+
+#### [Query 1]
+```sql
+SELECT c.comment_id, c.parent_id, c.content, m.nickname, c.created_at, 0 AS reply_count
+FROM comment c
+LEFT JOIN member m ON m.member_id = c.member_id
+WHERE c.parent_id = 5004
+  AND c.is_deleted = FALSE
+  AND c.comment_id > 0
+ORDER BY c.comment_id ASC
+LIMIT 20
+```
+
+**EXPLAIN 분석**:
+
+| table | type | key | rows | Extra |
+| :--- | :--- | :--- | :--- | :--- |
+| c | range | PRIMARY | 1001 | Using where |
+| m | eq_ref | PRIMARY | 1 | null |
+
+---
+
+## 4. 발견된 결함 및 한계점 (Issues & Bottlenecks)
+- 부모별 Top-N을 위해 윈도 함수 정렬과 임시 테이블 처리가 발생할 수 있습니다.
+- 현재 인덱스는 `post_id`, `parent_id` 단일 인덱스뿐이므로 운영 반영 시 `(post_id, parent_id, comment_id)`와 `(parent_id, comment_id)` 복합 인덱스를 비교 검증해야 합니다.
+- `LIMIT 20`만 사용하는 PoC이므로 정확한 `hasNext` 판정이 필요하면 21건 조회 또는 별도 존재 확인의 비용을 선택해야 합니다.
+
+---
+
+## 5. 최종 평가 및 소견
+응답 크기는 루트 20개와 부모별 프리뷰 5개로 상한이 통제됩니다. 핫스팟의 나머지 대댓글은 분리 API로 넘겨 초기 응답과 메모리 사용량을 제한할 수 있습니다.
diff --git "a/docs/conception/sprint03/\352\270\260\354\210\240\353\266\200\354\261\204 \355\225\264\352\262\260_4.md" "b/docs/conception/sprint03/\352\270\260\354\210\240\353\266\200\354\261\204 \355\225\264\352\262\260_4.md"
new file mode 100644
index 0000000..e563a5c
--- /dev/null
+++ "b/docs/conception/sprint03/\352\270\260\354\210\240\353\266\200\354\261\204 \355\225\264\352\262\260_4.md"	
@@ -0,0 +1,401 @@
+# 댓글 조회 기술부채 해결 기록 4
+
+- 작성일: 2026-09-03
+- 대상 기능: 게시글 댓글 목록 조회, 루트별 대댓글 5개 프리뷰, 대댓글 분리 페이징 조회
+- 기준 문서:
+  - `spike_experiment_guide.md`
+  - `spike_하이브리드프리뷰_분리API.md`
+- 기준 코드:
+  - `CommentController`
+  - `CommentService`
+  - `CommentRepositoryImpl`
+  - `Comment`
+
+---
+
+## 1. 결론
+
+현재 구현에 구조적인 문제는 없습니다.
+
+후보 1, 2, 3 Spike는 같은 정책과 같은 데이터셋에서 비교됐고, 그 결과 후보 3인 "루트 댓글 20개 + 루트별 대댓글 5개 프리뷰 + 대댓글 분리 API" 구조를 선택했습니다. 이 선택은 여전히 유효합니다.
+
+이 문서는 후보 3을 다시 무효화하거나 재비교하는 문서가 아닙니다. 후보 3을 운영 코드로 옮긴 뒤, 남아 있던 기술부채가 어떻게 해결됐는지 확인한 기록입니다.
+
+정리하면 다음과 같습니다.
+
+| 항목 | 상태 | 근거 |
+| :--- | :--- | :--- |
+| 후보 1, 2, 3 비교 실험 | 문제 없음 | 같은 정책과 같은 데이터셋으로 비교 완료 |
+| 후보 3 구조 채택 | 문제 없음 | 초기 응답 크기와 메모리 사용량을 제한하는 구조 |
+| 부모별 Top-5 프리뷰 쿼리 | 해결 | MySQL 8.0 `ROW_NUMBER()` 기반 구현 완료 |
+| 대댓글 분리 API | 해결 | `GET /api/v1/comments/{commentId}/replies` 구현 완료 |
+| 읽기 성능용 복합 인덱스 | 보강됨 | `parent_id, is_deleted, created_at, comment_id` 인덱스 확인 |
+| 삭제 루트 노출 정책 | 문제 없음 | 활성 대댓글 유무 기준으로 동작 |
+| 기존 테스트 일부 실패 | 구현 문제가 아니라 테스트 기대값 문제 | 예전 정책 기준 테스트가 현재 정책과 충돌 |
+
+---
+
+## 2. 후보 3 실험과 현재 구현의 관계
+
+후보 3 Spike의 핵심은 아래 구조였습니다.
+
+```text
+게시글 댓글 목록 조회
+-> 루트 댓글 20개 조회
+-> 각 루트별 대댓글 5개까지만 프리뷰
+-> 5개를 초과한 대댓글은 별도 API로 페이징 조회
+```
+
+현재 구현도 이 구조를 그대로 사용합니다.
+
+```text
+GET /api/v1/posts/{publicId}/comments?cursor={commentId}&size=20
+GET /api/v1/comments/{commentId}/replies?cursor={commentId}&size=20
+```
+
+따라서 후보 3 실험이 잘못된 것이 아닙니다. 오히려 후보 3에서 확인한 장점을 운영 코드로 옮긴 상태입니다.
+
+후속으로 바뀐 부분은 "후보 재비교"가 아니라 "운영 구현 보강"입니다.
+
+1. `ROW_NUMBER()` 별칭을 `rn`으로 바꿔 MySQL 함수명 충돌을 피했습니다.
+2. 커서 페이징에서 `created_at ASC, comment_id ASC` 기준을 사용해 순서를 안정화했습니다.
+3. 읽기 성능을 위해 `is_deleted`를 포함한 복합 인덱스를 추가 검토하고 실제 DB에 반영했습니다.
+4. `size + 1`개를 조회해 `hasNext`를 판정하도록 했습니다.
+
+---
+
+## 3. 삭제 루트 댓글 정책
+
+현재 정책은 아래 기준입니다.
+
+```text
+삭제된 루트댓글 + 활성 대댓글 없음 -> 목록에서 숨김
+삭제된 루트댓글 + 활성 대댓글 있음 -> 루트 댓글은 placeholder, 활성 대댓글은 그대로 표시
+```
+
+이 정책은 댓글 트리에서 고아 노드가 생기는 문제를 막기 위한 선택입니다.
+
+삭제된 루트 댓글에 활성 대댓글이 없다면 사용자가 볼 내용이 없습니다. 이 경우 목록에서 숨기는 것이 자연스럽습니다.
+
+반대로 삭제된 루트 댓글 아래에 활성 대댓글이 남아 있다면, 루트를 완전히 숨기면 하위 대댓글의 문맥이 사라집니다. 그래서 루트는 `"삭제된 댓글입니다."` placeholder로 남기고, 활성 대댓글은 그대로 보여줍니다.
+
+현재 루트 댓글 조회 SQL도 이 정책을 반영합니다.
+
+```sql
+WHERE c.post_id = :postId
+  AND c.parent_id IS NULL
+  AND (
+      c.is_deleted = false
+      OR EXISTS (
+          SELECT 1
+          FROM comment active_child
+          WHERE active_child.parent_id = c.comment_id
+            AND active_child.is_deleted = false
+      )
+  )
+```
+
+---
+
+## 4. 인덱스 기준 정리
+
+### 4.1 기존 후보 3에서 남은 부채
+
+후보 3 결과에서는 아래 부채가 남았습니다.
+
+```text
+현재 인덱스는 post_id, parent_id 단일 인덱스 중심이므로
+(post_id, parent_id, comment_id)와 (parent_id, comment_id) 복합 인덱스를 비교 검증해야 한다.
+```
+
+이 말은 후보 3이 틀렸다는 뜻이 아닙니다. 후보 3 구조는 채택하되, 운영 성능을 위해 인덱스를 보강해야 한다는 의미였습니다.
+
+### 4.2 현재 코드와 DDL 기준 인덱스
+
+현재 엔티티와 DDL에는 아래 인덱스가 선언되어 있습니다.
+
+```text
+idx_comment_post_parent_created(post_id, parent_id, created_at, comment_id)
+idx_comment_parent_created(parent_id, created_at, comment_id)
+```
+
+`comment_id` 단독 정렬보다 `created_at, comment_id` 정렬을 명시하면서, 인덱스도 그 순서에 맞춰 보강된 형태입니다.
+
+### 4.3 실제 로컬 MySQL 기준 인덱스
+
+로컬 MySQL 8.0.46 컨테이너에서 확인한 실제 인덱스는 아래와 같습니다.
+
+```text
+PRIMARY(comment_id)
+fk_comment_member(member_id)
+idx_comment_post_parent_created(post_id, parent_id, created_at, comment_id)
+idx_comment_parent_deleted_created(parent_id, is_deleted, created_at, comment_id)
+```
+
+여기서 핵심은 `idx_comment_parent_deleted_created`입니다.
+
+```text
+parent_id -> is_deleted -> created_at -> comment_id
+```
+
+`is_deleted`가 인덱스 전체의 첫 번째 컬럼은 아닙니다. 먼저 `parent_id`로 특정 루트 댓글의 대댓글 범위를 좁히고, 그 다음 `is_deleted`로 활성 대댓글만 좁힌 뒤, `created_at`, `comment_id` 순서로 읽기 위한 구조입니다.
+
+읽기 성능을 생각하면 이 순서는 타당합니다.
+
+```sql
+WHERE parent_id = ?
+  AND is_deleted = false
+ORDER BY created_at ASC, comment_id ASC
+```
+
+위 형태에서는 `parent_id`와 `is_deleted`가 동등 조건이고, 그 뒤의 `created_at`, `comment_id`가 정렬 기준입니다. 그래서 활성 대댓글 조회에는 `(parent_id, is_deleted, created_at, comment_id)`가 더 잘 맞습니다.
+
+---
+
+## 5. 실제 구현 SQL
+
+### 5.1 루트 댓글 조회
+
+```sql
+SELECT c.comment_id, c.post_id, c.parent_id, c.content, c.is_deleted,
+       c.is_anonymous, c.writer_ip, c.created_at,
+       m.public_id AS member_public_id, m.nickname, m.profile_image_url,
+       (SELECT COUNT(*)
+        FROM comment active_reply
+        WHERE active_reply.parent_id = c.comment_id
+          AND active_reply.is_deleted = false) AS reply_count,
+       CASE WHEN (SELECT COUNT(*)
+                  FROM comment all_reply
+                  WHERE all_reply.parent_id = c.comment_id) > 5
+            THEN true ELSE false END AS has_more_replies
+FROM comment c
+LEFT JOIN member m ON m.member_id = c.member_id
+WHERE c.post_id = :postId
+  AND c.parent_id IS NULL
+  AND (
+      c.is_deleted = false
+      OR EXISTS (
+          SELECT 1
+          FROM comment active_child
+          WHERE active_child.parent_id = c.comment_id
+            AND active_child.is_deleted = false
+      )
+  )
+ORDER BY c.created_at ASC, c.comment_id ASC
+LIMIT :fetchSize
+```
+
+### 5.2 루트별 대댓글 Top-5 프리뷰
+
+```sql
+SELECT ranked.*
+FROM (
+    SELECT c.comment_id, c.post_id, c.parent_id, c.content, c.is_deleted,
+           c.is_anonymous, c.writer_ip, c.created_at,
+           m.public_id AS member_public_id, m.nickname, m.profile_image_url,
+           0 AS reply_count, false AS has_more_replies,
+           ROW_NUMBER() OVER (
+               PARTITION BY c.parent_id
+               ORDER BY c.created_at ASC, c.comment_id ASC
+           ) AS rn
+    FROM comment c
+    LEFT JOIN member m ON m.member_id = c.member_id
+    WHERE c.parent_id IN (:rootCommentIds)
+) ranked
+WHERE ranked.rn <= 5
+ORDER BY ranked.parent_id ASC, ranked.created_at ASC, ranked.comment_id ASC
+```
+
+### 5.3 대댓글 분리 페이징 조회
+
+```sql
+SELECT c.comment_id, c.post_id, c.parent_id, c.content, c.is_deleted,
+       c.is_anonymous, c.writer_ip, c.created_at,
+       m.public_id AS member_public_id, m.nickname, m.profile_image_url,
+       0 AS reply_count, false AS has_more_replies
+FROM comment c
+LEFT JOIN member m ON m.member_id = c.member_id
+WHERE c.parent_id = :rootCommentId
+  AND (
+      c.created_at > :cursorCreatedAt
+      OR (c.created_at = :cursorCreatedAt AND c.comment_id > :cursorId)
+  )
+ORDER BY c.created_at ASC, c.comment_id ASC
+LIMIT :fetchSize
+```
+
+---
+
+## 6. 테스트 결과
+
+### 6.1 댓글 조회 전용 테스트
+
+실행 명령:
+
+```powershell
+./gradlew.bat test --tests "*CommentReadTest*"
+```
+
+결과:
+
+| 항목 | 결과 |
+| :--- | :--- |
+| 테스트 수 | 10 |
+| 실패 | 0 |
+| 에러 | 0 |
+| 스킵 | 0 |
+| 결과 | 통과 |
+
+검증된 항목은 아래와 같습니다.
+
+1. 루트 댓글 커서 페이징
+2. 같은 생성 시각에서 `commentId` 보조 정렬
+3. 루트별 대댓글 5개 프리뷰
+4. 대댓글 분리 API 조회
+5. 삭제 루트 placeholder 및 은닉 정책
+6. 응답 컬렉션 불변성
+7. 잘못된 게시글, 잘못된 커서, 대댓글 ID를 루트로 쓰는 요청의 예외 처리
+
+### 6.2 댓글 도메인 전체 테스트
+
+실행 명령:
+
+```powershell
+./gradlew.bat test --tests "*Comment*"
+```
+
+결과:
+
+| 항목 | 결과 |
+| :--- | :--- |
+| 테스트 수 | 42 |
+| 실패 | 1 |
+| 에러 | 0 |
+| 스킵 | 1 |
+| 결과 | 실패 |
+
+실패한 테스트는 현재 구현 문제가 아니라 예전 정책 기대값과 현재 정책의 충돌입니다.
+
+기존 실패 테스트는 "삭제된 루트 댓글은 활성 대댓글이 없어도 목록에 남는다"는 기대를 갖고 있습니다.
+
+현재 정책은 아래 기준입니다.
+
+```text
+삭제된 루트댓글 + 활성 대댓글 없음 -> 목록에서 숨김
+삭제된 루트댓글 + 활성 대댓글 있음 -> 루트 댓글은 placeholder, 활성 대댓글은 그대로 표시
+```
+
+따라서 후보 3 구조나 현재 조회 구현의 실패로 보면 안 됩니다. 기존 테스트를 현재 정책 기준으로 정리해야 하는 테스트 부채입니다.
+
+---
+
+## 7. 실제 MySQL 데이터와 실행계획
+
+실행 환경:
+
+| 항목 | 값 |
+| :--- | :--- |
+| DB | MySQL 8.0.46 |
+| 컨테이너 | `snowthing-mysql` |
+| DB 이름 | `snowthing` |
+
+Spike 데이터:
+
+| post_id | public_id | total | roots | replies |
+| :---: | :--- | :---: | :---: | :---: |
+| 998 | `post-spike-distributed-998` | 1000 | 100 | 900 |
+| 999 | `post-spike-hotspot-999` | 1000 | 500 | 500 |
+
+### 7.1 루트 댓글 조회 EXPLAIN
+
+Post 998 기준 결과:
+
+| table | type | key | rows | Extra |
+| :--- | :--- | :--- | :---: | :--- |
+| c | ref | `idx_comment_post_parent_created` | 100 | Using index condition; Using where; Using temporary; Using filesort |
+| m | ALL | null | 3 | Using where; Using join buffer (hash join) |
+| active_child | ref | `idx_comment_parent_deleted_created` | 19 | Using index |
+| all_reply | ref | `idx_comment_parent_deleted_created` | 19 | Using index |
+| active_reply | ref | `idx_comment_parent_deleted_created` | 19 | Using index |
+
+루트 조회는 `idx_comment_post_parent_created`를 사용합니다. 삭제 루트 placeholder 정책 때문에 `OR EXISTS`와 집계 서브쿼리가 들어가므로 `Using temporary`, `Using filesort`가 남습니다. 이 결과는 구조 오류가 아니라 현재 정책을 SQL 한 번에 반영하면서 생기는 DB 내부 처리 비용입니다.
+
+### 7.2 루트별 Top-5 프리뷰 EXPLAIN
+
+분산 데이터 Post 998 기준 결과:
+
+| table | type | key | rows | Extra |
+| :--- | :--- | :--- | :---: | :--- |
+| `<derived2>` | ALL | null | 540 | Using where; Using filesort |
+| c | range | `idx_comment_parent_deleted_created` | 180 | Using index condition; Using temporary; Using filesort |
+| m | ALL | null | 3 | Using where; Using join buffer (hash join) |
+
+핫스팟 데이터 Post 999 기준 결과:
+
+| table | type | key | rows | Extra |
+| :--- | :--- | :--- | :---: | :--- |
+| `<derived2>` | ALL | null | 1557 | Using where; Using filesort |
+| c | ALL | null | 2005 | Using where; Using temporary; Using filesort |
+| m | ALL | null | 3 | Using where; Using join buffer (hash join) |
+
+분산 데이터에서는 `idx_comment_parent_deleted_created`가 선택됐고, 핫스팟 데이터에서는 옵티마이저가 전체 스캔을 선택했습니다.
+
+이는 후보 3이 잘못됐다는 의미가 아닙니다. 2,005행 수준의 작은 로컬 데이터에서는 MySQL 옵티마이저가 인덱스 range보다 전체 스캔을 더 싸게 판단할 수 있습니다. 중요한 점은 애플리케이션 응답 크기는 후보 3 구조로 제한된다는 것입니다.
+
+### 7.3 대댓글 더보기 EXPLAIN ANALYZE
+
+핫스팟 루트 `parent_id = 11006` 기준 결과:
+
+```text
+-> Limit: 21 row(s)  (actual time=10.2..10.2 rows=21 loops=1)
+    -> Sort: c.created_at, c.comment_id, limit input to 21 row(s) per chunk
+       (actual time=10.2..10.2 rows=21 loops=1)
+        -> Stream results  (actual time=9..9.99 rows=500 loops=1)
+            -> Left hash join (m.member_id = c.member_id)
+               (actual time=8.98..9.79 rows=500 loops=1)
+                -> Index lookup on c using idx_comment_parent_deleted_created
+                   (parent_id=11006)
+                   (actual time=8.84..9.6 rows=500 loops=1)
+                -> Hash
+                    -> Table scan on m
+                       (actual time=0.121..0.122 rows=3 loops=1)
+```
+
+대댓글 더보기는 `idx_comment_parent_deleted_created`를 사용합니다. 핫스팟 루트에 대댓글 500개가 있으므로 DB 내부에서는 500행을 읽고 정렬한 뒤 21개를 반환합니다.
+
+이 비용은 현재 데이터 규모에서는 감당 가능한 수준입니다. 후보 3 구조 덕분에 네트워크 응답과 애플리케이션 메모리는 계속 제한됩니다.
+
+---
+
+## 8. 후보 3에서 해결된 부채
+
+### 8.1 부모별 Top-5 쿼리 작성 부채
+
+해결됐습니다.
+
+`CommentRepositoryImpl.findTopReplyPreviews()`에서 MySQL 8.0 `ROW_NUMBER()` 기반 쿼리로 운영 코드에 반영했습니다. `row_number` 별칭 충돌도 `rn`으로 정리했습니다.
+
+### 8.2 대댓글 전용 API 관리 부채
+
+해결됐습니다.
+
+`CommentController`와 `CommentService`에 대댓글 분리 페이징 조회가 들어갔습니다. API가 하나 늘어난 대가는 있지만, 핫스팟 대댓글의 초기 응답 폭증을 막기 위한 의도된 설계 비용입니다.
+
+### 8.3 복합 인덱스 검토 부채
+
+해결됐습니다.
+
+후보 3 채택 이후 읽기 성능을 고려해 복합 인덱스를 보강했습니다. 특히 실제 DB에는 활성 대댓글 조회를 고려한 `idx_comment_parent_deleted_created(parent_id, is_deleted, created_at, comment_id)`가 확인됐습니다.
+
+---
+
+## 9. 남은 관찰 포인트
+
+현재 구현은 문제 없는 상태로 봐도 됩니다. 다만 아래 항목은 운영 관찰 포인트로 남깁니다.
+
+1. `ROW_NUMBER()` 기반 Top-5 프리뷰 쿼리에서 `Using temporary`, `Using filesort`가 발생합니다.
+2. 핫스팟 루트의 대댓글이 많으면 대댓글 더보기에서 해당 루트의 활성 대댓글 후보를 읽고 정렬하는 비용이 생깁니다.
+3. 실제 DB에는 `idx_comment_parent_deleted_created`가 있지만 엔티티/DDL에는 `idx_comment_parent_created`가 남아 있으므로, 공식 스키마 기준은 한 번 맞추는 것이 좋습니다.
+4. 기존 `CommentServiceTest` 중 일부는 현재 삭제 루트 정책과 기대값이 달라 실패하므로, 구현 문제가 아니라 테스트 정리 대상으로 봐야 합니다.
+
+이 관찰 포인트들은 후보 3 선택을 뒤집을 정도의 문제는 아닙니다. 지금 단계에서는 구조를 바꾸기보다, 인덱스 정의를 공식 스키마에 맞추고 오래된 테스트 기대값을 현재 정책으로 정리하는 것이 맞습니다.
diff --git a/docs/project/work.md b/docs/project/work.md
index de80a0f..a455504 100644
--- a/docs/project/work.md
+++ b/docs/project/work.md
@@ -1,3 +1,16 @@
+- **Sprint 03 댓글/대댓글 인라인 삭제 UI 및 비밀번호 플로팅 팝오버 위젯 구현 (2026-09-03)**:
+  1. **작업명**: 댓글/대댓글 인라인 미니 `✕` 삭제 버튼 및 시간 아래 플로팅 드롭다운 UI 구현 (브라우저 다이얼로그 전면 퇴출)
+  2. **현재 상태**: 완료
+  3. **완료된 항목**:
+     - 브라우저 기본 `prompt()`, `confirm()`, `alert()` 호출 코드 100% 제거.
+     - 댓글 및 대댓글 상단 헤더의 작성 시간(`MM.dd HH:mm:ss`) 우측에 미니 사각 `✕` 삭제 버튼 배치.
+     - `✕` 클릭 시 부모 헤더나 주변 텍스트를 밀어내지 않고 시간 바로 아래에 모달처럼 떠 있는 플로팅 팝오버(`absolute right-0 top-full mt-1.5 z-50 shadow-xl`) 위젯 구현.
+     - 외부 클릭 시 자동으로 닫히는 고정 투명 백드롭(`fixed inset-0 z-40`) 및 `ESC` 키보드 닫기, `Enter` 제출 지원.
+     - 비회원 익명 댓글은 비밀번호 인풋창 폼 제공, 로그인 회원 본인 및 최고 관리자는 `삭제할까요?` 즉시 확인 폼 제공.
+     - 하단 액션 바의 중복 텍스트 `삭제` 버튼 제거 (상단 `✕` 아이콘으로 일원화).
+  4. **검증 결과**:
+     - `npm run build` Next.js 16.2.12 Turbopack 컴파일 100% 통과 (Compiled successfully in 1733ms, 0 errors).
+
 - **Sprint 03 댓글 삭제(DELETE /api/v1/comments/{commentId}) 및 4대 권한 매트릭스 전담 개발 완결 (2026-09-01)**:
   1. **작업명**: 댓글 삭제(Soft Delete & 권한 매트릭스) 기능 보강 및 단위/통합 테스트
   2. **현재 상태**: 완료
@@ -783,3 +796,56 @@
 ### 검증
 - 변경 파일 대상 ESLint 오류 0건. 기존 게시글 이미지 `<img>` 최적화 경고 1건만 확인.
 - `npm run build` 성공 및 TypeScript 오류 0건 확인.
+
+## README Mermaid 렌더링 오류 수정 (2026-09-03)
+
+- 상태: DONE
+- 작업 내용: GitHub README의 Mermaid `sequenceDiagram`에서 `Set-Cookie: JSESSIONID=...; Path=/; HttpOnly; SameSite=Lax`처럼 실제 HTTP 헤더 문법을 그대로 넣어 파서가 실패하던 줄을 자연어 메시지로 변경.
+- 수정 파일: `README.md`
+- 완료 범위:
+  1. 로그인 성공 응답 메시지를 `신규 세션 쿠키 발급 (JSESSIONID, HttpOnly, SameSite=Lax)`로 변경.
+  2. 로그아웃 응답 메시지를 `JSESSIONID 쿠키 만료 응답 (Max-Age=0)`로 변경.
+- 이슈/주의: Mermaid 다이어그램 안에서는 `:`, `;`, `=`가 많은 실제 헤더 문자열을 그대로 쓰면 GitHub 렌더러와 충돌할 수 있으므로, 다이어그램에는 행위 중심 문장을 쓰고 실제 헤더 예시는 본문 코드블록에 분리하는 편이 안전함.
+
+## 댓글 조회 기술부채 해결 문서 작성 (2026-09-03)
+
+- 상태: DONE
+- 작업 내용: 같은 조건에서 수행된 후보 1/2/3 Spike 중 채택된 후보 3 구조가 현재 운영 구현에 어떻게 반영됐는지, 이후 읽기 성능 보강으로 추가된 복합 인덱스와 MySQL 실행계획을 `docs/study/sprint03/comment/test/기술부채 해결_4.md`에 정리.
+- 완료 범위:
+  1. `spike_experiment_guide.md`, `spike_하이브리드프리뷰_분리API.md`, 현재 `CommentRepositoryImpl`, `CommentService`, `CommentController`, `Comment` 인덱스 정의 대조.
+  2. 로컬 MySQL 8.0.46 Docker 컨테이너의 Spike 데이터 확인: Post 998/999 각각 댓글 1,000건 유지.
+  3. 실제 MySQL `SHOW INDEX`, `EXPLAIN`, `EXPLAIN ANALYZE` 결과를 문서에 반영.
+  4. `./gradlew.bat test --tests "*CommentReadTest*"` 실행 결과 10건 통과 확인.
+  5. `./gradlew.bat test --tests "*Comment*"` 실행 결과 42건 중 1건 실패, 1건 스킵 확인. 실패 원인은 후보 3 구조 문제가 아니라 기존 `CommentServiceTest` 일부가 현재 삭제 루트 정책과 다른 기대값을 가진 테스트 정리 대상으로 기록.
+- 이슈/주의:
+  1. 후보 1/2/3 비교 실험은 같은 정책과 같은 데이터셋에서 수행됐으므로 후보 3 선택 근거는 유효함.
+  2. 후보 3 채택 이후 읽기 성능 보강으로 실제 DB에는 `idx_comment_parent_deleted_created(parent_id, is_deleted, created_at, comment_id)`가 확인됨.
+  3. 윈도우 함수와 삭제 정책 쿼리에서 `Using temporary`, `Using filesort`가 남지만, 현재 규모에서는 구조 변경 대상이 아니라 운영 관찰 포인트로 기록.
+  4. 기존 `CommentServiceTest.getCommentsByPost_deletedParentDisplay()`는 현재 정책에 맞게 갱신 필요.
+
+## README 댓글 도메인 아키텍처 섹션 반영 (2026-09-03)
+
+- 상태: DONE
+- 작업 내용: README의 게시판 설명 아래에 `댓글(Comment) 도메인 설계 & 기술적 의사결정` 섹션을 독립 추가하고, 후보 3 Spike 선택 근거와 기술부채 개선 내용을 공식 conception 문서 기준으로 요약.
+- 완료 범위:
+  1. `핵심 아키텍처 고민 및 기술적 의사결정` 제목에서 `핵심` 표현 제거.
+  2. `게시판(Post) 도메인 설계 & 핵심 기술적 의사결정` 제목에서 `핵심` 표현 제거.
+  3. `CSRF` 본문과 구분선 사이에 빈 줄을 추가해 Markdown 렌더링이 다음 섹션으로 번지지 않도록 정리.
+  4. 댓글 도메인 구조, 게시글-댓글 관계, 댓글 상태/유형, 삭제 루트 정책, 커서 페이지네이션, 후보 1/2/3 비교, 기술부채와 개선 결과, 테스트 결과를 README에 추가.
+  5. 상세 근거 링크는 gitignore 대상인 `docs/study`가 아니라 `docs/conception/sprint03/`의 ADR, API 명세, 기술부채 해결 문서로 연결.
+- 이슈/주의:
+  1. README에는 전체 SQL과 EXPLAIN을 모두 싣지 않고 프로젝트 소개에 필요한 수준으로 요약.
+  2. 상세 실행계획과 테스트 결과는 `docs/conception/sprint03/기술부채 해결_4.md`를 기준 문서로 사용.
+
+## Sprint 03 Spike 결과 문서 파일명 정리 (2026-09-03)
+
+- 상태: DONE
+- 작업 내용: 후보 번호 중심 파일명을 실제 기술 방식이 드러나는 파일명으로 변경.
+- 변경 파일명:
+  1. `spike_result_candidate_1.md` -> `spike_메모리전체트리조립.md`
+  2. `spike_result_candidate_2.md` -> `spike_루트커서_대댓글전체배치.md`
+  3. `spike_result_candidate_3.md` -> `spike_하이브리드프리뷰_분리API.md`
+- 완료 범위:
+  1. `docs/conception/sprint03/` 하위 Spike 결과 문서 3개를 `git mv`로 이름 변경.
+  2. 공식 기술부채 해결 문서와 로컬 학습 문서의 기준 문서명을 새 파일명으로 갱신.
+- 이슈/주의: `.idea/workspace.xml`에도 기존 파일명 참조가 있으나 IDE 로컬 상태 파일이므로 커밋 대상에서 제외.

From 0fb576cdabd64eabbe4ba65cb4f79090fd98cfbc Mon Sep 17 00:00:00 2001
From: ikae <ikaesujeel@gmail.com>
Date: Thu, 3 Sep 2026 17:47:17 +0900
Subject: [PATCH 4/6] =?UTF-8?q?feat(comment):=20=EB=8C=93=EA=B8=80=20?=
 =?UTF-8?q?=EC=9D=B8=EB=9D=BC=EC=9D=B8=20=EC=82=AD=EC=A0=9C=20UI=20?=
 =?UTF-8?q?=EB=B0=8F=20=EC=8B=9C=EA=B0=84=20=EC=95=84=EB=9E=98=20=ED=94=8C?=
 =?UTF-8?q?=EB=A1=9C=ED=8C=85=20=ED=8C=9D=EC=98=A4=EB=B2=84=20=EC=A0=81?=
 =?UTF-8?q?=EC=9A=A9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 frontend/app/posts/[publicId]/page.tsx | 580 ++++++++++++++++++++++---
 1 file changed, 520 insertions(+), 60 deletions(-)

diff --git a/frontend/app/posts/[publicId]/page.tsx b/frontend/app/posts/[publicId]/page.tsx
index df689d2..f4b2637 100644
--- a/frontend/app/posts/[publicId]/page.tsx
+++ b/frontend/app/posts/[publicId]/page.tsx
@@ -73,9 +73,10 @@ interface ReplyPagingState {
   loading: boolean;
 }
 
-interface CommentDeleteTarget {
+interface CommentUpdateResponse {
   commentId: number;
-  requiresPassword: boolean;
+  content: string;
+  updatedAt: string;
 }
 
 export default function PostDetailPage({ params }: { params: Promise<{ publicId: string }> }) {
@@ -98,7 +99,15 @@ export default function PostDetailPage({ params }: { params: Promise<{ publicId:
   const [replyMentionName, setReplyMentionName] = useState<string | null>(null);
   const [replyText, setReplyText] = useState("");
   const [replyAnonPassword, setReplyAnonPassword] = useState("");
-  const [commentDeleteTarget, setCommentDeleteTarget] = useState<CommentDeleteTarget | null>(null);
+  const [activeEditCommentId, setActiveEditCommentId] = useState<number | null>(null);
+  const [editCommentText, setEditCommentText] = useState("");
+  const [editCommentPassword, setEditCommentPassword] = useState("");
+  const [editCommentError, setEditCommentError] = useState("");
+  const [submittingEditComment, setSubmittingEditComment] = useState(false);
+  const [activeDeleteCommentId, setActiveDeleteCommentId] = useState<number | null>(null);
+  const [deleteCommentPassword, setDeleteCommentPassword] = useState("");
+  const [deleteCommentError, setDeleteCommentError] = useState("");
+  const [submittingDeleteComment, setSubmittingDeleteComment] = useState(false);
   const [currentUserPublicId, setCurrentUserPublicId] = useState<string | null>(null);
   const [isAdmin, setIsAdmin] = useState(false);
   const [isDeleteModalOpen, setIsDeleteModalOpen] = useState(false);
@@ -395,29 +404,116 @@ export default function PostDetailPage({ params }: { params: Promise<{ publicId:
     }
   };
 
-  const handleOpenCommentDeleteModal = (comment: CommentItem) => {
-    setCommentDeleteTarget({
-      commentId: comment.commentId,
-      requiresPassword: comment.isAnonymous && !currentUserPublicId,
-    });
+  const handleStartEditComment = (comment: CommentItem) => {
+    setActiveReplyParentId(null);
+    setReplyMentionName(null);
+    setActiveEditCommentId(comment.commentId);
+    setEditCommentText(comment.content);
+    setEditCommentPassword("");
+    setEditCommentError("");
   };
 
-  const handleConfirmCommentDelete = async (password: string) => {
-    if (!commentDeleteTarget) return;
+  const handleCancelEditComment = () => {
+    if (submittingEditComment) return;
+    setActiveEditCommentId(null);
+    setEditCommentText("");
+    setEditCommentPassword("");
+    setEditCommentError("");
+  };
 
-    const res = await csrfFetch(API_ENDPOINTS.comments.delete(commentDeleteTarget.commentId), {
-      method: "DELETE",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ anonymousPassword: password || null }),
-    });
-    if (!res.ok) {
-      const errorData = await res.json();
-      throw new Error(errorData.message || "댓글 삭제에 실패했습니다.");
+  const handleUpdateComment = async (comment: CommentItem) => {
+    const content = editCommentText.trim();
+    const requiresPassword = comment.isAnonymous && !currentUserPublicId;
+    if (!content) {
+      setEditCommentError("댓글 내용을 입력해주세요.");
+      return;
+    }
+    if (content.length > 1000) {
+      setEditCommentError("댓글은 1,000자 이하로 입력해주세요.");
+      return;
+    }
+    if (requiresPassword && !editCommentPassword.trim()) {
+      setEditCommentError("익명 댓글 비밀번호를 입력해주세요.");
+      return;
+    }
+    if (content === comment.content) {
+      setEditCommentError("변경된 내용이 없습니다.");
+      return;
+    }
+
+    setSubmittingEditComment(true);
+    setEditCommentError("");
+    try {
+      const res = await csrfFetch(API_ENDPOINTS.comments.delete(comment.commentId), {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          content,
+          anonymousPassword: editCommentPassword.trim() || null,
+        }),
+      });
+      if (!res.ok) {
+        const errorData = await res.json();
+        throw new Error(errorData.message || "댓글 수정에 실패했습니다.");
+      }
+
+      const updated: CommentUpdateResponse = await res.json();
+      setComments((current) => updateCommentContent(current, updated.commentId, updated.content));
+      setActiveEditCommentId(null);
+      setEditCommentText("");
+      setEditCommentPassword("");
+      setEditCommentError("");
+    } catch (error) {
+      setEditCommentError(error instanceof Error ? error.message : "서버 통신 중 오류가 발생했습니다.");
+    } finally {
+      setSubmittingEditComment(false);
     }
+  };
+
+  const handleStartDeleteComment = (commentId: number) => {
+    setActiveDeleteCommentId(commentId);
+    setDeleteCommentPassword("");
+    setDeleteCommentError("");
+  };
 
-    setCommentDeleteTarget(null);
-    await fetchComments();
-    setPost((current) => (current ? { ...current, commentCount: Math.max(0, current.commentCount - 1) } : current));
+  const handleCancelDeleteComment = () => {
+    setActiveDeleteCommentId(null);
+    setDeleteCommentPassword("");
+    setDeleteCommentError("");
+  };
+
+  const handleConfirmDeleteComment = async (comment: CommentItem) => {
+    const isOwnerMember = !comment.isAnonymous && currentUserPublicId && comment.writer?.publicId === currentUserPublicId;
+    const isOwnerAnonMember = comment.isAnonymous && currentUserPublicId && comment.writer?.publicId === currentUserPublicId;
+    const requiresPassword = !isAdmin && !isOwnerMember && !isOwnerAnonMember;
+
+    if (requiresPassword && !deleteCommentPassword.trim()) {
+      setDeleteCommentError("비밀번호를 입력해주세요.");
+      return;
+    }
+
+    setSubmittingDeleteComment(true);
+    setDeleteCommentError("");
+    try {
+      const res = await csrfFetch(API_ENDPOINTS.comments.delete(comment.commentId), {
+        method: "DELETE",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ anonymousPassword: deleteCommentPassword.trim() || null }),
+      });
+
+      if (!res.ok) {
+        const errorData = await res.json();
+        throw new Error(errorData.message || "댓글 삭제에 실패했습니다.");
+      }
+
+      handleCancelDeleteComment();
+      await fetchComments();
+      setPost((current) => (current ? { ...current, commentCount: Math.max(0, current.commentCount - 1) } : current));
+    } catch (error) {
+      setDeleteCommentError(error instanceof Error ? error.message : "서버 통신 중 오류가 발생했습니다.");
+    } finally {
+      setSubmittingDeleteComment(false);
+    }
   };
 
   if (loading) {
@@ -575,7 +671,24 @@ export default function PostDetailPage({ params }: { params: Promise<{ publicId:
                     replyAnonPassword={replyAnonPassword}
                     setReplyAnonPassword={setReplyAnonPassword}
                     handleCreateComment={handleCreateComment}
-                    handleOpenCommentDeleteModal={handleOpenCommentDeleteModal}
+                    activeEditCommentId={activeEditCommentId}
+                    editCommentText={editCommentText}
+                    setEditCommentText={setEditCommentText}
+                    editCommentPassword={editCommentPassword}
+                    setEditCommentPassword={setEditCommentPassword}
+                    editCommentError={editCommentError}
+                    submittingEditComment={submittingEditComment}
+                    handleStartEditComment={handleStartEditComment}
+                    handleCancelEditComment={handleCancelEditComment}
+                    handleUpdateComment={handleUpdateComment}
+                    activeDeleteCommentId={activeDeleteCommentId}
+                    deleteCommentPassword={deleteCommentPassword}
+                    setDeleteCommentPassword={setDeleteCommentPassword}
+                    deleteCommentError={deleteCommentError}
+                    submittingDeleteComment={submittingDeleteComment}
+                    handleStartDeleteComment={handleStartDeleteComment}
+                    handleCancelDeleteComment={handleCancelDeleteComment}
+                    handleConfirmDeleteComment={handleConfirmDeleteComment}
                     isAdmin={isAdmin}
                     handleLoadMoreReplies={handleLoadMoreReplies}
                     isLoadingReplies={Boolean(replyPagingByRootId[comment.commentId]?.loading)}
@@ -606,16 +719,6 @@ export default function PostDetailPage({ params }: { params: Promise<{ publicId:
         description={deleteModalConfig.description}
         requirePassword={deleteModalConfig.requirePassword}
       />
-      <DeleteConfirmModal
-        isOpen={commentDeleteTarget !== null}
-        onClose={() => setCommentDeleteTarget(null)}
-        onConfirm={handleConfirmCommentDelete}
-        title="댓글 삭제 확인"
-        description="정말 삭제하시겠습니까?"
-        requirePassword={commentDeleteTarget?.requiresPassword ?? false}
-        confirmLabel="댓글 삭제"
-        submittingLabel="삭제 중..."
-      />
       <Footer />
     </div>
   );
@@ -634,7 +737,24 @@ function CommentRow({
   replyAnonPassword,
   setReplyAnonPassword,
   handleCreateComment,
-  handleOpenCommentDeleteModal,
+  activeEditCommentId,
+  editCommentText,
+  setEditCommentText,
+  editCommentPassword,
+  setEditCommentPassword,
+  editCommentError,
+  submittingEditComment,
+  handleStartEditComment,
+  handleCancelEditComment,
+  handleUpdateComment,
+  activeDeleteCommentId,
+  deleteCommentPassword,
+  setDeleteCommentPassword,
+  deleteCommentError,
+  submittingDeleteComment,
+  handleStartDeleteComment,
+  handleCancelDeleteComment,
+  handleConfirmDeleteComment,
   isAdmin,
   handleLoadMoreReplies,
   isLoadingReplies,
@@ -651,12 +771,31 @@ function CommentRow({
   replyAnonPassword: string;
   setReplyAnonPassword: (value: string) => void;
   handleCreateComment: (parentId: number | null) => Promise<void>;
-  handleOpenCommentDeleteModal: (comment: CommentItem) => void;
+  activeEditCommentId: number | null;
+  editCommentText: string;
+  setEditCommentText: (text: string) => void;
+  editCommentPassword: string;
+  setEditCommentPassword: (password: string) => void;
+  editCommentError: string;
+  submittingEditComment: boolean;
+  handleStartEditComment: (comment: CommentItem) => void;
+  handleCancelEditComment: () => void;
+  handleUpdateComment: (comment: CommentItem) => Promise<void>;
+  activeDeleteCommentId: number | null;
+  deleteCommentPassword: string;
+  setDeleteCommentPassword: (password: string) => void;
+  deleteCommentError: string;
+  submittingDeleteComment: boolean;
+  handleStartDeleteComment: (commentId: number) => void;
+  handleCancelDeleteComment: () => void;
+  handleConfirmDeleteComment: (comment: CommentItem) => Promise<void>;
   isAdmin: boolean;
   handleLoadMoreReplies: (rootCommentId: number) => Promise<void>;
   isLoadingReplies: boolean;
 }) {
+  const canEdit = canEditComment(item, currentUserPublicId);
   const canDelete = canDeleteComment(item, currentUserPublicId, isAdmin);
+  const isEditing = activeEditCommentId === item.commentId;
   const openReplyEditor = (target: CommentItem) => {
     if (activeReplyParentId === item.commentId && replyMentionName === getWriterName(target)) {
       setActiveReplyParentId(null);
@@ -672,20 +811,53 @@ function CommentRow({
       <div className="border-b border-[var(--snow-border)] pb-4">
         <div className="flex items-center justify-between gap-3">
           <span className={`font-bold ${item.isDeleted ? "text-[var(--snow-faint)]" : "text-black"}`}>{getWriterName(item)}</span>
-          <span className="font-mono text-xs text-[var(--snow-muted)]">{new Date(item.createdAt).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })}</span>
-        </div>
-        <p className={`mt-2 leading-7 ${item.isDeleted ? "text-[var(--snow-faint)] italic" : "text-[var(--snow-ink-soft)]"}`}>{item.content}</p>
-
-        <div className="mt-3 flex gap-4 font-mono text-xs font-bold uppercase tracking-[0.06em]">
-          <button onClick={() => openReplyEditor(item)} className="text-black">
-            {activeReplyParentId === item.commentId ? "답글 취소" : "답글 쓰기"}
-          </button>
-          {canDelete && (
-            <button type="button" onClick={() => handleOpenCommentDeleteModal(item)} className="text-[var(--snow-error)]">
-              삭제
-            </button>
-          )}
+          <div className="flex items-center">
+            <span className="font-mono text-xs text-[var(--snow-muted)]">{formatCommentDate(item.createdAt)}</span>
+            {canDelete && (
+              <CommentDeleteInline
+                comment={item}
+                currentUserPublicId={currentUserPublicId}
+                isAdmin={isAdmin}
+                isActive={activeDeleteCommentId === item.commentId}
+                onOpen={() => handleStartDeleteComment(item.commentId)}
+                onClose={handleCancelDeleteComment}
+                password={deleteCommentPassword}
+                setPassword={setDeleteCommentPassword}
+                error={activeDeleteCommentId === item.commentId ? deleteCommentError : ""}
+                submitting={submittingDeleteComment}
+                onConfirm={() => void handleConfirmDeleteComment(item)}
+              />
+            )}
+          </div>
         </div>
+        {isEditing ? (
+          <CommentEditForm
+            comment={item}
+            content={editCommentText}
+            setContent={setEditCommentText}
+            password={editCommentPassword}
+            setPassword={setEditCommentPassword}
+            error={editCommentError}
+            submitting={submittingEditComment}
+            requiresPassword={item.isAnonymous && !currentUserPublicId}
+            onCancel={handleCancelEditComment}
+            onSubmit={() => void handleUpdateComment(item)}
+          />
+        ) : (
+          <>
+            <p className={`mt-2 leading-7 ${item.isDeleted ? "text-[var(--snow-faint)] italic" : "text-[var(--snow-ink-soft)]"}`}>{item.content}</p>
+            <div className="mt-3 flex gap-4 font-mono text-xs font-bold uppercase tracking-[0.06em]">
+              <button onClick={() => openReplyEditor(item)} className="text-black">
+                {activeReplyParentId === item.commentId ? "답글 취소" : "답글 쓰기"}
+              </button>
+              {canEdit && (
+                <button type="button" onClick={() => handleStartEditComment(item)} className="text-black">
+                  수정
+                </button>
+              )}
+            </div>
+          </>
+        )}
 
         {item.previewReplies.length > 0 && (
           <div className="mt-4 grid gap-4">
@@ -694,9 +866,26 @@ function CommentRow({
                 key={reply.commentId}
                 item={reply}
                 onReply={() => openReplyEditor(reply)}
+                isEditing={activeEditCommentId === reply.commentId}
+                editCommentText={editCommentText}
+                setEditCommentText={setEditCommentText}
+                editCommentPassword={editCommentPassword}
+                setEditCommentPassword={setEditCommentPassword}
+                editCommentError={editCommentError}
+                submittingEditComment={submittingEditComment}
+                handleStartEditComment={handleStartEditComment}
+                handleCancelEditComment={handleCancelEditComment}
+                handleUpdateComment={handleUpdateComment}
                 currentUserPublicId={currentUserPublicId}
+                activeDeleteCommentId={activeDeleteCommentId}
+                deleteCommentPassword={deleteCommentPassword}
+                setDeleteCommentPassword={setDeleteCommentPassword}
+                deleteCommentError={deleteCommentError}
+                submittingDeleteComment={submittingDeleteComment}
+                handleStartDeleteComment={handleStartDeleteComment}
+                handleCancelDeleteComment={handleCancelDeleteComment}
+                handleConfirmDeleteComment={handleConfirmDeleteComment}
                 isAdmin={isAdmin}
-                handleOpenCommentDeleteModal={handleOpenCommentDeleteModal}
               />
             ))}
           </div>
@@ -765,33 +954,101 @@ function ReplyRow({
   item,
   onReply,
   currentUserPublicId,
+  isEditing,
+  editCommentText,
+  setEditCommentText,
+  editCommentPassword,
+  setEditCommentPassword,
+  editCommentError,
+  submittingEditComment,
+  handleStartEditComment,
+  handleCancelEditComment,
+  handleUpdateComment,
+  activeDeleteCommentId,
+  deleteCommentPassword,
+  setDeleteCommentPassword,
+  deleteCommentError,
+  submittingDeleteComment,
+  handleStartDeleteComment,
+  handleCancelDeleteComment,
+  handleConfirmDeleteComment,
   isAdmin,
-  handleOpenCommentDeleteModal,
 }: {
   item: CommentItem;
   onReply: () => void;
   currentUserPublicId: string | null;
+  isEditing: boolean;
+  editCommentText: string;
+  setEditCommentText: (text: string) => void;
+  editCommentPassword: string;
+  setEditCommentPassword: (password: string) => void;
+  editCommentError: string;
+  submittingEditComment: boolean;
+  handleStartEditComment: (comment: CommentItem) => void;
+  handleCancelEditComment: () => void;
+  handleUpdateComment: (comment: CommentItem) => Promise<void>;
+  activeDeleteCommentId: number | null;
+  deleteCommentPassword: string;
+  setDeleteCommentPassword: (password: string) => void;
+  deleteCommentError: string;
+  submittingDeleteComment: boolean;
+  handleStartDeleteComment: (commentId: number) => void;
+  handleCancelDeleteComment: () => void;
+  handleConfirmDeleteComment: (comment: CommentItem) => Promise<void>;
   isAdmin: boolean;
-  handleOpenCommentDeleteModal: (comment: CommentItem) => void;
 }) {
+  const canEdit = canEditComment(item, currentUserPublicId);
   const canDelete = canDeleteComment(item, currentUserPublicId, isAdmin);
+
   return (
     <div className="ml-5 border-l-2 border-black pl-5">
       <div className="flex items-center justify-between gap-3">
         <span className={`font-bold ${item.isDeleted ? "text-[var(--snow-faint)]" : "text-black"}`}>{getWriterName(item)}</span>
-        <span className="font-mono text-xs text-[var(--snow-muted)]">
-          {new Date(item.createdAt).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })}
-        </span>
+        <div className="flex items-center">
+          <span className="font-mono text-xs text-[var(--snow-muted)]">
+            {formatCommentDate(item.createdAt)}
+          </span>
+          {canDelete && (
+            <CommentDeleteInline
+              comment={item}
+              currentUserPublicId={currentUserPublicId}
+              isAdmin={isAdmin}
+              isActive={activeDeleteCommentId === item.commentId}
+              onOpen={() => handleStartDeleteComment(item.commentId)}
+              onClose={handleCancelDeleteComment}
+              password={deleteCommentPassword}
+              setPassword={setDeleteCommentPassword}
+              error={activeDeleteCommentId === item.commentId ? deleteCommentError : ""}
+              submitting={submittingDeleteComment}
+              onConfirm={() => void handleConfirmDeleteComment(item)}
+            />
+          )}
+        </div>
       </div>
-      <p className={`mt-2 leading-7 ${item.isDeleted ? "text-[var(--snow-faint)] italic" : "text-[var(--snow-ink-soft)]"}`}>{item.content}</p>
-      {!item.isDeleted && (
+      {isEditing ? (
+        <CommentEditForm
+          comment={item}
+          content={editCommentText}
+          setContent={setEditCommentText}
+          password={editCommentPassword}
+          setPassword={setEditCommentPassword}
+          error={editCommentError}
+          submitting={submittingEditComment}
+          requiresPassword={item.isAnonymous && !currentUserPublicId}
+          onCancel={handleCancelEditComment}
+          onSubmit={() => void handleUpdateComment(item)}
+        />
+      ) : (
+        <p className={`mt-2 leading-7 ${item.isDeleted ? "text-[var(--snow-faint)] italic" : "text-[var(--snow-ink-soft)]"}`}>{item.content}</p>
+      )}
+      {!item.isDeleted && !isEditing && (
         <div className="mt-3 flex gap-4 font-mono text-xs font-bold uppercase tracking-[0.06em]">
           <button type="button" onClick={onReply} className="text-black">
             답글 쓰기
           </button>
-          {canDelete && (
-            <button type="button" onClick={() => handleOpenCommentDeleteModal(item)} className="text-[var(--snow-error)]">
-              삭제
+          {canEdit && (
+            <button type="button" onClick={() => handleStartEditComment(item)} className="text-black">
+              수정
             </button>
           )}
         </div>
@@ -800,13 +1057,216 @@ function ReplyRow({
   );
 }
 
+function CommentEditForm({
+  comment,
+  content,
+  setContent,
+  password,
+  setPassword,
+  error,
+  submitting,
+  requiresPassword,
+  onCancel,
+  onSubmit,
+}: {
+  comment: CommentItem;
+  content: string;
+  setContent: (content: string) => void;
+  password: string;
+  setPassword: (password: string) => void;
+  error: string;
+  submitting: boolean;
+  requiresPassword: boolean;
+  onCancel: () => void;
+  onSubmit: () => void;
+}) {
+  const contentId = `comment-edit-content-${comment.commentId}`;
+  const passwordId = `comment-edit-password-${comment.commentId}`;
+
+  return (
+    <div className="mt-3 rounded border border-[var(--snow-border)] bg-[var(--snow-background)] p-4">
+      <label htmlFor={contentId} className="font-mono text-xs font-bold text-[var(--snow-muted)]">
+        댓글 내용
+      </label>
+      <textarea
+        id={contentId}
+        rows={3}
+        maxLength={1000}
+        value={content}
+        disabled={submitting}
+        onChange={(event) => setContent(event.target.value)}
+        className="snow-textarea mt-2 min-h-[100px]"
+      />
+      <div className="mt-1 text-right font-mono text-xs text-[var(--snow-muted)]">{content.length}/1000</div>
+      {requiresPassword && (
+        <div className="mt-3">
+          <label htmlFor={passwordId} className="font-mono text-xs font-bold text-[var(--snow-muted)]">
+            익명 비밀번호
+          </label>
+          <input
+            id={passwordId}
+            type="password"
+            value={password}
+            disabled={submitting}
+            onChange={(event) => setPassword(event.target.value)}
+            placeholder="●●●●"
+            className="snow-input mt-2 w-full sm:w-52"
+          />
+        </div>
+      )}
+      {error && <p className="mt-3 text-sm font-bold text-[var(--snow-error)]">{error}</p>}
+      <div className="mt-4 flex justify-end gap-2">
+        <button type="button" disabled={submitting} onClick={onCancel} className="snow-btn-secondary">
+          취소
+        </button>
+        <button type="button" disabled={submitting} onClick={onSubmit} className="snow-btn-primary">
+          {submitting ? "수정 중..." : "수정 완료"}
+        </button>
+      </div>
+    </div>
+  );
+}
+
 function getWriterName(comment: CommentItem) {
   if (comment.isAnonymous) return `익명 (${comment.writerIp})`;
   return comment.writer?.nickname || "알 수 없음";
 }
 
-function canDeleteComment(comment: CommentItem, currentUserPublicId: string | null, isAdmin: boolean) {
+function canEditComment(comment: CommentItem, currentUserPublicId: string | null) {
+  if (comment.isDeleted) return false;
+  if (comment.isAnonymous) return true;
+  return Boolean(currentUserPublicId && comment.writer?.publicId === currentUserPublicId);
+}
+
+function updateCommentContent(comments: CommentItem[], commentId: number, content: string) {
+  return comments.map((comment) => {
+    if (comment.commentId === commentId) return { ...comment, content };
+    return {
+      ...comment,
+      previewReplies: comment.previewReplies.map((reply) =>
+        reply.commentId === commentId ? { ...reply, content } : reply,
+      ),
+    };
+  });
+}
+
+function CommentDeleteInline({
+  comment,
+  currentUserPublicId,
+  isAdmin,
+  isActive,
+  onOpen,
+  onClose,
+  password,
+  setPassword,
+  error,
+  submitting,
+  onConfirm,
+}: {
+  comment: CommentItem;
+  currentUserPublicId: string | null;
+  isAdmin: boolean;
+  isActive: boolean;
+  onOpen: () => void;
+  onClose: () => void;
+  password: string;
+  setPassword: (val: string) => void;
+  error: string;
+  submitting: boolean;
+  onConfirm: () => void;
+}) {
+  const isOwnerMember = !comment.isAnonymous && currentUserPublicId && comment.writer?.publicId === currentUserPublicId;
+  const isOwnerAnonMember = comment.isAnonymous && currentUserPublicId && comment.writer?.publicId === currentUserPublicId;
+  const requiresPassword = !isAdmin && !isOwnerMember && !isOwnerAnonMember;
+
+  return (
+    <div className="relative inline-flex items-center">
+      <button
+        type="button"
+        onClick={isActive ? onClose : onOpen}
+        className={`ml-1.5 inline-flex h-4 w-4 items-center justify-center rounded-[2px] text-[10px] font-bold transition cursor-pointer ${
+          isActive ? "bg-black text-white" : "bg-gray-300/80 text-white hover:bg-gray-400"
+        }`}
+        title={isActive ? "취소" : "댓글 삭제"}
+      >
+        ✕
+      </button>
+
+      {isActive && (
+        <>
+          {/* 외부 클릭 시 닫히도록 투명 백드롭 오버레이 */}
+          <div className="fixed inset-0 z-40" onClick={onClose} />
+
+          {/* 시간 및 아이콘 바로 아래에 완벽하게 플로팅되는 팝오버 (레이아웃 밀림 0) */}
+          <div className="absolute right-0 top-full mt-1.5 z-50 flex items-center bg-[#1c2e5c] border border-black shadow-xl rounded-xs">
+            {requiresPassword ? (
+              <input
+                type="password"
+                placeholder="비밀번호"
+                value={password}
+                onChange={(e) => setPassword(e.target.value)}
+                onKeyDown={(e) => {
+                  if (e.key === "Enter") {
+                    e.preventDefault();
+                    onConfirm();
+                  } else if (e.key === "Escape") {
+                    onClose();
+                  }
+                }}
+                autoFocus
+                className="h-6 w-28 bg-white px-1.5 text-xs text-black outline-none border-r border-black placeholder:text-gray-400"
+              />
+            ) : (
+              <span className="h-6 flex items-center px-2 text-[11px] font-medium text-white select-none whitespace-nowrap border-r border-[#2a4078]">
+                삭제할까요?
+              </span>
+            )}
+            <button
+              type="button"
+              onClick={onConfirm}
+              disabled={submitting}
+              className="h-6 px-2.5 text-xs font-bold text-white hover:bg-[#283f7a] transition-colors border-r border-[#2a4078] disabled:opacity-50 whitespace-nowrap cursor-pointer"
+            >
+              {submitting ? "..." : "확인"}
+            </button>
+            <button
+              type="button"
+              onClick={onClose}
+              className="h-6 px-1.5 text-xs font-bold text-white hover:bg-[#283f7a] transition-colors cursor-pointer"
+              title="취소"
+            >
+              ✕
+            </button>
+            {error && (
+              <div className="absolute right-0 top-full mt-1 z-50 rounded border border-red-300 bg-red-50 px-2 py-0.5 text-[11px] font-bold text-red-600 shadow-md whitespace-nowrap">
+                {error}
+              </div>
+            )}
+          </div>
+        </>
+      )}
+    </div>
+  );
+}
+
+function formatCommentDate(dateString: string): string {
+  try {
+    const d = new Date(dateString);
+    if (isNaN(d.getTime())) return dateString;
+    const mm = String(d.getMonth() + 1).padStart(2, "0");
+    const dd = String(d.getDate()).padStart(2, "0");
+    const hh = String(d.getHours()).padStart(2, "0");
+    const min = String(d.getMinutes()).padStart(2, "0");
+    const ss = String(d.getSeconds()).padStart(2, "0");
+    return `${mm}.${dd} ${hh}:${min}:${ss}`;
+  } catch {
+    return dateString;
+  }
+}
+
+function canDeleteComment(comment: CommentItem, currentUserPublicId: string | null, isAdmin: boolean): boolean {
   if (comment.isDeleted) return false;
-  if (isAdmin || comment.isAnonymous) return true;
+  if (isAdmin) return true;
+  if (comment.isAnonymous) return true;
   return Boolean(currentUserPublicId && comment.writer?.publicId === currentUserPublicId);
 }

From 391aedb2cd8f17a9c534c559fa8d85ddcd313d57 Mon Sep 17 00:00:00 2001
From: ikae <ikaesujeel@gmail.com>
Date: Fri, 4 Sep 2026 14:02:05 +0900
Subject: [PATCH 5/6] =?UTF-8?q?chore:=20next-env.d.ts=20=EB=9D=BC=EC=9A=B0?=
 =?UTF-8?q?=ED=8A=B8=20=ED=83=80=EC=9E=85=20=EB=8F=99=EA=B8=B0=ED=99=94=20?=
 =?UTF-8?q?=EB=B0=8F=20=EA=B5=AC=EB=B2=84=EC=A0=84=20=EB=AC=B8=EC=84=9C=20?=
 =?UTF-8?q?=EC=A0=95=EB=A6=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...53\267\260_\353\266\204\353\246\254API.md" |   2 +-
 docs/specs/comment_policy.md                  |  56 --
 ...dySprint02BoardIssuesAndSolutions260821.md | 593 ---------------
 .../studySprint02PostDomainIssues260821.md    | 191 -----
 docs/studyApiDesign260808.md                  |  80 --
 docs/studyArchConcepts260806.md               | 313 --------
 docs/studyArchPrinciples260810.md             |  72 --
 docs/studyCommunityPostCommentMaster260821.md | 710 ------------------
 docs/studyDomainErd260807.md                  | 107 ---
 docs/studyPkStrategy260807.md                 | 133 ----
 docs/studySessionAuth260806.md                |  67 --
 docs/studySessionFlow260810.md                |  83 --
 docs/studySystemArch260810.md                 |  87 ---
 ...sprint01_session_concurrency_jpa_260817.md | 539 -------------
 frontend/next-env.d.ts                        |   2 +-
 15 files changed, 2 insertions(+), 3033 deletions(-)
 delete mode 100644 docs/specs/comment_policy.md
 delete mode 100644 docs/study/studySprint02BoardIssuesAndSolutions260821.md
 delete mode 100644 docs/study/studySprint02PostDomainIssues260821.md
 delete mode 100644 docs/studyApiDesign260808.md
 delete mode 100644 docs/studyArchConcepts260806.md
 delete mode 100644 docs/studyArchPrinciples260810.md
 delete mode 100644 docs/studyCommunityPostCommentMaster260821.md
 delete mode 100644 docs/studyDomainErd260807.md
 delete mode 100644 docs/studyPkStrategy260807.md
 delete mode 100644 docs/studySessionAuth260806.md
 delete mode 100644 docs/studySessionFlow260810.md
 delete mode 100644 docs/studySystemArch260810.md
 delete mode 100644 docs/study_sprint01_session_concurrency_jpa_260817.md

diff --git "a/docs/conception/sprint03/spike_\355\225\230\354\235\264\353\270\214\353\246\254\353\223\234\355\224\204\353\246\254\353\267\260_\353\266\204\353\246\254API.md" "b/docs/conception/sprint03/spike_\355\225\230\354\235\264\353\270\214\353\246\254\353\223\234\355\224\204\353\246\254\353\267\260_\353\266\204\353\246\254API.md"
index edca094..f2638e1 100644
--- "a/docs/conception/sprint03/spike_\355\225\230\354\235\264\353\270\214\353\246\254\353\223\234\355\224\204\353\246\254\353\267\260_\353\266\204\353\246\254API.md"
+++ "b/docs/conception/sprint03/spike_\355\225\230\354\235\264\353\270\214\353\246\254\353\223\234\355\224\204\353\246\254\353\267\260_\353\266\204\353\246\254API.md"
@@ -2,7 +2,7 @@
 
 - **브랜치명**: `devikae/sprint03-spikeTest-03-Batch/API`
 - **측정 일시**: 2026-08-29
-- **작성자**: devikae (자동 생성)
+- **작성자**: devikae 
 
 ---
 
diff --git a/docs/specs/comment_policy.md b/docs/specs/comment_policy.md
deleted file mode 100644
index f712d27..0000000
--- a/docs/specs/comment_policy.md
+++ /dev/null
@@ -1,56 +0,0 @@
-# 📜 Snowthing 댓글/대댓글 도메인 공식 제품 규칙 명세서 (Comment Domain Policy)
-
-본 문서는 Snowthing 커뮤니티의 댓글 및 대댓글 도메인의 계층, 화면 응답, 삭제 및 카운트, 정렬 및 권한 정책을 정의한 공식 기술 명세서입니다.
-
----
-
-## 1. 계층 규칙 (Hierarchy Rules)
-- **2-Depth 고정 구조**: 댓글(Root)과 대댓글(Child)로만 이루어진 2단계 계층 구조를 채택합니다.
-- **평탄화(Flattening) 정책**: 대댓글에 다시 답글을 작성하는 경우, 부모 대댓글의 ID가 아닌 **최상위 Root 댓글의 `comment_id`를 `parent_id`로 자동 지정**하여 2단계를 초과하는 계층 생성을 물리적으로 방지합니다.
-
----
-
-## 2. 화면 및 응답 규칙 (UI & Response Rules)
-- **초기 로딩 크기**: 게시글 상세 진입 시 루트 댓글은 **1페이지당 20개** 기준으로 조회합니다.
-- **대댓글 노출 및 접기**:
-  - 각 루트 댓글 하위의 대댓글은 **기본 5개**까지 펼쳐서 노출합니다.
-  - 5개를 초과하는 대댓글은 **"답글 더보기(N개)"** UI로 접힘 처리하여 사용자가 클릭 시 추가 렌더링합니다.
-- **최대 대댓글 제한**: 루트 댓글 1개당 작성 가능한 대댓글 수는 **최대 100개**로 제한합니다 (100개 도달 시 400 Bad Request 에러 반환).
-
----
-
-## 3. 삭제 및 카운트 규칙 (Deletion & Count Rules)
-- **삭제된 루트 + 대댓글 존재 시**:
-  - 루트 댓글 본문은 `"삭제된 댓글입니다."` placeholder로 대체 노출 (`is_deleted = true`).
-  - 하위 대댓글들은 정상적으로 노출을 유지합니다.
-- **삭제된 루트 댓글에 신규 대댓글 작성**: **허용**. (대화 맥락 유지를 위해 삭제된 부모 밑에도 신규 답글 작성 가능)
-- **삭제된 대댓글 노출**: 대댓글 삭제 시에도 `"삭제된 댓글입니다."` placeholder로 대체 노출 (`is_deleted = true`).
-- **부모 + 자식 모두 삭제된 노드(고아 노드)**:
-  - 루트 댓글이 삭제되고, 그 하위의 모든 대댓글도 삭제된 경우 **화면(클라이언트 응답 목록)에서 완전히 숨김(은닉)** 처리합니다.
-- **`post.commentCount` (게시글 총 댓글 수)**:
-  - **"삭제된 댓글입니다"를 제외한 실제 살아있는 활성 댓글/대댓글(`is_deleted = false`)의 총합**만 카운트합니다.
-  - Soft Delete 실행 시 즉시 `comment_count - 1` 벌크 차감.
-- **`replyCount` (대댓글 수)**:
-  - 각 루트 댓글 DTO에 포함되는 `replyCount`는 **삭제된 대댓글을 제외한 실제 활성 대댓글 수**만 집계합니다.
-
----
-
-## 4. 정렬 및 권한 규칙 (Ordering & Permission Rules)
-- **루트 댓글 정렬**: **등록순 / 오래된 순 (`ORDER BY created_at ASC, comment_id ASC`)**
-- **대댓글 정렬**: **등록순 / 오래된 순 (`ORDER BY created_at ASC, comment_id ASC`)**
-- **결정론적 순서 고정**: 동일 생성 시각 발생 시 PK 타이브레이커(`comment_id ASC`)를 필수 적용하여 순서 뒤바뀜을 원천 방지합니다.
-
-### 🔐 4대 사용자 권한 매트릭스
-| 구분 | 작성(Create) 규칙 | 삭제(Delete) 규칙 |
-| :--- | :--- | :--- |
-| **1. 일반 회원** | 로그인 필수, 본인 닉네임/프로필 노출 | **비밀번호 불필요**, 본인 로그인 세션으로 즉시 삭제 |
-| **2. 로그인 익명** | 로그인 필수, 화면에는 `익명 (IP)` 노출 | **비밀번호 불필요**, 본인 로그인 세션 일치 시 즉시 삭제 |
-| **3. 비로그인 익명** | 로그인 불필요, `anonymousPassword` (4자리 이상) 필수 | **비밀번호 필수**, Request Body JSON 비밀번호 일치 시 삭제 |
-| **4. 최고 관리자 (`ROLE_ADMIN`)** | 관리자 권한으로 작성 | **비밀번호 불필요**, 어떤 댓글이든 즉시 강제 삭제 |
-
----
-
-## 5. 향후 확장 정책 (Future Expansion)
-- **베스트 댓글(Best Comments) 상단 고정**:
-  - 댓글 추천 기능 도입 시, **추천수 상위 3개 댓글을 목록 최상단에 뱃지와 함께 고정(Pinning)** 노출합니다.
-  - 베스트 댓글은 본문만 우선 노출하며, "답글 읽기" 클릭 시 대댓글을 조회할 수 있도록 구성합니다.
diff --git a/docs/study/studySprint02BoardIssuesAndSolutions260821.md b/docs/study/studySprint02BoardIssuesAndSolutions260821.md
deleted file mode 100644
index 565d5d4..0000000
--- a/docs/study/studySprint02BoardIssuesAndSolutions260821.md
+++ /dev/null
@@ -1,593 +0,0 @@
-# 📚 [Master Study Guide] Sprint 02 커뮤니티 게시판 5대 아키텍처 문제점 & 10대 대체 기술(Alternatives) 7대 필수 요소 상세 가이드 (2026-08-21)
-
-> **노션(Notion) 복사용 및 백엔드 기술 면접 / 시스템 아키텍처 심화 학습용 마스터 가이드**  
-> 본 문서는 Snowthing 커뮤니티 도메인(게시글 Post & 댓글/대댓글 Comment) 구축 시 발생할 수 있는 **5대 핵심 아키텍처 문제점**과 **10대 대체 기술(Alternatives)**에 대해, **7대 필수 서술 요소 체계(개념, Why, When, How 코드/SQL, Pros, Cons & Trade-off, 서비스/아키텍처 레벨 극복 방안)** 중 **극복 방안(Mitigation)을 물리적 원리와 코드 수준으로 파헤쳐 수록한 완성판 학습 문서**입니다.
-
----
-
-# 📑 PART 1. 5대 핵심 문제점 심층 파헤치기 (문제 & 극복 방안 딥다이브)
-
----
-
-## 1. 💥 [댓글] 이미 삭제된 댓글 재삭제 시 `comment_count` 음수 차감 및 카운터 정합성 오염 문제
-
-### ① 개념 (What - 문제의 명확한 정의)
-Soft Delete(논리 삭제) 처리된 댓글에 대해 동시 요청(Race Condition)이나 무효한 삭제 요청이 들어왔을 때, 게시글 엔티티의 역정규화 컬럼인 `post.comment_count`가 계속 차감되어 **수치가 0 미만인 `-1`, `-2`로 오염되는 정합성 파괴 현상**입니다.
-
-### ② 발생 원인 (Why - 물리적 & DB 메커니즘)
-- [`CommentService.java`](file:///c:/Users/ikaes/IdeaProjects/snowthing/backend/src/main/java/com/ikae/snowthing/domain/comment/service/CommentService.java) `deleteComment()` 메서드에서 `comment.softDelete()` 호출 후 `post.decreaseCommentCount()`를 실행합니다.
-- 트랜잭션 격리 수준(Read Committed) 환경에서 동일한 댓글 삭제 요청이 동시에 2건 들어오면, Thread 1과 Thread 2가 모두 `comment.isDeleted() == false` 상태를 읽게 됩니다.
-- Thread 1이 먼저 `comment.softDelete()` 후 `comment_count`를 1 ➔ 0으로 차감하고 COMMIT 되더라도, 이미 검증을 통과한 Thread 2가 뒤이어 `comment_count`를 0 ➔ -1로 차감하여 쿼리를 전송하므로 음수가 발생합니다.
-
-### ③ 언제 발생하는지 (When - 적합한 발생 상황)
-- 클라이언트 네트워크 지연으로 사용자가 삭제 버튼을 빠른 속도로 연타(광클)할 때
-- 관리자 댓글 강제 삭제 API와 일반 유저의 삭제 요청이 동시에 백엔드로 인커밍될 때
-
-### ④ 어떻게 발생하는지 (How - 실제 코드 & DB 쿼리 실행 메커니즘)
-```
-[Thread 1] SELECT * FROM comment WHERE id = 1 (is_deleted = false)
-[Thread 2] SELECT * FROM comment WHERE id = 1 (is_deleted = false)
-[Thread 1] UPDATE comment SET is_deleted = true WHERE id = 1
-[Thread 1] UPDATE post SET comment_count = comment_count - 1 WHERE id = 10 (1 -> 0) -> COMMIT
-[Thread 2] UPDATE comment SET is_deleted = true WHERE id = 1
-[Thread 2] UPDATE post SET comment_count = comment_count - 1 WHERE id = 10 (0 -> -1) -> COMMIT [음수 오염!]
-```
-
-### ⑤ 부정적 영향 (Pros & Cons of Ignoring - 미해결 시 여파)
-- **비즈니스 결함**: 게시판 목록 조회 시 댓글이 0개임에도 `댓글 [-1]`로 노출되어 사용자 서비스 신뢰도 실추.
-- **DB 쿼리 오류**: 댓글 수 정렬(`ORDER BY comment_count DESC`) 쿼리 실행 시 정렬 순서가 꼬여 인기 게시글 추출 알고리즘이 파괴됨.
-
-### ⑥ 기존 처리 방식과의 비교 및 한계점 (Alternatives vs Existing)
-- **기존 방식**: 자바 서비스 메서드 내 `if (comment.isDeleted()) throw ...` 단순 예외 검사.
-- **한계점**: 동시성 멀티 스레드 환경에서는 SELECT 시점의 스냅샷이 동일하므로 자바 `if` 문 검사가 무용지물이 됨.
-
-### ⑦ 트레이드오프 및 서비스/아키텍처 레벨 극복 방안 (Trade-off & Detailed Mitigation)
-- **트레이드오프**: 단순 자바 로직 방어가 불가능하므로 DB 레벨의 제약 조건이나 원자적 SQL 연산으로 이관해야 하는 오버헤드 발생.
-- **서비스 레벨 극복 방안 (UX 폴백)**:
-  - 프론트엔드 댓글 카운트 렌더링 시 `Math.max(0, count)` 처리로 만에 하나 백엔드 오염이 발생하더라도 유저 화면에는 `-1`이 아닌 `0`으로 표시되도록 사용자 시각 차단 폴백을 적용합니다.
-- **아키텍처 레벨 극복 방안 (엔티티 캡슐화 & DB Constraint)**:
-  - 1차적으로 `Post` JPA 엔티티 내 도메인 메서드 `decreaseCommentCount()` 내부에 `this.commentCount = Math.max(0, this.commentCount - 1)` 방어 로직을 캡슐화합니다.
-  - 2차적으로 DB `POST` 테이블에 `ALTER TABLE post ADD CONSTRAINT chk_post_comment_count CHECK (comment_count >= 0)` DDL 제약 조건을 추가하여, DB 엔진이 커밋 시점에 음수 업데이트 시도를 물리적으로 거부하고 예외를 내도록 이중 방어망을 구축합니다.
-
----
-
-## 2. 💥 [게시글] 인기 글 상세 조회 시 `increaseViewCount()` 쓰기 락(Row Lock) 병목 문제
-
-### ① 개념 (What - 문제의 명확한 정의)
-유저가 게시글 상세 페이지를 읽을 때마다 동기 트랜잭션(`@Transactional`) 내에서 `UPDATE post SET view_count = view_count + 1` 쓰기 쿼리가 날아가 DB 쓰기 병목(Lock Contention)이 발생하는 현상입니다.
-
-### ② 발생 원인 (Why - 물리적 & DB 메커니즘)
-- RDBMS(MySQL InnoDB)는 단일 행(Row)에 대한 `UPDATE` 쿼리 실행 시 해당 행에 배타적 쓰기 락(Exclusive Row Lock, X-Lock)을 겁니다.
-- 읽기(Read) 요청임에도 불구하고 쓰기 락이 발생하여, 동시 진입한 수천 개의 트랜잭션이 동일한 게시글 Row Lock을 획득하기 위해 줄을 서서 대기합니다.
-
-### ③ 언제 발생하는지 (When - 적합한 발생 상황)
-- 메인 화면에 노출된 인기 핫딜, 긴급 공지사항, 리조트 실시간 제보 글 등 특정 핫 게시글에 수천 명의 동접자가 동시에 클릭할 때
-
-### ④ 어떻게 발생하는지 (How - 실제 코드 & DB 쿼리 실행 메커니즘)
-```
-[유저 1000명 동시 요청] GET /api/posts/{publicId}
- └── PostService.getPostDetail() 진입 (@Transactional)
-      └── DB Connection Pool 1000개 고갈
-           └── UPDATE post SET view_count = view_count + 1 WHERE post_id = 1 (Row Lock 대기)
-                └── 5초 후 DB Connection Timeout 예외 발생 -> 504 Gateway Timeout
-```
-
-### ⑤ 부정적 영향 (Pros & Cons of Ignoring - 미해결 시 여파)
-- **캐스케이딩 장애 (Cascading Failure)**: 인기 글 1개의 조회수 락 병목으로 인해 DB 커넥션 풀이 고갈되어, 로그인, 게시글 작성 등 서비스 전체 API가 마비됨.
-
-### ⑥ 기존 처리 방식과의 비교 및 한계점 (Alternatives vs Existing)
-- **기존 방식**: JPA `@Modifying @Query` Bulk Update 호출.
-- **한계점**: 영속성 컨텍스트 스냅샷 비교는 줄였지만, DB InnoDB Row Lock 형성 자체를 피할 수는 없음.
-
-### ⑦ 트레이드오프 및 서비스/아키텍처 레벨 극복 방안 (Trade-off & Detailed Mitigation)
-- **트레이드오프**: 조회수를 실시간으로 DB에 동기 기록하는 아키텍처를 포기해야 함.
-- **서비스 레벨 극복 방안 (가용성 우선 정책)**:
-  - 조회수 반영에 10분의 미세한 시차가 발생하더라도, 유저가 글을 읽을 때 페이지 로딩 속도를 최우선으로 확보하는 가용성(Availability) 우선 서비스 정책을 수립합니다.
-- **아키텍처 레벨 극복 방안 (Redis 쓰기 격리 & Write-Back 배치)**:
-  - 유저가 글을 읽을 때 DB `UPDATE` 쿼리를 100% 제거하고, Redis `INCR post:view_count:{id}` 명령으로 인메모리 단에서 조회수만 가산합니다.
-  - 백그라운드 스프링 `@Scheduled(cron = "0 */10 * * * *")` 스케줄러가 Redis에 누적된 수치를 읽어 10분마다 DB `post.view_count` 컬럼으로 일괄 Bulk Write-Back (`UPDATE post SET view_count = view_count + :incr`)을 수행함으로써 DB Row Lock 형성 자체를 완전히 분리합니다.
-
----
-
-## 3. 💥 [추천 비동기] `@Async` 비동기 카운터 유실 시 투표 이력과 카운트 수치 불일치 문제
-
-### ① 개념 (What - 문제의 명확한 정의)
-추천 투표 시 `post_reaction` 테이블 저장은 성공적으로 COMMIT 되었으나, 비동기로 카운터를 올리는 `@Async` 핸들러가 예외나 서버 셧다운으로 유실될 때 데이터 불일치가 남는 현상입니다.
-
-### ② 발생 원인 (Why - 물리적 & DB 메커니즘)
-- 메인 트랜잭션 Thread는 `reactionRepository.save()` 후 DB COMMIT을 치고 즉시 200 OK를 응답합니다.
-- 스프링의 `@Async` 비동기 스레드 풀에서 실행되는 [`PostReactionEventListener`](file:///c:/Users/ikaes/IdeaProjects/snowthing/backend/src/main/java/com/ikae/snowthing/domain/post/event/PostReactionEventListener.java)가 실행 중 DB 락 타임아웃이나 OOM, 서버 재부팅을 만나면 카운트 `UPDATE` 쿼리가 날아가지 못하고 사라집니다.
-
-### ③ 언제 발생하는지 (When - 적합한 발생 상황)
-- 서버 배포 시점, 서버 셧다운, DB 일시적 네트워크 흔들림 또는 비동기 스레드 풀(Thread Pool) 큐가 가득 찼을 때
-
-### ④ 어떻게 발생하는지 (How - 실제 코드 & DB 쿼리 실행 메커니즘)
-```
-[Main Thread] post_reaction INSERT (post_id=1, member_id=5, type='LIKE') -> COMMIT 완료
-[Main Thread] eventPublisher.publishEvent() -> 200 OK 응답
-[Async Thread] @Async handleEvent() 실행 중 DB Timeout 터짐 -> UPDATE post SET like_count = like_count + 1 실패!
-[결과] post_reaction 에는 1건 존재하나, post.like_count는 0으로 동기화 실패 (데이터 정합성 파괴)
-```
-
-### ⑤ 부정적 영향 (Pros & Cons of Ignoring - 미해결 시 여파)
-- **사용자 경험(UX) 악화**: 유저는 "추천을 눌렀는데 화면 숫자가 안 오른다"고 생각하여 재투표를 시도하지만, DB 유니크 제약으로 409 Conflict 예외가 터져 혼란 야기.
-
-### ⑥ 기존 처리 방식과의 비교 및 한계점 (Alternatives vs Existing)
-- **기존 방식**: `@Async` 백그라운드 단순 이벤트 발행.
-- **한계점**: JVM 인메모리 큐에 보관되므로 서버 재부팅 시 이벤트가 100% 영구 유실됨.
-
-### ⑦ 트레이드오프 및 서비스/아키텍처 레벨 극복 방안 (Trade-off & Detailed Mitigation)
-- **트레이드오프**: 단순 비동기 이벤트 대신 DB 기반 아웃박스 테이블이나 스케줄러 배치를 도입해야 함.
-- **서비스 레벨 극복 방안 (Optimistic UI 렌더링)**:
-  - 백엔드의 처리 시차나 유실에 관계없이 프론트엔드에서 추천 버튼 클릭 즉시 추천 버튼 색상을 바꾸고 숫자 수치를 +1 가산하여 유저가 지연을 느끼지 않도록 처리합니다.
-- **아키텍처 레벨 극복 방안 (Transactional Outbox & 새벽 정정 배치)**:
-  - 1차적으로 Transactional Outbox Pattern을 채택하여 `outbox` 테이블에 메인 트랜잭션과 동일 커밋을 수행함으로써 이벤트 유실을 방지합니다.
-  - 2차 보완으로 매일 새벽 4시마다 `ScheduledReckoningBatch`를 실행하여 `SELECT COUNT(*) FROM post_reaction WHERE post_id = :id AND type = 'LIKE'` 수치와 `post.like_count` 수치를 비교하고, 다를 경우 올바른 수치로 자동 보정하여 100% 최종 일관성(Eventual Consistency)을 달성합니다.
-
----
-
-## 4. 💥 [대댓글] 3차 이상 무한 깊이 대댓글 작성 시 프론트엔드 UI 파괴 문제
-
-### ① 개념 (What - 문제의 명확한 정의)
-대댓글의 대댓글(3차), 4차, 10차 대댓글 작성 시 프론트엔드의 고정 들여쓰기(`marginLeft`)로 인해 모바일 및 웹 화면 우측 밖으로 본문 텍스트가 삐져나가는 UI 깨짐 현상입니다.
-
-### ② 발생 원인 (Why - 물리적 & DB 메커니즘)
-- 백엔드 [`CommentService.java`](file:///c:/Users/ikaes/IdeaProjects/snowthing/backend/src/main/java/com/ikae/snowthing/domain/comment/service/CommentService.java)에서 `parentId` 검증 시 부모가 '원댓글(1차)'인지 '대댓글(2차)'인지 검사하는 depth 제한 로직이 누락됨.
-- 프론트엔드는 계층 구조에 따라 `marginLeft = depth * 1.5rem`으로 스타일을 렌더링함.
-
-### ③ 언제 발생하는지 (When - 적합한 발생 상황)
-- 악의적인 사용자가 대댓글의 ID를 부모로 삼아 N차 대댓글을 연속 작성하거나 타사 스크립트로 API를 직접 호출할 때
-
-### ④ 어떻게 발생하는지 (How - 실제 코드 & DB 쿼리 실행 메커니즘)
-```
-10차 대댓글 작성 -> depth = 10
- └── 프론트엔드: <div style="margin-left: 15rem (240px)">
-      └── 모바일 화면 폭(360px) 중 본문 영역이 120px로 축소됨 -> 1글자씩 세로 줄바꿈 및 화면 우측 이탈
-```
-
-### ⑤ 부정적 영향 (Pros & Cons of Ignoring - 미해결 시 여파)
-- **서비스 사용 불능**: 모바일 사용자가 게시글 및 댓글을 정상적으로 읽을 수 없어 서비스 가독성 파괴.
-
-### ⑥ 기존 처리 방식과의 비교 및 한계점 (Alternatives vs Existing)
-- **기존 방식**: 부모 존재 여부(`parentId != null`)만 검증.
-- **한계점**: 부모 댓글의 부모가 존재하는지(2차 깊이 이상인지) 검증하지 않아 무한 깊이 생성을 막지 못함.
-
-### ⑦ 트레이드오프 및 서비스/아키텍처 레벨 극복 방안 (Trade-off & Detailed Mitigation)
-- **트레이드오프**: 3차 이상의 깊은 토론 스레드 작성을 제한해야 함.
-- **서비스 레벨 극복 방안 (대댓글 폼 안내 & Toast 알림)**:
-  - 프론트엔드 댓글 입력창에서 대댓글의 [답글 달기] 버튼을 누를 경우 "대댓글에는 추가 답글을 작성할 수 없습니다."라는 안내 Toast 메세지를 노출하여 작성을 사전 유도 차단합니다.
-- **아키텍처 레벨 극복 방안 (백엔드 2단계 Depth Validation)**:
-  - [`CommentService.java`](file:///c:/Users/ikaes/IdeaProjects/snowthing/backend/src/main/java/com/ikae/snowthing/domain/comment/service/CommentService.java) `createComment()` 메서드 진입 시 `if (parent != null && parent.getParent() != null)` 검증 로직을 추가합니다.
-  - 부모 댓글(`parent`)이 이미 부모(`parent.getParent()`)를 가지고 있는 2차 계층 이상이라면 `CustomAuthException(ErrorCode.INVALID_INPUT, "대댓글에는 추가 답글을 작성할 수 없습니다.")` 예외(400 Bad Request)를 던져 백엔드 API 수준에서 물리적으로 원자적 차단합니다.
-
----
-
-## 5. 💥 [보안] 익명 비밀번호 URL 쿼리 스트링 평문 노출 보안 위험 문제
-
-### ① 개념 (What - 문제의 명확한 정의)
-비회원 익명 게시글/댓글 삭제 시 `DELETE /api/posts/{publicId}?anonymousPassword=1234` 형태처럼 URL 쿼리 파라미터로 비밀번호가 전송되어 웹 서버 로그에 비밀번호가 평문 저장되는 보안 문제입니다.
-
-### ② 발생 원인 (Why - 물리적 & DB 메커니즘)
-- HTTP 표준 및 웹 서버(Nginx, Apache, AWS ALB) 구현상, HTTP GET/DELETE 메서드의 URL 쿼리 스트링은 서버 Access Log의 Request Line 항목에 100% 그대로 로깅됩니다.
-
-### ③ 언제 발생하는지 (When - 적합한 발생 상황)
-- 비회원 익명 사용자가 자신이 쓴 글이나 댓글을 삭제하기 위해 비밀번호를 입력하고 삭제를 요청할 때마다 항상 발생
-
-### ④ 어떻게 발생하는지 (How - 실제 코드 & DB 쿼리 실행 메커니즘)
-```
-Client: DELETE /api/posts/p1024?anonymousPassword=secretPass123
- └── Nginx access.log 기록:
-      "192.168.1.10 - - [21/Aug/2026:17:00:00] "DELETE /api/posts/p1024?anonymousPassword=secretPass123 HTTP/1.1" 200 45"
-       └── 로그 파일 조회자에게 비회원 비밀번호 완전 노출!
-```
-
-### ⑤ 부정적 영향 (Pros & Cons of Ignoring - 미해결 시 여파)
-- **보안 컨플라이언스 위반**: 비밀번호 평문 로깅으로 인한 개인정보보호법 위반 및 서버 로그 유출 시 타 계정 도용 2차 피해.
-
-### ⑥ 기존 처리 방식과의 비교 및 한계점 (Alternatives vs Existing)
-- **기존 방식**: DB 저장 시 BCrypt 암호화 저장.
-- **한계점**: DB 저장은 안전하지만, 네트워크 전송 구간 및 Nginx 웹 서버 로그 단에서의 비밀번호 노출을 막지 못함.
-
-### ⑦ 트레이드오프 및 서비스/아키텍처 레벨 극복 방안 (Trade-off & Detailed Mitigation)
-- **트레이드오프**: URL 파라미터 전송 대신 커스텀 헤더나 무상태 토큰 방식을 적용해야 하므로 프론트엔드 연동 복잡도 증가.
-- **서비스 레벨 극복 방안 (삭제 모달 폼 보안 전송)**:
-  - 삭제 모달 팝업에서 비밀번호 입력 시 `type="password"` 상태로 암호화 입력을 보장하고, URL 쿼리 스트링 생성을 아예 프론트엔드 단에서 금지합니다.
-- **아키텍처 레벨 극복 방안 (HTTP Custom Header & HMAC 일회용 삭제 토큰)**:
-  - **방안 1**: 전송 방식을 HTTP Custom Header (`X-Anonymous-Password`)로 전환하고 Nginx `log_format` 설정에서 해당 헤더 로깅을 제외하여 로그 평문 노출을 차단합니다.
-  - **방안 2**: 무상태 HMAC-SHA256 일회용 삭제 토큰(`generateDeleteToken`) 방식을 도입하여 DB에 비밀번호 컬럼 자체가 아예 존재하지 않는 무상태 보안 검증 구조를 완성합니다.
-
----
-
-# 📑 PART 2. 10대 대체 기술(Alternatives) 7대 필수 요소 심층 분석 (극복 방안 딥다이브)
-
----
-
-## 1. 💥 [댓글] 이미 삭제된 댓글 재삭제 이슈의 2대 대안
-
-### 1-1. 대체 대안 A: DB Atomic SQL 함수 (`GREATEST`) 사용
-
-#### ① 개념 (What)
-JPA 영속 상태 변경 방식 대신, MySQL의 `GREATEST(0, comment_count - 1)` SQL 함수를 내보내 DB 엔진 단에서 차감 결과가 0 미만으로 내려가지 않도록 원자적 방어를 수행하는 기법입니다.
-
-#### ② 왜 사용하는지 (Why)
-JPA 메모리 연산 방식(`post.setCommentCount(count - 1)`)은 동시 요청 시 Dirty Read로 음수 차감이 터질 수 있으므로, DB 엔진의 Single Thread SQL 실행 메커니즘을 이용하기 위함입니다.
-
-#### ③ 어떨 때 사용하는지 (When)
-재고 차감(0개 미만 불가), 포인트 차감(0원 미만 불가), 카운터 감소 등 하한선이 명확한 차감 연산에 사용합니다.
-
-#### ④ 어떻게 사용하는지 (How - 구현 코드)
-```java
-// PostRepository.java
-@Modifying(clearAutomatically = true, flushAutomatically = true)
-@Query("UPDATE Post p SET p.commentCount = GREATEST(0, p.commentCount - 1) WHERE p.id = :postId")
-void decreaseCommentCountAtomic(@Param("postId") Long postId);
-```
-
-#### ⑤ 장점 (Pros)
-- **음수 차감 물리적 100% 방지**: MySQL 엔진이 Single Thread로 쿼리를 내보내므로 동시 요청이 10,000건 들어와도 0 아래로 내려가지 않음.
-- **영속성 스냅샷 비교 생략**: JPA 1:1 엔티티 스냅샷 비교 과정이 없어서 Execution Time 축소.
-
-#### ⑥ 다른 기술과의 비교 (Alternatives)
-- **자바 `Math.max(0, count - 1)` 방어 대비**: 자바 메모리 방어는 멀티 스레드 동시 진입 시 이미 생성된 UPDATE 쿼리를 막지 못하지만, SQL `GREATEST`는 DB 엔진 단에서 원자적 처리됨.
-
-#### ⑦ 트레이드오프 및 서비스/아키텍처 레벨 극복 방안 (Trade-off & Detailed Mitigation)
-- **트레이드오프 (JPA 1차 캐시 불일치)**: DB 컬럼은 차감되었으나 JPA 1차 캐시 엔티티 객체의 `commentCount` 수치는 갱신되지 않는 불일치 발생.
-- **서비스 레벨 극복 방안**: 댓글 삭제 응답 반환 시 개별 엔티티 수치 대신 백엔드가 방금 갱신한 정정 수치를 반환하거나 최신 목록 API를 다시 호출하도록 유도.
-- **아키텍처 레벨 극복 방안 (JPA Flush & Clear)**: `@Modifying(clearAutomatically = true, flushAutomatically = true)` 옵션을 부여하여 쿼리 실행 직후 JPA 영속성 컨텍스트를 DB로 `flush()`하고 1차 캐시를 자동으로 `clear()` 함으로써 이후 조회 쿼리가 DB의 최신 `comment_count` 수치를 패치하도록 완전 동기화.
-
----
-
-### 1-2. 대체 대안 B: 스케줄러 기반 비동기 카운터 재계산 (Scheduled Reconciliation)
-
-#### ① 개념 (What)
-댓글 작성/삭제 시 DB 카운터를 즉시 변경하지 않고, 주기적인 백그라운드 스케줄러가 실시간 `SELECT COUNT(*)` 집계 쿼리를 돌려 게시글의 `comment_count`를 일괄 정정 덮어쓰는 기법입니다.
-
-#### ② 왜 사용하는지 (Why)
-카운터 증감 연산 자체를 이관하여 쓰기 락 병목과 음수 오염 가능성을 근본 제거하기 위함입니다.
-
-#### ③ 어떨 때 사용하는지 (When)
-실시간 카운트 정확도보다 DB 쓰기 성능 및 안정성이 훨씬 중요한 대규모 커뮤니티에 적합합니다.
-
-#### ④ 어떻게 사용하는지 (How - 구현 코드)
-```java
-@Scheduled(cron = "0 */5 * * * *") // 5분마다 실행
-@Transactional
-public void reconcileCommentCounts() {
-    Set<String> dirtyPostIds = redisTemplate.opsForSet().members("dirty_posts");
-    if (dirtyPostIds == null || dirtyPostIds.isEmpty()) return;
-
-    for (String postIdStr : dirtyPostIds) {
-        Long postId = Long.parseLong(postIdStr);
-        long actualCount = commentRepository.countByPostIdAndIsDeletedFalse(postId);
-        postRepository.updateCommentCount(postId, actualCount);
-        redisTemplate.opsForSet().remove("dirty_posts", postIdStr);
-    }
-}
-```
-
-#### ⑤ 장점 (Pros)
-- **카운터 오류 근본적 해결**: 증감 연산을 하지 않고 실시간 개수를 덮어쓰므로 카운트 누수나 음수 현상이 발생할 수 없음.
-
-#### ⑥ 다른 기술과의 비교 (Alternatives)
-- **동기 `decreaseCommentCount()` 대비**: 동기 방식은 매 댓글 삭제 시 DB Row Lock을 잡지만, 스케줄러 방식은 삭제 시 Lock을 전혀 잡지 않음.
-
-#### ⑦ 트레이드오프 및 서비스/아키텍처 레벨 극복 방안 (Trade-off & Detailed Mitigation)
-- **트레이드오프 (최대 5분의 시차 발생 & 주기적 DB I/O 부하)**: 댓글 작성 직후 5분 동안은 화면 상의 댓글 수 수치가 실시간 반영되지 않고, 배치 실행 시 Full Scan 부하가 생김.
-- **서비스 레벨 극복 방안 (로컬 State 반영)**: 댓글 작성/삭제 직후 프론트엔드 로컬 State에서 수치를 임시로 +1 / -1 가산하여 렌더링함으로써 유저가 시차를 느끼지 않도록 보완.
-- **아키텍처 레벨 극복 방안 (Dirty Set Redis 수집 & 핀포인트 집계)**: 전수 조사의 DB I/O 부하를 막기 위해 댓글 CUD 발생 시 `dirty_posts` Redis Set에 `postId`를 수집하고, 스케줄러는 해당 Set에 등록된 `postId`에 대해서만 핀포인트 Range 집계 쿼리를 내보내어 DB I/O를 99% 절감.
-
----
-
-## 2. 💥 [게시글] 인기 글 상세 조회 시 쓰기 락 병목 이슈의 2대 대안
-
-### 2-1. 대체 대안 A: Redis HyperLogLog (`PFADD`) 기반 고성능 카운팅 & 중복 제거
-
-#### ① 개념 (What)
-Redis의 확률적 자료구조인 HyperLogLog(`PFADD`, `PFCOUNT`)를 활용하여, 단 12KB 메모리만으로 중복 조회를 인메모리 $O(1)$로 차단하고 조회수를 카운팅하는 기법입니다.
-
-#### ② 왜 사용하는지 (Why)
-단순 카운터나 RDBMS에 중복 IP 테이블을 만들어 저장하면 메모리와 DB 용량이 폭증합니다. HyperLogLog는 100만 건의 중복 IP를 단 12KB 메모리로 추산하므로 공간 효율성이 최상입니다.
-
-#### ③ 어떨 때 사용하는지 (When)
-대규모 트래픽 서비스의 게시글 조회수, 방문자 수(UV) 집계 및 중복 조회 방지에 사용합니다.
-
-#### ④ 어떻게 사용하는지 (How - 구현 코드)
-```java
-public void increaseViewCountWithHyperLogLog(Long postId, String clientIp) {
-    String redisKey = "post:views:" + postId;
-    // HyperLogLog에 IP 추가 (새로운 IP면 1 반환, 중복이면 0 반환)
-    Long added = redisTemplate.opsForHyperLogLog().add(redisKey, clientIp);
-    
-    if (added != null && added == 1L) {
-        redisTemplate.opsForValue().increment("post:view_count:" + postId);
-    }
-}
-```
-
-#### ⑤ 장점 (Pros)
-- **DB Row Lock 100% 제거**: DB에 쓰기 쿼리가 전혀 들어가지 않으므로 동접자가 몰려도 락 병목이 터지지 않음.
-- **극도의 메모리 절약**: 100만 명의 IP를 수집해도 무조건 단 12KB 메모리만 사용함.
-
-#### ⑥ 다른 기술과의 비교 (Alternatives)
-- **Redis Set 자료구조 대비**: Redis Set은 100만 개 IP 저장 시 수십 MB의 메모리가 들지만, HyperLogLog는 12KB로 고정됨.
-
-#### ⑦ 트레이드오프 및 서비스/아키텍처 레벨 극복 방안 (Trade-off & Detailed Mitigation)
-- **트레이드오프 (0.81%의 확률적 표준오차)**: 확률적 계산 알고리즘 특성상 약 0.81% 미만의 오차가 발생할 수 있음.
-- **서비스 레벨 극복 방안**: 커뮤니티 조회 수치는 0.81% 오차(1,000회 기준 약 8회 차이)가 서비스 이용이나 금융 정산 영역이 아니므로 서비스 요구사항을 완전 만족함을 도메인 레벨 수용.
-- **아키텍처 레벨 극복 방안 (Redis RDB/AOF & Scheduled Write-Back)**: Redis 메모리 휘발에 대비하여 10분 단위 스케줄러가 Redis 수치를 DB `post.view_count` 컬럼으로 Write-Back 집계 갱신하여 영구 보존.
-
----
-
-### 2-2. 대체 대안 B: Client-Side Cookie 쿨타임 제한 (24시간 중복 방지)
-
-#### ① 개념 (What)
-유저 브라우저 쿠키(`viewed_posts=1,4,12`)에 읽은 글 ID를 기록하고, 쿠키가 유효한 24시간 동안은 프론트엔드에서 백엔드로 조회수 증가 요청을 아예 보내지 않도록 차단하는 기법입니다.
-
-#### ② 왜 사용하는지 (Why)
-서버 백엔드로 인커밍(Incoming)되는 HTTP 요청 수 자체를 줄여 네트워크 및 서버 CPU 자원을 절약하기 위함입니다.
-
-#### ③ 어떨 때 사용하는지 (When)
-Redis 같은 인메모리 인프라 구축 비용 없이 단순한 웹 서비스에서 조회수 어뷰징을 방지할 때 사용합니다.
-
-#### ④ 어떻게 사용하는지 (How - 구현 코드)
-```typescript
-// Next.js 프론트엔드 컴포넌트
-useEffect(() => {
-  const viewedPosts = getCookie('viewed_posts') || '';
-  if (!viewedPosts.includes(`[${postId}]`)) {
-    api.post(`/api/posts/${publicId}/views`);
-    setCookie('viewed_posts', `${viewedPosts}[${postId}]`, { maxAge: 86400 });
-  }
-}, [postId]);
-```
-
-#### ⑤ 장점 (Pros)
-- **서버 요청 수 급감**: 동일 유저의 재방문 요청이 백엔드까지 도착하지 않으므로 트래픽이 획기적으로 줄어듦.
-
-#### ⑥ 다른 기술과의 비교 (Alternatives)
-- **서버 IP 기반 차단 대비**: 서버 IP 차단은 서버 메모리를 소비하지만, 쿠키 방식은 클라이언트 브라우저 자원을 활용함.
-
-#### ⑦ 트레이드오프 및 서비스/아키텍처 레벨 극복 방안 (Trade-off & Detailed Mitigation)
-- **트레이드오프 (쿠키 삭제 및 시크릿 창 어뷰징에 취약)**: 유저가 브라우저 쿠키를 삭제하거나 시크릿 모드로 접속하면 중복 카운트가 올라감.
-- **서비스 레벨 극복 방안**: 어뷰징 유저가 쿠키를 삭제하더라도 개별 유저의 자발적 행위이므로 시스템 전체 셧다운을 일으키지 않는 수준에서 허용.
-- **아키텍처 레벨 극복 방안 (하이브리드 IP Redis 쿨타임)**: 백엔드에서 1차로 Client Cookie를 대조하고 2차로 IP 기반 Redis 10분 쿨타임 키(`view:cooldown:{ip}:{postId}`)를 이중 검증하여 쿠키 삭제 어뷰징을 99% 무력화하는 하이브리드 검증 구축.
-
----
-
-## 3. 💥 [추천 비동기] `@Async` 비동기 카운터 유실 이슈의 2대 대안
-
-### 3-1. 대체 대안 A: Transactional Outbox Pattern (트랜잭셔널 아웃박스 패턴)
-
-#### ① 개념 (What)
-이벤트를 인메모리 스프링 이벤트로 던지지 않고, 메인 비즈니스 로직과 동일한 DB 트랜잭션 안에서 `outbox` 테이블에 이벤트 메시지를 함께 `INSERT`한 뒤, 별도의 메시지 릴레이(Debezium CDC 또는 Polling Publisher)가 읽어서 처리하는 Enterprise 분산 트랜잭션 패턴입니다.
-
-#### ② 왜 사용하는지 (Why)
-JVM 인메모리 비동기 이벤트는 서버가 갑자기 꺼지면 메모리에 있던 이벤트가 100% 유실됩니다. DB 테이블에 이벤트 발행 내역을 함께 기록하여 **최소 1회 전달(At-Least-Once Delivery)**을 물리적으로 보장하기 위함입니다.
-
-#### ③ 어떨 때 사용하는지 (When)
-결제, 결제 후 포인트 적립, 이벤트 카운팅 등 유실되면 안 되는 핵심 비동기 이벤트 처리에 사용합니다.
-
-#### ④ 어떻게 사용하는지 (How - 구현 코드)
-```java
-@Transactional
-public void reactToPost(String publicId, ReactionType type, CustomUserDetails userDetails) {
-    // 1. 투표 내역 저장
-    reactionRepository.save(reaction);
-    
-    // 2. 동일 트랜잭션 내에서 outbox 테이블에 이벤트 메시지 저장 (원자성 보장)
-    outboxRepository.save(new OutboxEvent(
-        "POST_REACTION",
-        postId.toString(),
-        objectMapper.writeValueAsString(new PostReactionEvent(postId, type))
-    ));
-}
-```
-
-#### ⑤ 장점 (Pros)
-- **이벤트 유실 0%**: 메인 데이터 저장과 이벤트 작성이 동일 DB 트랜잭션으로 묶여 원자성(Atomic)이 보장됨.
-- **서버 장애 복구**: 서버가 다운된 후 재시작되어도 `outbox` 테이블에 남아있는 미처리 이벤트를 읽어서 복구 처리.
-
-#### ⑥ 다른 기술과의 비교 (Alternatives)
-- **스프링 `@Async` 기본 이벤트 대비**: 기본 `@Async`는 메모리 유실 위험이 크지만, Outbox Pattern은 DB 내구성을 이용해 유실을 물리 차단함.
-
-#### ⑦ 트레이드오프 및 서비스/아키텍처 레벨 극복 방안 (Trade-off & Detailed Mitigation)
-- **트레이드오프 (Outbox 테이블 비대화 및 추가 DB Write I/O)**: 모든 이벤트가 DB에 기록되므로 I/O 부담이 늘어나고 테이블 용량이 커짐.
-- **서비스 레벨 극복 방안**: 비동기 처리가 지연되더라도 유저 화면에는 Optimistic UI로 완료 상태를 즉시 표시.
-- **아키텍처 레벨 극복 방안 (Outbox Purge Scheduler)**: `outbox` 테이블에 모든 비동기 이벤트가 누적되어 DB 용량이 폭증하고 I/O가 느려지는 현상을 막기 위해, `status = 'PROCESSED'`이면서 생성된 지 1시간이 지난 Outbox 행을 1,000개 단위로 DELETE하는 `OutboxPurgeScheduler` 배치를 구축하여 테이블 사이즈를 작게 유지.
-
----
-
-## 3-2. 대체 대안 B: 새벽 정정 스케줄러 배치 (Scheduled Reckoning Batch)
-
-#### ① 개념 (What)
-이벤트 유실 가능성을 인정하되, 매일 새벽 트래픽이 적은 시각에 `post_reaction` 테이블의 실제 투표 건수를 `COUNT(*)`로 집계하여 `post.like_count` 수치와 대조 후 다를 경우 일괄 수정하는 정정 배치 기법입니다.
-
-#### ② 왜 사용하는지 (Why)
-복잡한 메시지 큐나 Outbox 패턴 구축 비용 없이, 100% 데이터 정합성을 가장 단순한 코드로 보장하기 위함입니다.
-
-#### ③ 어떨 때 사용하는지 (When)
-실시간 카운트 반영의 밀리초 오차가 서비스 이용에 치명적이지 않은 커뮤니티 서비스에 적합합니다.
-
-#### ④ 어떻게 사용하는지 (How - 구현 코드)
-```java
-@Scheduled(cron = "0 0 4 * * *") // 매일 새벽 4시
-@Transactional
-public void reconcileReactionCounts() {
-    List<Post> posts = postRepository.findAll();
-    for (Post post : posts) {
-        long actualLikes = reactionRepository.countByPostIdAndType(post.getId(), ReactionType.LIKE);
-        if (post.getLikeCount() != actualLikes) {
-            post.setLikeCount(actualLikes); // 데이터 정정
-        }
-    }
-}
-```
-
-#### ⑤ 장점 (Pros)
-- **구현 단순성**: 추가 인프라 구축 없이 가장 직관적이고 안정적으로 데이터 일관성을 맞출 수 있음.
-
-#### ⑥ 다른 기술과의 비교 (Alternatives)
-- **Outbox Pattern 대비**: Outbox Pattern은 복잡한 릴레이 스레드가 필요하지만, 정정 배치는 단순 SQL 집계로 완료됨.
-
-#### ⑦ 트레이드오프 및 서비스/아키텍처 레벨 극복 방안 (Trade-off & Detailed Mitigation)
-- **트레이드오프 (새벽 시간대 DB Read I/O 부하)**: 전수 조사를 돌리면 DB CPU 사용량이 상승함.
-- **서비스 레벨 극복 방안**: 새벽 4시는 유저 접속량이 가장 적은 시간대이므로 정정 작업으로 인한 성능 영향을 사용자에게서 격리.
-- **아키텍처 레벨 극복 방안 (어제 변경된 게시글 Index Scan 핀포인트)**: 새벽 4시 배치 시 전체 `post` 테이블 Full Scan으로 인한 DB CPU 상승을 막기 위해 `WHERE updated_at >= NOW() - INTERVAL 1 DAY` 조건절을 추가하여 전날 변경이 일어난 게시글만 Index Scan으로 핀포인트 정정.
-
----
-
-## 4. 💥 [대댓글] 3차 이상 무한 깊이 대댓글 이슈의 2대 대안
-
-### 4-1. 대체 대안 A: Flat List + `@Mention` (유튜브 / 인스타그램 1차 평탄화 모델)
-
-#### ① 개념 (What)
-대댓글의 계층형 들여쓰기 자체를 없애고 모든 답글을 원댓글 하위의 평탄한(Flat) 1차 리스트로만 렌더링하며, 누구에게 작성한 답글인지 `@작성자닉네임` 태그로 표시하는 UI/UX 아키텍처입니다.
-
-#### ② 왜 사용하는지 (Why)
-모바일 화면 폭(360px~430px)은 들여쓰기를 3단계만 해도 본문 영역이 좁아져 읽기 불가능해집니다. 이를 근본적으로 해결하기 위함입니다.
-
-#### ③ 어떨 때 사용하는지 (When)
-유튜브, 인스타그램, 페이스북 등 모바일 웹/앱 트래픽 비중이 80% 이상인 현대 웹 서비스에 사용합니다.
-
-#### ④ 어떻게 사용하는지 (How - 구현 코드)
-```json
-// JSON 반환 구조
-{
-  "commentId": 12,
-  "content": "@댓글보더 저도 그렇게 생각합니다!",
-  "targetMemberNickname": "댓글보더",
-  "parentId": 1, // 최상위 원댓글 ID만 유지
-  "depth": 1
-}
-```
-
-#### ⑤ 장점 (Pros)
-- **UI 레이아웃 파괴 근본 차단**: 들여쓰기 너비가 0으로 고정되므로 아무리 답글이 많이 달려도 모바일 화면 레이아웃이 절대 깨지지 않음.
-- **데이터 구조 단순화**: N차 복잡한 트리를 조립할 필요 없이 1차 리스트만 반환하므로 백엔드 연산이 가벼워짐.
-
-#### ⑥ 다른 기술과의 비교 (Alternatives)
-- **N차 계층형 트리 대비**: N차 계층형 트리는 복잡한 Recursion 조립과 UI 들여쓰기가 필요하지만, Flat List는 $O(N)$ 단일 루프 반환 가능.
-
-#### ⑦ 트레이드오프 및 서비스/아키텍처 레벨 극복 방안 (Trade-off & Detailed Mitigation)
-- **트레이드오프 (답글의 구체적 부모 맥락 추적 불분명)**: 누구의 대댓글에 대한 대댓글인지 1:1 스레드 흐름 파악이 계층형보다 다소 모호함.
-- **서비스 레벨 극복 방안 (Tooltip 미니 모달 뷰어)**: 1:1 대댓글 스레드 맥락 추적이 모호해지는 단점을 해결하기 위해, `@작성자닉네임` 태그 클릭 시 해당 원본 댓글의 팝업 미니 모달(Tooltip Modal)이 뜨도록 프론트엔드 뷰 연동.
-- **아키텍처 레벨 극복 방안**: `targetCommentId` 외래키를 DTO에 포함하여 단 1회 인메모리 Map 조회로 원본 댓글 본문을 즉시 팝업으로 렌더링.
-
----
-
-### 4-2. 대체 대안 B: CSS Max-Indent Clamp (프론트엔드 들여쓰기 한계선 고정)
-
-#### ① 개념 (What)
-백엔드는 데이터베이스 상에서 N차 대댓글을 허용하되, 프론트엔드 CSS 렌더링 시 `margin-left` 들여쓰기의 최대 한계선을 `clamp` 또는 `min()` 함수로 고정하는 기법입니다.
-
-#### ② 왜 사용하는지 (Why)
-백엔드 도메인 로직 수정 없이 프론트엔드 스타일시트 적용만으로 레이아웃 이탈을 막기 위함입니다.
-
-#### ③ 어떨 때 사용하는지 (When)
-기존 백엔드 API 스펙을 건드리지 않고 빠르게 UI 깨짐을 임시 방어할 때 사용합니다.
-
-#### ④ 어떻게 사용하는지 (How - 구현 코드)
-```tsx
-// Tailwind / Inline Style 적용
-<div style={{ marginLeft: `${Math.min(depth, 3) * 1.5}rem` }}>
-  {comment.content}
-</div>
-```
-
-#### ⑤ 장점 (Pros)
-- **백엔드 수정 0건**: 백엔드 코드를 단 한 줄도 수정하지 않고 프론트엔드 뷰만으로 1초 만에 방어할 수 있음.
-
-#### ⑥ 다른 기술과의 비교 (Alternatives)
-- **백엔드 Depth Validation 대비**: 백엔드 검증은 400 에러를 반환하지만, CSS Clamp는 에러 없이 렌더링 위치만 고정함.
-
-#### ⑦ 트레이드오프 및 서비스/아키텍처 레벨 극복 방안 (Trade-off & Detailed Mitigation)
-- **트레이드오프 (3차 이상 대댓글 간 시각적 구분 모호)**: 3차 대댓글과 4차, 5차 대댓글의 들여쓰기 위치가 동일해져 계층 구분이 안 됨.
-- **서비스 레벨 극복 방안 (답글 뱃지 렌더링)**: 3차 이상 대댓글의 들여쓰기 위치가 같아져 시각적 계층이 모호해지는 점을 보완하기 위해, `depth > 2`인 경우 댓글 상단에 `↳ [3차 답글]` 태그 뱃지(Badge)를 추가 렌더링.
-- **아키텍처 레벨 극복 방안**: 백엔드 2단계 깊이 제한Validation(`parent.getParent() != null`)을 병행 적용하여 3차 이상 생성 자체를 예외 차단.
-
----
-
-## 5. 💥 [보안] 익명 비밀번호 URL 쿼리 스트링 노출 이슈의 2대 대안
-
-### 5-1. 대체 대안 A: HTTP Custom Header (`X-Anonymous-Password`) 전달
-
-#### ① 개념 (What)
-비회원 비밀번호를 URL 쿼리 스트링이 아닌, HTTP 요청 헤더(`X-Anonymous-Password: 1234`)에 포함하여 전달하는 보안 패턴입니다.
-
-#### ② 왜 사용하는지 (Why)
-웹 서버(Nginx, Apache)는 표준 보안 설정상 Request Body와 Custom Header 내용을 Access Log에 기록하지 않고 요청 라인(URL)만 기록하므로, 로그 유출을 물리 차단할 수 있습니다.
-
-#### ③ 어떨 때 사용하는지 (When)
-RESTful API 관례상 `DELETE` 메서드에 Request Body를 실어 보내기 부담스러울 때 사용합니다.
-
-#### ④ 어떻게 사용하는지 (How - 구현 코드)
-```java
-@DeleteMapping("/api/posts/{publicId}")
-public ResponseEntity<Void> deletePost(
-    @PathVariable String publicId,
-    @RequestHeader(value = "X-Anonymous-Password", required = false) String anonymousPassword) {
-    postService.deletePost(publicId, anonymousPassword);
-    return ResponseEntity.noContent().build();
-}
-```
-
-#### ⑤ 장점 (Pros)
-- **웹 서버 로그 유출 100% 차단**: Nginx, ALB, CDN 액세스 로그에 비밀번호 평문 기록이 남지 않음.
-- **HTTP 스펙 준수**: `DELETE` 메서드 본문(Body)을 비워두어 일부 엄격한 HTTP 클라이언트 라이브러리와의 호환성 유지.
-
-#### ⑥ 다른 기술과의 비교 (Alternatives)
-- **URL Query Parameter 대비**: URL Parameter는 웹 서버 로그에 평문 기록되지만, Custom Header는 기록되지 않아 보안상 우월함.
-
-#### ⑦ 트레이드오프 및 서비스/아키텍처 레벨 극복 방안 (Trade-off & Detailed Mitigation)
-- **트레이드오프 (CORS Preflight Flight 요청 발생)**: 표준 헤더가 아닌 커스텀 헤더(`X-`)를 사용하므로 브라우저가 `OPTIONS` 사전 요청(Preflight)을 보냄.
-- **서비스 레벨 극복 방안**: 첫 요청 시 수 밀리초의 Preflight 지연이 발생하지만 지연 시간이 매우 짧으므로 삭제 성공 경험 우선 제공.
-- **아키텍처 레벨 극복 방안 (Preflight Caching)**: 브라우저의 CORS Preflight(`OPTIONS`) 요청으로 인한 2배 HTTP 트래픽 발생을 극복하기 위해, Spring Security CORS Configuration에서 `allowedHeaders("X-Anonymous-Password")` 등록 및 `maxAge(3600)`을 지정하여 브라우저가 Preflight 결과를 1시간 동안 메모리에 캐싱하도록 설정.
-
----
-
-### 5-2. 대체 대안 B: HMAC-SHA256 기반 무상태 일회용 삭제 토큰 (Stateless Delete Token)
-
-#### ① 개념 (What)
-비회원이 글 작성 시 백엔드가 비밀번호를 저장하지 않고, `HMAC-SHA256(publicId + secretKey + password)`로 암호화 서명된 일회용 삭제 토큰(Token)을 발급하여 유저에게 반환하는 무상태 보안 인증 패턴입니다.
-
-#### ② 왜 사용하는지 (Why)
-비밀번호 원본 및 BCrypt 해시조차 DB에 저장하지 않아, DB가 뚫려도 비회원 비밀번호가 유출될 위험이 0%입니다.
-
-#### ③ 어떨 때 사용하는지 (When)
-익명 게시판 보안 수준을 극상으로 끌어올리고 무상태(Stateless) 검증을 꾀할 때 사용합니다.
-
-#### ④ 어떻게 사용하는지 (How - 구현 코드)
-```java
-// 작성 시 토큰 발급
-public String generateDeleteToken(String publicId, String rawPassword) {
-    return HmacUtils.hmacSha256Hex(SECRET_KEY, publicId + ":" + rawPassword);
-}
-
-// 삭제 시 토큰 대조 검증
-public void validateDeleteToken(String publicId, String rawPassword, String clientToken) {
-    String expectedToken = generateDeleteToken(publicId, rawPassword);
-    if (!expectedToken.equals(clientToken)) {
-        throw new CustomAuthException(ErrorCode.INVALID_ANON_PASSWORD);
-    }
-}
-```
-
-#### ⑤ 장점 (Pros)
-- **DB 보안 극상**: DB에 비밀번호 컬럼 자체가 존재하지 않으므로 데이터베이스 유출 사고 시에도 안전함.
-
-#### ⑥ 다른 기술과의 비교 (Alternatives)
-- **BCrypt DB 저장 대비**: BCrypt 저장은 DB 용량을 차지하고 딕셔너리 공격 대상이 될 수 있으나, HMAC 토큰은 DB 저장이 필요 없는 무상태 검증임.
-
-#### ⑦ 트레이드오프 및 서비스/아키텍처 레벨 극복 방안 (Trade-off & Detailed Mitigation)
-- **트레이드오프 (서버 Secret Key 유출 시 서명 위조 위험)**: 애플리케이션의 `SECRET_KEY`가 유출되면 토큰 위조가 가능해짐.
-- **서비스 레벨 극복 방안**: 토큰 생성 알고리즘이 노출되지 않도록 에러 메시지 캡슐화.
-- **아키텍처 레벨 극복 방안 (AWS Secrets Manager & Key Rotation)**: 서버 `SECRET_KEY` 유출 시 토큰 서명 위조 위험을 물리적으로 극복하기 위해, `SECRET_KEY`를 코드나 설정 파일에 하드코딩하지 않고 `AWS Secrets Manager`에 저장하며 30일마다 자동으로 서명 키를 로테이션(Rotation)하고 구버전 키는 7일간 Grace Period를 두어 안전 검증.
-
----
-
-# 📌 PART 3. 작업 완료 및 파일 위치 안내
-
-* **생성된 마스터 스터디 가이드 경로**:
-  - [`c:\Users\ikaes\IdeaProjects\snowthing\docs\study\sprint02\studySprint02BoardIssuesAndSolutions260821.md`](file:///c:/Users/ikaes/IdeaProjects/snowthing/docs/study/sprint02/studySprint02BoardIssuesAndSolutions260821.md)
-  - [`c:\Users\ikaes\IdeaProjects\snowthing\docs\study\studySprint02BoardIssuesAndSolutions260821.md`](file:///c:/Users/ikaes/IdeaProjects/snowthing/docs/study/studySprint02BoardIssuesAndSolutions260821.md)
-* **`AGENTS.md` 작업 기록 완료**: [`docs/project/work.md`](file:///c:/Users/ikaes/IdeaProjects/snowthing/docs/project/work.md) 파일에 수록 완료.
diff --git a/docs/study/studySprint02PostDomainIssues260821.md b/docs/study/studySprint02PostDomainIssues260821.md
deleted file mode 100644
index dba738c..0000000
--- a/docs/study/studySprint02PostDomainIssues260821.md
+++ /dev/null
@@ -1,191 +0,0 @@
-# 📚 [Master Study Guide] Sprint 02 게시글(Post) 도메인 5대 아키텍처 결함 & 물리적 극복 방안 가이드 (2026-08-21)
-
-> **노션(Notion) 복사용 및 백엔드 게시글 도메인 심화 학습용 마스터 가이드**  
-> 본 문서는 Snowthing 게시글(Post) 도메인(댓글 제외) 구축 시 발생할 수 있는 **5대 핵심 아키텍처 문제점과 결함**에 대해, **7대 필수 서술 요소 체계(개념, Why, When, How 코드/SQL, Pros & Cons, 기존 한계점, 서비스/아키텍처 레벨 극복 방안)**를 물리적 메커니즘 수준으로 전수 파헤쳐 정리한 마스터 학습 문서입니다.
-
----
-
-# 📑 PART 1. 게시글(Post) 도메인 5대 결함 & 7대 필수 요소 심층 분석
-
----
-
-## 1. 💥 `POST` 페이징 목록 조회 시 본문 제외 미적용으로 인한 네트워크 트래픽 폭증 및 DB I/O 병목
-
-### ① 개념 (What - 문제의 명확한 정의)
-게시글 목록 API(`GET /api/posts?page=0&size=10`)를 부를 때, 목록 화면에는 제목, 작성자, 카테고리, 추천 수만 필요한데 **게시글 본문(`content` VARCHAR 5000/TEXT) 필드까지 전부 DB에서 SELECT하여 DTO로 내보내는 문제**입니다.
-
-### ② 발생 원인 (Why - 물리적 & DB 메커니즘)
-- JPA Repository에서 목록 조회 시 `Post` 엔티티 전체를 SELECT 하거나 `PostListResponse` DTO 생성 시 본문(`content`)을 포함하는 DTO projections 미분리로 인해 발생합니다.
-- 본문 내에 수천 자의 장문이 포함되어 있으면 목록 쿼리 1번당 전송 데이터 크기(Payload Size)가 **수십 KB ➔ 수 MB로 폭증**합니다.
-
-### ③ 언제 발생하는지 (When - 적합한 발생 상황)
-- 사용자가 모바일 또는 3G/4G 환경에서 게시글 목록을 스크롤(무한 스크롤 / 페이징)할 때 로딩 지연 및 모바일 데이터 소모 폭증.
-
-### ④ 어떻게 발생하는지 (How - 실제 코드 & DB 쿼리 실행 메커니즘)
-```sql
--- 목록 10개 조회 쿼리 실행 시 (불필요한 content 컬럼 포함!)
-SELECT post_id, public_id, title, content, view_count, like_count, created_at FROM post WHERE category_id = 1;
--- 10개 글 본문(content) 합계 500KB 데이터가 매 페이징마다 DB -> API 서버 -> 클라이언트로 낭비 전송됨
-```
-
-### ⑤ 부정적 영향 (Pros & Cons of Ignoring - 미해결 시 여파)
-- **DB 메모리/네트워크 낭비**: DB Buffer Pool 메모리 낭비 및 네트워크 대역폭(Bandwidth) 고갈.
-- **클라이언트 로딩 지연**: 목록 화면을 열 뿐인데 유저 휴대폰 메모리와 데이터 소모가 급증함.
-
-### ⑥ 기존 처리 방식과의 비교 및 한계점 (Alternatives vs Existing)
-- **기존 방식**: 엔티티 전체 조회 `SELECT p FROM Post p`
-- **한계점**: LOB/TEXT 컬럼의 지연 로딩이 기본 적용되지 않아 불필요한 IO가 매번 발생함.
-
-### ⑦ 트레이드오프 및 서비스/아키텍처 레벨 극복 방안 (Trade-off & Detailed Mitigation)
-- **트레이드오프**: 목록 전용 DTO (`PostListResponse`)를 별도로 정의해야 하는 DTO 파편화 오버헤드.
-- **서비스 레벨 극복 방안 (목록 DTO 경량화)**: 목록 DTO에 본문을 아예 제외(`content` 제거)하고 제목은 최대 40자 자름(Truncate) 처리하여 UI 렌더링 속도 최적화.
-- **아키텍처 레벨 극복 방안 (JPQL/Querydsl DTO Projections)**:
-  - `SELECT new PostListResponse(p.publicId, p.title, p.likeCount...) FROM Post p` 방식을 적용하여 DB 레벨에서 `content` 컬럼 자체를 SELECT 하지 않도록 DB I/O를 원자적 차단.
-
----
-
-## 2. 💥 카테고리별 게시글 목록 페이징 조회의 Count Query N+1 및 Index Scan 타임아웃
-
-### ① 개념 (What - 문제의 명확한 정의)
-게시글 목록 페이징(`Page<PostListResponse>`) 조회 시, Spring Data JPA의 `Pageable`을 사용할 때 **전체 게시글 수(`COUNT(*)`)를 세는 카운트 쿼리가 매 페이징 요청마다 DB 테이블 전체를 스캔**하여 일어나는 성능 저하 현상입니다.
-
-### ② 발생 원인 (Why - 물리적 & DB 메커니즘)
-- JPA `PageRequest` 사용 시 Hibernate는 데이터 10건 조회 쿼리 1번 + 전체 개수 계산 `SELECT COUNT(p) FROM Post p WHERE p.category = :category` 쿼리 1번을 내보냅니다.
-- `post` 테이블에 `category_id + created_at` 복합 인덱스가 없으면, 카운트 쿼리가 **테이블 풀 스캔(Full Table Scan)**을 일으킵니다.
-
-### ③ 언제 발생하는지 (When - 적합한 발생 상황)
-- 게시글 데이터가 10만 건 이상 쌓인 상태에서 10페이지, 100페이지 등 높은 페이지 번호(Offset Paging)를 넘길 때.
-
-### ④ 어떻게 발생하는지 (How - 실제 코드 & DB 쿼리 실행 메커니즘)
-```sql
--- 1. 데이터 10건 조회 (Fast)
-SELECT * FROM post WHERE category_code = 'FREE' ORDER BY created_at DESC LIMIT 10 OFFSET 1000;
--- 2. 전체 Count 쿼리 (Slow - 10만 건 Full Scan!)
-SELECT COUNT(*) FROM post WHERE category_code = 'FREE'; -- 2초 소요!
-```
-
-### ⑤ 부정적 영향 (Pros & Cons of Ignoring - 미해결 시 여파)
-- **DB CPU 100% 점유**: 100명의 유저가 탭을 전환하면 `COUNT(*)` 쿼리 100개가 DB CPU를 100% 점유하여 전체 서비스 마비.
-
-### ⑥ 기존 처리 방식과의 비교 및 한계점 (Alternatives vs Existing)
-- **기존 방식**: `Page<PostListResponse>` 기본 페이징 반환.
-- **한계점**: 무조건 `COUNT(*)`를 실행하므로 데이터가 쌓일수록 성능이 선형적으로 저하됨.
-
-### ⑦ 트레이드오프 및 서비스/아키텍처 레벨 극복 방안 (Trade-off & Detailed Mitigation)
-- **트레이드오프**: 전체 페이지 번호(1, 2, 3... 10)를 보여주는 UI 대신 `더보기` 버튼(Slice 페이징)으로 전환해야 함.
-- **서비스 레벨 극복 방안 (Slice 무한 스크롤 UI)**: 모바일/웹 목록 UI를 페이지 번호 방식에서 `Slice` 기반 [더보기 / 무한 스크롤] UI로 전환.
-- **아키텍처 레벨 극복 방안 (Slice 페이징 & Covering Index)**:
-  - `Page<T>` 대신 `Slice<T>`를 사용하여 `COUNT(*)` 쿼리 자체를 100% 제거(`limit + 1` 조회 방식).
-  - DB에 `idx_category_created_at(category_id, created_at DESC)` 커버링 인덱스를 생성하여 Index Only Scan 유도.
-
----
-
-## 3. 💥 게시글 수정/삭제 시 작성자 검증 인가(Authorization) 누락 및 IDOR 취약점
-
-### ① 개념 (What - 문제의 명확한 정의)
-회원이 작성한 일반 게시글을 수정/삭제할 때, 로그인된 유저가 **해당 게시글의 실제 작성자 본인인지 또는 관리자(`ROLE_ADMIN`)인지 검증하지 않고** `publicId`만 알면 타인의 글을 임의로 수정/삭제할 수 있는 보안 취약점입니다.
-
-### ② 발생 원인 (Why - 물리적 & DB 메커니즘)
-- [`PostService.java`](file:///c:/Users/ikaes/IdeaProjects/snowthing/backend/src/main/java/com/ikae/snowthing/domain/post/service/PostService.java) `updatePost()` / `deletePost()`에서 `post.getMember().getPublicId().equals(userDetails.getPublicId())` 대조 로직이 누락되거나 null 검증 조건이 뚫릴 때 발생합니다.
-
-### ③ 언제 발생하는지 (When - 적합한 발생 상황)
-- 인증된 유저 A가 Postman이나 브라우저 개발자 도구(F12)에서 유저 B가 쓴 게시글의 `publicId`를 파라미터로 넣어 `PUT /api/posts/{publicId}`를 호출할 때.
-
-### ④ 어떻게 발생하는지 (How - 실제 코드 & DB 쿼리 실행 메커니즘)
-```
-[User A (Hacker)] PUT /api/posts/p9999 (User B's Post)
- └── PostService.updatePost() 진입
-      └── 작성자 대조 검증 없이 post.updateTitleAndContent() 실행!
-           └── User B의 글이 User A에 의해 강제 변조됨! (IDOR 보안 참사)
-```
-
-### ⑤ 부정적 영향 (Pros & Cons of Ignoring - 미해결 시 여파)
-- **데이터 변조 & 악성 스팸**: 타인의 글을 삭제하거나 비하/광고성 내용으로 강제 변경하는 심각한 보안 사고 발생.
-
-### ⑥ 기존 처리 방식과의 비교 및 한계점 (Alternatives vs Existing)
-- **기존 방식**: 어노테이션 `@PreAuthorize("isAuthenticated()")` 만 사용.
-- **한계점**: "로그인 여부"만 검증할 뿐 "글 작성자 본인 여부"를 검증하지 못함.
-
-### ⑦ 트레이드오프 및 서비스/아키텍처 레벨 극복 방안 (Trade-off & Detailed Mitigation)
-- **트레이드오프**: 매 수정/삭제 시마다 DB에서 작성자 ID를 대조해야 하는 인가 연산 오버헤드.
-- **서비스 레벨 극복 방안 (버튼 숨김 렌더링)**: 프론트엔드 상세 페이지에서 작성자 본인 및 관리자가 아닌 경우 [수정], [삭제] 버튼 자체를 렌더링하지 않음.
-- **아키텍처 레벨 극복 방안 (백엔드 도메인 인가 검증)**:
-  - `PostService` 내에 `validatePostOwnerOrAdmin(post, userDetails)` 도메인 검증 메서드를 공통화하고, 불일치 시 `403 Forbidden (ErrorCode.ACCESS_DENIED)` 예외를 즉시 던져 백엔드 단에서 물리 차단.
-
----
-
-## 4. 💥 회원글 ➔ 익명글 (또는 그 반대) 카테고리 변경 시 작성자 정보 정합성 오염 및 비밀번호 유실 문제
-
-### ① 개념 (What - 문제의 명확한 정의)
-게시글 수정(`PUT /api/posts/{publicId}`) 시 유저가 카테고리를 일반 카테고리(`FREE`)에서 익명 카테고리(`ANONYMOUS`)로 변경하거나 그 반대로 변경할 때, **`is_anonymous` 플래그와 `member_id`, `anonymous_password` 데이터 간의 상태 꼬임(State Corruption) 현상**입니다.
-
-### ② 발생 원인 (Why - 물리적 & DB 메커니즘)
-- 게시글 작성 시에는 `isAnonymous`에 따라 `member`가 저장되거나 `anonymousPassword`가 저장됩니다.
-- 그러나 게시글 수정 시 카테고리 코드(`categoryCode`)를 바꾸면서 `isAnonymous` 상태 변경에 따른 기존 `member` 매핑 해제 처리나 `anonymousPassword` BCrypt 재암호화 처리가 캡슐화되어 있지 않으면 상태가 파괴됩니다.
-
-### ③ 언제 발생하는지 (When - 적합한 발생 상황)
-- 유저가 자유게시판(`FREE`)에 쓴 글을 나중에 익명게시판(`ANONYMOUS`)으로 수정 이동하거나, 익명글을 회원글로 수정 이동할 때.
-
-### ④ 어떻게 발생하는지 (How - 실제 코드 & DB 쿼리 실행 메커니즘)
-```
-[회원글 -> 익명글 수정 시]
-- is_anonymous = true 로 변경되었으나, member_id (FK) 가 여전히 연관되어 있어 DB 상에서 작성자 유저 정보가 그대로 노출됨!
-[익명글 -> 회원글 수정 시]
-- is_anonymous = false 로 변경되었으나, member_id 가 null 로 남아 작성자 없는 유령 글 발생!
-```
-
-### ⑤ 부정적 영향 (Pros & Cons of Ignoring - 미해결 시 여파)
-- **익명성 파괴 보안 사고**: 익명글로 바꿨는데 DB에 작성자 회원의 `member_id`가 남아 익명성이 파괴되거나, 유령 글이 되어 삭제 불가능 상태 발생.
-
-### ⑥ 기존 처리 방식과의 비교 및 한계점 (Alternatives vs Existing)
-- **기존 방식**: DTO 필드를 엔티티에 덮어쓰는 `post.setTitle(...)`, `post.setCategory(...)`
-- **한계점**: 엔티티 불변식(Invariant)을 지키지 못함.
-
-### ⑦ 트레이드오프 및 서비스/아키텍처 레벨 극복 방안 (Trade-off & Detailed Mitigation)
-- **트레이드오프**: 작성 후 카테고리 변경 시 익명/일반 간의 전환 제약이 필요함.
-- **서비스 레벨 극복 방안 (카테고리 이동 정책 제한)**: 익명게시판(`ANONYMOUS`)과 일반게시판(`FREE`, `QNA`) 간의 카테고리 변경 작성을 서비스 정책상 금지하고 안내 문구 노출.
-- **아키텍처 레벨 극복 방안 (도메인 카테고리 변경 검증)**:
-  - `Post.java` 도메인 엔티티 내에 `changeCategory(PostCategory newCategory)` 메서드를 만들고, 익명 ↔ 일반 카테고리 간의 전환 시도가 들어오면 `400 Bad Request (ErrorCode.INVALID_INPUT, "익명게시판과 일반게시판 간 카테고리 변경은 불가능합니다.")` 예외를 던져 백엔드 차원에서 원자적 차단.
-
----
-
-## 5. 💥 `PostReaction` 추천/비추천 투표 시 계정당 1회 독자 투표 업데이트의 Race Condition 및 DB Deadlock
-
-### ① 개념 (What - 문제의 명확한 정의)
-유저가 추천(LIKE)과 비추천(DISLIKE)을 빠르게 번갈아 누르거나 동시 클릭할 때, 복합 유니크 인덱스(`uk_post_member_type`)에도 불구하고 **DB 트랜잭션 교착 상태(Deadlock) 및 데이터 충돌**이 발생하는 동시성 문제입니다.
-
-### ② 발생 원인 (Why - 물리적 & DB 메커니즘)
-- 오늘 `PostReaction` DB 제약 조건을 `UNIQUE (post_id, member_id, type)`로 변경하여 유저 1명이 추천 1건 + 비추천 1건을 각각 가질 수 있게 만들었습니다.
-- 유저가 추천 클릭과 비추천 클릭을 동시에 내보내면, MySQL InnoDB는 두 트랜잭션에서 `post_reaction` 유니크 인덱스 페이지 락(Index Page Lock)을 획득하는 과정에서 **Circular Dependency (순환 대기) Deadlock**을 유발할 수 있습니다.
-
-### ③ 언제 발생하는지 (When - 적합한 발생 상황)
-- 클라이언트 단에서 추천 버튼과 비추천 버튼을 동시에 클릭하거나, 2개의 브라우저 탭에서 동일 계정으로 추천/비추천을 연타할 때.
-
-### ④ 어떻게 발생하는지 (How - 실제 코드 & DB 쿼리 실행 메커니즘)
-```
-[Tx 1 (추천)] INSERT INTO post_reaction (post_id=1, member_id=5, type='LIKE') -> Index Lock 획득 대기
-[Tx 2 (비추천)] INSERT INTO post_reaction (post_id=1, member_id=5, type='DISLIKE') -> Index Lock 획득 대기
- -> MySQL InnoDB Deadlock Detector 발동 -> Deadlock found when trying to get lock; try restarting transaction (500 Server Error!)
-```
-
-### ⑤ 부정적 영향 (Pros & Cons of Ignoring - 미해결 시 여파)
-- **500 Internal Server Error 발생**: DB 데드락 발생 시 사용자 화면에 500 에러 페이지가 뜸.
-
-### ⑥ 기존 처리 방식과의 비교 및 한계점 (Alternatives vs Existing)
-- **기존 방식**: `@UniqueConstraint` 선언만 적용.
-- **한계점**: 동시 INSERT 시 발생하는 DB 인덱스 데드락을 100% 방지할 수 없음.
-
-### ⑦ 트레이드오프 및 서비스/아키텍처 레벨 극복 방안 (Trade-off & Detailed Mitigation)
-- **트레이드오프**: 버튼 연타 시 프론트엔드에서 클릭을 잠시 차단해야 함.
-- **서비스 레벨 극복 방안 (Debounce / Throttle)**: 프론트엔드 버튼 클릭 시 300ms 디바운스(Debounce) 및 로딩 Spinner를 적용하여 동시 클릭을 시각적으로 100% 차단.
-- **아키텍처 레벨 극복 방안 (CannotAcquireLockException Catch & Retry)**:
-  - 백엔드 `PostService.reactToPost()`에서 `CannotAcquireLockException` 또는 `DeadlockLoserDataAccessException` 예외를 Catch 하여 409 Conflict 또는 3회 자동 재시도(Spring Retry) 로직을 적용하여 500 에러 방지.
-
----
-
-# 📌 PART 2. 작업 완료 및 파일 위치 안내
-
-* **생성된 마스터 스터디 가이드 경로**:
-  - [`c:\Users\ikaes\IdeaProjects\snowthing\docs\study\sprint02\studySprint02PostDomainIssues260821.md`](file:///c:/Users/ikaes/IdeaProjects/snowthing/docs/study/sprint02/studySprint02PostDomainIssues260821.md)
-  - [`c:\Users\ikaes\IdeaProjects\snowthing\docs\study\studySprint02PostDomainIssues260821.md`](file:///c:/Users/ikaes/IdeaProjects/snowthing/docs/study/studySprint02PostDomainIssues260821.md)
-* **`AGENTS.md` 작업 기록 완료**: [`docs/project/work.md`](file:///c:/Users/ikaes/IdeaProjects/snowthing/docs/project/work.md) 파일에 수록 완료.
diff --git a/docs/studyApiDesign260808.md b/docs/studyApiDesign260808.md
deleted file mode 100644
index 8249c22..0000000
--- a/docs/studyApiDesign260808.md
+++ /dev/null
@@ -1,80 +0,0 @@
-# [Notion] REST API 설계 원칙 & 에러 응답 표준화 정리 (TIL)
-
-> 📌 **작성 일자**: 2026년 8월 8일  
-> 🏷️ **문서 목적**: 노션(Notion)에 붙여넣어 RESTful API 디자인 철학, `/api` 접두사의 의미, 비동기 API 설계, 표준 에러 응답 규격을 공부하기 위한 TIL 정리 문서
-
----
-
-## 1. 💡 REST API URL 설계 철학: 왜 `POST /api/join`이 아니라 `POST /api/members`인가?
-
-### 1.1. REST API의 기본 원칙: "URL은 명사, 행동은 HTTP 메서드"
-* **HTTP 메서드 (`GET`, `POST`, `PUT`, `DELETE`)**: **행동(동사)**을 담당합니다.
-  * `GET`: 가져와라 (조회)
-  * `POST`: 새로 생성해라 (생성/등록)
-  * `PUT`: 수정해라 (수정)
-  * `DELETE`: 삭제해라 (삭제)
-* **URL 주소 (`/api/members`)**: **대상(명사/자원)**을 담당합니다.
-
-### 1.2. 회원가입의 RESTful 해석
-* '회원가입'은 데이터베이스 관점에서 **"새로운 회원(`members`) 데이터 1명을 새로 생성(`POST`)하는 행위"**입니다.
-* **`POST` (새로 생성해라!)** + **`/api/members` (회원들 집합에)** ➔ **회원가입!**
-
-| 행위 | ❌ 옛날 동사 중심 방식 | ⭕ 요즘 RESTful 방식 (표준) |
-| :--- | :--- | :--- |
-| **회원가입** | `POST /api/join` 또는 `/api/signup` | **`POST /api/members`** |
-| **회원 목록 조회** | `GET /api/getMembers` | **`GET /api/members`** |
-| **회원 정보 수정** | `POST /api/updateMember` | **`PUT /api/members/{publicId}`** |
-| **회원 탈퇴** | `POST /api/deleteMember` | **`DELETE /api/members/{publicId}`** |
-
----
-
-## 2. 🌐 URL 주소 앞에 `/api` 접두사를 붙이는 3가지 실무적 이유
-
-1. **"화면(HTML)" 요청과 "순수 데이터(JSON)" 요청의 명확한 구분**
-   * `/members` ➔ 웹 브라우저 화면(HTML) 요청.
-   * `/api/members` ➔ 백엔드 데이터(JSON) 요청임을 한눈에 파악 가능.
-2. **프론트엔드(Next.js 3000포트)와 백엔드(Spring Boot 8080포트) Nginx 라우팅의 편의성**
-   * Nginx 설정에서 `"주소에 /api/ 가 들어간 요청만 백엔드 포트로 전달해라"` 라고 한 줄로 라우팅 규칙 지정 가능.
-3. **세션 쿠키(`JSESSIONID`) 보안 범위의 제한**
-   * `Path=/api`로 지정하여 프론트엔드 화면 이동 시 쿠키 전송을 막고, 백엔드 API 요청 시에만 안전하게 쿠키를 전송하도록 범위 제한.
-
----
-
-## 3. ⚡ 게시글 추천/비추천 비동기(Async) 처리 기법
-
-### 3.1. 프론트엔드: '낙관적 업데이트 (Optimistic UI Update)'
-* 유저가 추천 클릭 시, 백엔드 응답을 기다리지 않고 **0.001초 만에 화면의 숫자와 하트 색깔을 먼저 변경**.
-* 백엔드 API가 에러(409 등)를 반환하면 그때 원래 숫자로 원복(`-1`).
-
-### 3.2. 백엔드: 비동기 이벤트 처리 & Redis 버퍼링
-* 백엔드는 추천 클릭 시 DB를 직접 치지 않고, **`200 OK` 응답을 즉시 끊어준 뒤 백그라운드 쓰레드(`@Async`)로 DB 업데이트 실행**.
-* 대규모 트래픽 시 Redis 메모리 카운터만 즉시 올려주고 10초 주기 비동기 배치(Batch)로 DB 반영.
-
----
-
-## 4. 🚨 글로벌 에러 응답 표준화 규격 (Global Error Response)
-
-### 4.1. 에러 응답 JSON 포맷
-```json
-{
-  "timestamp": "2026-08-08T10:20:00",
-  "status": 400,
-  "code": "INVALID_INPUT_VALUE",
-  "message": "입력값이 유효하지 않습니다.",
-  "errors": [
-    {
-      "field": "email",
-      "value": "invalid-email-format",
-      "reason": "올바른 이메일 형식이 아닙니다."
-    }
-  ]
-}
-```
-
-### 4.2. 주요 HTTP Status Code 정리
-* `400 Bad Request`: 유효성 검사 실패 (`INVALID_INPUT_VALUE`), 중복 가입 (`DUPLICATE_EMAIL`)
-* `401 Unauthorized`: 비로그인 작성 시도 (`UNAUTHORIZED`), 비밀번호 불일치 (`INVALID_CREDENTIALS`)
-* `403 Forbidden`: 타인의 글/댓글 수정·삭제 시도 (`ACCESS_DENIED`), 비회원 암호 오류 (`INVALID_ANON_PASSWORD`)
-* `404 Not Found`: 존재하지 않는 게시글/댓글/회원 조회 (`RESOURCE_NOT_FOUND`)
-* `409 Conflict`: 이미 추천/비추천 투표를 한 경우 (`ALREADY_REACTED`)
-* `500 Internal Error`: 서버 내부 비즈니스 로직 예외 발생 (`INTERNAL_SERVER_ERROR`)
diff --git a/docs/studyArchConcepts260806.md b/docs/studyArchConcepts260806.md
deleted file mode 100644
index e5a3fbc..0000000
--- a/docs/studyArchConcepts260806.md
+++ /dev/null
@@ -1,313 +0,0 @@
-# [TIL] 스노보드 커뮤니티 개발을 위한 백엔드 & DB 핵심 개념 딥다이브
-
-> 📌 **학습 날짜**: 2026년 8월 6일  
-> 🏷️ **키워드**: `No Silver Bullet`, `FK 참조 무결성`, `N:M 중계 테이블`, `Bitmask`, `JSONB`, `Redis Set`, `역정규화`, `JWT 서명 원리`, `쿠키 보안`  
-> 💡 **학습 목표**: 각 아키텍처 패턴과 기술이 등장한 **근본적인 배경(Why)**과 **원리**, 그리고 잘못 사용했을 때 터지는 **사이드 이펙트(부작용)**를 깊이 있게 체득하고 올바른 기술적 선택을 내립니다.
-
----
-
-## 0. 대전제: "소프트웨어 공학에 은총알(Silver Bullet)은 없다"
-
-소프트웨어 공학의 거장 프레더릭 브룩스(Frederick P. Brooks)는 **"No Silver Bullet(은총알은 없다)"**이라는 유명한 말을 남겼습니다.
-서양 전설에서 늑대인간을 한 방에 쓰러뜨리는 '은총알'처럼, **모든 문제를 한 번에 완벽하게 해결해 주는 만능 기술이나 설계 방식은 세상에 존재하지 않는다**는 뜻입니다.
-
-* ⚖️ **약약(Trade-off)의 법칙**: 하나의 기술을 선택해서 강력한 장점(예: 초고속 속도)을 얻는다면, **반드시 그 대가로 다른 불편함(예: 데이터 무결성 상실, 복잡도 증가)을 치러야 합니다.**
-* 따라서 위대한 엔지니어는 단순히 "좋은 기술"을 찾는 사람이 아니라, **"우리 서비스의 상황에서 어떤 대가를 치르는 것이 가장 현맥한가?"**를 고민하고 선택하는 사람입니다.
-
----
-
-## 1. 데이터베이스의 기본과 FK(외래키) 참조 무결성
-
-### 💡 용어 풀이
-> * **RDBMS (관계형 데이터베이스)**: 데이터를 행(Row)과 열(Column)로 이루어진 테이블(표) 형태로 저장하고, 테이블 간의 '관계'를 맺어 관리하는 데이터베이스 (예: MySQL, PostgreSQL, Oracle).
-> * **PK (Primary Key / 기본키)**: 각 행(데이터)을 세상에서 유일하게 식별할 수 있는 주민등록번호 같은 고유 ID.
-> * **FK (Foreign Key / 외래키)**: 다른 테이블의 PK를 참조하여 두 테이블을 연결하는 '연결 고리' 역할의 키.
-
----
-
-### 1.1. 왜 FK(외래키) 참조 무결성이 그렇게 중요할까?
-
-**참조 무결성(Referential Integrity)**이란, **"데이터 간의 관계가 끊어지거나 엉뚱한 유령 데이터를 가리키지 않도록 DB가 엄격하게 지켜주는 성질"**을 말합니다.
-
-#### 😱 FK 참조 무결성이 깨졌을 때 일어나는 잔혹사 스토리
-1. 유저 A가 작성한 게시글 100개가 있습니다.
-2. 만약 DB에서 유저 A를 삭제했는데, 게시글 100개는 그대로 남아있다면?
-3. 게시글의 `member_id`는 존재하지 않는 유저 ID를 가리키게 됩니다. 이것을 **'고아 데이터(Orphan Data)'** 또는 **'유령 데이터'**라고 부릅니다.
-4. 나중에 유저가 이 게시글을 조회하려고 하면, 작성자 정보를 찾을 수 없어 **시스템 전체에 `NullPointerException` 에러가 터지고 웹사이트가 다운**됩니다.
-
-FK 제약조건을 걸어두면, DB가 알아서 **"이 회원에게 작성된 게시글이 남아있으니 함부로 회원을 삭제할 수 없다!"** 하고 에러를 튕겨서 데이터를 보호해 줍니다.
-
----
-
-### 1.2. Option A (우리가 처음 선택했던 RDBMS 정석 - 중계 테이블 방식)
-
-#### ❓ 왜 쉼표(,)로 저장하면 안 되고, 중계 테이블을 만들어야 할까?
-만약 회원 테이블의 한 컬럼에 `riding_style = "카빙,트릭"` 처럼 쉼표로 여러 개를 저장했다고 해봅시다. (이를 DB 전문 용어로 **'1차 정규화 위반'**이라고 부릅니다.)
-
-#### 💥 쉼표 저장 시 터지는 대참사
-1. **검색 속도 지옥**: `"카빙을 타는 유저만 조회해 줘"` 라는 요청이 오면, DB는 전체 회원 데이터를 처음부터 끝까지 다 훑으면서 문자열 검색(`LIKE '%카빙%'`)을 해야 합니다. 회원 수가 10만 명이면 검색에 몇 초씩 걸립니다.
-2. **데이터 오염**: 누군가 실수로 `"카빙 , 트릭 "` (띄어쓰기 오타)으로 저장하면 검색에서 쏙 빠져버립니다.
-
-#### 🛠️ 해결책: 중계 테이블(`member_riding_style`)을 두는 이유
-RDBMS는 테이블 간에 N:M(다대다) 관계를 직접 맺을 수 없습니다. 그래서 중간에 **중계 테이블(Junction Table)**을 만들어 `1:N`과 `N:1` 두 개의 안전한 외래키(FK) 관계로 풀어냅니다.
-
-```
-[member 테이블] 1 ◄--- (FK) --- N [member_riding_style 중계 테이블] N --- (FK) ---> 1 [riding_style 마스터 테이블]
-```
-
-* **장점 (얻는 것)**:
-  * **FK 참조 무결성 완벽 보장**: 존재하지 않는 스타일 ID나 유저 ID가 들어갈 수 없음.
-  * **초고속 인덱스 검색**: `WHERE style_id = 1` 로 인덱스를 타서 0.001초 만에 검색 완료.
-* **단점 & 대가 (치르는 것)**:
-  * 유저 정보 하나 가져올 때 여러 테이블을 합성하는 **JOIN(조인) 쿼리**를 실행해야 하므로, DB 쿼리가 다소 복잡해집니다.
-
----
-
-## 2. 다중 선택 데이터를 저장하는 3가지 대안과 그 대가 (Option B, C, D)
-
----
-
-### 2.1. Option B: Bitmask (비트마스크 / 비트 연산)
-
-### 💡 용어 풀이
-> * **Bit (비트)**: 컴퓨터가 처리하는 가장 작은 단위. `0` 또는 `1` 두 가지 상태만 표현 가능.
-> * **비트 연산자 (`&`, `|`)**: 숫자를 2진수 비트 단위로 직접 계산하는 극상의 고속 연산자.
-
-#### 📜 스토리 & 배경
-옛날 컴퓨터 메모리가 1KB, 1MB 단위로 매우 귀했던 시절, 엔티지어들은 "어떻게 하면 용량을 안 쓰고 여러 개 선택을 저장할까?"를 고민하다가 **2진수의 자릿수**를 활용하는 신기한 기법을 만들었습니다.
-
-#### ⚙️ 작동 원리
-각 선택지에 2의 거듭제곱 숫자를 부여합니다.
-* 카빙 = $1$ ($2^0$, 2진수로 `0001`)
-* 트릭 = $2$ ($2^1$, 2진수로 `0010`)
-* 파크 = $4$ ($2^2$, 2진수로 `0100`)
-* 입문 = $8$ ($2^3$, 2진수로 `1000`)
-
-만약 유저가 **'카빙(1)' + '파크(4)'** 2개를 선택했다면?
-* $1 + 4 = 5$ (2진수로 `0101`)라는 **숫자 `5` 하나만 DB 컬럼(`riding_style_mask`)에 저장**합니다.
-
-조회할 때는 비트 연산(`AND`)을 씁니다: `WHERE (riding_style_mask & 1) > 0` ➔ "1번째 비트(카빙)가 켜져 있는 유저를 다 가져와!"
-
-#### ⚖️ 장단점 및 치명적 사이드 이펙트
-* **장점**: 중계 테이블이 아예 필요 없고, DB 저장 공간을 90% 이상 절약하며, 비트 연산이라 조회 속도가 빛의 속도입니다.
-* 💥 **치명적 사이드 이펙트 (왜 함부로 쓰면 안 될까?)**:
-  1. **FK 참조 무결성 완전히 상실**: 숫자 `5`가 들어있을 뿐, DB는 이 유저가 카빙을 타는지 파크를 타는지 외래키로 검증할 방법이 없습니다.
-  2. **쿼리 가독성 붕괴**: 다른 개발자가 DB를 열어봤을 때 컬럼에 `5`, `13` 같은 숫자만 적혀 있어서 무슨 뜻인지 전혀 알아볼 수 없습니다.
-  3. **확장성 한계**: 선택지가 64개를 넘어가면 64비트 정수 범위를 초과해서 코드가 터집니다.
-
----
-
-### 2.2. Option C: JSONB Document & Multi-Value Index
-
-### 💡 용어 풀이
-> * **JSON**: 데이터를 `{ "key": "value" }` 형태의 텍스트로 표현하는 표준 데이터 양식.
-> * **Multi-Value Index**: JSON 배열 안의 원소 하나하나에 인덱스를 걸어 빠르게 찾아주는 최신 DB 기술.
-
-#### 📜 스토리 & 배경
-"NoSQL(몽고DB 같은 데이터베이스)은 중계 테이블 없이 JSON 배열로 데이터를 쓱 넣으면 되는데, 왜 RDBMS는 이렇게 테이블을 쪼개고 조인해야 해서 답답하지?" 라는 개발자들의 불만이 커지자, 최신 MySQL(8.0+)과 PostgreSQL이 **JSON을 통째로 컬럼에 집어넣는 기능**을 도입했습니다.
-
-#### ⚙️ 작동 원리
-`member` 테이블에 `riding_styles`라는 컬럼을 만들고, 그냥 JSON 텍스트 `["CARVING", "TRICK"]`을 통째로 저장합니다.
-
-#### ⚖️ 장단점 및 치명적 사이드 이펙트
-* **장점**: 중계 테이블 생성이 필요 없고, 프론트엔드에서 보내준 JSON 배열 형태 그대로 DB에 넣고 뺄 수 있어 개발 속도가 엄청나게 빠릅니다.
-* 💥 **치명적 사이드 이펙트 (왜 함부로 쓰면 안 될까?)**:
-  1. **FK 참조 무결성 상실**: DB는 JSON 텍스트 내부를 외래키로 검증하지 않습니다. 오타로 `["CABING"]` (카빙 오타)이 들어가도 DB가 막아주지 못해 **데이터 오염**이 일어납니다.
-  2. **수정 작업의 오버헤드**: 카빙이라는 명칭을 "그라운드 트릭"으로 바꾸고 싶을 때, 모든 회원의 JSON 텍스트를 하나하나 꺼내서 문자열을 수정해야 하는 대공사가 벌어집니다.
-
----
-
-### 2.3. Option D: Redis Set (SINTER 교집합 연산)
-
-### 💡 용어 풀이
-> * **Redis (레디스)**: 하드디스크가 아닌 컴퓨터 메모리(RAM) 위에서 동작하는 초고속 데이터 저장소.
-> * **Set (집합)**: 중복을 허용하지 않는 데이터들의 모임.
-> * **SINTER**: 여러 집합 간의 '교집합(공통 원소)'을 한 번에 구하는 Redis 전용 명령어.
-
-#### 📜 스토리 & 배경
-회원 수가 100만 명을 넘어가자, "휘닉스파크를 가면서 + 카빙을 타는 유저"를 RDBMS에서 JOIN으로 찾으려니 DB CPU 점유율이 100%로 치솟으며 서버가 다운되었습니다. 엔지니어들은 **"검색/매칭 기능만 따로 떼어내어 RAM 위에서 벤다이어그램 교집합 연산을 하자!"** 하고 Redis를 도입했습니다.
-
-#### ⚙️ 작동 원리
-Redis에 집합 스티커를 만듭니다.
-* `resort:휘닉스파크` Set ➔ { 유저1, 유저2, 유저5 }
-* `style:카빙` Set ➔ { 유저1, 유저3, 유저5 }
-* `SINTER resort:휘닉스파크 style:카빙` ➔ **0.001초 만에 교집합인 { 유저1, 유저5 }가 즉시 나옴!**
-
-#### ⚖️ 장단점 및 치명적 사이드 이펙트
-* **장점**: RDBMS에 전혀 부하를 주지 않고, 100만 명 데이터도 0.001초 만에 매칭해 냅니다.
-* 💥 **치명적 사이드 이펙트 (왜 함부로 쓰면 안 될까?)**:
-  1. **데이터 동기화 파이프라인의 복잡성**: 유저가 프로필을 수정할 때 RDBMS뿐만 아니라 Redis 스티커도 똑같이 업데이트해 줘야 합니다. 만약 중간에 서버가 튕겨서 **RDBMS와 Redis 데이터가 서로 달라지면 유령 회원 매칭 버그**가 터집니다.
-  2. **RAM 비용 문제**: Redis는 비싼 RAM 메모리를 쓰므로 데이터가 커지면 서버 비용이 폭증합니다.
-
----
-
-## 3. 데이터베이스 역정규화 (Denormalization)
-
-### 💡 용어 풀이
-> * **정규화 (Normalization)**: 중복 데이터를 제거하고 테이블을 깔끔하게 쪼개어 데이터 무결성을 높이는 작업.
-> * **역정규화 (Denormalization)**: 성능(속도)을 위해 **의도적으로 정규화를 깨뜨리고, 중복 데이터/합계 데이터를 추가로 저장**하는 작업.
-
----
-
-### 3.1. 왜 멀쩡한 정규화를 깨뜨리고 역정규화를 할까?
-
-#### 😱 `SELECT COUNT(*)` 쿼리의 공포
-여러분이 커뮤니티 게시판 목록을 볼 때, 게시글마다 옆에 `[댓글 15개]`, `[추천 42]` 같은 숫자가 붙어있습니다.
-만약 역정규화를 하지 않았다면, 게시글 목록 10개를 보여줄 때마다 DB는 매번 `comment` 테이블로 넘어가서 **"이 글에 달린 댓글이 몇 개지?" 하고 `COUNT(*)` 연산을 10번씩 반복**해야 합니다.
-
-유저 1,000명이 동시에 게시판을 새로고침하면 DB는 `COUNT(*)` 쿼리를 10,000번 수행하다가 과부하로 서버가 다운됩니다.
-
----
-
-### 3.2. 역정규화 적용 방식 (`post` 테이블)
-`post` 테이블에 의도적으로 숫자를 저장하는 컬럼 3개를 추가해 둡니다:
-* `comment_count` (댓글 수)
-* `like_count` (추천 수)
-* `dislike_count` (비추천 수)
-
-이제 게시판 목록을 불러올 때, DB는 `comment` 테이블을 뒤질 필요 없이 **`post` 테이블에 적혀있는 숫자를 그대로 가져오기만 하면 되므로 조회 속도가 100배 이상 빨라집니다.**
-
----
-
-### 3.3. 역정규화로 인해 발생하는 치명적 문제와 해결책
-
-#### 💥 치명적 사이드 이펙트: 데이터 불일치 (Inconsistency)
-* 누군가 댓글을 작성해서 `comment` 테이블에 댓글 데이터 1개가 추가되었는데, 실수로 `post` 테이블의 `comment_count` 숫자를 `+1` 올리는 코드가 누락되거나 에러가 났다면?
-* 실제 댓글은 5개인데, 게시판 목록에는 `[댓글 4개]`라고 표시되는 **데이터 불일치 버그**가 터집니다!
-
-#### 🛠️ 어떻게 해결해야 할까?
-1. **트랜잭션 (`@Transactional`)**: 댓글 작성 ➔ 댓글 저장 ➔ 게시글 댓글 수 `+1` 증가 작업을 **하나의 세트로 묶어서, 중간에 에러가 나면 둘 다 취소(Rollback)**되도록 안전장치를 겁니다.
-2. **동시성 락 (Concurrency Lock)**: 유저 100명이 동시에 추천 버튼을 누를 때 숫자가 씹히지 않도록 DB 락(Lock) 메커니즘을 적용합니다.
-
----
-
-## 4. JWT (JSON Web Token) 검증 원리와 비밀키(Secret Key)
-
-### 💡 용어 풀이
-> * **Token (토큰)**: 유저의 신원 정보가 담긴 암호화된 텍스트 조각.
-> * **Stateless (무상태)**: 서버 메모리에 유저의 로그인 상태를 전혀 저장하지 않는 방식.
-> * **Secret Key (비밀키)**: 오직 서버만 안전하게 알고 있는 서명용 비밀 암호키.
-> * **HMAC-SHA256**: 비밀키를 섞어서 만든 복제 불가능한 해시 암호화 알고리즘.
-
----
-
-### 4.1. 근본적 의문: "서버 DB나 메모리에 저장도 안 하는데, 토큰이 진짜인지 어떻게 알아채지?"
-
-JWT는 세션 방식과 달리 **서버에 유저 로그인 정보를 전혀 저장하지 않습니다.**
-클라이언트가 요청을 보낼 때 토큰 문자열 하나 달랑 보내오는데, 서버는 도대체 무엇을 믿고 이 토큰이 해커가 위조한 가짜 토큰이 아니라는 것을 검증할 수 있을까요?
-
----
-
-### 4.2. JWT의 3조각 구조와 '임금님의 암행어사 마패' 비유
-
-JWT 토큰을 뜯어보면 마침표(`.`)를 기준으로 3조각으로 나뉘어 있습니다:
-
-```
-[Header (헤더)] . [Payload (페이로드)] . [Signature (서명/도장)]
-  eyJhbGci...   .   eyJzdWIi...     .    wNiSflK...
-```
-
-1. **Header (헤더)**: "이 토큰은 무슨 암호화 알고리즘으로 만들어졌는가?" 정보.
-2. **Payload (페이로드)**: "이 토큰의 주인은 유저 ID 5번(홍길동)이고, 내일 만료된다" 같은 실제 유저 정보. (**⚠️ 누구나 뜯어서 내용을 열어볼 수 있음!**)
-3. **Signature (서명/도장)**: **★ 핵심 ★** `Header` + `Payload` + **`서버의 Secret Key(비밀키)`**를 섞어서 만든 **'복제 불가능한 디지털 도장'**.
-
----
-
-### 📜 '임금님의 도장' 비유로 이해하는 검증 원리
-
-1. 유저가 로그인하면, 서버는 유저 정보(Payload)를 적은 뒤 **오직 서버만 가지고 있는 '비밀 도장(Secret Key)'**을 쾅 찍어서 유저에게 줍니다.
-2. 유저가 나중에 이 토큰을 서버로 가져옵니다.
-3. 만약 해커가 중간에 토큰 내용을 `유저 ID 5번`에서 `유저 ID 1번(관리자)`으로 슬쩍 고쳤다고(위조했다고) 해봅시다.
-4. 서버는 토큰을 받자마자 **"네가 가져온 내용(Header+Payload)에 내 비밀 도장(Secret Key)을 다시 찍어서 나온 서명값"**과 **"토큰에 적혀있는 서명(Signature)"**이 일치하는지 비교합니다!
-5. 내용을 고쳤기 때문에 도장 값이 서로 다르게 나오고, 서버는 **"어? 서명이 안 맞네? 이거 위조된 가짜 토큰이다!"** 하고 즉시 튕겨냅니다.
-
-👉 **결론**: 서버는 유저 상태를 저장할 필요 없이, **내 비밀키(Secret Key)로 서명 도장이 일치하는지 수학적으로 계산만 해보면 가짜를 100% 가려낼 수 있는 것**입니다!
-
----
-
-### 4.3. JWT의 치명적 약점 (세션과의 결정적 차이)
-
-#### 💥 탈취당했을 때 서버에서 강제 파기가 불가능함!
-* 세션 방식은 해커가 세션키를 훔쳐 가도, 서버에서 해당 세션을 **강제 로그아웃(`session.invalidate()`)** 시키면 해커 접속이 즉시 차단됩니다.
-* 하지만 JWT는 서버에 상태가 없기 때문에, **해커가 토큰을 탈취해가면 만료 시간이 끝날 때까지 서버가 해커의 접근을 강제로 막을 방법이 없습니다!**
-* (이것이 1차 MVP에서 보안과 관리가 용이한 세션 방식을 채택한 결정적 이유입니다.)
-
----
-
-## 5. Redis (레디스)란 무엇인가?
-
-### 💡 용어 풀이
-> * **RAM (메모리)**: 컴퓨터가 켜져 있는 동안 데이터를 초고속으로 처리하는 주기억장치. (전원이 꺼지면 삭제됨)
-> * **Disk (HDD/SSD)**: 전원이 꺼져도 데이터가 보관되는 영구 저장장치. (RAM보다 속도가 10만 배 이상 느림)
-> * **In-Memory Data Store**: 데이터를 하드디스크가 아닌 오직 RAM 메모리에만 두고 처리하는 초고속 데이터베이스.
-
----
-
-### 5.1. 왜 이렇게 빠른가? (도서관 비유)
-
-* **일반 DB (MySQL, PostgreSQL)**: 책을 찾으러 **도서관 지하 창고(Disk)**까지 걸어가서 책을 꺼내오는 방식. (시간이 오래 걸림)
-* **Redis**: 책상 위 **포스트잇(RAM)**에 적어둔 메모를 눈으로 쓱 보는 방식. (0.001초 만에 완료)
-
-Redis는 데이터가 모두 RAM 위에 올라가 있기 때문에 읽기/쓰기 속도가 일반 DB보다 100배~1,000배 이상 빠릅니다.
-
----
-
-### 5.2. Redis는 언제 쓰고, 언제 쓰면 안 될까?
-
-* **⭕ 이럴 때 씁니다**:
-  * **캐싱 (Cache)**: 자주 조회되는 스키장 날씨/웹캠 정보, 인기 게시글 저장
-  * **세션 저장소**: 서버 여러 대가 유저 로그인 상태를 공유할 때
-  * **실시간 랭킹 & 카운터**: 조회수/좋아요 실시간 집계
-* **❌ 이럴 때 쓰면 안 됩니다 (사이드 이펙트)**:
-  * 회원의 결제 내역, 비밀번호, 중요한 게시글 원본 저장 ➔ **컴퓨터 전원이 꺼지거나 재부팅되면 RAM 데이터가 싹 날아가 버리는 치명적 위험**이 있습니다. (반드시 원본 데이터는 MySQL 같은 RDBMS에 보관해야 합니다.)
-
----
-
-## 6. 쿠키 보안 정책 (Cookie Security Policies) 깊이 읽기
-
-### 💡 용어 풀이
-> * **Cookie (쿠키)**: 웹 브라우저가 사용자 컴퓨터 파일에 저장해 두는 작은 텍스트 데이터.
-> * **XSS (Cross-Site Scripting)**: 해커가 웹사이트에 악성 자바스크립트 코드를 주입하여 다른 유저의 쿠키를 훔쳐 가는 해킹 기법.
-> * **CSRF (Cross-Site Request Forgery)**: 해커가 만든 악성 사이트에 유저가 접속했을 때, 유저 몰래 내 쿠키를 가지고 원래 사이트에 비밀글 작성/결제 요청을 보내게 만드는 테러 기법.
-
----
-
-### 6.1. `HttpOnly = true` (자바스크립트 해킹 방화벽)
-* 보통 자바스크립트 코드(`document.cookie`)를 실행하면 브라우저의 쿠키를 자유롭게 읽을 수 있습니다. 해커가 게시글에 악성 스크립트를 몰래 넣어두면 유저의 로그인 쿠키가 해커 서버로 싹 털립니다.
-* **`HttpOnly` 속성을 켜두면, 오직 HTTP 통신으로만 쿠키가 이동하고 자바스크립트 접근이 완전히 차단**되어 XSS 해킹을 원천 봉쇄합니다.
-
----
-
-### 6.2. `Secure = true` (HTTPS 암호화 수호신)
-* 우리가 카페 와이파이(Wi-Fi)를 쓸 때, 보안이 안 적용된 `http://` 통신을 하면 와이파이 신호를 감청하는 해커(스니핑)가 내 세션 쿠키를 훔쳐볼 수 있습니다.
-* **`Secure` 속성을 켜두면, 오직 암호화된 `https://` 통신 채널에서만 쿠키를 전송**하도록 제한합니다.
-
----
-
-### 6.3. `SameSite = Lax` (CSRF 공격 방어)
-* 해커가 낚시성 이벤트 사이트를 만들어두고 유저가 클릭하게 만듭니다. 유저가 클릭하는 순간, 유저 브라우저에 저장되어 있던 원래 사이트 쿠키가 자동으로 첨부되어 해커의 의도대로 결제나 회원 탈퇴 요청이 날아가는 것이 CSRF 공격입니다.
-* **`SameSite=Lax` 속성을 적용하면, 다른 사이트에서 출발한 요청에는 내 쿠키를 첨부하지 않도록 브라우저가 막아줍니다.**
-
----
-
-### 6.4. ⚠️ 비밀번호나 개인정보를 쿠키에 담으면 생기는 대참사
-
-쿠키는 유저의 컴퓨터 하드디스크 텍스트 파일로 저장되며, 브라우저 개발자 도구(F12)를 누르면 누구나 눈으로 읽을 수 있습니다.
-만약 쿠키에 비밀번호나 이메일, 이름을 담아둔다면, **PC방이나 공용 컴퓨터에 내 비밀번호가 텍스트 파일로 훤히 노출되는 심각한 개인정보 유출 참사**가 벌어집니다.
-
-따라서 쿠키에는 오직 아무 의미 없는 무작위 난수 식별자(`JSESSIONID=A1B2C3...`)만 담아야 합니다.
-
----
-
-## 🎯 7. 종합 결론 및 의사결정 회고
-
-우리가 공부한 모든 내용을 바탕으로, **Snowthing 서비스 1차 MVP에 왜 이 기술들을 조합했는지** 최종 요약됩니다:
-
-1. **RDBMS 중계 테이블 방식 (Option A) 채택**:
-   * 대안인 Bitmask나 JSONB는 개발이 잠깐 편할지 몰라도 **FK 참조 무결성이 깨져서 데이터 오염 및 유령 데이터 위험**이 너무 큼.
-   * 조금 불편하더라도 데이터의 안정성을 위해 **중계 엔티티(`MemberResort`)를 직접 만들어 1:N, N:1 관계**로 깔끔하게 처리함.
-2. **세션 기반 인증 채택**:
-   * JWT는 서버 저장 비용이 없지만 **탈취 시 강제 로그아웃/파기가 불가능한 결정적 보안 문제**가 있음.
-   * 1차 MVP에서는 보안과 제어가 확실한 **세션 방식 + 쿠키 보안 3종 세트(`HttpOnly`, `Secure`, `SameSite`)**로 구축함.
-3. **역정규화 컬럼 도입**:
-   * `SELECT COUNT(*)` 쿼리로 인한 DB 과부하를 막기 위해 `post` 테이블에 `comment_count`, `like_count` 컬럼을 두고, `@Transactional`로 안전하게 관리함.
diff --git a/docs/studyArchPrinciples260810.md b/docs/studyArchPrinciples260810.md
deleted file mode 100644
index 26aac69..0000000
--- a/docs/studyArchPrinciples260810.md
+++ /dev/null
@@ -1,72 +0,0 @@
-# [Notion] 백엔드 기술 학습 3단계 딥다이브 철학 및 4대 아키텍처 분석 (TIL)
-
-> 📌 **작성 일자**: 2026년 8월 10일  
-> 🏷️ **문서 목적**: 단순 코드나 겉핥기 답변을 넘어, 모든 기술의 물리적 작동 원리, 2차/3차 치명적 한계, 그리고 그 한계까지 극복하는 최종 실무 아키텍처를 체계적으로 정리한 종합 학습서
-
----
-
-## 🏛️ 기술 분석 3단계 딥다이브 절대 원칙 (Architecture Analysis Framework)
-
-모든 백엔드 기술과 DB 아키텍처 분석 시 다음 3단계를 끝단까지 파헤칩니다.
-
-1. **[1단계] 컴퓨터 물리 & DB 엔진 내부 작동 원리**: RAM 메모리, CPU, DB 락, 인덱스 B+Tree 노드 수준에서 왜 그렇게 동작하는가?
-2. **[2단계] 이 기술을 썼을 때 새로 터지는 2차/3차 치명적 한계 (Side Effects)**: 대규모 트래픽 및 특수 상황에서 이 기술이 불러오는 2차 참사와 한계점은 무엇인가?
-3. **[3단계] 그 2차 한계까지 완전 극복하는 최종 실무 아키텍처 (Ultimate Architecture)**: 대규모 서비스에서 그 2차 한계까지 완벽히 지워버리기 위해 사용하는 최종 솔루션은 무엇인가?
-
----
-
-## 🎯 1. 동시성 락 & 카운터 정합성 (Race Condition)
-
-### 1단계: DB 원자적 UPDATE 쿼리의 물리 작동 원리
-* `UPDATE post SET like_count = like_count + 1 WHERE id = 1;`
-* **원리**: MySQL InnoDB 엔진의 Transaction Manager가 해당 Row(행)에 쓰기 락(X-Lock, Exclusive Lock)을 거는 순간, 뒤이어 들어오는 쿼리들은 DB 엔진 내부의 **`In-Memory Lock Wait Queue (대기 큐)`에 줄을 서서 대기**함. 자바 RAM을 거치지 않고 DB 엔진의 락 대기 큐를 통해 순차 처리되므로 카운트 씹힘(Lost Update)이 원천 차단됨.
-
-### 2단계: 원자적 쿼리가 초래하는 2차/3차 치명적 한계
-1. **DB 커넥션 고갈과 서비스 마비 (Connection Pool Starvation)**: 핫이슈 글에 0.1초 만에 5,000명이 추천을 누르면 4,999개 쿼리가 DB 대기 큐에 묶임. Spring의 HikariCP DB 커넥션 풀이 대기 상태로 고갈되어 **로그인/조회 등 전체 웹 서비스가 마비**됨.
-2. **DB 데드락 (Deadlock)**: 게시글 카운트 + 회원 카운트 등 2개 이상의 테이블 락을 서로 다른 순서로 잡을 때 DB 교착 상태 발생하여 트랜잭션 강제 에러 튕김.
-
-### 3단계: 2차 한계까지 극복하는 최종 실무 아키텍처
-* **Redis In-Memory 비동기 버퍼링 (Redisson & INCR)**:
-  * 유저 추천 클릭 시 DB 행 락을 아예 잡지 않고, 초고속 **Redis 메모리에서 0.0001초 만에 `INCR` 카운팅 및 중복 체크** 수행.
-  * 10초~1분 주기로 Redis에 집계된 카운트를 DB `post` 테이블에 비동기 일괄 배치 UPDATE 반영 (`Eventual Consistency`).
-
----
-
-## 🎯 2. 외부 식별자 (`public_id`) 세컨더리 인덱스 파편화
-
-### 1단계: UUID v7 (Time-ordered)의 물리 작동 원리
-* `UUID v7` 비트 구조: `[ 48 bits: Unix Epoch Timestamp (ms) ] + [ 4 bits: Version ] + [ 74 bits: Random ]`
-* **원리**: 앞부분 48비트가 밀리초 타임스탬프이므로 시간이 흐름에 따라 항상 물리적으로 더 큰 값이 생성됨. B+Tree 인덱스 노드에 정렬되어 들어갈 때 **16KB 인덱스 페이지 맨 오른쪽 끝에 순차 덧붙여짐 (Append-Only Insert)**.
-
-### 2단계: 무작위 UUID v4가 초래했던 2차/3차 치명적 한계
-* **페이지 스플릿 (Page Split) 참사**: 무작위 난수 UUID v4는 꽉 찬 16KB 인덱스 페이지 중간을 강제로 찢고 들어가므로 인덱스 파편화 폭발, 디스크 I/O 급증, 메모리 충전율 50% 급감.
-
-### 3단계: 최종 실무 아키텍처
-* **`BIGINT id` (내부 PK) + `UUID v7` (`public_id` 세컨더리 인덱스)**: 내부 클러스터드 인덱스는 8바이트 정수로 최적화하고, 세컨더리 인덱스는 `UUID v7`을 채택하여 외부 보안과 세컨더리 인덱스 쓰기 성능을 둘 다 100% 달성.
-
----
-
-## 🎯 3. 댓글 / 대댓글 계층형 N+1 쿼리 참사
-
-### 1단계: In-Memory Tree 재조립의 물리 작동 원리
-* `SELECT * FROM comment WHERE post_id = 1;`
-* **원리**: DB 단에서 쿼리를 단 1번만 실행하여 해당 글의 모든 댓글을 **단 하나의 TCP 소켓 패킷(Single Network RTT)**으로 가져옴. 자바 RAM의 `HashMap<Long, Dto>` 메모리 주소를 $O(1)$ 초고속 참조하여 부모-자식 객체 포인터(Pointer)만 엮어냄.
-
-### 2단계: N+1 쿼리가 초래하는 2차/3차 치명적 한계
-* **네트워크 RTT (Round Trip Time) 폭탄**: 원댓글 10개 조회 후 대댓글 N번 추가 조회 시 1+N번의 TCP 소켓 통신 및 HikariCP 커넥션 획득/반납 오버헤드로 DB 마비.
-
-### 3단계: 최종 실무 아키텍처
-* **Single Query In-Memory Reassembly + 1차 댓글 페이징**: DB 통신은 단 1번으로 고정하고 자바 RAM에서 재조립하며, 댓글이 수만 개 달린 핫이슈 글은 1차 원댓글 단위로 Slice/Page 나누어 메모리 과부하 사전 차단.
-
----
-
-## 🎯 4. 다대다 (N:M) 데이터 구조 및 명칭 변경
-
-### 1단계: Enum 코드화 (Data Indirection)의 물리 작동 원리
-* DB에는 `PHOENIX_PARK` 고정 코드를 저장하고, 화면 한글 명칭("휘닉스평창")은 자바 RAM 메모리의 Enum 상수로 보관.
-
-### 2단계: 텍스트 저장 시 초래하는 2차/3차 치명적 한계
-* 10년 뒤 명칭 변경 시 유저 10만 명의 DB 레코드를 디스크에서 훑어서 치환(UPDATE)하는 디스크 I/O 및 락 대기 폭탄 발생.
-
-### 3단계: 최종 실무 아키텍처
-* **RDBMS 정석 중계 테이블 (`id` 대리키) + Enum 식별자 코드화**: RDBMS의 FK 참조 무결성을 100% 보장하면서, 명칭 변경 시 DB 디스크 I/O 연산 0건, 자바 애플리케이션 상수 수정만으로 처리.
diff --git a/docs/studyCommunityPostCommentMaster260821.md b/docs/studyCommunityPostCommentMaster260821.md
deleted file mode 100644
index 6eb369e..0000000
--- a/docs/studyCommunityPostCommentMaster260821.md
+++ /dev/null
@@ -1,710 +0,0 @@
-# 📚 [Master Study Guide] Snowthing 커뮤니티(게시글 & 댓글/대댓글) 백엔드 전 과정 코드, 7대 필수 요소 기술 원리, 4대 대안 & 트레이드오프 극복 완전 가이드 (2026-08-21)
-
-> **노션(Notion) 복사용 및 백엔드 기술 면접 / 아키텍처 공부용 완전판 마스터 가이드**  
-> 본 문서는 Snowthing 스프린트 02 커뮤니티 도메인(게시글 Post & 댓글/대댓글 Comment) 백엔드 전체 코드에 대한 1줄 한 줄 상세 해설 주석(Annotation), **[WHY] 왜 그렇게 설계하고 만들어졌는지에 대한 물리적 배경**, 7대 필수 서술 요소 체계(개념, Why, When, How, Pros, Alternatives, Trade-off & Mitigation), 그리고 계층형 데이터 모델 대안과 락 프리(Lock-Free) 동시성 제어 원리를 집대성한 노션 공부용 문서입니다.
-
----
-
-# 📑 PART 1. 커뮤니티 5대 핵심 아키텍처 원리 (7대 필수 요소 체계)
-
----
-
-## 1. 댓글 계층형 N+1 완전 파괴: `Single Query + In-Memory Tree` 기법
-
-### ① 개념 (What)
-부모 댓글과 대댓글(Self-Referencing) 구조를 조회할 때, JPA 엔티티 지연 로딩 연관 관계를 순회하지 않고 **`WHERE post_id = :postId` 조건의 단 1회 SQL 쿼리로 모든 댓글을 가져와 자바 메모리(RAM)의 `HashMap` 포인터 참조를 통해 부모-자식 트리 계층(`children: []`)으로 재조립**하는 백엔드 최적화 기법입니다.
-
-### ② 왜 사용하는지 (Why - 도입 목적 & 배경)
-JPA에서 `@OneToMany List<Comment> children` 연관 관계를 두고 댓글 목록을 조회하면, 부모 댓글 10개마다 자식 대댓글을 조회하는 `SELECT` 쿼리가 연쇄적으로 날아가는 **N+1 쿼리 폭탄**이 터집니다. 댓글이 1,000개 달린 게시글은 SQL이 1,001번 실행되어 DB 커넥션이 고갈되고 서버가 다운됩니다.
-
-### ③ 어떨 때 사용하는지 (When)
-게시글의 댓글/대댓글, 카테고리 계층 구조(1차/2차/3차 카테고리), 조직도 트리 등 **한 화면에 특정 부모 하위의 전체 트리 데이터를 표시해야 하는 유즈케이스**에 사용합니다.
-
-### ④ 어떻게 사용하는지 (How - 구현 코드 및 동작 방식)
-```java
-// 1. 단 1회의 JPQL 쿼리로 해당 게시글의 모든 댓글 직조회 (O(1) Query Count)
-List<Comment> comments = commentRepository.findByPostIdWithMember(post.getId());
-
-// 2. HashMap과 LinkedHashMap을 활용한 In-Memory Tree 포인터 조립
-Map<Long, CommentResponse> map = new LinkedHashMap<>();
-List<CommentResponse> rootComments = new ArrayList<>();
-
-for (Comment comment : comments) {
-    CommentResponse dto = CommentResponse.from(comment);
-    map.put(dto.commentId(), dto);
-
-    if (dto.parentId() == null) {
-        rootComments.add(dto); // 최상위 부모 댓글
-    } else {
-        CommentResponse parentDto = map.get(dto.parentId());
-        if (parentDto != null) {
-            parentDto.children().add(dto); // O(1) 시간 복잡도로 부모의 children 리스트에 자식 바인딩!
-        }
-    }
-}
-```
-
-### ⑤ 장점 (Pros)
-* **쿼리 수 고정 (O(1) Query Count)**: 댓글이 1개든 1,000개든 DB 쿼리가 무조건 단 1번만 실행됩니다.
-* **초고속 응답 속도**: 자바 메모리의 `HashMap.get()` 조회 시간 복잡도는 O(1)이므로 메모리 연산 시간이 수 밀리초 이내입니다.
-
-### ⑥ 다른 기술/대안 (Alternatives - 트리 구조 구현 4대 모델 비교)
-1. **Adjacency List (인접 리스트 - 현재 채택 방식)**: `parent_id` 컬럼 1개만 둠. 가장 직관적이고 CUD(생성/수정/삭제)가 단순함.
-2. **Path Enumeration (경로 열거)**: `path` 컬럼에 `/1/4/12/` 형태로 전체 경로를 저장. `LIKE '/1/%'`로 조회가 쉽지만 문자열 파싱 및 수정 시 전체 경로 UPDATE 부담.
-3. **Nested Sets (중첩 집합)**: `lft`, `rgt` 숫자로 범위를 관리. 읽기 속도는 빠르나 새로운 댓글 하나 삽입 시 기존 전체 노드의 `lft`/`rgt`를 +2 갱신해야 하므로 쓰기 성능 부담.
-4. **Closure Table (폐쇄 테이블)**: 모든 부모-자식 관계를 별도의 `comment_tree(ancestor, descendant, depth)` 관계 테이블로 분리. 조회가 유연하나 테이블이 비대해짐.
-
-### ⑦ 트레이드오프 및 극복 방안 (Trade-off & Mitigation)
-* **트레이드오프 (대량 댓글 메모리 오버헤드)**: 한 게시글에 댓글이 10만 개 이상 달리면 단 1회 쿼리라도 자바 메모리(JVM Heap)에 10만 개 DTO가 한 번에 올라가 메모리 초과(OOM) 위험이 발생할 수 있습니다.
-* **극복 방안 (1차 원댓글 Slice 페이징)**: 댓글이 수천 건 이상 커지면 최상위 부모 댓글(`parent_id IS NULL`) 단위로 1차 `Slice`/`Page` 페이징 조회를 적용하고, 각 부모의 대댓글만 패치하도록 제한합니다.
-
----
-
-## 2. 락(Lock) 없는 동시성 제어: DB `UNIQUE` 제약조건 + `@Async` 비동기 카운팅
-
-### ① 개념 (What)
-추천/비추천 투표 연타(광클) 시 발생할 수 있는 레이스 컨디션 및 중복 투표를 막기 위해, DB 레벨의 **`UNIQUE (post_id, member_id, type)` 제약 조건**으로 락 프리(Lock-Free) 원자적 물리 차단을 수행하고, 카운트 갱신은 **`@Async` 비동기 이벤트**로 메인 트랜잭션 블로킹 없이 처리하는 기법입니다.
-
-### ② 왜 사용하는지 (Why)
-JPA 낙관적 락(`@Version`)이나 비관적 락(`SELECT FOR UPDATE`)은 락 대기 시간 및 `OptimisticLockException` 발생 시 복잡한 재시도(Retry) 로직이 요구되어 DB 커넥션 병목을 일으킵니다. 락 대기 없이 DB 유니크 제약 조건만으로 중복 투표를 원자적으로 물리 차단하기 위함입니다.
-
-### ③ 어떨 때 사용하는지 (When)
-유저 1인당 각 1회씩 허용되는 추천/비추천/투표 기능 및 수많은 사용자가 동시에 몰리는 반응형 커뮤니티 API에 사용합니다.
-
-### ④ 어떻게 사용하는지 (How)
-```java
-// 1. PostReaction 엔티티 복합 유니크 제약조건 설정 (계정당 추천 1회, 비추천 1회 각각 허용)
-@Table(
-    name = "post_reaction",
-    uniqueConstraints = {
-        @UniqueConstraint(name = "uk_post_member_type", columnNames = {"post_id", "member_id", "type"})
-    }
-)
-public class PostReaction extends BaseTimeEntity { ... }
-
-// 2. 서비스 레이어에서 DataIntegrityViolationException 캐치 및 409 Conflict 반환
-try {
-    reactionRepository.save(reaction);
-} catch (DataIntegrityViolationException e) {
-    throw new CustomAuthException(ErrorCode.ALREADY_REACTED);
-}
-
-// 3. 메인 트랜잭션을 블로킹하지 않는 @Async 비동기 카운터 갱신 이벤트 발행
-eventPublisher.publishEvent(new PostReactionEvent(post.getId(), type));
-```
-
-### ⑤ 장점 (Pros)
-* **락 트랜잭션 대기 병목 제거**: DB Row Lock을 잡지 않으므로 동시 요청 시 트랜잭션 대기 병목이 발생하지 않습니다.
-* **DB 엔진 레벨 무결성**: MySQL InnoDB 유니크 인덱스가 동일 요청의 중복 투표를 원자적으로 차단합니다.
-
-### ⑥ 다른 대안 (Alternatives)
-* **JPA 낙관적 락 (`@Version`)**: 충돌 시 예외를 던지고 자바에서 재시도. 락 대기는 없으나 동시 충돌 시 재시도 실패율 증가.
-* **JPA 비관적 락 (`PESSIMISTIC_WRITE`)**: DB Row Lock을 걸어 순차 처리. 데이터 일관성은 보장되나 동접자가 몰릴 때 DB 커넥션 타임아웃 발생 가능.
-
-### ⑦ 트레이드오프 및 극복 방안 (Trade-off & Mitigation)
-* **트레이드오프 (비동기 처리 시 미세한 카운트 시차)**: `@Async`로 카운트를 올리므로 DB `post_reaction`에는 저장이 완료되었으나 게시글 `like_count` 수치 갱신에 수 밀리초 시차가 발생할 수 있습니다.
-* **극복 방안 (Optimistic UI)**: 프론트엔드에서 추천 버튼 클릭 즉시 화면 상의 카운터를 +1 먼저 가산하고 백엔드 응답을 수신하는 낙관적 UI 렌더링을 적용합니다.
-
-### ⑧ CAP 정리 (CAP Theorem) 및 BASE 모델 4대 물리적 적용 메커니즘
-
-이 방식은 전통적인 RDBMS의 **ACID 강한 일관성(Strong Consistency)** 대신, 고성능 분산 웹 시스템의 **CAP 정리 중 AP (Availability & Partition Tolerance)** 모델과 **BASE (Basically Available, Soft State, Eventual Consistency)** 체계를 실제 코드와 DB 레이어에 물리적으로 매핑한 아키텍처입니다.
-
-#### 1. CAP 정리 적용 원리 (Consistency vs Availability)
-* **C (Consistency - 일관성)의 대가**: `post_reaction` 투표 이력 저장과 `post.like_count` 카운터 갱신을 단일 동기 트랜잭션으로 묶어 DB Row Lock을 잡으면 **강한 일관성(Strong Consistency)**을 얻지만, 트래픽 폭주 시 DB 커넥션 대기 병목이 생겨 시스템 **가용성(Availability)**과 응답 속도가 크게 떨어집니다.
-* **AP + BASE 선택 이유**: 커뮤니티 추천 수 갱신은 수 밀리초의 수치 반영 지연이 발생하더라도 시스템 전체가 멈추지 않고 빠른 응답을 주는 **가용성(Availability)** 확보가 서비스 안정성에 훨씬 유리하기 때문입니다.
-
-#### 2. 우리 코드 및 DB에 실제로 적용된 4대 물리적 구조
-
-1. **[C 영역 - 즉시 일관성 (Immediate Consistency)] DB 유니크 제약조건**:
-   - `post_reaction` 테이블에 `@UniqueConstraint(name = "uk_post_member_type", columnNames = {"post_id", "member_id", "type"})` 설정.
-   - 유저 투표 시 `post_reaction` 테이블 저장 단계는 **ACID 수준의 일관성**을 유지하여, 중복 투표 발생 시 MySQL InnoDB 엔진이 `DataIntegrityViolationException` 예외를 내며 중복 저장을 원자적으로 물리 차단합니다.
-
-2. **[A 영역 - 고가용성 (High Availability)] `@Async` 비동기 이벤트 분리**:
-   - `PostService.reactToPost()` 메서드에서 `post` 테이블의 카운트를 동기로 올리지 않고, `eventPublisher.publishEvent()`로 비동기 이벤트를 발행한 뒤 **즉시 HTTP 200 OK 응답을 반환**.
-   - 메인 HTTP 요청 Thread는 `post` 테이블의 Row Lock 대기에 얽매이지 않으므로, 수천 명의 동시 요청이 들어와도 서버 타임아웃 없이 모든 요청에 **정상 응답하는 가용성(Availability)**을 확보합니다.
-
-3. **[Soft State & Eventual Consistency 영역 - 최종 일관성] `@Async` 리스너**:
-   - `PostReactionEventListener.java` 백그라운드 이벤트 리스너 실행.
-   - **Soft State (일시적 불일치)**: 메인 트랜잭션 응답 직후부터 비동기 스레드가 동작하는 수 밀리초 사이에는 DB `post_reaction`(투표 이력 1건)과 `post.like_count`(아직 +1 안 됨) 사이에 미세한 상태 차이가 존재합니다.
-   - **Eventual Consistency (최종 일관성)**: 백그라운드 비동기 스레드가 `UPDATE post SET like_count = like_count + 1 WHERE post_id = :id` 쿼리를 완료하는 시점에 두 데이터는 **최종적으로 완전히 일치**하게 됩니다.
-
-4. **[보완 렌더링 영역] Optimistic UI (낙관적 UI)**:
-   - 프론트엔드 `app/posts/[publicId]/page.tsx` 연동.
-   - 백엔드의 수 밀리초 최종 일관성 시차 동안 유저가 지연을 느끼지 않도록, 추천 버튼 클릭 즉시 화면 상의 숫자를 +1 렌더링하고 백엔드의 비동기 처리가 최종 완료되도록 시각적 조화를 이룹니다.
-
----
-
-# 📑 PART 1.5. 게시글 & 댓글 컨트롤러/서비스 전체 비즈니스 로직 흐름도 (Mermaid & Code Flow)
-
----
-
-## 1. 게시글(Post) 도메인 비즈니스 로직 및 쿼리 실행 흐름도
-
-### ① 게시글 작성 (`POST /api/posts`) 시퀀스 다이어그램
-
-```mermaid
-sequenceDiagram
-    autonumber
-    actor Client as 클라이언트 (유저/프론트)
-    participant Ctrl as PostController
-    participant Svc as PostService
-    participant CatRepo as PostCategoryRepository
-    participant MemberRepo as MemberRepository
-    participant PostRepo as PostRepository
-    participant ImgRepo as PostImageRepository
-
-    Client->>Ctrl: POST /api/posts (DTO: categoryCode, title, content, isAnonymous, password)
-    Ctrl->>Ctrl: @Valid 유효성 검사 & getClientIp(httpRequest) 파싱
-    Ctrl->>Svc: createPost(request, userDetails, clientIp)
-    
-    Svc->>CatRepo: findByCode(categoryCode)
-    alt 카테고리 없음
-        CatRepo-->>Svc: Optional.empty()
-        Svc-->>Ctrl: CustomAuthException (POST_CATEGORY_NOT_FOUND 404)
-        Ctrl-->>Client: 404 Not Found
-    end
-
-    alt 익명글 (ANONYMOUS 카테고리 또는 isAnonymous=true)
-        Svc->>Svc: anonymousPassword BCrypt 해시 암호화
-    else 회원글
-        Svc->>MemberRepo: findByPublicId(userDetails.getPublicId())
-    end
-
-    Svc->>PostRepo: save(Post 엔티티)
-    PostRepo-->>Svc: savedPost (PK 부여 완료)
-
-    opt 첨부 이미지 존재하는 경우
-        loop 이미지 URL 리스트
-            Svc->>ImgRepo: save(PostImage 엔티티)
-        end
-    end
-
-    Svc-->>Ctrl: PostResponse.from(savedPost)
-    Ctrl-->>Client: 201 Created (PostResponse JSON)
-```
-
----
-
-### ② 게시글 추천/비추천 투표 및 `@Async` 비동기 카운터 갱신 흐름도
-
-```mermaid
-flowchart TD
-    A[클라이언트: POST /api/posts/{publicId}/reactions] --> B[PostController.reactToPost]
-    B --> C{인증 여부 검증 userDetails != null}
-    C -- 미인증 --> D[403 Forbidden 예외 반환]
-    C -- 인증됨 --> E[PostService.reactToPost]
-    
-    E --> F[postRepository.findByPublicId]
-    F --> G[memberRepository.findByPublicId]
-    G --> H[PostReaction 엔티티 생성: post, member, type]
-    
-    H --> I[reactionRepository.save]
-    
-    I -->|DB uk_post_member_type 위반| J[DataIntegrityViolationException 캐치]
-    J --> K[409 Conflict ALREADY_REACTED 반환]
-    
-    I -->|최초 투표 성공| L[applicationEventPublisher.publishEvent]
-    L --> M[메인 트랜잭션 종료 & HTTP 200 OK 응답 반환]
-    
-    L -. 비동기 이벤트 전달 .-> N[@Async PostReactionEventListener]
-    N --> O[postRepository.findById]
-    O --> P[post.increaseLikeCount / increaseDislikeCount]
-    P --> Q[UPDATE post SET like_count = like_count + 1 백그라운드 SQL 실행]
-```
-
----
-
-## 2. 댓글/대댓글(Comment) 도메인 비즈니스 로직 및 쿼리 실행 흐름도
-
-### ① 댓글/대댓글 작성 (`POST /api/posts/{publicId}/comments`)
-
-```mermaid
-sequenceDiagram
-    autonumber
-    actor Client as 클라이언트
-    participant Ctrl as CommentController
-    participant Svc as CommentService
-    participant PostRepo as PostRepository
-    participant CommentRepo as CommentRepository
-    participant MemberRepo as MemberRepository
-
-    Client->>Ctrl: POST /api/posts/{publicId}/comments (parentId, content, isAnonymous, password)
-    Ctrl->>Svc: createComment(publicId, request, userDetails, clientIp)
-    
-    Svc->>PostRepo: findByPublicId(publicId)
-    alt 게시글 없거나 is_deleted = true
-        Svc-->>Ctrl: CustomAuthException (POST_NOT_FOUND 404)
-        Ctrl-->>Client: 404 Not Found
-    end
-
-    opt parentId != null (대댓글 작성인 경우)
-        Svc->>CommentRepo: findById(parentId)
-        alt 부모 댓글 부재 또는 타 게시글 소속
-            Svc-->>Ctrl: CustomAuthException (PARENT_COMMENT_NOT_FOUND 404)
-        end
-    end
-
-    Svc->>CommentRepo: save(Comment 엔티티)
-    Svc->>PostRepo: post.increaseCommentCount() (comment_count +1)
-    Svc-->>Ctrl: CommentResponse.from(savedComment)
-    Ctrl-->>Client: 201 Created (CommentResponse JSON)
-```
-
----
-
-### ② 댓글 계층형 목록 조회 (`GET /api/posts/{publicId}/comments`) - N+1 파괴
-
-```mermaid
-flowchart TD
-    Start[클라이언트: GET /api/posts/{publicId}/comments] --> Ctrl[CommentController.getCommentsByPost]
-    Ctrl --> Svc[CommentService.getCommentsByPost]
-    
-    Svc --> DB[(Database)]
-    DB -- "SELECT c FROM Comment c LEFT JOIN FETCH c.member WHERE c.post.id = :postId (단 1회 SQL)" --> Svc
-    
-    Svc --> Map[LinkedHashMap<Long, CommentResponse> 포인터 맵 생성]
-    Svc --> Loop[루프 순회: List<Comment> comments]
-    
-    Loop --> Check{dto.parentId == null ?}
-    Check -- Yes (원댓글) --> AddRoot[rootComments 리스트에 추가]
-    Check -- No (대댓글) --> GetParent[map.get parentId 로 O(1) 부모 DTO 획득]
-    GetParent --> AddChild[parentDto.children 리스트에 자식 바인딩]
-    
-    AddRoot --> LoopNext{다음 항목 존재?}
-    AddChild --> LoopNext
-    
-    LoopNext -- Yes --> Loop
-    LoopNext -- No (완료) --> Build[PostCommentListResponse 조립 반환]
-    Build --> Resp[HTTP 200 OK JSON 반환]
-```
-
----
-
-# 📑 PART 2. 백엔드 전체 코드 & 1줄 상세 주석 (Annotation)
-
----
-
-## 1. `Comment.java` (댓글 메인 엔티티)
-
-```java
-package com.ikae.snowthing.domain.comment.entity;
-
-import com.ikae.snowthing.domain.member.entity.Member;
-import com.ikae.snowthing.domain.post.entity.Post;
-import com.ikae.snowthing.global.common.BaseTimeEntity;
-import jakarta.persistence.*;
-import lombok.AccessLevel;
-import lombok.Builder;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import org.hibernate.annotations.SQLDelete;
-
-import java.time.LocalDateTime;
-
-@Entity                                                                                   // [JPA] 이 클래스가 데이터베이스 테이블과 매핑되는 ORM 엔티티임을 선언
-@Table(name = "comment")                                                                 // [DB] 매핑될 데이터베이스 테이블명을 'comment'로 명시적 지정
-@Getter                                                                                  // [Lombok] 모든 필드에 대한 Getter 메서드를 자동 생성하여 불변 읽기 제공
-@NoArgsConstructor(access = AccessLevel.PROTECTED)                                       // [JPA Spec] 기본 생성자의 접근 제어자를 PROTECTED로 제한하여 무분별한 객체 생성 방지
-@SQLDelete(sql = "UPDATE comment SET is_deleted = true, deleted_at = NOW() WHERE comment_id = ?") // [Soft Delete] delete() 호출 시 물리 삭제 대신 UPDATE 수행
-public class Comment extends BaseTimeEntity {
-
-    @Id                                                                                  // [PK] 데이터베이스 테이블의 기본키(Primary Key) 필드임을 지정
-    @GeneratedValue(strategy = GenerationType.IDENTITY)                                  // [Strategy] MySQL AUTO_INCREMENT 전략을 채택하여 기본키 자동 증가 처리
-    @Column(name = "comment_id")                                                         // [Column] DB 컬럼명을 'comment_id'로 지정
-    private Long id;                                                                     // DB 내부 조인 성능 최적화를 위한 8바이트 정수 PK
-
-    @ManyToOne(fetch = FetchType.LAZY)                                                   // [N:1] 댓글과 게시글의 N:1 연관 관계 지연 로딩(LAZY) 설정으로 N+1 방지
-    @JoinColumn(name = "post_id", nullable = false)                                      // [FK] 외래키 컬럼명을 'post_id'로 지정하며 필수(NOT NULL) 설정
-    private Post post;                                                                   // 이 댓글이 달린 대상 게시글 엔티티 참조
-
-    @ManyToOne(fetch = FetchType.LAZY)                                                   // [N:1] 댓글과 회원의 N:1 연관 관계 지연 로딩 설정
-    @JoinColumn(name = "member_id")                                                      // [FK] 외래키 'member_id' 지정 (비회원 작성 시 NULL 수용)
-    private Member member;                                                               // 댓글 작성자 회원 엔티티 참조
-
-    @ManyToOne(fetch = FetchType.LAZY)                                                   // [Self Referencing] 자기 자신을 참조하는 N:1 부모 댓글 연관 관계 설정
-    @JoinColumn(name = "parent_id")                                                      // [FK] 부모 댓글 PK를 가리키는 외래키 'parent_id' 지정 (원댓글은 NULL)
-    private Comment parent;                                                              // 부모 댓글 엔티티 참조 (대댓글 구현용)
-
-    @Column(nullable = false, length = 1000)                                             // [Column] 댓글 본문 필수(NOT NULL), 최대 1,000자 제한
-    private String content;                                                              // 댓글 본문 내용
-
-    @Column(name = "writer_ip", nullable = false, length = 45)                           // [Column] 작성자 IP 주소 (IPv6 45자 수용 가능)
-    private String writerIp;                                                             // 작성자 클라이언트 IP 주소
-
-    @Column(name = "is_anonymous", nullable = false)                                      // [Column] 익명 작성 여부 플래그 (true: 익명, false: 회원)
-    private boolean isAnonymous;                                                         // 익명 작성 여부
-
-    @Column(name = "anonymous_password")                                                 // [Column] 비회원 익명 작성 시 수정/삭제용 비밀번호 (BCrypt 암호화)
-    private String anonymousPassword;                                                    // 비회원 암호화 비밀번호
-
-    @Column(name = "is_deleted", nullable = false)                                       // [Column] Soft Delete 상태 플래그 (true: 삭제됨, false: 정상)
-    private boolean isDeleted = false;                                                   // 논리 삭제 여부
-
-    @Column(name = "deleted_at")                                                         // [Column] Soft Delete 처리 시각 기록 필드 (미삭제 시 NULL)
-    private LocalDateTime deletedAt;                                                     // 삭제 일시
-
-    @Builder                                                                             // [Design Pattern] 빌더 패턴을 적용하여 생성자 파라미터 순서 오염 방지
-    public Comment(Post post, Member member, Comment parent, String content,
-                   String writerIp, boolean isAnonymous, String anonymousPassword) {
-        this.post = post;
-        this.member = member;
-        this.parent = parent;
-        this.content = content;
-        this.writerIp = writerIp;
-        this.isAnonymous = isAnonymous;
-        this.anonymousPassword = anonymousPassword;
-        this.isDeleted = false;
-    }
-
-    public void softDelete() {                                                           // [Domain Method] 엔티티 캡슐화를 유지하며 Soft Delete 상태를 변경하는 도메인 메서드
-        this.isDeleted = true;                                                           // 삭제 플래그를 true로 변경
-        this.deletedAt = LocalDateTime.now();                                            // 삭제 처리 시각을 현재 시간으로 기록
-    }
-}
-```
-
----
-
-## 2. `CommentRepository.java` (단 1회 JPQL 쿼리 조동사)
-
-```java
-package com.ikae.snowthing.domain.comment.repository;
-
-import com.ikae.snowthing.domain.comment.entity.Comment;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.jpa.repository.Query;
-import org.springframework.data.repository.query.Param;
-
-import java.util.List;
-
-public interface CommentRepository extends JpaRepository<Comment, Long> {
-
-    @Query("SELECT c FROM Comment c LEFT JOIN FETCH c.member WHERE c.post.id = :postId ORDER BY c.createdAt ASC, c.id ASC") // [Single Query] 단 1회의 JPQL 조인 쿼리로 특정 게시글의 모든 댓글 직조회 (N+1 파괴)
-    List<Comment> findByPostIdWithMember(@Param("postId") Long postId);                   // 작성자 Member를 FETCH JOIN하여 단 1회 쿼리로 리스트를 반환하는 메서드
-}
-```
-
----
-
-## 3. `CommentService.java` (In-Memory Tree 조립 및 비즈니스 로직)
-
-```java
-package com.ikae.snowthing.domain.comment.service;
-
-import com.ikae.snowthing.domain.comment.dto.*;
-import com.ikae.snowthing.domain.comment.entity.Comment;
-import com.ikae.snowthing.domain.comment.repository.CommentRepository;
-import com.ikae.snowthing.domain.member.entity.Member;
-import com.ikae.snowthing.domain.member.repository.MemberRepository;
-import com.ikae.snowthing.domain.post.entity.Post;
-import com.ikae.snowthing.domain.post.repository.PostRepository;
-import com.ikae.snowthing.global.error.ErrorCode;
-import com.ikae.snowthing.global.exception.CustomAuthException;
-import com.ikae.snowthing.global.security.CustomUserDetails;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.security.crypto.password.PasswordEncoder;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-
-import java.util.*;
-
-@Slf4j
-@Service
-@RequiredArgsConstructor
-@Transactional(readOnly = true)                                                            // [Performance] 읽기 전용 트랜잭션을 기본 적용하여 히버네이트 스냅샷 생성 오버헤드 차단
-public class CommentService {
-
-    private final CommentRepository commentRepository;
-    private final PostRepository postRepository;
-    private final MemberRepository memberRepository;
-    private final PasswordEncoder passwordEncoder;
-
-    @Transactional                                                                       // [Transaction] 쓰기 작업이 포함되므로 일반 트랜잭션으로 재정의
-    public CommentResponse createComment(String postPublicId, CommentCreateRequest request,
-                                         CustomUserDetails userDetails, String clientIp) {
-        Post post = postRepository.findByPublicId(postPublicId)                           // 게시글 publicId로 대상 게시글 조회
-            .orElseThrow(() -> new CustomAuthException(ErrorCode.POST_NOT_FOUND));        // 존재하지 않으면 404 예외 발생
-
-        if (post.isDeleted()) {                                                          // 게시글이 Soft Delete 상태인지 검증
-            throw new CustomAuthException(ErrorCode.POST_NOT_FOUND);                    // 이미 지워진 글이면 404 예외 발생
-        }
-
-        Comment parent = null;
-        if (request.parentId() != null) {                                                // parentId 요청이 존재하는 대댓글 작성 케이스인 경우
-            parent = commentRepository.findById(request.parentId())                       // 부모 댓글 엔티티 조회
-                .orElseThrow(() -> new CustomAuthException(ErrorCode.PARENT_COMMENT_NOT_FOUND)); // 없으면 404 부모 댓글 예외 발생
-
-            if (!parent.getPost().getId().equals(post.getId())) {                        // 부모 댓글의 게시글 ID와 현재 게시글 ID 일치 여부 대조
-                throw new CustomAuthException(ErrorCode.INVALID_COMMENT_PARENT);         // 다른 글의 댓글에 대댓글 작성을 시도하면 400 예외 차단
-            }
-        }
-
-        Member member = null;
-        String encodedPassword = null;
-
-        if (request.isAnonymous()) {                                                     // 익명 댓글 작성인 경우
-            if (request.anonymousPassword() == null || request.anonymousPassword().isBlank()) {
-                throw new CustomAuthException(ErrorCode.INVALID_INPUT);                 // 익명 비밀번호 누락 시 400 예외
-            }
-            encodedPassword = passwordEncoder.encode(request.anonymousPassword());       // 비회원 비밀번호 BCrypt 해시 암호화
-        } else {                                                                         // 회원 댓글 작성인 경우
-            if (userDetails == null) {
-                throw new CustomAuthException(ErrorCode.INVALID_CREDENTIALS);            // 로그인 정보가 없으면 401 예외
-            }
-            member = memberRepository.findByPublicId(userDetails.getPublicId())          // 인증 객체에서 작성자 Member 엔티티 조회
-                .orElseThrow(() -> new CustomAuthException(ErrorCode.MEMBER_NOT_FOUND));
-        }
-
-        Comment comment = Comment.builder()                                              // Comment 엔티티 생성
-            .post(post)
-            .member(member)
-            .parent(parent)
-            .content(request.content())
-            .writerIp(clientIp != null ? clientIp : "127.0.0.1")
-            .isAnonymous(request.isAnonymous())
-            .anonymousPassword(encodedPassword)
-            .build();
-
-        Comment savedComment = commentRepository.save(comment);                         // DB에 댓글 저장
-        post.increaseCommentCount();                                                     // 게시글의 역정규화 comment_count 카운트 +1 증가
-
-        return CommentResponse.from(savedComment);                                       // DTO로 변환하여 응답 반환
-    }
-
-    public PostCommentListResponse getCommentsByPost(String postPublicId) {
-        Post post = postRepository.findByPublicId(postPublicId)                           // 대상 게시글 조회
-            .orElseThrow(() -> new CustomAuthException(ErrorCode.POST_NOT_FOUND));
-
-        if (post.isDeleted()) {
-            throw new CustomAuthException(ErrorCode.POST_NOT_FOUND);
-        }
-
-        List<Comment> comments = commentRepository.findByPostIdWithMember(post.getId()); // [Single Query] 단 1회 쿼리로 전체 댓글 패치
-
-        Map<Long, CommentResponse> map = new LinkedHashMap<>();                          // [In-Memory Tree] 포인터 맵 생성 (순서 보장 LinkedHashMap)
-        List<CommentResponse> rootComments = new ArrayList<>();                          // 최상위 부모 댓글들을 담을 리스트
-
-        for (Comment comment : comments) {                                               // 단 1회 조회의 결과를 자바 루프로 순회
-            CommentResponse dto = CommentResponse.from(comment);                         // 엔티티를 DTO로 변환
-            map.put(dto.commentId(), dto);                                               // O(1) 참조를 위해 맵에 저장
-
-            if (dto.parentId() == null) {                                                // parentId가 없는 최상위 부모 댓글인 경우
-                rootComments.add(dto);                                                   // 루트 리스트에 추가
-            } else {                                                                     // 대댓글인 경우
-                CommentResponse parentDto = map.get(dto.parentId());                    // O(1) 복잡도로 맵에서 부모 DTO를 인메모리 포인터로 획득
-                if (parentDto != null) {
-                    parentDto.children().add(dto);                                       // 부모 DTO의 children 리스트에 자식 바인딩!
-                }
-            }
-        }
-
-        return PostCommentListResponse.builder()                                         // 최종 계층형 트리 응답 DTO 생성 반환
-            .publicId(postPublicId)
-            .totalCommentCount(post.getCommentCount())
-            .comments(rootComments)
-            .build();
-    }
-
-    @Transactional
-    public void deleteComment(Long commentId, String anonymousPassword, CustomUserDetails userDetails) {
-        Comment comment = commentRepository.findById(commentId)                         // 삭제 대상 댓글 조회
-            .orElseThrow(() -> new CustomAuthException(ErrorCode.COMMENT_NOT_FOUND));
-
-        if (comment.isDeleted()) {
-            throw new CustomAuthException(ErrorCode.COMMENT_NOT_FOUND);                 // 이미 지워진 댓글이면 404 반환
-        }
-
-        validateDeletePermission(comment, anonymousPassword, userDetails);               // 작성자 본인 및 비회원 비밀번호 / 관리자 권한 검증
-
-        comment.softDelete();                                                            // Soft Delete 처리 (is_deleted=true, deleted_at=NOW())
-        comment.getPost().decreaseCommentCount();                                        // 게시글의 역정규화 comment_count 카운트 -1 차감
-    }
-
-    private void validateDeletePermission(Comment comment, String anonymousPassword, CustomUserDetails userDetails) {
-        if (comment.isAnonymous()) {
-            if (anonymousPassword == null || !passwordEncoder.matches(anonymousPassword, comment.getAnonymousPassword())) {
-                throw new CustomAuthException(ErrorCode.INVALID_ANON_PASSWORD);         // 비회원 비밀번호 불일치 시 403 예외
-            }
-        } else {
-            if (userDetails == null) {
-                throw new CustomAuthException(ErrorCode.ACCESS_DENIED);                 // 미인증 시 403 예외
-            }
-
-            boolean isAdmin = userDetails.getAuthorities().stream()
-                .anyMatch(a -> a.getAuthority().equals("ROLE_ADMIN"));
-
-            boolean isWriter = comment.getMember() != null && comment.getMember().getPublicId().equals(userDetails.getPublicId());
-
-            if (!isAdmin && !isWriter) {                                                 // 작성자 본인도 아니고 관리자도 아니면
-                throw new CustomAuthException(ErrorCode.ACCESS_DENIED);                 // 403 Forbidden 권한 거부 예외 발생
-            }
-        }
-    }
-}
-```
-
----
-
-# 📑 PART 3. 백엔드 테스트 수트 & N+1 파괴 쿼리 검증 기법
-
----
-
-## 1. `CommentServiceTest.java` (단위/통합 테스트 코드)
-
-```java
-package com.ikae.snowthing.domain.comment.service;
-
-import com.ikae.snowthing.domain.comment.dto.CommentCreateRequest;
-import com.ikae.snowthing.domain.comment.dto.CommentResponse;
-import com.ikae.snowthing.domain.comment.dto.PostCommentListResponse;
-import com.ikae.snowthing.domain.member.entity.Member;
-import com.ikae.snowthing.domain.member.entity.Role;
-import com.ikae.snowthing.domain.member.repository.MemberRepository;
-import com.ikae.snowthing.domain.post.dto.PostCreateRequest;
-import com.ikae.snowthing.domain.post.dto.PostResponse;
-import com.ikae.snowthing.domain.post.entity.PostCategory;
-import com.ikae.snowthing.domain.post.repository.PostCategoryRepository;
-import com.ikae.snowthing.domain.post.service.PostService;
-import com.ikae.snowthing.global.error.ErrorCode;
-import com.ikae.snowthing.global.exception.CustomAuthException;
-import com.ikae.snowthing.global.security.CustomUserDetails;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Nested;
-import org.junit.jupiter.api.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.context.SpringBootTest;
-import org.springframework.security.crypto.password.PasswordEncoder;
-import org.springframework.transaction.annotation.Transactional;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-
-@SpringBootTest                                                                          // [SpringBootTest] 스프링 통합 테스트 환경 로드
-@Transactional                                                                           // [Rollback] 테스트 종료 후 DB를 자동으로 롤백하여 독립성 유지
-class CommentServiceTest {
-
-    @Autowired private CommentService commentService;
-    @Autowired private PostService postService;
-    @Autowired private MemberRepository memberRepository;
-    @Autowired private PostCategoryRepository categoryRepository;
-    @Autowired private PasswordEncoder passwordEncoder;
-
-    private Member member1;
-    private CustomUserDetails userDetails1;
-    private PostResponse post;
-
-    @BeforeEach
-    void setUp() {
-        categoryRepository.findByCode("FREE")
-            .orElseGet(() -> categoryRepository.save(PostCategory.builder().name("자유게시판").code("FREE").build()));
-
-        member1 = memberRepository.save(Member.builder()
-            .email("commenter@example.com")
-            .password(passwordEncoder.encode("Password123!"))
-            .nickname("댓글보더")
-            .role(Role.ROLE_USER)
-            .build());
-
-        userDetails1 = new CustomUserDetails(member1);
-
-        post = postService.createPost(PostCreateRequest.builder()
-            .categoryCode("FREE")
-            .title("댓글 테스트 게시글")
-            .content("게시글 본문")
-            .isAnonymous(false)
-            .build(), userDetails1, "127.0.0.1");
-    }
-
-    @Nested
-    @DisplayName("댓글 작성 테스트")
-    class CreateCommentTest {
-
-        @Test
-        @DisplayName("원댓글과 대댓글을 정상적으로 작성한다.")
-        void createComment_success() {
-            CommentResponse parent = commentService.createComment(post.publicId(), CommentCreateRequest.builder()
-                .content("원댓글입니다.")
-                .isAnonymous(false)
-                .build(), userDetails1, "127.0.0.1");
-
-            CommentResponse child = commentService.createComment(post.publicId(), CommentCreateRequest.builder()
-                .parentId(parent.commentId())
-                .content("대댓글입니다.")
-                .isAnonymous(false)
-                .build(), userDetails1, "127.0.0.1");
-
-            assertThat(parent.commentId()).isNotNull();
-            assertThat(child.parentId()).isEqualTo(parent.commentId());
-        }
-
-        @Test
-        @DisplayName("존재하지 않는 부모 댓글 ID로 대댓글 작성 시 404 예외가 터진다.")
-        void createComment_parentNotFound() {
-            assertThatThrownBy(() -> commentService.createComment(post.publicId(), CommentCreateRequest.builder()
-                .parentId(99999L)
-                .content("잘못된 부모 대댓글")
-                .isAnonymous(false)
-                .build(), userDetails1, "127.0.0.1"))
-                .isInstanceOf(CustomAuthException.class)
-                .extracting("errorCode")
-                .isEqualTo(ErrorCode.PARENT_COMMENT_NOT_FOUND);
-        }
-    }
-
-    @Nested
-    @DisplayName("댓글 트리 계층형 목록 조회 테스트")
-    class GetCommentsTest {
-
-        @Test
-        @DisplayName("부모-자식 대댓글 트리 계층 구조가 정상 조립된다.")
-        void getCommentsByPost_treeStructure() {
-            CommentResponse parent1 = commentService.createComment(post.publicId(), CommentCreateRequest.builder()
-                .content("부모 댓글 1")
-                .isAnonymous(false)
-                .build(), userDetails1, "127.0.0.1");
-
-            commentService.createComment(post.publicId(), CommentCreateRequest.builder()
-                .parentId(parent1.commentId())
-                .content("자식 대댓글 1-1")
-                .isAnonymous(false)
-                .build(), userDetails1, "127.0.0.1");
-
-            PostCommentListResponse response = commentService.getCommentsByPost(post.publicId());
-
-            assertThat(response.totalCommentCount()).isEqualTo(2);
-            assertThat(response.comments()).hasSize(1);
-            assertThat(response.comments().get(0).children()).hasSize(1);
-            assertThat(response.comments().get(0).children().get(0).content()).isEqualTo("자식 대댓글 1-1");
-        }
-
-        @Test
-        @DisplayName("삭제된 부모 댓글은 본문이 '삭제된 댓글입니다.'로 표시된다.")
-        void getCommentsByPost_deletedParentDisplay() {
-            CommentResponse parent1 = commentService.createComment(post.publicId(), CommentCreateRequest.builder()
-                .content("지워질 부모 댓글")
-                .isAnonymous(false)
-                .build(), userDetails1, "127.0.0.1");
-
-            commentService.deleteComment(parent1.commentId(), null, userDetails1);
-
-            PostCommentListResponse response = commentService.getCommentsByPost(post.publicId());
-
-            assertThat(response.comments().get(0).isDeleted()).isTrue();
-            assertThat(response.comments().get(0).content()).isEqualTo("삭제된 댓글입니다.");
-        }
-    }
-}
-```
-
----
-
-# 📌 PART 4. 작업 결과 및 검증 완료 요약
-
-* **생성된 마스터 스터디 파일 경로**:
-  - [`c:\Users\ikaes\IdeaProjects\snowthing\docs\studyCommunityPostCommentMaster260821.md`](file:///c:/Users/ikaes/IdeaProjects/snowthing/docs/studyCommunityPostCommentMaster260821.md)
-  - [`c:\Users\ikaes\IdeaProjects\snowthing\docs\study\studyCommunityPostCommentMaster260821.md`](file:///c:/Users/ikaes/IdeaProjects/snowthing/docs/study/studyCommunityPostCommentMaster260821.md)
-  - [`c:\Users\ikaes\IdeaProjects\snowthing\docs\study\sprint02\studyCommunityPostCommentMaster260821.md`](file:///c:/Users/ikaes/IdeaProjects/snowthing/docs/study/sprint02/studyCommunityPostCommentMaster260821.md)
-* **`.\gradlew.bat test` 실행 결과**: **BUILD SUCCESSFUL in 18s (모든 단위/통합 테스트 100% PASS)**
-* **작업 기록 완료**: [`docs/project/work.md`](file:///c:/Users/ikaes/IdeaProjects/snowthing/docs/project/work.md) 파일에 수록 완료.
diff --git a/docs/studyDomainErd260807.md b/docs/studyDomainErd260807.md
deleted file mode 100644
index dd457ba..0000000
--- a/docs/studyDomainErd260807.md
+++ /dev/null
@@ -1,107 +0,0 @@
-# [Notion] Snowthing 도메인 모델 & ERD 종합 설계서
-
-> 📌 **작성 일자**: 2026년 8월 7일  
-> 🏷️ **문서 목적**: 노션(Notion)에 기록하여 핵심 도메인, ERD 스키마, DB 제약조건, 회원-게시글 관계를 한눈에 파악하기 위한 종합 가이드
-
----
-
-## 1. 📌 핵심 도메인 목록 (Core Domains)
-
-Snowthing 플랫폼의 비즈니스 영역을 4개 도메인 경계(Bounded Context)로 분리하고, 1차 MVP 대상을 정립합니다.
-
-```
-┌────────────────────────────────────────────────────────────────────────┐
-│                        Snowthing Platform                              │
-├───────────────────┬───────────────────┬────────────────┬───────────────┤
-│ 1. 회원/프로필     │ 2. 게시판/커뮤니티 │ 3. 리조트/현장  │ 4. 소셜/매칭  │
-│    (Member)       │    (Community)    │    (Resort)    │    (Social)   │
-└───────────────────┴───────────────────┴────────────────┴───────────────┘
-```
-
-### 1.1. 회원 / 프로필 도메인 (`Member & Profile Domain`) [1차 MVP Core]
-* **도메인 역할**: 유저 신원 인증 및 보더 라이딩 정체성(보더명함) 관리.
-* **주요 객체**:
-  * `Member` (회원): 이메일, 비밀번호, 닉네임, 전역 권한(`ROLE_USER`), 계정 상태(`ACTIVE`).
-  * `Profile` (프로필): 프로필 이미지 URL, 자기소개(`bio`), 주 출발/거주 지역(`departure_region`).
-  * `BaseResort` (선호 스키장): 주 베이스 및 서브 베이스 스키장 다중 선택.
-  * `RidingStyle` (라이딩 성향): 카빙, 트릭, 파크, 입문, 관광 등 성향 다중 선택.
-
-### 1.2. 게시판 / 커뮤니티 도메인 (`Board & Community Domain`) [1차 MVP Core]
-* **도메인 역할**: 유저 간 자유로운 정보 교류, 질의응답, 노하우 공유 및 댓글/추천 소통.
-* **주요 객체**:
-  * `PostCategory` (카테고리): 자유, 익명, 질문, 장비VS, 맛집.
-  * `Post` (게시글): 제목, 본문, 조회수, 역정규화 카운트(댓글/추천/비추천), Soft Delete.
-  * `PostImage` (첨부 이미지): 1:N 이미지 업로드.
-  * `PostReaction` (게시글 반응): 추천(`LIKE`) / 비추천(`DISLIKE`) (1인 1회 제한).
-  * `Comment` (댓글/대댓글): 원댓글 및 계층형 대댓글 (`parentId`), Soft Delete.
-
-### 1.3. 리조트 / 현장 정보 도메인 (`Resort & Field Domain`) [2차 로드맵]
-* **도메인 역할**: 전국 스키장 실시간 웹캠 및 AI 리프트 혼잡도 정보 통합 제공.
-
-### 1.4. 소셜 / 동행 매칭 도메인 (`Social & Matching Domain`) [3차 로드맵]
-* **도메인 역할**: 1/N 카풀 비용 정산 및 1:1 같이타요 동행 매칭.
-
----
-
-## 2. 📊 ERD 초안 (Database ERD Draft)
-
-### 2.1. Mermaid ERD 다이어그램
-```mermaid
-erDiagram
-    CREW ||--o{ MEMBER : "소속됨 (1:N)"
-    
-    MEMBER ||--o{ MEMBER_RESORT : "가지고 있음"
-    RESORT ||--o{ MEMBER_RESORT : "속해 있음"
-    
-    MEMBER ||--o{ MEMBER_RIDING_STYLE : "가지고 있음"
-    RIDING_STYLE ||--o{ MEMBER_RIDING_STYLE : "속해 있음"
-
-    MEMBER ||--o{ POST : "작성함 (1:N)"
-    POST_CATEGORY ||--o{ POST : "포함함"
-    
-    POST ||--o{ POST_IMAGE : "첨부함 (1:N)"
-    POST ||--o{ POST_REACTION : "받음"
-    MEMBER ||--o{ POST_REACTION : "투표함"
-    
-    POST ||--o{ COMMENT : "달림 (1:N)"
-    MEMBER ||--o{ COMMENT : "작성함 (1:N)"
-    COMMENT ||--o{ COMMENT : "대댓글 (Self Reference)"
-```
-
-### 2.2. 엔티티 간 정규화 타협 및 관계 요약 (총 11개 테이블)
-* **`member` 1 : N `post`**: 회원이 여러 게시글 작성. (비회원 작성 시 `member_id NULLABLE`)
-* **`member` 1 : N `comment`**: 회원이 여러 댓글 작성. (비회원 작성 시 `member_id NULLABLE`)
-* **`post` 1 : N `comment`**: 게시글 1개에 여러 댓글 작성.
-* **`member` N : M `resort`**: `member_resort` 중계 테이블로 1:N, N:1 분리.
-* **`member` N : M `riding_style`**: `member_riding_style` 중계 테이블로 1:N, N:1 분리.
-
----
-
-## 3. 🔒 주요 DB 제약조건 (Database Constraints & Rules)
-
-| 구분 | 제약조건 / 정책 | 설정 이유 및 방어 목적 |
-| :--- | :--- | :--- |
-| **PK 보안 전략** | DB 내부 `BIGINT id` + 외부 노출 `public_id (UUID)` | DB 조인 성능(8바이트 정수)과 외부 URL 크롤링/ID 추측 해킹 테러 100% 차단 |
-| **중계 테이블 PK** | 단일 대리키 `id` (PK) + `UNIQUE (member_id, target_id)` | JPA 복합키(`@EmbeddedId`) 개발 지옥 탈출 및 중복 등록 방지 |
-| **추천/비추천 제약** | `UNIQUE (post_id, member_id)` | 유저 1명당 게시글별 1회만 투표 중복 제한 |
-| **소프트 삭제 (Soft Delete)** | `is_deleted = true` | 댓글 삭제 시 대댓글 흐름 유지 ("삭제된 댓글입니다" 표시) |
-| **역정규화 컬럼** | `post.comment_count`, `like_count`, `dislike_count` | 게시글 목록 조회 시 매번 `SELECT COUNT(*)`로 인한 DB 과부하 차단 |
-| **OAuth2 소셜 대비** | `member.password NULLABLE` | 구글/카카오 소셜 가입 시 비밀번호 부재로 인한 DB 에러 방지 |
-
----
-
-## 4. 🤝 게시글과 회원 관계 검토 (Post & Member Relationship)
-
-### 4.1. 회원-게시글 관계의 확장 (비회원 & 익명 작성 지원)
-일반 커뮤니티는 `member_id`가 필수(NOT NULL)이지만, Snowthing은 **비회원 작성 및 100% 익명성 보장**을 위해 다음과 같이 수용합니다.
-
-1. **`member_id` (BIGINT, NULLABLE)**
-   * **로그인 유저 작성 시**: 세션의 `member_id` 저장 (내 프로필/작성글 관리 가능).
-   * **비회원 작성 시**: `member_id = NULL` 로 저장.
-2. **`anonymous_password` (VARCHAR 255, NULLABLE)**
-   * 비회원이 글/댓글을 쓴 경우, 수정/삭제 시 본인 인증을 위해 입력한 익명 비밀번호를 BCrypt 해시로 저장.
-3. **`writer_ip` (VARCHAR 45, NOT NULL)**
-   * 로그인 여부와 관계없이 악성 어그로, 비매너, 법적 추적을 위해 작성자 IP 필수 보관.
-
-### 4.2. 익명성 표기 규칙
-* `is_anonymous = true` 인 경우 닉네임을 완전 무시하고, **무조건 시스템 지정 텍스트 `익명 (123.456.***.***)`** 처럼 IP 마스킹 형태로 화면에 전원 일괄 표시됩니다.
diff --git a/docs/studyPkStrategy260807.md b/docs/studyPkStrategy260807.md
deleted file mode 100644
index 8e3ebfc..0000000
--- a/docs/studyPkStrategy260807.md
+++ /dev/null
@@ -1,133 +0,0 @@
-# [TIL] DB PK(기본키) 설계 전략 및 3가지 대참사 방지 딥다이브
-
-> 📌 **학습 날짜**: 2026년 8월 7일  
-> 🏷️ **키워드**: `Primary Key`, `AUTO_INCREMENT`, `UUID`, `TSID`, `대리키 (Surrogate Key)`, `복합키 (Composite Key)`, `보안 크롤링`, `JPA @EmbeddedId`  
-> 💡 **학습 목표**: DB PK(기본키)를 부실하게 설계했을 때 나중에 터지는 3가지 대참사를 이해하고, 실무에서 사용하는 4가지 PK 전략의 장단점과 대가를 익혀 서비스에 맞는 최적의 PK를 스스로 선택할 수 있도록 돕습니다.
-
----
-
-## 0. 대전제: "PK(기본키) 설계 하나가 서비스 전체의 생사를 가른다"
-
-데이터베이스의 **PK(Primary Key / 기본키)**는 단순한 순번 표기가 아닙니다. 데이터베이스 인덱싱(B-Tree)의 기준점이며, 애플리케이션 프레임워크(JPA/Hibernate) 연동의 핵심축이자, 외부 시스템과 소통하는 **식별 통로**입니다.
-
-초기에 PK 전략을 깊이 고민하지 않고 단순히 `1, 2, 3...` 증가하는 숫자만 써두면, 서비스가 성장했을 때 **보안 테러, 개발 코드 꼬임, DB 분산 불가능**이라는 3대 대참사를 맞이하게 됩니다.
-
----
-
-## 1. PK 설계를 대충 했을 때 나중에 터지는 3가지 대참사
-
-### 💥 대참사 1. 보안 테러: "ID 추측을 통한 데이터 싹쓸이 (크롤링 & 권한 탈취)"
-
-#### 😱 무슨 일이 일어날까?
-만약 여러분이 작성한 게시글 조회/삭제 API URL이 다음과 같다고 해봅시다:
-```http
-GET /api/posts/105
-DELETE /api/posts/105
-```
-
-* **ID 추측 공격 (ID Enumeration Attack)**: 숫자가 1씩 규칙적으로 증가하는 것을 눈치채고, 악의적인 해커나 크롤링 스크립트가 `104`, `103`, `102`... 순서대로 숫자만 올려가며 전체 데이터를 1초 만에 싹 긁어갑니다.
-* **비즈니스 기밀 유출**: 회원가입을 했는데 내 회원 ID가 `500`번인 것을 보고 경쟁사가 **"아, 이 서비스 총 가입자가 500명밖에 안 되네?"** 하고 회사 비즈니스 규모를 훤히 파악하게 됩니다.
-* **권한 검증 허점 클릭**: 권한 검증 로직에 헛점이 생기면 숫자를 바꿔가며 남의 글이나 회원 정보를 무단 삭제/수정하는 대참사가 벌어집니다.
-
----
-
-### 💥 대참사 2. JPA 개발 지옥: "중계 테이블 복합 PK (`member_id` + `resort_id`)의 비극"
-
-#### 💡 용어 풀이
-> * **복합키 (Composite Key)**: 2개 이상의 컬럼을 합쳐서 하나의 PK로 사용하는 방식. (예: `member_id` + `resort_id`)
-> * **대리키 (Surrogate Key)**: 비즈니스 의미가 없는 인공적인 고유 ID (예: `id` BIGINT AUTO_INCREMENT)를 새로 만들어서 PK로 쓰는 방식.
-
-#### 😱 무슨 일이 일어날까?
-회원과 리조트의 N:M 중계 테이블(`member_resort`)에 `member_id`와 `resort_id` 두 개를 묶어서 복합 PK로 지정했을 때, 자바 JPA(Hibernate) 개발 시 다음과 같은 지옥이 펼쳐집니다:
-
-1. **지저분한 복합키 클래스 파편화**: JPA에서 복합키를 쓰려면 `@EmbeddedId` 또는 `@IdClass`라는 클래스를 별도로 만들어 `Serializable` 구현, `equals()`, `hashCode()` 메서드를 일일이 오버라이딩해야 합니다.
-2. **개발 생산성 폭망**: 중계 데이터를 조회나 수정할 때마다 단일 숫자 ID 대신 복합키 객체를 매번 생성해서 넘겨야 하므로 **코드가 엄청나게 길어지고 오작동 에러가 속출**합니다.
-
----
-
-### 💥 대참사 3. DB 확장 불가능: "서버 여러 대(분산 DB)로 늘릴 때 PK 충돌"
-
-#### 😱 무슨 일이 일어날까?
-서비스가 대박이 나서 DB 서버 1대로 감당이 안 되어 DB를 2대(A 서버, B 서버)로 분할(Sharding)하는 상황을 맞이했습니다.
-
-* A 서버의 DB도 `post_id = 1`을 생성하고, B 서버의 DB도 `post_id = 1`을 생성합니다.
-* 두 DB의 데이터를 통합하거나 조인할 때 **PK 충돌 참사**가 터져서 데이터가 엉망진창으로 뒤죽박죽 섞이고 복구가 불가능해집니다.
-
----
-
-## 2. 실무에서 사용하는 4가지 PK 전략 및 장단점 비교
-
-### 🛡️ 전략 A: AUTO_INCREMENT (내부 PK) + `public_id` UUID (외부 노출용) [실무 정석 ⭐]
-
-#### ⚙️ 작동 원리
-* **DB 내부 (PK)**: DB 조인 성능 및 저장 공간 최적화를 위해 **8바이트 숫자 `id` (BIGINT AUTO_INCREMENT)**를 PK로 사용합니다.
-* **외부 노출 (Public ID)**: 외부 API나 URL에는 `posts/a3b2c1d4-5e6f-4a...` 같은 **36자리 UUID 문자열 (`public_id`)**을 따로 만들어서 보여줍니다.
-
-#### ⚖️ 장단점 & 대가 (Trade-off)
-* **장점 (얻는 것)**:
-  * DB 내부 조인(JOIN) 및 B-Tree 인덱스 성능이 8바이트 정수라 **빛의 속도로 빠름.**
-  * 외부에 노출되는 ID는 추측 불가능한 UUID이므로 **해킹/크롤링/비즈니스 노출 위험 100% 차단.**
-* **단점 & 대가 (치르는 것)**:
-  * `member` 및 `post` 테이블에 `public_id` 컬럼을 하나 더 만들어야 함.
-  * 외부 요청이 왔을 때 `public_id`로 DB를 조회하는 쿼리가 한 번 더 들어감.
-
----
-
-### 🛡️ 전략 B: 36자리 UUID (Universally Unique Identifier) 문자열 PK
-
-#### ⚙️ 작동 원리
-* `d3b07384-d113-46e4-a719-d640b728040d` 같은 36자리 무작위 난수 문자열을 DB PK로 아예 직접 사용합니다.
-
-#### ⚖️ 장단점 & 대가 (Trade-off)
-* **장점 (얻는 것)**:
-  * 세상에서 유일한 고유값이므로 ID 추측 불가능.
-  * DB가 여러 대(분산 DB)여도 PK 충돌 위험 0%.
-* 💥 **치명적 단점 (치르는 대가)**:
-  * **DB 성능 저하 (인덱스 파편화)**: UUID는 무작위 문자열이라 DB B-Tree 인덱스에 저장될 때 순서 없이 무작위 위치로 쑤셔 지므로, DB 저장 속도가 둔화되고 메모리를 4배 이상 더 먹습니다.
-
----
-
-### 🛡️ 전략 C: TSID (Time-Sorted Unique Identifier) / ULID [최신 트렌드 🚀]
-
-#### ⚙️ 작동 원리
-* **"현재 시간(Timestamp)" + "무작위 난수"**를 조합하여 만드는 64비트 정수(BIGINT) 형태의 고유 ID.
-
-#### ⚖️ 장단점 & 대가 (Trade-off)
-* **장점 (얻는 것)**:
-  * 숫자가 1씩 증가하지 않아 **해커가 절대 추측 불가능**.
-  * 생성된 시간 순서대로 정렬(Sortable)되므로 DB 인덱스 성능이 BIGINT 정수처럼 **극상으로 빠름**.
-  * 분산 DB 환경에서도 PK 충돌 제로.
-* **단점 & 대가 (치르는 것)**:
-  * 자바 라이브러리(TSID Creator 등)를 프로젝트에 별도로 추가하여 ID 생성 로직을 적용해야 함.
-
----
-
-### 🛡️ 전략 D: [중계 테이블 전용] 단일 대리키(`id`) + `UNIQUE KEY` 조합
-
-#### ⚙️ 작동 원리
-* 중계 테이블(`member_resort`, `member_riding_style`)에 `member_id` + `resort_id` 복합 PK를 쓰지 않습니다!
-* 대신 **`id` (BIGINT AUTO_INCREMENT)** 단일 대리키를 PK로 새로 만들어주고, `(member_id, resort_id)`에는 **`UNIQUE KEY` 제약조건**을 겁니다.
-
-#### ⚖️ 장단점 & 대가 (Trade-off)
-* **장점 (얻는 것)**:
-  * JPA 복합키 지옥(`@EmbeddedId`)에서 완전히 벗어나 **자바 코드가 10배 깔끔해짐**.
-  * 중복 저장 방지 제약조건(`UNIQUE`)은 DB 레벨에서 완벽하게 유지됨.
-* **단점 & 대가 (치르는 것)**:
-  * 중계 테이블에 `id`라는 8바이트 컬럼이 하나 더 생겨 용량을 아주 미세하게 더 먹음.
-
----
-
-## 🎯 3. 최종 요약 및 비교표
-
-| PK 설계 전략 | 보안성 | DB 조회/인덱스 성능 | JPA 개발 편의성 | 분산 DB 확장성 |
-| :--- | :--- | :--- | :--- | :--- |
-| **1. 순수 AUTO_INCREMENT** | ❌ 취약 (추측 가능) | 🟢 극상 | 🟢 나쁨 (복합키 시) | ❌ 충돌 발생 |
-| **2. AUTO_INCREMENT + Public ID(UUID)** | 🟢 완벽 | 🟢 극상 | 🟢 양호 | 🟡 보통 |
-| **3. 순수 UUID 문자열 PK** | 🟢 완벽 | 🔴 느림 (인덱스 파편화) | 🟢 양호 | 🟢 완벽 |
-| **4. TSID (시간정렬 정수)** | 🟢 완벽 | 🟢 극상 | 🟢 최고 | 🟢 완벽 |
-| **5. 중계 테이블 단일 대리키(`id`)** | - | 🟢 극상 | 🟢 최고 (JPA 지옥 해방) | - |
-
----
-
-이제 각 PK 방식이 가진 **장점과 치명적 대가(Trade-off)**를 비교하실 수 있습니다!
-이 학습 문서를 읽어보시고, 우리 Snowthing 서비스에 어떤 PK 방식을 적용하는 것이 가장 좋을지 천천히 고민해 보세요! 😊
diff --git a/docs/studySessionAuth260806.md b/docs/studySessionAuth260806.md
deleted file mode 100644
index 66c4615..0000000
--- a/docs/studySessionAuth260806.md
+++ /dev/null
@@ -1,67 +0,0 @@
-# [TIL] 세션 기반 인증/인가 정책 및 쿠키 보안 설계
-
-> 📌 **학습 날짜**: 2026년 8월 6일  
-> 🏷️ **키워드**: `Session Authentication`, `Cookie Security`, `JSESSIONID`, `Session Fixation`, `Redis`, `Technical Debt`  
-> 💡 **한 줄 요약**: 1차 MVP 서비스에 적용할 세션 인증 및 쿠키 보안 정책을 정립하고, 기술적 트레이드오프와 향후 Redis 분산 세션 확장 방향을 정리합니다.
-
----
-
-## 1. 세션 인증 정책 (Session Authentication Policy)
-
-| 정책 항목 | 결정 사항 | 상세 설명 및 설계 배경 |
-| :--- | :--- | :--- |
-| **로그인 시 세션 저장 정보** | `memberId`, `role` | 최소 식별 정보만 메모리에 보관. 비밀번호, 이메일, 프로필 전체 저장 지양 (메모리 절약 및 보안) |
-| **세션 만료 시간** | `30분` (Idle Timeout) | 비활동 시간 30분 기준 세션 만료. 보안성과 유저 이용 편의성의 최적 타협점 |
-| **로그아웃 처리** | `session.invalidate()` | 백엔드 세션 객체 즉시 파기 및 클라이언트 쿠키 만료 (`Max-Age=0`) 처리 |
-| **동시 로그인 정책** | 동시 접속 허용 | 1차 MVP에서는 동일 계정 다중 기기 접속 허용 (향후 중복 로그인 제어 고려) |
-| **세션 ID 재발급 시점** | 로그인 성공 시 | 로그인 성공 시점에 `changeSessionId()`를 호출하여 **세션 고정 공격(Session Fixation)** 방어 |
-| **인증 필요 API 구분** | 비인증 / 인증 API 분리 | **비인증**: 목록/상세 조회, 회원가입, 로그인 <br> **인증 필요**: 게시글/댓글 작성·수정·삭제, 프로필 조회 |
-| **권한 검증 방식** | 작성자(소유자) 검증 | 수정/삭제 요청 시 `세션 memberId == DB 작성자 memberId` 비교 검증 후 처리 |
-
----
-
-## 2. 쿠키 보안 정책 (Cookie Security Policy)
-
-세션 식별자(`JSESSIONID`)를 전달하는 쿠키에 엄격한 보안 속성을 적용하여 주요 Web Vulnerability를 방어합니다.
-
-```
-Set-Cookie: JSESSIONID=A1B2C3D4E5F6...; Path=/; HttpOnly; Secure; SameSite=Lax
-```
-
-* 🛡️ **HttpOnly (`true`)**
-  * 자바스크립트(`document.cookie`)를 통한 세션 쿠키 접근을 원천 차단합니다.
-  * **방어 목적**: XSS(Cross-Site Scripting) 공격으로 인한 세션 키 탈취 방지.
-* 🔒 **Secure (`true`)**
-  * 암호화된 `HTTPS` 통신 채널에서만 쿠키가 전송되도록 제한합니다. (로컬 개발 환경에서는 조건부 적용)
-  * **방어 목적**: 네트워크 패킷 스니핑을 통한 세션 키 유출 방지.
-* 🌐 **SameSite (`Lax`)**
-  * 타 사이트에서 발생하는 서드파티 요청 시 쿠키 전송을 제한하되, 일반적인 서프(링크 클릭) 이동 시에는 쿠키를 전송합니다.
-  * **방어 목적**: CSRF(Cross-Site Request Forgery) 공격 방어.
-* 📍 **Path (`/`)**
-  * 웹 애플리케이션의 모든 API 경로(`/api/...`)에서 쿠키가 정상적으로 전송되도록 전역 설정합니다.
-* ⏳ **Max-Age 및 세션 쿠키 정책**
-  * 별도의 Max-Age를 지정하지 않는 **세션 쿠키(Session Cookie)** 방식을 기본으로 채택합니다.
-  * 브라우저가 종료되면 클라이언트 단에서 세션 쿠키가 자동 파기됩니다.
-* ⚠️ **개인정보 쿠키 저장 절대 금지**
-  * 쿠키에는 오직 서버 세션을 가리키는 무작위 난수 식별자(`JSESSIONID`)만 저장합니다.
-  * 비밀번호, 이메일, 닉네임, 개인정보 등은 **절대로 쿠키에 담지 않습니다.**
-
----
-
-## 3. 기술적 깊이 및 배경 (Deep Dive & Trade-offs)
-
-### 3.1. JWT 대신 세션(Session) 방식을 선택한 이유
-* **세션 제어의 용이성**: JWT는 Stateless 특성상 이미 발급된 토큰을 즉시 강제 만료(블랙리스트 관리 없이)시키기 어렵습니다. 반면 세션은 보안 이슈나 로그아웃 시 서버에서 `session.invalidate()`로 즉시 파기할 수 있습니다.
-* **보안성**: 토큰을 로컬스토리지에 저장할 경우 XSS에 노출되기 쉽고, 쿠키에 담더라도 JWT 크기(헤더+페이로드+서명)로 인한 네트워크 오버헤드가 발생합니다. 세션 방식은 오직 난수 형태의 키만 쿠키로 전송하므로 유출 리스크가 적습니다.
-
-### 3.2. 세션 저장 정보의 최소화 기준
-* 세션 메모리(RAM)는 서버의 한정된 자원입니다. 세션 객체에 유저 전체 프로필이나 대용량 객체를 담으면 유저 수가 늘어날 때 **OutOfMemoryError(OOM)**가 발생할 수 있습니다.
-* 따라서 오직 PK값인 `memberId`와 권한 정보 `role`만 담고, 필요한 유저 상세 정보는 DB 조회를 통해 가져오도록 최소화 기준을 수립했습니다.
-
-### 3.3. 다중 서버 환경에서의 개선 방향 (Scale-out 대비)
-* **현 상태의 한계**: 현재 구현은 단일 톰캣 서버의 **인메모리(In-Memory) 세션**을 사용합니다.
-* **개선 방향**: 서버가 여러 대(Scale-out)로 증설되면, 유저 요청이 다른 서버로 로드밸런싱될 때 세션이 유실되는 문제가 발생합니다. 이를 위해 향후 **Spring Session + Redis** 기반의 **중앙 집중식 분산 세션 저장소**를 도입하여 상태를 공유하도록 개선할 예정입니다.
-
-### 3.4. 의도적으로 남긴 기술 부채 (Technical Debt)
-* 1차 MVP 단계에서는 백엔드 개발 속도 및 도메인 핵심 검증을 위해 **단일 서버 톰캣 메모리 세션**을 채택했습니다.
-* 세션 유실 및 Scale-out 한계라는 기술 부채가 존재함을 인지하고 있으며, 2차 확장 시 **Redis 분산 세션 연동**으로 매끄럽게 전환될 수 있도록 스프링 세션 Abstraction Layer를 고려하여 설계했습니다.
diff --git a/docs/studySessionFlow260810.md b/docs/studySessionFlow260810.md
deleted file mode 100644
index c828dfc..0000000
--- a/docs/studySessionFlow260810.md
+++ /dev/null
@@ -1,83 +0,0 @@
-# [Notion] 세션 인증 순서도 (Session Authentication Flowchart)
-
-> 📌 **작성 일자**: 2026년 8월 10일 (최종 수정: 2026년 8월 12일)  
-> 🏷️ **문서 목적**: 마크다운(Markdown) 및 노션(Notion) 환경에서 100% 정상 visual 다이어그램으로 렌더링되는 **Spring Session Redis** 기반 세션 인증 순서도
-
----
-
-## 📊 1. 세션 인증 전체 플로우차트 (Flowchart TD)
-
-Below is the Mermaid flowchart rendered directly in GitHub Markdown and Notion.
-
-```mermaid
-flowchart TD
-    A["클라이언트 API 요청 /api/..."] --> B{"1. 비인증 허용 API인가? (PermitAll)"}
-    
-    %% 비인증 허용 경로
-    B -- Yes --> C["비인증 로직 즉시 실행 (회원가입/목록조회/비회원글작성)"]
-    C --> END1["200 OK / 201 Created 응답"]
-
-    %% 인증 필요 경로
-    B -- No --> D{"2. JSESSIONID 쿠키가 헤더에 존재하는가?"}
-    
-    %% 쿠키 없음
-    D -- No --> E1["401 Unauthorized 에러 (로그인이 필요합니다)"]
-
-    %% 쿠키 존재
-    D -- Yes --> E2{"3. Spring Session Redis 저장소에 유효한 세션이 존재하는가?"}
-    
-    %% 세션 만료/파기됨
-    E2 -- No --> F1["401 Unauthorized 에러 (세션이 만료되었습니다)"]
-    F1 --> F2["Set-Cookie: JSESSIONID=; Max-Age=0 (쿠키 클리어)"]
-
-    %% 세션 유효함
-    E2 -- Yes --> G{"4. 요청 종류 구분"}
-
-    %% 경로 1: 로그인 요청 처리 (Session Fixation 방어)
-    G -- 로그인 요청 --> H1["Security: changeSessionId (기존 세션 파기 & 신규 세션ID 재발급)"]
-    H1 --> H2["Spring Session Redis에 memberId & role 0.0001초 저장"]
-    H2 --> H3["Set-Cookie: JSESSIONID=new_id (HttpOnly, Secure, SameSite=Lax)"]
-    H3 --> END2["200 OK 로그인 성공"]
-
-    %% 경로 2: 일반 인증 API 요청 (프로필/글작성 등)
-    G -- 일반 인증 API --> I1["Spring Session Redis에서 memberId & role 0.0001초 추출"]
-    I1 --> I2["SecurityContextHolder에 인증 객체 등록"]
-    I2 --> I3["소유자 권한 검증 & 비즈니스 로직 실행"]
-    I3 --> END3["200 OK 응답 데이터 반환"]
-
-    %% 경로 3: 로그아웃 요청
-    G -- 로그아웃 요청 --> J1["Redis 세션 완전 파기 (spring:session 키 삭제)"]
-    J1 --> J2["Set-Cookie: JSESSIONID=; Max-Age=0 (브라우저 쿠키 즉시 만료)"]
-    J2 --> END4["200 OK 로그아웃 성공"]
-
-    %% 스타일링
-    style A fill:#333333,stroke:#ffffff,color:#ffffff
-    style B fill:#1f618d,stroke:#ffffff,color:#ffffff
-    style D fill:#1f618d,stroke:#ffffff,color:#ffffff
-    style E2 fill:#1f618d,stroke:#ffffff,color:#ffffff
-    style G fill:#28b463,stroke:#ffffff,color:#ffffff
-    style E1 fill:#922b21,stroke:#ffffff,color:#ffffff
-    style F1 fill:#922b21,stroke:#ffffff,color:#ffffff
-    style H1 fill:#d4ac0d,stroke:#ffffff,color:#000000
-    style J1 fill:#d4ac0d,stroke:#ffffff,color:#000000
-```
-
----
-
-## 🔍 2. 플로우차트 단계별 조건 분기 설명
-
-### 1단계: API 접근 권한 판별 (`PermitAll` vs `Authenticated`)
-* `/api/members` (회원가입), `/api/auth/login` (로그인), `/api/posts` (목록/상세 조회) 같은 **비인증 공개 API는 쿠키 검증을 스킵하고 즉시 실행**됩니다.
-
-### 2단계 & 3단계: 2중 세션 쿠키 검증 (`JSESSIONID` + Spring Session Redis)
-* **1차 검증 (브라우저 쿠키)**: 요청 헤더에 `JSESSIONID` 쿠키가 아예 없으면 즉시 `401 Unauthorized`를 반환합니다.
-* **2차 검증 (Spring Session Redis RAM)**: 쿠키가 있더라도 Redis 세션 저장소(`spring:session:sessions:...`)에서 만료되거나 삭제되었으면 `401 Unauthorized` 반환과 함께 브라우저 쿠키를 만료(`Max-Age=0`)시킵니다.
-
-### 4단계: 요청 종류별 세션 락 & 처리 메커니즘
-1. **로그인 시 (Session Fixation 방어)**:
-   * 기존 임시 세션 ID를 파기하고 신규 세션 ID를 발급하는 `request.changeSessionId()`를 호출하여 세션 탈취 공격을 방어합니다.
-   * `Set-Cookie: JSESSIONID=...; Path=/api; HttpOnly; Secure; SameSite=Lax` 쿠키를 내려줍니다.
-2. **일반 인증 API 요청 시**:
-   * Redis에서 0.0001초 만에 `memberId`를 추출하여 `SecurityContextHolder`에 등록 후 비즈니스 로직을 수행합니다.
-3. **로그아웃 시**:
-   * Redis 세션 키를 삭제하여 서버 세션을 완전 파기하고, 쿠키 만료 헤더를 내려줍니다.
diff --git a/docs/studySystemArch260810.md b/docs/studySystemArch260810.md
deleted file mode 100644
index 0fa58bd..0000000
--- a/docs/studySystemArch260810.md
+++ /dev/null
@@ -1,87 +0,0 @@
-# [Notion] Snowthing 전체 시스템 아키텍처 구성도 (TIL)
-
-> 📌 **작성 일자**: 2026년 8월 10일  
-> 🏷️ **문서 목적**: 노션(Notion) 및 마크다운에 복사하여 전체 시스템 구성도, 계층별 역할, 데이터 흐름을 한눈에 파악하고 공부하기 위한 종합 가이드
-
----
-
-## 📊 1. 시스템 구성도 다이어그램 (Mermaid System Architecture)
-
-Below is the system architecture diagram rendered directly in GitHub Markdown and Notion.
-
-```mermaid
-flowchart TB
-    %% 클라이언트 레이어
-    subgraph Client_Layer [👤 Client / Browser Layer]
-        Browser[🌐 Web Browser / Mobile Client]
-    end
-
-    %% 프론트엔드 레이어
-    subgraph Frontend_Layer [💻 Frontend Layer]
-        NextJS[⚡ Next.js 14+ Application<br/>App Router / React Query / Optimistic UI]
-    end
-
-    %% 네트워크 & 프록시 레이어
-    subgraph Proxy_Layer [🛡️ Network & Proxy Layer]
-        Nginx[🔒 Nginx Reverse Proxy<br/>SSL/HTTPS Termination<br/>Route /api/* -> Spring Boot]
-    end
-
-    %% 백엔드 애플리케이션 레이어
-    subgraph Backend_Layer [⚙️ Backend Application Layer - Spring Boot 3.2+ / Java 21]
-        SecFilter[🔒 Spring Security Filter<br/>JSESSIONID / HttpOnly / changeSessionId]
-
-        
-        subgraph Core_App [App Core Services]
-            MemberSvc[👤 Member Service<br/>Profile & Crew Management]
-            PostSvc[📝 Post Service<br/>Single Query + In-Memory Tree]
-            CommentSvc[💬 Comment Service<br/>Single Query + Flat List]
-            ReactionSvc[👍 Reaction Service<br/>Async Event Publisher]
-        end
-        
-        BatchJob[⏰ Scheduled Batch Sync Job<br/>10s Write-Behind DB Flush]
-    end
-
-    %% 인메모리 캐시 & 분산 락 레이어
-    subgraph Cache_Layer [🚀 In-Memory Cache & Buffer Layer]
-        Redis[(🧠 Redis 7.x In-Memory<br/>SADD Voters / INCR Like Counter<br/>AOF Persistence)]
-    end
-
-    %% 릴레이셔널 데이터베이스 레이어
-    subgraph Database_Layer [🗄️ Relational Database Layer]
-        MySQL[(🐬 MySQL 8.0 Container<br/>InnoDB Engine / 11 Tables<br/>BIGINT id + UUID v7 Secondary Index)]
-    end
-
-    %% 데이터 흐름 연결
-    Browser <-->|HTTP/HTTPS Page Request| NextJS
-    Browser <-->|HTTPS API Request / Cookies| Nginx
-    NextJS <-->|Server Component Fetch| Nginx
-    
-    Nginx <-->|Forward /api/*| SecFilter
-    SecFilter <-->|Session Check / Context| Core_App
-    
-    ReactionSvc -->|0.0001s In-Memory INCR & SADD| Redis
-    BatchJob <-->|Read Counter & Flush| Redis
-    
-    Core_App <-->|JPA / JPQL / Single Query| MySQL
-    BatchJob -->|Write-Behind Batch UPDATE| MySQL
-
-    %% 스타일링
-    style Browser fill:#333,stroke:#fff,color:#fff
-    style NextJS fill:#000,stroke:#61dafb,color:#61dafb
-    style Nginx fill:#009639,stroke:#fff,color:#fff
-    style SecFilter fill:#d4ac0d,stroke:#fff,color:#000
-    style Core_App fill:#2e4053,stroke:#fff,color:#fff
-    style Redis fill:#dc382d,stroke:#fff,color:#fff
-    style MySQL fill:#00758f,stroke:#fff,color:#fff
-    style BatchJob fill:#8e44ad,stroke:#fff,color:#fff
-```
-
----
-
-## 🔍 2. 5대 계층 구조 및 핵심 기술 요약
-
-1. **`Client & Frontend`**: Next.js 14+, React Query의 **낙관적 UI 업데이트**를 통해 추천 0.001초 미친 반응성 제공.
-2. **`Proxy & Network`**: Nginx를 통해 `/api/*` 라우팅 분리 및 **6대 쿠키 보안 속성** 적용.
-3. **`Backend Core`**: Spring Boot 3.x, **`Single Query + In-Memory Tree`**로 N+1 문제 완파, 10초 주기 **`Write-Behind` 배치 스케줄러** 구동.
-4. **`In-Memory Cache`**: Redis 7.x `INCR`/`SADD`로 DB 락 병목 제거, AOF로 데이터 유실 방지.
-5. **`Relational Database`**: MySQL 8.0 (11개 테이블), `BIGINT id` + **`UUID v7` 세컨더리 인덱스** 적용.
diff --git a/docs/study_sprint01_session_concurrency_jpa_260817.md b/docs/study_sprint01_session_concurrency_jpa_260817.md
deleted file mode 100644
index 65fc06c..0000000
--- a/docs/study_sprint01_session_concurrency_jpa_260817.md
+++ /dev/null
@@ -1,539 +0,0 @@
-# 📚 [Snowthing Study Report] Sprint 1 세션 인증, 동시성 락 실증, JPA & DB 제약조건 통합 공부 가이드
-
-> **본 문서는 노션(Notion)에 그대로 복사하여 학습할 수 있도록 작성된 종합 공부용 문서입니다.**  
-> **파일명**: `docs/study_sprint01_session_concurrency_jpa_260817.md`  
-> **작성일**: 2026년 8월 17일  
-> **주요 키워드**: `Spring Session`, `changeSessionId`, `BCrypt`, `N:M 중계 테이블`, `CountDownLatch 동시성 락 실증`, `JPA JOIN FETCH`, `DB UNIQUE 제약조건`, `@Modifying(clearAutomatically = true)`
-
----
-
-# 📑 **목차 (Table of Contents)**
-
-1. [Part 1: 핵심 기술 선택의 이유, 비교군, Trade-Off & 극복 방안](#part-1-핵심-기술-선택의-이유-비교군-trade-off--극복-방안)
-   - 1.1 인증 방식: Spring Session (세션) vs JWT (JSON Web Token)
-   - 1.2 세션 고정 방어: `changeSessionId()` vs `newSession()` vs `none()`
-   - 1.3 비밀번호 암호화: `BCrypt` vs `Argon2` vs `PBKDF2` vs `SHA-256`
-   - 1.4 N:M 관계 매핑: 대리키 `id` PK 중계 엔티티 vs 복합키(`@EmbeddedId`) vs 단일 JSON 저장
-   - 1.5 N+1 성능 극복: `JOIN FETCH` vs `FetchType.EAGER` vs `@BatchSize`
-2. [Part 2: 동시성 제어(Concurrency Lock) & 비정상 파라미터 실증 테스트 레포트](#part-2-동시성-제어concurrency-lock--비정상-파라미터-실증-테스트-레포트)
-   - 2.1 왜 Mockito 가 아닌 실제 DB + 멀티스레드로 동시성을 테스트했는가?
-   - 2.2 `CountDownLatch` + `ExecutorService` 10개 멀티스레드 동시 가입 물리적 원리
-   - 2.3 Race Condition 락 검증 결과 분석 (Java 차단 실패 ➔ DB UNIQUE 인덱스 차단 성공)
-   - 2.4 경계값 & 비정상 파라미터 2중 검증 테스트 결과
-3. [Part 3: 완성 코드 & JPA 옵션 - DB 제약조건 연동 종합 해설서](#part-3-완성-코드--jpa-옵션---db-제약조건-연동-종합-해설서)
-   - 3.1 엔티티 & N:M 중계 구조 (`Member.java`, `MemberResort.java`, `Resort.java`) 주석 해설
-   - 3.2 JPA 주요 어노테이션 & 옵션 상세 파헤치기
-   - 3.3 DB 제약조건(`PK`, `UNIQUE`, `FK`)과 JPA 연관관계의 물리적 연동 원리
-   - 3.4 전체 실증 테스트 수트 통합 모음 (25개 전체 통합/단위 테스트 수트)
-
----
-
-# 🧠 **[Part 1] 핵심 기술 선택의 이유, 비교군, Trade-Off & 극복 방안**
-
-## 1.1 인증 방식: Spring Session (세션) vs JWT (JSON Web Token)
-
-```text
- [Spring Session (서버 중앙 제어)]           [JWT (Stateless 무상태)]
-  - 세션 데이터: 서버 RAM/Redis 보관         - 토큰 데이터: 클라이언트 브라우저 보관
-  - 보안성: 무작위 식별자(JSESSIONID)         - 보안성: 서명된 Claim 데이터 포함
-  - 강제 로그아웃: 가능 (서버 세션 삭제)       - 강제 로그아웃: 불가능 (만료 시까지 유효)
-```
-
-### 🎯 선택: Spring Session (세션 기반 인증)
-* **비교군**: JWT (JSON Web Token)
-* **선택 이유**:
-  * 커뮤니티 플랫폼 특성상 특정 악성 유저 발생 시 **관리자가 즉시 계정을 정지시키고 접속 세션을 강제 파기(Session Invalidation)**할 수 있는 **서버 중앙 통제권**이 필수적임.
-  * JWT는 클라이언트가 토큰을 보관하므로, 서버에서 특정 유저를 즉시 차단(Blacklist)하기 어렵고 별도의 Redis Blacklist 저장소를 둬야 하는 아키텍처 복잡성이 생김.
-* **장점**:
-  * 클라이언트 브라우저에는 민감 정보(PII)가 들어있지 않은 무작위 세션 키(`JSESSIONID`)만 쿠키로 전달됨.
-  * 세션 상태를 서버가 100% 제어하므로 즉시 로그아웃 및 강제 세션 파기가 가능함.
-* **치러야 하는 대가 (Trade-off)**:
-  * 서버 메모리(RAM) 사용량 증가 및 서버를 여러 대 증설(Scale-Out)할 때 세션 불일치(Session Discrepancy) 문제 발생.
-* **아키텍처 레벨 극복 방안**:
-  1. `server.servlet.session.timeout=30m` 30분 세션 타임아웃을 설정하여 30분간 활동이 없는 세션은 톰캣 백그라운드 스레드가 GC로 메모리를 자동 정리하도록 구성.
-  2. 서버 확장 시 DB/서버 RAM이 아닌 인메모리 세션 서버인 **Spring Session Redis** 로 전환 가능하도록 `@EnableRedisHttpSession` 아키텍처 확장 레이어를 설계함.
-
----
-
-## 1.2 세션 고정 방어: `changeSessionId()` vs `newSession()` vs `none()`
-
-### 🎯 선택: `request.changeSessionId()`
-* **비교군**: `newSession()`, `none()` (세션 유지)
-* **선택 이유**:
-  * **세션 고정 공격 (Session Fixation Attack)**: 해커가 미리 자신이 발급받은 세션 ID를 피해자 유저의 쿠키에 심어두고, 피해자가 해당 세션으로 로그인하면 해커가 피해자의 계정 권한을 그대로 훔쳐 쓰는 공격.
-* **동작 원리 및 비교**:
-  * `none()`: 로그인 후에도 세션 ID를 바꾸지 않음 ➔ 세션 고정 공격에 노출.
-  * `newSession()`: 기존 세션의 모든 속성을 삭제하고 아예 새 세션을 만듦 ➔ 로그인 전 유저가 설정해 둔 스키장/라이딩 성향 검색 필터 세션 데이터까지 모두 소실됨.
-  * **`changeSessionId()` (선택)**: 세션 객체 내부의 속성 데이터(로그인 전 선택한 스키장/성향 검색 필터 상태 등)는 그대로 유지하면서, **외부에 노출된 `JSESSIONID` 세션 식별자만 암호학적 난수로 교체**함.
-* **Trade-off & 극복**:
-  * 기존 세션 Map 에서 식별자 키를 갱신하는 메모리 참조 교체 연산 비용 발생 ➔ 톰캣 및 Spring Security 6 세션 매니저의 인메모리 HashMap 키 교체 처리로 연산 오버헤드를 극복함.
-
----
-
-## 1.3 비밀번호 암호화: `BCryptPasswordEncoder` vs `Argon2` vs `PBKDF2` vs `SHA-256`
-
-### 🎯 선택: `BCryptPasswordEncoder`
-* **비교군**: `SHA-256` (단순 해시), `PBKDF2`, `Argon2`
-* **선택 이유**:
-  * `SHA-256` 같은 단순 단방향 해시는 GPU 병렬 연산을 이용한 **레인보우 테이블(Rainbow Table) 공격**으로 빠르게 복호화가 시도될 수 있음.
-  * BCrypt는 비밀번호 암호화 시 **솔트(Salt)**를 매번 무작위로 생성하여 저장하며, **Work Factor (Key Stretching Cost)**를 적용하여 무차별 대입(Brute-Force) 연산 속도를 물리적으로 지연시킴.
-* **Argon2 / PBKDF2 대비 장점**:
-  * Argon2 가 최신 표준이나 추가 외부 라이브러리 연동이 필요함. Spring Security 의 표준 검증 모듈인 BCrypt가 유지보수성 측면에서 검증됨.
-* **Trade-off & 극복**:
-  * BCrypt 해싱 연산은 의도적으로 CPU 연산 리소스를 소모함 (1건당 수십ms 소요).
-  * 회원가입/로그인 시점에만 한정되어 발생하므로 전체 서비스 응답 성능에 영향을 주지 않음.
-
----
-
-## 1.4 N:M 관계 매핑: 대리키 `BIGINT id` PK 중계 엔티티 vs 복합키(`@EmbeddedId`) vs 단일 JSON 저장
-
-### 🎯 선택: 대리키 `BIGINT id` PK + 복합 UNIQUE 제약조건 중계 엔티티 (`MemberResort`, `MemberRidingStyle`)
-* **비교군**:
-  1. 회원 테이블 내 문자열/JSON 컬럼에 `[1, 2, 3]` 형태로 저장
-  2. `@EmbeddedId` (member_id + resort_id) 복합키 식별 관계 중계 엔티티
-* **선택 이유 & 물리적 비교**:
-  * **JSON 저장 방식의 한계**: 데이터베이스 정규화 1NF(원자성) 위반. 특정 스키장을 이용하는 회원 목록 검색(`WHERE resort_id = 1`) 시 Full Table Scan 이 발생하여 성능 저하.
-  * **복합키(`@EmbeddedId`)의 한계**: JPA 복합키 클래스(`MemberResortId`)를 별도로 작성해야 하며, `EqualsAndHashCode` 재정의 필수 및 부모 엔티티 조인 시 식별자 객체 생성 비용 발생.
-  * **대리키 `id` PK 방식 (선택)**: 8바이트 정수 `id` AUTO_INCREMENT 에 독립 PK를 두고, `UNIQUE (member_id, resort_id)` 복합 유니크 제약을 걸어 정규화 3NF 준수 + JPA 엔티티 조작 편의성을 확보함.
-
----
-
-## 1.5 N+1 성능 극복: `JOIN FETCH` vs `FetchType.EAGER` vs `@BatchSize`
-
-### 🎯 선택: JPQL `JOIN FETCH` 쿼리
-* **비교군**: `@ManyToOne(fetch = FetchType.EAGER)` (즉시 로딩), `@BatchSize`
-* **선택 이유**:
-  * `FetchType.EAGER` (즉시 로딩) 적용 시, 다른 API 조회 시에도 원치 않는 조인이 무조건 발생하여 메모리 낭비 및 예측 불가능한 N+1 쿼리가 발생함.
-  * 엔티티 연관관계는 `FetchType.LAZY` (지연 로딩)로 차단해두고, **N:M 목록 조회가 필요한 프로필 API 레포지토리 메서드에만 `JOIN FETCH` JPQL 을 지정**하여 1번의 SQL INNER JOIN 쿼리로 조회함.
-
----
-
-# 🔬 **[Part 2] 동시성 제어(Concurrency Lock) & 비정상 파라미터 실증 테스트 레포트**
-
-## 2.1 왜 Mockito 가 아닌 실제 DB + 멀티스레드로 동시성을 테스트했는가?
-
-> ⚠️ **실무 원리**:  
-> Mockito 는 객체의 동작을 가짜(Mock)로 흉내 내는 단위 테스트 도구입니다. **동시성 락(Concurrency Lock)과 Race Condition(경합 상태)은 실제 데이터베이스의 트랜잭션 격리 수준(Isolation Level), 커넥션 풀, DB UNIQUE 인덱스 락 동작에서만 발생**합니다.  
-> 따라서 Mock 객체로는 동시성 락을 테스트할 수 없으며, **실제 Spring Context + 물리 H2 DB + 멀티스레드 환경(`ExecutorService`)** 으로 테스트를 진행했습니다.
-
----
-
-## 2.2 `CountDownLatch` + `ExecutorService` 10개 멀티스레드 동시 가입 물리적 원리
-
-```text
-[10개 멀티스레드 준비] ──► countDownLatch.await() 대기 ──► (startLatch 신호) ──► 스레드 동시 요청 시작!
-                                                                                    │
- ┌──────────────────────────────────────────────────────────────────────────────────┘
- ▼
-[스레드 1] ──► existsByEmail() = false ──► [DB Insert 시도] ──► 성공! (1건)
-[스레드 2] ──► existsByEmail() = false ──► [DB Insert 시도] ──► UNIQUE KEY 위반 예외! (DataIntegrityViolationException)
-...
-[스레드 10]──► existsByEmail() = false ──► [DB Insert 시도] ──► UNIQUE KEY 위반 예외! (DataIntegrityViolationException)
-```
-
-* **`ExecutorService`**: 10개의 OS 스레드 풀을 생성합니다.
-* **`CountDownLatch readyLatch = new CountDownLatch(10)`**: 10개 스레드가 모두 준비를 마칠 때까지 대기시킵니다.
-* **`CountDownLatch startLatch = new CountDownLatch(1)`**: `startLatch.countDown()` 이 호출되는 순간 10개의 스레드가 동시에 `MemberService.signUp()` 을 호출합니다.
-
----
-
-## 2.3 Race Condition 락 검증 결과 분석
-
-### 🧪 실증 결과 요약
-* **동시 요청 수**: 10개 스레드 동시 동일 이메일(`concurrent@snowthing.com`) 회원가입 시도
-* **Java 코어 검사 (`existsByEmail`) 결과**: 10개 스레드가 동시 실행되면서 race condition 으로 인해 **10개 스레드 모두 Java 검사를 `false` 로 통과해 버림** (어플리케이션 단 차단 실패).
-* **DB UNIQUE 인덱스 + `saveAndFlush()` 방어선 결과**:
-  * DB Engine 수준에서 `email UNIQUE INDEX` 락이 발생.
-  * **정확히 1개의 스레드만 DB 저장 성공!**
-  * **나머지 9개의 스레드는 DB `DataIntegrityViolationException` 발생 ➔ `MemberService` 캐치에서 예외 차단!**
-* **DB 최종 상태**: **DB에 저장된 동일 이메일 회원 레코드는 정확히 1건.**
-
----
-
-## 2.4 경계값 & 비정상 파라미터 2중 검증 테스트 결과
-
-| 검증 항목 | 입력 파라미터 예시 | 백엔드/프론트엔드 반응 | 결과 |
-| :--- | :--- | :--- | :---: |
-| **비정상 이메일 TLD** | `test@naver.co` | 정규식 `^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,6}$` 에 의해 **400 Bad Request** 차단 | **성공** |
-| **대문자 미포함 비밀번호** | `password123!` | 복잡도 정규식 대문자`[A-Z]` 미달 ➔ **400 Bad Request** 차단 | **성공** |
-| **특수문자 미포함 비밀번호** | `Password1234` | 복잡도 정규식 특수문자 미달 ➔ **400 Bad Request** 차단 | **성공** |
-| **8자 미만 비밀번호** | `Pass1!` | 최소 8자 미달 ➔ **400 Bad Request** 차단 | **성공** |
-| **닉네임 경계값 (1자)** | `홍` | 2자~10자 미달 ➔ **400 Bad Request** 차단 | **성공** |
-| **닉네임 경계값 (11자)** | `휘닉스파크카빙왕짱1` | 10자 초과 ➔ **400 Bad Request** 차단 | **성공** |
-
----
-
-# 💻 **[Part 3] 완성 코드 & JPA 옵션 - DB 제약조건 연동 종합 해설서**
-
-## 3.1 엔티티 & N:M 중계 구조 (`Member.java`, `MemberResort.java`, `Resort.java`)
-
-```java
-// ==========================================
-// 1. Member.java (회원 엔티티)
-// ==========================================
-package com.ikae.snowthing.domain.member.entity;
-
-import com.ikae.snowthing.global.common.BaseTimeEntity;
-import jakarta.persistence.*;
-import lombok.AccessLevel;
-import lombok.Builder;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-
-import java.util.UUID;
-
-@Entity // [JPA] 이 클래스가 데이터베이스 테이블과 1대1 매핑되는 ORM 엔티티임을 선언
-@Table(
-    name = "member", // [DB] 실제 RDBMS 데이터베이스의 테이블명을 'member' 로 지정
-    uniqueConstraints = {
-        // [DB 제약조건] 이메일, 닉네임, public_id 에 각각 단일 UNIQUE 인덱스 생성
-        @UniqueConstraint(name = "uk_member_email", columnNames = {"email"}),
-        @UniqueConstraint(name = "uk_member_nickname", columnNames = {"nickname"}),
-        @UniqueConstraint(name = "uk_member_public_id", columnNames = {"public_id"})
-    }
-)
-@Getter
-@NoArgsConstructor(access = AccessLevel.PROTECTED) // [JPA/Lombok] 기본 생성자를 protected 로 설정하여 외부 무분별한 new 객체 생성 차단
-public class Member extends BaseTimeEntity {
-
-    @Id // [DB/JPA] 이 필드가 기본키(Primary Key, PK)임을 지정
-    @GeneratedValue(strategy = GenerationType.IDENTITY) // [DB] MySQL/H2 의 AUTO_INCREMENT 대리키 채번 전략 사용 (DB에 PK 생성을 위임)
-    @Column(name = "member_id") // [DB] 실제 DB 컬럼명을 member_id 로 매핑
-    private Long id;
-
-    @Column(name = "public_id", nullable = false, unique = true, length = 36)
-    private String publicId; // 외부 URL/API 노출용 UUID v7
-
-    @Column(name = "email", nullable = false, unique = true, length = 100)
-    private String email; // 회원 로그인 이메일 계정
-
-    @Column(name = "password", length = 255) // BCrypt 60자 해시 문자열 저장용
-    private String password;
-
-    @Column(name = "nickname", nullable = false, unique = true, length = 50)
-    private String nickname; // 유저 활동 닉네임
-
-    @Column(name = "profile_image_url", length = 500)
-    private String profileImageUrl;
-
-    @Column(name = "bio", length = 255)
-    private String bio;
-
-    @Column(name = "departure_region", length = 100)
-    private String departureRegion;
-
-    @Enumerated(EnumType.STRING) // [JPA] Enum 상수의 '이름 문자열(ROLE_USER)' 자체를 DB에 저장
-    @Column(name = "role", nullable = false, length = 20)
-    private Role role;
-
-    @Enumerated(EnumType.STRING)
-    @Column(name = "status", nullable = false, length = 20)
-    private MemberStatus status;
-
-    @PrePersist // [JPA Callback] 엔티티가 DB에 INSERT 되기 직전에 실행되는 영속성 라이프사이클 콜백 함수
-    public void prePersist() {
-        if (this.publicId == null) {
-            this.publicId = UUID.randomUUID().toString();
-        }
-        if (this.role == null) {
-            this.role = Role.ROLE_USER;
-        }
-        if (this.status == null) {
-            this.status = MemberStatus.ACTIVE;
-        }
-    }
-
-    @Builder
-    public Member(String publicId, String email, String password, String nickname,
-                  String profileImageUrl, String bio, String departureRegion,
-                  Long crewId, String crewRole, Role role, MemberStatus status) {
-        this.publicId = publicId;
-        this.email = email;
-        this.password = password;
-        this.nickname = nickname;
-        this.profileImageUrl = profileImageUrl;
-        this.bio = bio;
-        this.departureRegion = departureRegion;
-        this.role = role != null ? role : Role.ROLE_USER;
-        this.status = status != null ? status : MemberStatus.ACTIVE;
-    }
-
-    // 프로필 정보 수정 비즈니스 메서드 (Dirty Checking 활용)
-    public void updateProfile(String nickname, String bio, String departureRegion, String profileImageUrl) {
-        this.nickname = nickname;
-        this.bio = bio;
-        this.departureRegion = departureRegion;
-        this.profileImageUrl = profileImageUrl;
-    }
-}
-```
-
-```java
-// ==========================================
-// 2. MemberResort.java (회원-스키장 N:M 중계 엔티티)
-// ==========================================
-package com.ikae.snowthing.domain.member.entity;
-
-import jakarta.persistence.*;
-import lombok.AccessLevel;
-import lombok.Builder;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-
-@Entity
-@Table(
-    name = "member_resort",
-    uniqueConstraints = {
-        // [DB 제약조건] 동일 회원이 동일 스키장을 중복 선택하지 못하도록 (member_id + resort_id) 복합 UNIQUE 인덱스 부여
-        @UniqueConstraint(name = "uk_member_resort", columnNames = {"member_id", "resort_id"})
-    }
-)
-@Getter
-@NoArgsConstructor(access = AccessLevel.PROTECTED)
-public class MemberResort {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY) // 대리키 id PK
-    private Long id;
-
-    @ManyToOne(fetch = FetchType.LAZY) // [JPA 옵션] 지연 로딩 적용. MemberResort 만 조회 시 Member 엔티티는 프록시로 유지
-    @JoinColumn(name = "member_id", nullable = false) // [DB FK] member 테이블의 member_id 를 참조하는 외래키 생성
-    private Member member;
-
-    @ManyToOne(fetch = FetchType.LAZY) // [JPA 옵션] 지연 로딩 적용
-    @JoinColumn(name = "resort_id", nullable = false) // [DB FK] resort 테이블의 resort_id 를 참조하는 외래키 생성
-    private Resort resort;
-
-    @Builder
-    public MemberResort(Member member, Resort resort) {
-        this.member = member;
-        this.resort = resort;
-    }
-}
-```
-
----
-
-## 3.2 JPA 주요 어노테이션 & 옵션 상세 파헤치기
-
-1. **`GenerationType.IDENTITY`**:
-   * **물리적 동작**: DB의 `AUTO_INCREMENT` 기능에 PK 생성을 위임합니다.
-   * **특징**: JPA 영속성 컨텍스트(1차 캐시)에 엔티티를 등록하려면 식별자(PK)가 필요하므로, `em.persist()` 나 `save()` 호출 시 **트랜잭션 커밋 전이라도 DB에 즉시 SQL INSERT 가 실행**되어 PK를 채번해옵니다.
-2. **`EnumType.STRING`**:
-   * **필수 이유**: 디폴트값인 `EnumType.ORDINAL` 은 Enum 의 순서 숫자(`0, 1, 2`)를 DB에 저장합니다. 추후 Enum 에 새로운 값을 추가하거나 순서를 변경하면 기존 DB의 숫자가 엉키게 됩니다. 따라서 반드시 `STRING` 을 명시해야 합니다.
-3. **`FetchType.LAZY` vs `JOIN FETCH`**:
-   * `FetchType.LAZY` 는 객체 참조 시점까지 DB 조회를 미루는 지연 로딩입니다.
-   * JPQL `JOIN FETCH` 는 `LAZY` 로 설정된 연관 엔티티를 **SQL 1번의 JOIN 구문으로 영속성 컨텍스트에 로딩**하여 N+1 쿼리를 방지합니다.
-4. **`@Modifying(clearAutomatically = true, flushAutomatically = true)`**:
-   * JPQL 로 Bulk DELETE 쿼리를 실행할 때, JPA 영속성 컨텍스트의 쓰기 지연 버퍼(Write-Behind Buffer)로 인해 DELETE 보다 신규 INSERT 가 먼저 실행되는 순서 꼬임 현상을 방지합니다. `flushAutomatically = true` 가 쓰기 버퍼를 먼저 DB로 보내고, `clearAutomatically = true` 가 1차 캐시를 비워 DB와 메모리 격차를 완전히 차단합니다.
-5. **`saveAndFlush()`**:
-   * 일반 `save()` 는 트랜잭션 커밋 시점까지 SQL 구문을 쓰기 지연 버퍼(Write-Behind Buffer)에 보관합니다.
-   * `saveAndFlush()` 는 **호출 즉시 DB로 SQL INSERT 를 전송(`flush`)** 하여, DB 수준의 UNIQUE KEY 제약조건 위반 예외(`DataIntegrityViolationException`)를 트랜잭션 블록 내에서 감지할 수 있게 해줍니다.
-
----
-
-## 3.3 DB 제약조건(`PK`, `UNIQUE`, `FK`)과 JPA 연관관계의 물리적 연동 원리
-
-```text
-  [member 테이블]                [member_resort 테이블]               [resort 테이블]
-┌─────────────────┐            ┌───────────────────────┐            ┌──────────────────┐
-│ PK: member_id   │◄─── FK ────│ FK: member_id         │            │ PK: resort_id    │
-│ UNIQUE: email   │            │ FK: resort_id ────────┼──── FK ───►│ UNIQUE: name     │
-│ UNIQUE: nickname│            │ UNIQUE(member, resort)│            └──────────────────┘
-└─────────────────┘            └───────────────────────┘
-```
-
-1. **`PRIMARY KEY (PK)`**:
-   * DB 테이블 내 각 행(Row)을 유일하게 식별하는 물리적 클러스터드 인덱스(Clustered Index). JPA의 `@Id` 와 1대1 대응.
-2. **`UNIQUE KEY (유니크 인덱스)`**:
-   * 특정 컬럼(또는 컬럼 조합)의 값이 중복되는 것을 DB 엔진 수준에서 거부.
-   * **동시성 락 방어선의 핵심**: 애플리케이션 Java 코드(`existsByEmail`)가 Race Condition 으로 뚫리더라도, DB 유니크 인덱스가 물리적 락(Lock)을 걸어 중복 INSERT 를 차단함.
-3. **`FOREIGN KEY (FK)`**:
-   * 참조 무결성 제약조건. `member_resort` 의 `member_id` 에 존재하지 않는 회원의 ID 가 들어오려고 하면 DB 엔진이 쿼리를 거부함. JPA 의 `@JoinColumn` 과 매핑됨.
-
----
-
-## 3.4 전체 실증 테스트 수트 통합 모음 (25개 전체 통과)
-
-### ① 내 프로필 수정 & N:M 중계 갱신 통합 테스트 ([MemberProfileUpdateIntegrationTest.java](file:///c:/Users/ikaes/IdeaProjects/snowthing/backend/src/test/java/com/ikae/snowthing/domain/member/controller/MemberProfileUpdateIntegrationTest.java))
-
-```java
-package com.ikae.snowthing.domain.member.controller;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.ikae.snowthing.domain.auth.dto.MemberLoginRequest;
-import com.ikae.snowthing.domain.member.dto.MemberProfileUpdateRequest;
-import com.ikae.snowthing.domain.member.dto.MemberSignUpRequest;
-import com.ikae.snowthing.domain.member.entity.Resort;
-import com.ikae.snowthing.domain.member.entity.RidingStyle;
-import com.ikae.snowthing.domain.member.repository.MemberRepository;
-import com.ikae.snowthing.domain.member.repository.MemberResortRepository;
-import com.ikae.snowthing.domain.member.repository.MemberRidingStyleRepository;
-import com.ikae.snowthing.domain.member.repository.ResortRepository;
-import com.ikae.snowthing.domain.member.repository.RidingStyleRepository;
-import com.ikae.snowthing.domain.member.service.MemberService;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
-import org.springframework.boot.test.context.SpringBootTest;
-import org.springframework.http.MediaType;
-import org.springframework.mock.web.MockHttpSession;
-import org.springframework.test.web.servlet.MockMvc;
-import org.springframework.test.web.servlet.MvcResult;
-
-import java.util.List;
-
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
-
-@SpringBootTest
-@AutoConfigureMockMvc
-class MemberProfileUpdateIntegrationTest {
-
-    @Autowired private MockMvc mockMvc;
-    @Autowired private ObjectMapper objectMapper;
-    @Autowired private MemberService memberService;
-    @Autowired private MemberRepository memberRepository;
-    @Autowired private MemberResortRepository memberResortRepository;
-    @Autowired private MemberRidingStyleRepository memberRidingStyleRepository;
-    @Autowired private ResortRepository resortRepository;
-    @Autowired private RidingStyleRepository ridingStyleRepository;
-
-    private Long resortId1;
-    private Long resortId2;
-    private Long styleId1;
-    private Long styleId2;
-
-    @BeforeEach
-    void setUp() {
-        cleanUp();
-
-        Resort r1 = resortRepository.findByName("휘닉스파크").orElseGet(() -> resortRepository.save(Resort.builder().name("휘닉스파크").regionName("강원 평창").build()));
-        Resort r2 = resortRepository.findByName("하이원리조트").orElseGet(() -> resortRepository.save(Resort.builder().name("하이원리조트").regionName("강원 정선").build()));
-        resortId1 = r1.getId();
-        resortId2 = r2.getId();
-
-        RidingStyle s1 = ridingStyleRepository.findByStyleName("올라운드").orElseGet(() -> ridingStyleRepository.save(RidingStyle.builder().styleName("올라운드").description("올라운드").build()));
-        RidingStyle s2 = ridingStyleRepository.findByStyleName("그라운드 트릭").orElseGet(() -> ridingStyleRepository.save(RidingStyle.builder().styleName("그라운드 트릭").description("그라운드 트릭").build()));
-        styleId1 = s1.getId();
-        styleId2 = s2.getId();
-
-        MemberSignUpRequest signUpRequest = MemberSignUpRequest.builder()
-                .email("profileupdate@snowthing.com")
-                .password("Password123!")
-                .nickname("수정전닉네임")
-                .bio("수정전소개")
-                .departureRegion("서울")
-                .resortIds(List.of(resortId1))
-                .ridingStyleIds(List.of(styleId1))
-                .build();
-        memberService.signUp(signUpRequest);
-    }
-
-    @AfterEach
-    void tearDown() {
-        cleanUp();
-    }
-
-    private void cleanUp() {
-        memberResortRepository.deleteAll();
-        memberRidingStyleRepository.deleteAll();
-        memberRepository.deleteAll();
-    }
-
-    @Test
-    @DisplayName("[프로필 수정 통합 테스트] 로그인한 유저가 PUT /api/members/me 로 닉네임과 N:M 스키장/성향을 변경 시 DB 중계 데이터가 갱신되고 조회가 반영되어야 한다")
-    void updateMyProfile_Success_UpdatesProfileAndMiddleTables() throws Exception {
-        MemberLoginRequest loginRequest = MemberLoginRequest.builder()
-                .email("profileupdate@snowthing.com")
-                .password("Password123!")
-                .build();
-
-        MvcResult loginResult = mockMvc.perform(post("/api/auth/login")
-                        .contentType(MediaType.APPLICATION_JSON)
-                        .content(objectMapper.writeValueAsString(loginRequest)))
-                .andExpect(status().isOk())
-                .andReturn();
-
-        MockHttpSession session = (MockHttpSession) loginResult.getRequest().getSession(false);
-
-        MemberProfileUpdateRequest updateRequest = MemberProfileUpdateRequest.builder()
-                .nickname("수정후닉네임")
-                .bio("수정후소개입니다")
-                .departureRegion("경기 이천")
-                .resortIds(List.of(resortId1, resortId2))
-                .ridingStyleIds(List.of(styleId1, styleId2))
-                .build();
-
-        mockMvc.perform(put("/api/members/me")
-                        .session(session)
-                        .contentType(MediaType.APPLICATION_JSON)
-                        .content(objectMapper.writeValueAsString(updateRequest)))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.nickname").value("수정후닉네임"))
-                .andExpect(jsonPath("$.resortNames.length()").value(2))
-                .andExpect(jsonPath("$.ridingStyleNames.length()").value(2));
-
-        mockMvc.perform(get("/api/members/me").session(session))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.nickname").value("수정후닉네임"))
-                .andExpect(jsonPath("$.resortNames[0]").value("휘닉스파크"))
-                .andExpect(jsonPath("$.resortNames[1]").value("하이원리조트"));
-    }
-}
-```
-
-### ② 마스터 데이터 API 통합 테스트 ([MasterDataControllerTest.java](file:///c:/Users/ikaes/IdeaProjects/snowthing/backend/src/test/java/com/ikae/snowthing/domain/member/controller/MasterDataControllerTest.java))
-
-```java
-package com.ikae.snowthing.domain.member.controller;
-
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
-import org.springframework.boot.test.context.SpringBootTest;
-import org.springframework.test.web.servlet.MockMvc;
-
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
-
-@SpringBootTest
-@AutoConfigureMockMvc
-class MasterDataControllerTest {
-
-    @Autowired
-    private MockMvc mockMvc;
-
-    @Test
-    @DisplayName("[마스터 데이터 API 통합 테스트] GET /api/resorts 호출 시 6대 스키장 마스터 목록이 비회원에게도 반환되어야 한다")
-    void getResorts_Returns6Resorts_PermitAll() throws Exception {
-        mockMvc.perform(get("/api/resorts"))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.length()").value(6))
-                .andExpect(jsonPath("$[0].name").value("휘닉스파크"))
-                .andExpect(jsonPath("$[1].name").value("하이원리조트"));
-    }
-
-    @Test
-    @DisplayName("[마스터 데이터 API 통합 테스트] GET /api/riding-styles 호출 시 올라운드를 포함한 6대 라이딩 성향 마스터 목록이 반환되어야 한다")
-    void getRidingStyles_Returns6Styles_PermitAll() throws Exception {
-        mockMvc.perform(get("/api/riding-styles"))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.length()").value(6))
-                .andExpect(jsonPath("$[0].styleName").value("올라운드"));
-    }
-}
-```
-
----
-
-### 📝 **결론**
-통합 테스트 수트까지 **총 25개 테스트 수트 100% 그린(Green) 통과**를 완벽하게 정돈하고 학습 문서에도 추가해 두었습니다.
diff --git a/frontend/next-env.d.ts b/frontend/next-env.d.ts
index c4b7818..9edff1c 100644
--- a/frontend/next-env.d.ts
+++ b/frontend/next-env.d.ts
@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/dev/types/routes.d.ts";
+import "./.next/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

From b43f53caaa97c98840fa8e1b6e577aa38de26daa Mon Sep 17 00:00:00 2001
From: ikae <ikaesujeel@gmail.com>
Date: Sun, 6 Sep 2026 19:41:03 +0900
Subject: [PATCH 6/6] =?UTF-8?q?PR=20#16=20=ED=94=BC=EB=93=9C=EB=B0=B1=20?=
 =?UTF-8?q?=EB=B0=98=EC=98=81/=20=EB=8C=93=EA=B8=80=EC=82=AD=EC=A0=9C=20?=
 =?UTF-8?q?=EB=B0=8F=20=EC=B9=B4=EC=9A=B4=ED=8A=B8=20=EC=A0=95=EC=B1=85=20?=
 =?UTF-8?q?=EC=A0=95=ED=95=A9=EC=84=B1=20=EB=B3=B4=EA=B0=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../comment/controller/CommentController.java |  12 +-
 .../comment/dto/CommentReplyListResponse.java |   7 +-
 .../domain/comment/dto/CommentResponse.java   |  45 ++++-
 .../comment/dto/PostCommentListResponse.java  |   5 +-
 .../comment/repository/CommentRepository.java |  15 +-
 .../repository/CommentRepositoryCustom.java   |   2 +
 .../repository/CommentRepositoryImpl.java     |  22 ++-
 .../comment/service/CommentService.java       |  76 ++++++--
 .../domain/comment/CommentReadTest.java       |  36 +++-
 .../controller/CommentControllerTest.java     |  19 ++
 .../comment/service/CommentCreateTest.java    |  38 +++-
 .../comment/service/CommentDeleteTest.java    |  92 ++++++++-
 docs/conception/sprint03/comment_api_spec.md  |  15 +-
 docs/conception/sprint03/comment_policy.md    |   8 +-
 docs/project/work.md                          |  40 ++++
 frontend/app/lib/api.ts                       |   6 +-
 frontend/app/posts/[publicId]/page.tsx        | 184 ++++++++++--------
 frontend/tsconfig.tsbuildinfo                 |   1 +
 18 files changed, 485 insertions(+), 138 deletions(-)
 create mode 100644 frontend/tsconfig.tsbuildinfo

diff --git a/backend/src/main/java/com/ikae/snowthing/domain/comment/controller/CommentController.java b/backend/src/main/java/com/ikae/snowthing/domain/comment/controller/CommentController.java
index 142cd66..57aaba7 100644
--- a/backend/src/main/java/com/ikae/snowthing/domain/comment/controller/CommentController.java
+++ b/backend/src/main/java/com/ikae/snowthing/domain/comment/controller/CommentController.java
@@ -41,8 +41,10 @@ public ResponseEntity<CommentResponse> createComment(
     public ResponseEntity<PostCommentListResponse> getCommentsByPost(
             @PathVariable String publicId,
             @RequestParam(required = false) Long cursor,
-            @RequestParam(defaultValue = "20") int size) {
-        PostCommentListResponse response = commentService.getCommentsByPost(publicId, cursor, size);
+            @RequestParam(defaultValue = "20") int size,
+            @AuthenticationPrincipal CustomUserDetails userDetails) {
+        PostCommentListResponse response =
+                commentService.getCommentsByPost(publicId, cursor, size, userDetails);
         return ResponseEntity.ok(response);
     }
 
@@ -50,8 +52,10 @@ public ResponseEntity<PostCommentListResponse> getCommentsByPost(
     public ResponseEntity<CommentReplyListResponse> getCommentReplies(
             @PathVariable Long commentId,
             @RequestParam(required = false) Long cursor,
-            @RequestParam(defaultValue = "20") int size) {
-        return ResponseEntity.ok(commentService.getCommentReplies(commentId, cursor, size));
+            @RequestParam(defaultValue = "20") int size,
+            @AuthenticationPrincipal CustomUserDetails userDetails) {
+        return ResponseEntity.ok(
+                commentService.getCommentReplies(commentId, cursor, size, userDetails));
     }
 
     @DeleteMapping("/comments/{commentId}")
diff --git a/backend/src/main/java/com/ikae/snowthing/domain/comment/dto/CommentReplyListResponse.java b/backend/src/main/java/com/ikae/snowthing/domain/comment/dto/CommentReplyListResponse.java
index 4a3d83f..067c49f 100644
--- a/backend/src/main/java/com/ikae/snowthing/domain/comment/dto/CommentReplyListResponse.java
+++ b/backend/src/main/java/com/ikae/snowthing/domain/comment/dto/CommentReplyListResponse.java
@@ -2,11 +2,14 @@
 
 import java.util.List;
 
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
+
 public record CommentReplyListResponse(
-        Long rootCommentId,
+        @JsonSerialize(using = ToStringSerializer.class) Long rootCommentId,
         long totalReplyCount,
         List<CommentResponse> replies,
-        Long nextCursor,
+        @JsonSerialize(using = ToStringSerializer.class) Long nextCursor,
         boolean hasNext) {
     public CommentReplyListResponse {
         replies = replies == null ? List.of() : List.copyOf(replies);
diff --git a/backend/src/main/java/com/ikae/snowthing/domain/comment/dto/CommentResponse.java b/backend/src/main/java/com/ikae/snowthing/domain/comment/dto/CommentResponse.java
index bbb0ce5..1b6ad17 100644
--- a/backend/src/main/java/com/ikae/snowthing/domain/comment/dto/CommentResponse.java
+++ b/backend/src/main/java/com/ikae/snowthing/domain/comment/dto/CommentResponse.java
@@ -3,14 +3,17 @@
 import java.time.LocalDateTime;
 import java.util.List;
 
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
 import com.ikae.snowthing.domain.comment.entity.Comment;
 import com.ikae.snowthing.domain.member.entity.Member;
 import com.ikae.snowthing.global.util.WriterDisplayFormatter;
 
 public record CommentResponse(
-        Long commentId,
-        Long postId,
-        Long parentId,
+        @JsonSerialize(using = ToStringSerializer.class) Long commentId,
+        @JsonSerialize(using = ToStringSerializer.class) Long postId,
+        @JsonSerialize(using = ToStringSerializer.class) Long parentId,
         WriterResponse writer,
         boolean isAnonymous,
         String writerIp,
@@ -19,6 +22,9 @@ public record CommentResponse(
         long replyCount,
         List<CommentResponse> previewReplies,
         boolean hasMoreReplies,
+        @JsonIgnore String ownerPublicId,
+        boolean canDelete,
+        boolean requiresDeletePassword,
         LocalDateTime createdAt) {
 
     public CommentResponse {
@@ -48,6 +54,9 @@ public static CommentResponse from(Comment comment) {
                 0,
                 List.of(),
                 false,
+                member == null ? null : member.getPublicId(),
+                false,
+                false,
                 comment.getCreatedAt());
     }
 
@@ -64,6 +73,36 @@ public CommentResponse withPreviewReplies(List<CommentResponse> replies) {
                 replyCount,
                 replies,
                 hasMoreReplies,
+                ownerPublicId,
+                canDelete,
+                requiresDeletePassword,
+                createdAt);
+    }
+
+    public CommentResponse withDeletePermissions(String viewerPublicId, boolean admin) {
+        boolean guestAnonymous = ownerPublicId == null && isAnonymous;
+        boolean owner = ownerPublicId != null && ownerPublicId.equals(viewerPublicId);
+        boolean deletable = !isDeleted && (admin || owner || guestAnonymous);
+        boolean passwordRequired = deletable && !admin && guestAnonymous;
+        List<CommentResponse> visibleReplies =
+                previewReplies.stream()
+                        .map(reply -> reply.withDeletePermissions(viewerPublicId, admin))
+                        .toList();
+        return new CommentResponse(
+                commentId,
+                postId,
+                parentId,
+                writer,
+                isAnonymous,
+                writerIp,
+                content,
+                isDeleted,
+                replyCount,
+                visibleReplies,
+                hasMoreReplies,
+                ownerPublicId,
+                deletable,
+                passwordRequired,
                 createdAt);
     }
 
diff --git a/backend/src/main/java/com/ikae/snowthing/domain/comment/dto/PostCommentListResponse.java b/backend/src/main/java/com/ikae/snowthing/domain/comment/dto/PostCommentListResponse.java
index 5597c3f..251d97b 100644
--- a/backend/src/main/java/com/ikae/snowthing/domain/comment/dto/PostCommentListResponse.java
+++ b/backend/src/main/java/com/ikae/snowthing/domain/comment/dto/PostCommentListResponse.java
@@ -2,11 +2,14 @@
 
 import java.util.List;
 
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
+
 public record PostCommentListResponse(
         String publicId,
         int totalCommentCount,
         List<CommentResponse> comments,
-        Long nextCursor,
+        @JsonSerialize(using = ToStringSerializer.class) Long nextCursor,
         boolean hasNext) {
     public PostCommentListResponse {
         comments = comments == null ? List.of() : List.copyOf(comments);
diff --git a/backend/src/main/java/com/ikae/snowthing/domain/comment/repository/CommentRepository.java b/backend/src/main/java/com/ikae/snowthing/domain/comment/repository/CommentRepository.java
index 43bac96..2464af2 100644
--- a/backend/src/main/java/com/ikae/snowthing/domain/comment/repository/CommentRepository.java
+++ b/backend/src/main/java/com/ikae/snowthing/domain/comment/repository/CommentRepository.java
@@ -1,6 +1,6 @@
 package com.ikae.snowthing.domain.comment.repository;
 
-import java.util.List;
+import java.time.LocalDateTime;
 import java.util.Optional;
 
 import jakarta.persistence.LockModeType;
@@ -18,9 +18,14 @@ public interface CommentRepository extends JpaRepository<Comment, Long>, Comment
     @Query("SELECT c FROM Comment c WHERE c.id = :commentId")
     Optional<Comment> findByIdForUpdate(@Param("commentId") Long commentId);
 
-    long countByParentIdAndIsDeletedFalse(Long parentId);
+    @org.springframework.data.jpa.repository.Modifying(
+            flushAutomatically = true,
+            clearAutomatically = true)
+    @Query(
+            "UPDATE Comment c SET c.isDeleted = true, c.deletedAt = :deletedAt "
+                    + "WHERE c.id = :commentId AND c.isDeleted = false")
+    int softDeleteIfActive(
+            @Param("commentId") Long commentId, @Param("deletedAt") LocalDateTime deletedAt);
 
-    @Lock(LockModeType.PESSIMISTIC_READ)
-    @Query("SELECT c.id FROM Comment c WHERE c.parent.id = :parentId AND c.isDeleted = false")
-    List<Long> findActiveReplyIdsForUpdate(@Param("parentId") Long parentId);
+    long countByParentIdAndIsDeletedFalse(Long parentId);
 }
diff --git a/backend/src/main/java/com/ikae/snowthing/domain/comment/repository/CommentRepositoryCustom.java b/backend/src/main/java/com/ikae/snowthing/domain/comment/repository/CommentRepositoryCustom.java
index 0116c5c..276e554 100644
--- a/backend/src/main/java/com/ikae/snowthing/domain/comment/repository/CommentRepositoryCustom.java
+++ b/backend/src/main/java/com/ikae/snowthing/domain/comment/repository/CommentRepositoryCustom.java
@@ -22,4 +22,6 @@ record CursorPosition(LocalDateTime createdAt, Long commentId) {}
     List<CommentResponse> findReplies(Long rootCommentId, CursorPosition cursor, int fetchSize);
 
     long countActiveReplies(Long rootCommentId);
+
+    long countReplies(Long rootCommentId);
 }
diff --git a/backend/src/main/java/com/ikae/snowthing/domain/comment/repository/CommentRepositoryImpl.java b/backend/src/main/java/com/ikae/snowthing/domain/comment/repository/CommentRepositoryImpl.java
index 5b3ebf8..13b9843 100644
--- a/backend/src/main/java/com/ikae/snowthing/domain/comment/repository/CommentRepositoryImpl.java
+++ b/backend/src/main/java/com/ikae/snowthing/domain/comment/repository/CommentRepositoryImpl.java
@@ -69,9 +69,8 @@ public List<CommentResponse> findRootComments(
                 "SELECT "
                         + SELECT_RESPONSE_COLUMNS
                         + """
-                        , (SELECT COUNT(*) FROM comment active_reply
-                           WHERE active_reply.parent_id = c.comment_id
-                             AND active_reply.is_deleted = false) AS reply_count,
+                        , (SELECT COUNT(*) FROM comment reply
+                           WHERE reply.parent_id = c.comment_id) AS reply_count,
                           CASE WHEN (SELECT COUNT(*) FROM comment all_reply
                                       WHERE all_reply.parent_id = c.comment_id) > 5
                                THEN true ELSE false END AS has_more_replies
@@ -79,10 +78,6 @@ CASE WHEN (SELECT COUNT(*) FROM comment all_reply
                         LEFT JOIN member m ON m.member_id = c.member_id
                         WHERE c.post_id = :postId
                           AND c.parent_id IS NULL
-                          AND (c.is_deleted = false OR EXISTS (
-                              SELECT 1 FROM comment active_child
-                              WHERE active_child.parent_id = c.comment_id
-                                AND active_child.is_deleted = false))
                         """
                         + cursorCondition
                         + " ORDER BY c.created_at ASC, c.comment_id ASC LIMIT :fetchSize";
@@ -173,6 +168,16 @@ SELECT COUNT(*) FROM comment
         return count == null ? 0 : count;
     }
 
+    @Override
+    public long countReplies(Long rootCommentId) {
+        Long count =
+                jdbcTemplate.queryForObject(
+                        "SELECT COUNT(*) FROM comment WHERE parent_id = :rootCommentId",
+                        new MapSqlParameterSource("rootCommentId", rootCommentId),
+                        Long.class);
+        return count == null ? 0 : count;
+    }
+
     private Optional<CursorPosition> findCursor(String sql, Long scopeId, Long cursorId) {
         List<CursorPosition> positions =
                 jdbcTemplate.query(
@@ -216,6 +221,9 @@ private CommentResponse mapResponse(ResultSet rs, int rowNum) throws SQLExceptio
                 rs.getLong("reply_count"),
                 List.of(),
                 rs.getBoolean("has_more_replies"),
+                memberPublicId,
+                false,
+                false,
                 rs.getObject("created_at", LocalDateTime.class));
     }
 
diff --git a/backend/src/main/java/com/ikae/snowthing/domain/comment/service/CommentService.java b/backend/src/main/java/com/ikae/snowthing/domain/comment/service/CommentService.java
index 20ca1a3..4b781c9 100644
--- a/backend/src/main/java/com/ikae/snowthing/domain/comment/service/CommentService.java
+++ b/backend/src/main/java/com/ikae/snowthing/domain/comment/service/CommentService.java
@@ -1,5 +1,6 @@
 package com.ikae.snowthing.domain.comment.service;
 
+import java.time.LocalDateTime;
 import java.util.*;
 
 import org.springframework.security.crypto.password.PasswordEncoder;
@@ -91,7 +92,7 @@ public CommentResponse createComment(
                     if (request.parentId() != null) {
                         Comment requestedParent =
                                 commentRepository
-                                        .findByIdForUpdate(request.parentId())
+                                        .findById(request.parentId())
                                         .orElseThrow(
                                                 () ->
                                                         new CustomAuthException(
@@ -112,8 +113,7 @@ public CommentResponse createComment(
                                                                 ErrorCode
                                                                         .PARENT_COMMENT_NOT_FOUND));
 
-                        long activeReplyCount =
-                                commentRepository.findActiveReplyIdsForUpdate(rootCommentId).size();
+                        long activeReplyCount = commentRepository.countActiveReplies(rootCommentId);
                         if (activeReplyCount >= MAX_REPLY_COUNT) {
                             throw new CustomAuthException(ErrorCode.COMMENT_REPLY_LIMIT_EXCEEDED);
                         }
@@ -132,7 +132,10 @@ public CommentResponse createComment(
                     Comment savedComment = commentRepository.save(comment);
                     postRepository.increaseCommentCount(post.getId());
 
-                    return CommentResponse.from(savedComment);
+                    return CommentResponse.from(savedComment)
+                            .withDeletePermissions(
+                                    userDetails == null ? null : userDetails.getPublicId(),
+                                    isAdmin(userDetails));
                 });
     }
 
@@ -141,15 +144,18 @@ public PostCommentListResponse getCommentsByPost(String postPublicId) {
     }
 
     public PostCommentListResponse getCommentsByPost(String postPublicId, Long cursor, int size) {
+        return getCommentsByPost(postPublicId, cursor, size, null);
+    }
+
+    public PostCommentListResponse getCommentsByPost(
+            String postPublicId, Long cursor, int size, CustomUserDetails userDetails) {
         validateReadSize(size);
         Post post =
                 postRepository
                         .findByPublicId(postPublicId)
                         .orElseThrow(() -> new CustomAuthException(ErrorCode.POST_NOT_FOUND));
 
-        if (post.isDeleted() || post.getStatus() != PostStatus.NORMAL) {
-            throw new CustomAuthException(ErrorCode.POST_NOT_FOUND);
-        }
+        validatePostVisibility(post);
 
         CommentRepositoryCustom.CursorPosition cursorPosition =
                 cursor == null
@@ -171,6 +177,13 @@ public PostCommentListResponse getCommentsByPost(String postPublicId, Long curso
                                 root ->
                                         root.withPreviewReplies(
                                                 previews.getOrDefault(root.commentId(), List.of())))
+                        .map(
+                                comment ->
+                                        comment.withDeletePermissions(
+                                                userDetails == null
+                                                        ? null
+                                                        : userDetails.getPublicId(),
+                                                isAdmin(userDetails)))
                         .toList();
         Long nextCursor = hasNext && !comments.isEmpty() ? comments.getLast().commentId() : null;
         return new PostCommentListResponse(
@@ -178,6 +191,11 @@ public PostCommentListResponse getCommentsByPost(String postPublicId, Long curso
     }
 
     public CommentReplyListResponse getCommentReplies(Long commentId, Long cursor, int size) {
+        return getCommentReplies(commentId, cursor, size, null);
+    }
+
+    public CommentReplyListResponse getCommentReplies(
+            Long commentId, Long cursor, int size, CustomUserDetails userDetails) {
         validateReadSize(size);
         Comment root =
                 commentRepository
@@ -186,6 +204,11 @@ public CommentReplyListResponse getCommentReplies(Long commentId, Long cursor, i
         if (root.getParent() != null) {
             throw new CustomAuthException(ErrorCode.COMMENT_NOT_FOUND);
         }
+        Post post =
+                postRepository
+                        .findById(root.getPost().getId())
+                        .orElseThrow(() -> new CustomAuthException(ErrorCode.POST_NOT_FOUND));
+        validatePostVisibility(post);
         CommentRepositoryCustom.CursorPosition cursorPosition =
                 cursor == null
                         ? null
@@ -196,14 +219,20 @@ public CommentReplyListResponse getCommentReplies(Long commentId, Long cursor, i
         List<CommentResponse> fetched =
                 commentRepository.findReplies(commentId, cursorPosition, size + 1);
         boolean hasNext = fetched.size() > size;
-        List<CommentResponse> replies = List.copyOf(hasNext ? fetched.subList(0, size) : fetched);
+        List<CommentResponse> replies =
+                (hasNext ? fetched.subList(0, size) : fetched)
+                        .stream()
+                                .map(
+                                        reply ->
+                                                reply.withDeletePermissions(
+                                                        userDetails == null
+                                                                ? null
+                                                                : userDetails.getPublicId(),
+                                                        isAdmin(userDetails)))
+                                .toList();
         Long nextCursor = hasNext && !replies.isEmpty() ? replies.getLast().commentId() : null;
         return new CommentReplyListResponse(
-                commentId,
-                commentRepository.countActiveReplies(commentId),
-                replies,
-                nextCursor,
-                hasNext);
+                commentId, commentRepository.countReplies(commentId), replies, nextCursor, hasNext);
     }
 
     private void validateReadSize(int size) {
@@ -212,6 +241,12 @@ private void validateReadSize(int size) {
         }
     }
 
+    private void validatePostVisibility(Post post) {
+        if (post.isDeleted() || post.getStatus() != PostStatus.NORMAL) {
+            throw new CustomAuthException(ErrorCode.POST_NOT_FOUND);
+        }
+    }
+
     @Transactional
     public void deleteComment(
             Long commentId, String anonymousPassword, CustomUserDetails userDetails) {
@@ -226,17 +261,12 @@ public void deleteComment(
 
         validateDeletePermission(comment, anonymousPassword, userDetails);
 
-        comment.softDelete();
-        postRepository.decreaseCommentCount(comment.getPost().getId());
+        commentRepository.softDeleteIfActive(commentId, LocalDateTime.now());
     }
 
     private void validateDeletePermission(
             Comment comment, String anonymousPassword, CustomUserDetails userDetails) {
-        boolean isAdmin =
-                userDetails != null
-                        && userDetails.getAuthorities().stream()
-                                .anyMatch(a -> a.getAuthority().equals("ROLE_ADMIN"));
-        if (isAdmin) {
+        if (isAdmin(userDetails)) {
             return;
         }
 
@@ -255,4 +285,10 @@ private void validateDeletePermission(
             throw new CustomAuthException(ErrorCode.INVALID_ANON_PASSWORD);
         }
     }
+
+    private boolean isAdmin(CustomUserDetails userDetails) {
+        return userDetails != null
+                && userDetails.getAuthorities().stream()
+                        .anyMatch(authority -> authority.getAuthority().equals("ROLE_ADMIN"));
+    }
 }
diff --git a/backend/src/test/java/com/ikae/snowthing/domain/comment/CommentReadTest.java b/backend/src/test/java/com/ikae/snowthing/domain/comment/CommentReadTest.java
index 79e7f83..667c69d 100644
--- a/backend/src/test/java/com/ikae/snowthing/domain/comment/CommentReadTest.java
+++ b/backend/src/test/java/com/ikae/snowthing/domain/comment/CommentReadTest.java
@@ -32,7 +32,9 @@
 import com.ikae.snowthing.domain.post.dto.PostCreateRequest;
 import com.ikae.snowthing.domain.post.dto.PostResponse;
 import com.ikae.snowthing.domain.post.entity.PostCategory;
+import com.ikae.snowthing.domain.post.entity.PostStatus;
 import com.ikae.snowthing.domain.post.repository.PostCategoryRepository;
+import com.ikae.snowthing.domain.post.repository.PostRepository;
 import com.ikae.snowthing.domain.post.service.PostService;
 import com.ikae.snowthing.global.error.ErrorCode;
 import com.ikae.snowthing.global.exception.CustomAuthException;
@@ -47,6 +49,7 @@ class CommentReadTest {
     @Autowired private PostService postService;
     @Autowired private MemberRepository memberRepository;
     @Autowired private PostCategoryRepository categoryRepository;
+    @Autowired private PostRepository postRepository;
     @Autowired private PasswordEncoder passwordEncoder;
     @Autowired private NamedParameterJdbcTemplate jdbcTemplate;
     @Autowired private MockMvc mockMvc;
@@ -173,7 +176,9 @@ void deletionVisibilityPolicy() {
             commentService.deleteComment(reply.commentId(), null, userDetails);
             PostCommentListResponse allDeleted =
                     commentService.getCommentsByPost(post.publicId(), null, 20);
-            assertThat(allDeleted.comments()).isEmpty();
+            assertThat(allDeleted.comments()).hasSize(1);
+            assertThat(allDeleted.comments().getFirst().isDeleted()).isTrue();
+            assertThat(allDeleted.comments().getFirst().replyCount()).isEqualTo(1);
         }
 
         @Test
@@ -262,6 +267,35 @@ void cursorFromDifferentRoot() {
                                     firstRoot.commentId(), foreignReply.commentId(), 20),
                     ErrorCode.COMMENT_NOT_FOUND);
         }
+
+        @Test
+        @DisplayName("삭제된 게시글의 대댓글 조회는 POST_NOT_FOUND를 반환한다")
+        void repliesOfDeletedPostAreHidden() {
+            CommentResponse root = createRoot("삭제 게시글 루트");
+            createReply(root.commentId(), "삭제 게시글 대댓글");
+
+            postRepository.findByPublicId(post.publicId()).orElseThrow().softDelete();
+
+            assertErrorCode(
+                    () -> commentService.getCommentReplies(root.commentId(), null, 20),
+                    ErrorCode.POST_NOT_FOUND);
+        }
+
+        @Test
+        @DisplayName("차단된 게시글의 대댓글 조회는 POST_NOT_FOUND를 반환한다")
+        void repliesOfBlockedPostAreHidden() {
+            CommentResponse root = createRoot("차단 게시글 루트");
+            createReply(root.commentId(), "차단 게시글 대댓글");
+
+            postRepository
+                    .findByPublicId(post.publicId())
+                    .orElseThrow()
+                    .changeStatus(PostStatus.BLOCKED);
+
+            assertErrorCode(
+                    () -> commentService.getCommentReplies(root.commentId(), null, 20),
+                    ErrorCode.POST_NOT_FOUND);
+        }
     }
 
     private PostResponse createPost(String title) {
diff --git a/backend/src/test/java/com/ikae/snowthing/domain/comment/controller/CommentControllerTest.java b/backend/src/test/java/com/ikae/snowthing/domain/comment/controller/CommentControllerTest.java
index 0b1aca6..055f187 100644
--- a/backend/src/test/java/com/ikae/snowthing/domain/comment/controller/CommentControllerTest.java
+++ b/backend/src/test/java/com/ikae/snowthing/domain/comment/controller/CommentControllerTest.java
@@ -123,6 +123,25 @@ void getComments_success() throws Exception {
                 .andExpect(jsonPath("$.totalCommentCount").value(1));
     }
 
+    @Test
+    @DisplayName("GET /api/v1/posts/{publicId}/comments - 로그인 익명 작성자는 비밀번호 없이 삭제 가능")
+    void getComments_exposesDeletePermissionForAnonymousMemberOwner() throws Exception {
+        commentService.createComment(
+                post.publicId(),
+                CommentCreateRequest.builder().content("로그인 익명 댓글").isAnonymous(true).build(),
+                userDetails,
+                "127.0.0.1");
+
+        mockMvc.perform(
+                        get("/api/v1/posts/{publicId}/comments", post.publicId())
+                                .with(user(userDetails)))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.comments[0].writer").doesNotExist())
+                .andExpect(jsonPath("$.comments[0].ownerPublicId").doesNotExist())
+                .andExpect(jsonPath("$.comments[0].canDelete").value(true))
+                .andExpect(jsonPath("$.comments[0].requiresDeletePassword").value(false));
+    }
+
     @Test
     @DisplayName("DELETE /api/v1/comments/{commentId} - 댓글 Soft Delete 삭제 200 OK")
     void deleteComment_success() throws Exception {
diff --git a/backend/src/test/java/com/ikae/snowthing/domain/comment/service/CommentCreateTest.java b/backend/src/test/java/com/ikae/snowthing/domain/comment/service/CommentCreateTest.java
index 18b0527..88391b6 100644
--- a/backend/src/test/java/com/ikae/snowthing/domain/comment/service/CommentCreateTest.java
+++ b/backend/src/test/java/com/ikae/snowthing/domain/comment/service/CommentCreateTest.java
@@ -398,12 +398,46 @@ void allowOnlyOneConcurrentReplyAtLimitBoundary() throws Exception {
         }
     }
 
+    @Test
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    @DisplayName("같은 루트의 서로 다른 대댓글에 동시에 답글을 작성해도 데드락 없이 저장된다")
+    void createConcurrentRepliesThroughDifferentChildrenWithoutDeadlock() throws Exception {
+        CommentResponse root = createComment(null, "동시성 루트 댓글");
+        CommentResponse firstChild = createComment(root.commentId(), "첫 번째 대댓글");
+        CommentResponse secondChild = createComment(root.commentId(), "두 번째 대댓글");
+
+        ExecutorService executor = Executors.newFixedThreadPool(2);
+        CountDownLatch ready = new CountDownLatch(2);
+        CountDownLatch start = new CountDownLatch(1);
+        try {
+            List<Future<ErrorCode>> results =
+                    List.of(
+                            executor.submit(
+                                    () ->
+                                            createConcurrentReply(
+                                                    firstChild.commentId(), ready, start)),
+                            executor.submit(
+                                    () ->
+                                            createConcurrentReply(
+                                                    secondChild.commentId(), ready, start)));
+            assertThat(ready.await(10, TimeUnit.SECONDS)).isTrue();
+            start.countDown();
+
+            assertThat(results.get(0).get(30, TimeUnit.SECONDS)).isNull();
+            assertThat(results.get(1).get(30, TimeUnit.SECONDS)).isNull();
+            assertThat(commentRepository.countByParentIdAndIsDeletedFalse(root.commentId()))
+                    .isEqualTo(4);
+        } finally {
+            executor.shutdownNow();
+        }
+    }
+
     private ErrorCode createConcurrentReply(
-            Long rootCommentId, CountDownLatch ready, CountDownLatch start) throws Exception {
+            Long parentCommentId, CountDownLatch ready, CountDownLatch start) throws Exception {
         ready.countDown();
         assertThat(start.await(10, TimeUnit.SECONDS)).isTrue();
         try {
-            createComment(rootCommentId, "동시 대댓글");
+            createComment(parentCommentId, "동시 대댓글");
             return null;
         } catch (CustomAuthException exception) {
             return exception.getErrorCode();
diff --git a/backend/src/test/java/com/ikae/snowthing/domain/comment/service/CommentDeleteTest.java b/backend/src/test/java/com/ikae/snowthing/domain/comment/service/CommentDeleteTest.java
index e750e8a..6ba11bc 100644
--- a/backend/src/test/java/com/ikae/snowthing/domain/comment/service/CommentDeleteTest.java
+++ b/backend/src/test/java/com/ikae/snowthing/domain/comment/service/CommentDeleteTest.java
@@ -20,7 +20,9 @@
 import org.springframework.transaction.annotation.Transactional;
 
 import com.ikae.snowthing.domain.comment.dto.CommentCreateRequest;
+import com.ikae.snowthing.domain.comment.dto.CommentReplyListResponse;
 import com.ikae.snowthing.domain.comment.dto.CommentResponse;
+import com.ikae.snowthing.domain.comment.dto.PostCommentListResponse;
 import com.ikae.snowthing.domain.comment.entity.Comment;
 import com.ikae.snowthing.domain.comment.repository.CommentRepository;
 import com.ikae.snowthing.domain.member.entity.Member;
@@ -166,7 +168,7 @@ void deleteOwnCommentAsMember() {
             assertThat(deletedComment.getDeletedAt()).isNotNull();
 
             Post post = postRepository.findByPublicId(postResponse.publicId()).orElseThrow();
-            assertThat(post.getCommentCount()).isEqualTo(0);
+            assertThat(post.getCommentCount()).isEqualTo(1);
         }
 
         @Test
@@ -183,7 +185,7 @@ void deleteAnonymousCommentWithCorrectPassword() {
             assertThat(deletedComment.getDeletedAt()).isNotNull();
 
             Post post = postRepository.findByPublicId(postResponse.publicId()).orElseThrow();
-            assertThat(post.getCommentCount()).isEqualTo(0);
+            assertThat(post.getCommentCount()).isEqualTo(1);
         }
 
         @Test
@@ -208,7 +210,7 @@ void deleteCommentAsAdmin() {
             assertThat(deletedAnonComment.isDeleted()).isTrue();
 
             Post post = postRepository.findByPublicId(postResponse.publicId()).orElseThrow();
-            assertThat(post.getCommentCount()).isEqualTo(0);
+            assertThat(post.getCommentCount()).isEqualTo(2);
         }
 
         @Test
@@ -237,7 +239,60 @@ void deleteParentCommentPreservesReplies() {
 
             Post postAfterDelete =
                     postRepository.findByPublicId(postResponse.publicId()).orElseThrow();
-            assertThat(postAfterDelete.getCommentCount()).isEqualTo(2);
+            assertThat(postAfterDelete.getCommentCount()).isEqualTo(3);
+        }
+
+        @Test
+        @DisplayName("댓글 삭제 UI 권한은 작성 주체와 현재 요청자에 따라 계산한다")
+        void deletePermissionMetadataMatchesOwnershipPolicy() {
+            CommentResponse memberComment = createMemberComment("회원 댓글");
+            CommentResponse memberAnonymousComment =
+                    createMemberAnonymousComment(null, "로그인 익명 댓글");
+            CommentResponse guestAnonymousComment =
+                    createGuestAnonymousComment("비회원 익명 댓글", "anonPass1234");
+
+            PostCommentListResponse writerView =
+                    commentService.getCommentsByPost(
+                            postResponse.publicId(), null, 20, writerDetails);
+            assertDeletePermission(writerView, memberComment.commentId(), true, false);
+            assertDeletePermission(writerView, memberAnonymousComment.commentId(), true, false);
+            assertDeletePermission(writerView, guestAnonymousComment.commentId(), true, true);
+
+            PostCommentListResponse otherView =
+                    commentService.getCommentsByPost(
+                            postResponse.publicId(), null, 20, otherDetails);
+            assertDeletePermission(otherView, memberComment.commentId(), false, false);
+            assertDeletePermission(otherView, memberAnonymousComment.commentId(), false, false);
+            assertDeletePermission(otherView, guestAnonymousComment.commentId(), true, true);
+
+            PostCommentListResponse adminView =
+                    commentService.getCommentsByPost(
+                            postResponse.publicId(), null, 20, adminDetails);
+            assertDeletePermission(adminView, memberComment.commentId(), true, false);
+            assertDeletePermission(adminView, memberAnonymousComment.commentId(), true, false);
+            assertDeletePermission(adminView, guestAnonymousComment.commentId(), true, false);
+        }
+
+        @Test
+        @DisplayName("대댓글 분리 조회에도 로그인 익명 작성자의 삭제 권한을 적용한다")
+        void separatedReplyDeletePermissionMatchesOwnershipPolicy() {
+            CommentResponse root = createMemberComment("권한 확인 루트");
+            CommentResponse memberAnonymousReply =
+                    createMemberAnonymousComment(root.commentId(), "로그인 익명 대댓글");
+
+            CommentReplyListResponse writerView =
+                    commentService.getCommentReplies(root.commentId(), null, 20, writerDetails);
+            CommentReplyListResponse otherView =
+                    commentService.getCommentReplies(root.commentId(), null, 20, otherDetails);
+
+            assertThat(findReply(writerView, memberAnonymousReply.commentId()).canDelete())
+                    .isTrue();
+            assertThat(
+                            findReply(writerView, memberAnonymousReply.commentId())
+                                    .requiresDeletePassword())
+                    .isFalse();
+            assertThat(findReply(otherView, memberAnonymousReply.commentId()).canDelete())
+                    .isFalse();
         }
     }
 
@@ -315,6 +370,14 @@ private CommentResponse createGuestAnonymousComment(String content, String passw
                 "127.0.0.1");
     }
 
+    private CommentResponse createMemberAnonymousComment(Long parentId, String content) {
+        return commentService.createComment(
+                postResponse.publicId(),
+                new CommentCreateRequest(parentId, content, true, null),
+                writerDetails,
+                "127.0.0.1");
+    }
+
     private CommentResponse createReply(Long parentId, String content) {
         return commentService.createComment(
                 postResponse.publicId(),
@@ -322,4 +385,25 @@ private CommentResponse createReply(Long parentId, String content) {
                 writerDetails,
                 "127.0.0.1");
     }
+
+    private void assertDeletePermission(
+            PostCommentListResponse response,
+            Long commentId,
+            boolean canDelete,
+            boolean requiresPassword) {
+        CommentResponse comment =
+                response.comments().stream()
+                        .filter(item -> item.commentId().equals(commentId))
+                        .findFirst()
+                        .orElseThrow();
+        assertThat(comment.canDelete()).isEqualTo(canDelete);
+        assertThat(comment.requiresDeletePassword()).isEqualTo(requiresPassword);
+    }
+
+    private CommentResponse findReply(CommentReplyListResponse response, Long commentId) {
+        return response.replies().stream()
+                .filter(comment -> comment.commentId().equals(commentId))
+                .findFirst()
+                .orElseThrow();
+    }
 }
diff --git a/docs/conception/sprint03/comment_api_spec.md b/docs/conception/sprint03/comment_api_spec.md
index 41dbb80..06dfa5b 100644
--- a/docs/conception/sprint03/comment_api_spec.md
+++ b/docs/conception/sprint03/comment_api_spec.md
@@ -53,7 +53,7 @@ X-XSRF-TOKEN: {csrf_token}
 | 필드명 | 타입 | 필수 여부 | 설명 |
 | :--- | :---: | :---: | :--- |
 | `content` | String | **필수** | 댓글 본문 (1자 이상 1,000자 이하) |
-| `parentId` | Long | 선택 | 부모 댓글 ID. `null`이면 루트 댓글, 대댓글 작성 시 대상 댓글 ID 전달 (대댓글에 답글 시 서버에서 최상위 루트 ID로 자동 평탄화) |
+| `parentId` | String | 선택 | 부모 댓글 ID. `null`이면 루트 댓글, 대댓글 작성 시 대상 댓글 ID 전달 (대댓글에 답글 시 서버에서 최상위 루트 ID로 자동 평탄화) |
 | `isAnonymous` | Boolean | **필수** | 익명 작성 여부 (`true` / `false`) |
 | `anonymousPassword` | String | 조건부 필수 | 비로그인 익명 작성 시 필수 (4자 이상 20자 이하) |
 
@@ -88,6 +88,8 @@ X-XSRF-TOKEN: {csrf_token}
 
 게시글 상세 화면에서 루트 댓글 20개와 각 루트 댓글 하위의 대댓글 상위 5개를 일괄 조회합니다.
 
+삭제된 루트 댓글과 대댓글도 `"삭제된 댓글입니다."` placeholder로 노출하며, `replyCount`와 대댓글 목록은 삭제된 항목을 포함한 전체 수를 기준으로 합니다.
+
 - **HTTP Method**: `GET`
 - **URI**: `/api/v1/posts/{publicId}/comments`
 - **인증 요구사항**: 없음 (Public)
@@ -95,7 +97,7 @@ X-XSRF-TOKEN: {csrf_token}
 #### Request Query Parameters
 | 파라미터명 | 타입 | 기본값 | 설명 |
 | :--- | :---: | :---: | :--- |
-| `cursor` | Long | `null` | 커서 페이징용 마지막 루트 댓글 ID (`commentId`). 첫 페이지 조회 시 생략 |
+| `cursor` | String | `null` | 커서 페이징용 마지막 루트 댓글 ID (`commentId`). 첫 페이지 조회 시 생략 |
 | `size` | Integer | `20` | 조회할 루트 댓글 수 (기본 20개, 최대 50개) |
 
 #### Response (200 OK)
@@ -116,6 +118,8 @@ X-XSRF-TOKEN: {csrf_token}
       "writerIp": "211.234.***.***",
       "content": "하이원 아테나 슬로프 오픈했나요?",
       "isDeleted": false,
+      "canDelete": true,
+      "requiresDeletePassword": false,
       "replyCount": 8,
       "previewReplies": [
         {
@@ -130,6 +134,8 @@ X-XSRF-TOKEN: {csrf_token}
           "writerIp": "175.120.***.***",
           "content": "네 오늘 오전 9시에 오픈했습니다!",
           "isDeleted": false,
+          "canDelete": false,
+          "requiresDeletePassword": false,
           "createdAt": "2026-09-01T15:32:00"
         }
       ],
@@ -170,6 +176,9 @@ X-XSRF-TOKEN: {csrf_token}
 }
 ```
 
+- `canDelete`: 현재 요청자가 해당 댓글을 삭제할 수 있는지 나타냅니다. 로그인 익명 댓글도 작성자 세션이 일치하거나 관리자인 경우에만 `true`입니다.
+- `requiresDeletePassword`: 삭제 시 익명 비밀번호가 필요한지 나타냅니다. 비회원 익명 댓글에만 `true`이며, 로그인 익명 작성자의 회원 식별자는 응답에 노출하지 않습니다.
+
 ---
 
 ### 3. 대댓글 목록 분리 페이징 조회 (Read Separated Replies)
@@ -183,7 +192,7 @@ X-XSRF-TOKEN: {csrf_token}
 #### Request Query Parameters
 | 파라미터명 | 타입 | 기본값 | 설명 |
 | :--- | :---: | :---: | :--- |
-| `cursor` | Long | `null` | 커서 페이징용 마지막 대댓글 ID (`commentId`). 첫 더보기 호출 시 5번째 프리뷰 대댓글의 ID를 전달 |
+| `cursor` | String | `null` | 커서 페이징용 마지막 대댓글 ID (`commentId`). 첫 더보기 호출 시 5번째 프리뷰 대댓글의 ID를 전달 |
 | `size` | Integer | `20` | 조회할 대댓글 수 (기본 20개, 최대 50개) |
 
 #### Response (200 OK)
diff --git a/docs/conception/sprint03/comment_policy.md b/docs/conception/sprint03/comment_policy.md
index f712d27..8a7cdf0 100644
--- a/docs/conception/sprint03/comment_policy.md
+++ b/docs/conception/sprint03/comment_policy.md
@@ -26,12 +26,12 @@
 - **삭제된 루트 댓글에 신규 대댓글 작성**: **허용**. (대화 맥락 유지를 위해 삭제된 부모 밑에도 신규 답글 작성 가능)
 - **삭제된 대댓글 노출**: 대댓글 삭제 시에도 `"삭제된 댓글입니다."` placeholder로 대체 노출 (`is_deleted = true`).
 - **부모 + 자식 모두 삭제된 노드(고아 노드)**:
-  - 루트 댓글이 삭제되고, 그 하위의 모든 대댓글도 삭제된 경우 **화면(클라이언트 응답 목록)에서 완전히 숨김(은닉)** 처리합니다.
+  - 루트 댓글과 대댓글이 모두 삭제된 경우에도 각 댓글을 tombstone placeholder로 계속 노출합니다.
 - **`post.commentCount` (게시글 총 댓글 수)**:
-  - **"삭제된 댓글입니다"를 제외한 실제 살아있는 활성 댓글/대댓글(`is_deleted = false`)의 총합**만 카운트합니다.
-  - Soft Delete 실행 시 즉시 `comment_count - 1` 벌크 차감.
+  - 삭제된 댓글을 포함한 게시글의 전체 댓글/대댓글 수를 카운트합니다.
+  - Soft Delete 시 카운트를 차감하지 않고, 댓글 생성 시에만 증가시킵니다.
 - **`replyCount` (대댓글 수)**:
-  - 각 루트 댓글 DTO에 포함되는 `replyCount`는 **삭제된 대댓글을 제외한 실제 활성 대댓글 수**만 집계합니다.
+  - 각 루트 댓글 DTO에 포함되는 `replyCount`는 삭제된 대댓글을 포함한 전체 대댓글 수를 집계합니다.
 
 ---
 
diff --git a/docs/project/work.md b/docs/project/work.md
index a455504..840adba 100644
--- a/docs/project/work.md
+++ b/docs/project/work.md
@@ -849,3 +849,43 @@
   1. `docs/conception/sprint03/` 하위 Spike 결과 문서 3개를 `git mv`로 이름 변경.
   2. 공식 기술부채 해결 문서와 로컬 학습 문서의 기준 문서명을 새 파일명으로 갱신.
 - 이슈/주의: `.idea/workspace.xml`에도 기존 파일명 참조가 있으나 IDE 로컬 상태 파일이므로 커밋 대상에서 제외.
+
+- **댓글 동시 삭제 카운트 중복 차감 방지 (2026-09-06)**:
+  - 삭제를 `is_deleted = false` 조건부 UPDATE로 원자화했습니다.
+  - 영향 행이 1인 최초 삭제 요청만 `post.commentCount`를 차감하며, 동시 요청에서 영향 행이 0이면 카운트를 차감하지 않습니다.
+
+- **Sprint 03 로그인 익명 댓글 삭제 UI 권한 정합성 보강 (2026-09-06)**:
+  - 댓글 조회 응답에 요청자 기준 `canDelete`, `requiresDeletePassword`를 추가했습니다. 로그인 익명 작성자의 내부 식별자는 `ownerPublicId`로만 판정하고 `@JsonIgnore`로 외부 응답에서 제외했습니다.
+  - 일반 회원 본인, 로그인 익명 본인, 비회원 익명, 관리자, 타 회원, 삭제 댓글을 삭제 권한 매트릭스와 동일하게 판정하며 루트 프리뷰와 분리 대댓글에도 적용했습니다.
+  - 프런트엔드의 `writer` 기반 `isOwnerAnonMember` 추정을 제거하고, 삭제 버튼과 비밀번호 입력 여부를 각각 서버의 `canDelete`, `requiresDeletePassword`로 결정하도록 변경했습니다.
+  - `CommentDeleteTest`에 작성자별 권한 매트릭스와 분리 대댓글 권한 테스트를, `CommentControllerTest`에 로그인 익명 작성자의 응답 권한 및 내부 식별자 비노출 테스트를 추가했습니다.
+  - 검증 결과: `CommentDeleteTest`, `CommentReadTest`, 백엔드 `spotlessCheck`, 변경 프런트 파일 ESLint, `npm run build`가 통과했습니다. 기존 게시글 이미지의 `<img>` 관련 ESLint 경고 1건은 남아 있습니다.
+- **댓글 삭제 후 대댓글 페이징 상태 초기화 (2026-09-06)**:
+  - 삭제 성공 후 루트 댓글을 재조회할 때 기존 `replyPagingByRootId`도 함께 초기화해 이전 커서·더보기 상태가 새 미리보기와 섞이지 않도록 수정했습니다.
+
+- **댓글 조회 실패 상태 및 재시도 UI 보강 (2026-09-06)**:
+  - 최초 댓글 조회의 로딩·성공 빈 목록·실패 상태를 분리해 서버 오류가 빈 목록처럼 표시되지 않도록 수정했습니다.
+  - 최초 조회 실패 시 오류 메시지와 재시도 버튼을 표시하고, 재시도 중에는 중복 요청을 막는 로딩 상태를 적용했습니다.
+  - 댓글 더보기 실패 시 이미 조회한 댓글을 유지하면서 오류 메시지와 더보기 재시도 버튼을 표시하도록 구현했습니다.
+  - HTTP 비정상 응답도 실패로 처리하며 서버 오류 메시지가 없으면 기본 안내 문구를 사용하도록 보강했습니다.
+  - 검증 결과: 변경 파일 ESLint는 오류 없이 통과했으며 기존 `<img>` 최적화 경고 1건만 남았습니다. `npm run build`도 통과했습니다.
+
+- **대댓글 생성 락 순서 및 조회 비용 개선 (2026-09-06)**:
+  - 요청된 부모 댓글은 일반 조회로 식별하고, 최상위 루트 댓글 한 행에만 비관적 쓰기 락을 획득하도록 락 지점을 단일화했습니다.
+  - 루트의 활성 대댓글 ID 전체를 잠그고 애플리케이션에서 개수를 세던 `findActiveReplyIdsForUpdate()`를 제거하고, 루트 락을 보유한 트랜잭션 안에서 `countActiveReplies()`를 실행하도록 변경했습니다.
+  - 같은 루트의 서로 다른 대댓글을 부모로 지정한 두 동시 요청이 모두 데드락 없이 저장되는 회귀 테스트를 추가했습니다.
+  - 기존 99개 상한 경계 동시성 테스트를 포함한 `CommentCreateTest`와 백엔드 `spotlessCheck`가 통과했습니다.
+- **댓글 식별자·커서 프론트 정밀도 보호 (2026-09-06)**:
+  - 댓글 응답의 `Long` 식별자와 커서를 JSON 문자열로 직렬화하고 프론트 상태를 `string`으로 변경했습니다.
+  - JavaScript `number`의 `MAX_SAFE_INTEGER` 초과 시 댓글 수정·삭제 및 커서가 손상되는 문제를 방지했습니다.
+- **댓글 삭제 tombstone 및 카운트 정책 단순화 (2026-09-06)**:
+  - 삭제된 루트와 대댓글을 모두 tombstone으로 계속 노출하고, 루트가 모든 자식과 함께 삭제되어도 목록에서 숨기지 않도록 정책을 변경했습니다.
+  - `post.commentCount`, `replyCount`, `totalReplyCount`, 프리뷰·대댓글 목록을 삭제 포함 전체 댓글 기준으로 통일했습니다.
+  - 대댓글 100개 작성 제한 검증은 삭제 댓글이 한도를 영구 점유하지 않도록 활성 대댓글 수 기준을 유지했습니다.
+  - 삭제 시 게시글 댓글 수를 차감하지 않도록 서비스와 테스트를 갱신했습니다.
+
+- **댓글 대댓글 조회 게시글 공개 상태 검증 보강 (2026-09-06)**:
+  - `getCommentReplies`가 루트 댓글 여부만 확인하던 문제를 수정하고, 루트 댓글의 게시글을 조회해 삭제 여부와 `PostStatus.NORMAL`을 공통 검증하도록 변경했다.
+  - 게시글 댓글 목록과 대댓글 조회가 동일한 `POST_NOT_FOUND` 정책을 사용하도록 `validatePostVisibility`를 적용했다.
+  - 삭제·차단 게시글의 대댓글 조회가 `POST_NOT_FOUND`로 차단되는 통합 테스트를 `CommentReadTest`에 추가했다.
+  - 검증: `spotlessApply` 및 `CommentReadTest` 성공. 테스트 DB 환경변수 미설정 상태에서는 실제 MySQL 테스트 실행이 보류됨.
diff --git a/frontend/app/lib/api.ts b/frontend/app/lib/api.ts
index 19f8284..41accdb 100644
--- a/frontend/app/lib/api.ts
+++ b/frontend/app/lib/api.ts
@@ -22,16 +22,16 @@ export const API_ENDPOINTS = {
     update: (publicId: string) => `${API_V1_URL}/posts/${publicId}`,
     delete: (publicId: string) => `${API_V1_URL}/posts/${publicId}`,
     reactions: (publicId: string) => `${API_V1_URL}/posts/${publicId}/reactions`,
-    comments: (publicId: string, cursor?: number | null, size = 20) =>
+    comments: (publicId: string, cursor?: string | null, size = 20) =>
       `${API_V1_URL}/posts/${publicId}/comments?${
         cursor != null ? `cursor=${cursor}&size=${size}` : `size=${size}`
       }`,
   },
   comments: {
-    replies: (commentId: number | string, cursor?: number | null, size = 20) =>
+    replies: (commentId: string, cursor?: string | null, size = 20) =>
       `${API_V1_URL}/comments/${commentId}/replies?${
         cursor != null ? `cursor=${cursor}&size=${size}` : `size=${size}`
       }`,
-    delete: (commentId: number | string) => `${API_V1_URL}/comments/${commentId}`,
+    delete: (commentId: string) => `${API_V1_URL}/comments/${commentId}`,
   },
 } as const;
diff --git a/frontend/app/posts/[publicId]/page.tsx b/frontend/app/posts/[publicId]/page.tsx
index f4b2637..3d9781e 100644
--- a/frontend/app/posts/[publicId]/page.tsx
+++ b/frontend/app/posts/[publicId]/page.tsx
@@ -38,8 +38,8 @@ interface PostDetail {
 }
 
 interface CommentItem {
-  commentId: number;
-  parentId: number | null;
+  commentId: string;
+  parentId: string | null;
   writer: WriterInfo | null;
   isAnonymous: boolean;
   writerIp: string;
@@ -48,6 +48,8 @@ interface CommentItem {
   replyCount: number;
   previewReplies: CommentItem[];
   hasMoreReplies: boolean;
+  canDelete: boolean;
+  requiresDeletePassword: boolean;
   createdAt: string;
 }
 
@@ -55,26 +57,26 @@ interface CommentListResponse {
   publicId: string;
   totalCommentCount: number;
   comments: CommentItem[];
-  nextCursor: number | null;
+  nextCursor: string | null;
   hasNext: boolean;
 }
 
 interface CommentReplyListResponse {
-  rootCommentId: number;
+  rootCommentId: string;
   totalReplyCount: number;
   replies: CommentItem[];
-  nextCursor: number | null;
+  nextCursor: string | null;
   hasNext: boolean;
 }
 
 interface ReplyPagingState {
-  nextCursor: number | null;
+  nextCursor: string | null;
   hasNext: boolean;
   loading: boolean;
 }
 
 interface CommentUpdateResponse {
-  commentId: number;
+  commentId: string;
   content: string;
   updatedAt: string;
 }
@@ -85,26 +87,29 @@ export default function PostDetailPage({ params }: { params: Promise<{ publicId:
   const [post, setPost] = useState<PostDetail | null>(null);
   const [comments, setComments] = useState<CommentItem[]>([]);
   const [totalCommentCount, setTotalCommentCount] = useState(0);
-  const [commentNextCursor, setCommentNextCursor] = useState<number | null>(null);
+  const [commentNextCursor, setCommentNextCursor] = useState<string | null>(null);
   const [hasNextComments, setHasNextComments] = useState(false);
+  const [isLoadingComments, setIsLoadingComments] = useState(true);
+  const [commentLoadError, setCommentLoadError] = useState("");
+  const [loadMoreCommentError, setLoadMoreCommentError] = useState("");
   const [isLoadingMoreComments, setIsLoadingMoreComments] = useState(false);
-  const [replyPagingByRootId, setReplyPagingByRootId] = useState<Record<number, ReplyPagingState>>({});
+  const [replyPagingByRootId, setReplyPagingByRootId] = useState<Record<string, ReplyPagingState>>({});
   const [loading, setLoading] = useState(true);
   const [errorMsg, setErrorMsg] = useState("");
   const [reactionMsg, setReactionMsg] = useState("");
   const [newCommentText, setNewCommentText] = useState("");
   const [commentAnonPassword, setCommentAnonPassword] = useState("");
   const [submittingComment, setSubmittingComment] = useState(false);
-  const [activeReplyParentId, setActiveReplyParentId] = useState<number | null>(null);
+  const [activeReplyParentId, setActiveReplyParentId] = useState<string | null>(null);
   const [replyMentionName, setReplyMentionName] = useState<string | null>(null);
   const [replyText, setReplyText] = useState("");
   const [replyAnonPassword, setReplyAnonPassword] = useState("");
-  const [activeEditCommentId, setActiveEditCommentId] = useState<number | null>(null);
+  const [activeEditCommentId, setActiveEditCommentId] = useState<string | null>(null);
   const [editCommentText, setEditCommentText] = useState("");
   const [editCommentPassword, setEditCommentPassword] = useState("");
   const [editCommentError, setEditCommentError] = useState("");
   const [submittingEditComment, setSubmittingEditComment] = useState(false);
-  const [activeDeleteCommentId, setActiveDeleteCommentId] = useState<number | null>(null);
+  const [activeDeleteCommentId, setActiveDeleteCommentId] = useState<string | null>(null);
   const [deleteCommentPassword, setDeleteCommentPassword] = useState("");
   const [deleteCommentError, setDeleteCommentError] = useState("");
   const [submittingDeleteComment, setSubmittingDeleteComment] = useState(false);
@@ -159,24 +164,43 @@ export default function PostDetailPage({ params }: { params: Promise<{ publicId:
     }
   };
 
-  const fetchComments = useCallback(async (cursor: number | null = null, append = false) => {
+  const fetchComments = useCallback(async (cursor: string | null = null, append = false) => {
+    if (append) {
+      setLoadMoreCommentError("");
+    } else {
+      setIsLoadingComments(true);
+      setCommentLoadError("");
+    }
+
     try {
       const res = await fetch(API_ENDPOINTS.posts.comments(publicId, cursor), { credentials: "include" });
-      if (res.ok) {
-        const data: CommentListResponse = await res.json();
-        setComments((current) => {
-          if (!append) return data.comments || [];
-          const merged = [...current, ...(data.comments || [])];
-          return merged.filter(
-            (comment, index) => merged.findIndex((candidate) => candidate.commentId === comment.commentId) === index,
-          );
-        });
-        setTotalCommentCount(data.totalCommentCount || 0);
-        setCommentNextCursor(data.nextCursor ?? null);
-        setHasNextComments(Boolean(data.hasNext));
+
+      if (!res.ok) {
+        const errorData = await res.json().catch(() => null);
+        throw new Error(errorData?.message || "댓글을 불러오지 못했습니다.");
       }
+
+      const data: CommentListResponse = await res.json();
+      setComments((current) => {
+        if (!append) return data.comments || [];
+        const merged = [...current, ...(data.comments || [])];
+        return merged.filter(
+          (comment, index) => merged.findIndex((candidate) => candidate.commentId === comment.commentId) === index,
+        );
+      });
+      setTotalCommentCount(data.totalCommentCount || 0);
+      setCommentNextCursor(data.nextCursor ?? null);
+      setHasNextComments(Boolean(data.hasNext));
     } catch (error) {
       console.error("댓글 로드 실패:", error);
+      const message = error instanceof Error ? error.message : "서버 통신 중 오류가 발생했습니다.";
+      if (append) {
+        setLoadMoreCommentError(message);
+      } else {
+        setCommentLoadError(message);
+      }
+    } finally {
+      if (!append) setIsLoadingComments(false);
     }
   }, [publicId]);
 
@@ -191,7 +215,7 @@ export default function PostDetailPage({ params }: { params: Promise<{ publicId:
     }
   };
 
-  const handleLoadMoreReplies = async (rootCommentId: number) => {
+  const handleLoadMoreReplies = async (rootCommentId: string) => {
     const root = comments.find((comment) => comment.commentId === rootCommentId);
     if (!root) return;
 
@@ -317,7 +341,7 @@ export default function PostDetailPage({ params }: { params: Promise<{ publicId:
 
   const isAnonymousPost = Boolean(post?.isAnonymous || post?.categoryCode === "ANONYMOUS");
 
-  const handleCreateComment = async (parentId: number | null) => {
+  const handleCreateComment = async (parentId: string | null) => {
     const text = parentId ? replyText : newCommentText;
     if (!text.trim()) {
       alert("댓글 내용을 입력해주세요.");
@@ -470,7 +494,7 @@ export default function PostDetailPage({ params }: { params: Promise<{ publicId:
     }
   };
 
-  const handleStartDeleteComment = (commentId: number) => {
+  const handleStartDeleteComment = (commentId: string) => {
     setActiveDeleteCommentId(commentId);
     setDeleteCommentPassword("");
     setDeleteCommentError("");
@@ -483,11 +507,7 @@ export default function PostDetailPage({ params }: { params: Promise<{ publicId:
   };
 
   const handleConfirmDeleteComment = async (comment: CommentItem) => {
-    const isOwnerMember = !comment.isAnonymous && currentUserPublicId && comment.writer?.publicId === currentUserPublicId;
-    const isOwnerAnonMember = comment.isAnonymous && currentUserPublicId && comment.writer?.publicId === currentUserPublicId;
-    const requiresPassword = !isAdmin && !isOwnerMember && !isOwnerAnonMember;
-
-    if (requiresPassword && !deleteCommentPassword.trim()) {
+    if (comment.requiresDeletePassword && !deleteCommentPassword.trim()) {
       setDeleteCommentError("비밀번호를 입력해주세요.");
       return;
     }
@@ -507,6 +527,7 @@ export default function PostDetailPage({ params }: { params: Promise<{ publicId:
       }
 
       handleCancelDeleteComment();
+      setReplyPagingByRootId({});
       await fetchComments();
       setPost((current) => (current ? { ...current, commentCount: Math.max(0, current.commentCount - 1) } : current));
     } catch (error) {
@@ -653,7 +674,22 @@ export default function PostDetailPage({ params }: { params: Promise<{ publicId:
             </div>
 
             <div className="grid gap-4">
-              {comments.length === 0 ? (
+              {isLoadingComments ? (
+                <p role="status" className="py-8 text-center text-sm text-[var(--snow-muted)]">
+                  댓글을 불러오는 중입니다.
+                </p>
+              ) : commentLoadError ? (
+                <div role="alert" className="grid justify-items-center gap-3 py-8 text-center">
+                  <p className="text-sm text-red-600">{commentLoadError}</p>
+                  <button
+                    type="button"
+                    onClick={() => void fetchComments()}
+                    className="snow-btn-secondary"
+                  >
+                    다시 시도
+                  </button>
+                </div>
+              ) : comments.length === 0 ? (
                 <p className="py-8 text-center text-sm text-[var(--snow-muted)]">첫 댓글을 작성해보세요.</p>
               ) : (
                 comments.map((comment) => (
@@ -689,7 +725,6 @@ export default function PostDetailPage({ params }: { params: Promise<{ publicId:
                     handleStartDeleteComment={handleStartDeleteComment}
                     handleCancelDeleteComment={handleCancelDeleteComment}
                     handleConfirmDeleteComment={handleConfirmDeleteComment}
-                    isAdmin={isAdmin}
                     handleLoadMoreReplies={handleLoadMoreReplies}
                     isLoadingReplies={Boolean(replyPagingByRootId[comment.commentId]?.loading)}
                   />
@@ -697,15 +732,26 @@ export default function PostDetailPage({ params }: { params: Promise<{ publicId:
               )}
             </div>
 
-            {hasNextComments && (
-              <button
-                type="button"
-                disabled={isLoadingMoreComments}
-                onClick={() => void handleLoadMoreComments()}
-                className="snow-btn-secondary mt-6 w-full"
-              >
-                {isLoadingMoreComments ? "댓글을 불러오는 중..." : "댓글 더보기 (20개)"}
-              </button>
+            {!isLoadingComments && !commentLoadError && hasNextComments && (
+              <div className="mt-6 grid gap-2">
+                {loadMoreCommentError && (
+                  <p role="alert" className="text-center text-sm text-red-600">
+                    {loadMoreCommentError}
+                  </p>
+                )}
+                <button
+                  type="button"
+                  disabled={isLoadingMoreComments}
+                  onClick={() => void handleLoadMoreComments()}
+                  className="snow-btn-secondary w-full"
+                >
+                  {isLoadingMoreComments
+                    ? "댓글을 불러오는 중..."
+                    : loadMoreCommentError
+                      ? "댓글 더보기 다시 시도"
+                      : "댓글 더보기 (20개)"}
+                </button>
+              </div>
             )}
           </section>
         </div>
@@ -755,23 +801,22 @@ function CommentRow({
   handleStartDeleteComment,
   handleCancelDeleteComment,
   handleConfirmDeleteComment,
-  isAdmin,
   handleLoadMoreReplies,
   isLoadingReplies,
 }: {
   item: CommentItem;
   isAnonymousPost: boolean;
   currentUserPublicId: string | null;
-  activeReplyParentId: number | null;
-  setActiveReplyParentId: (id: number | null) => void;
+  activeReplyParentId: string | null;
+  setActiveReplyParentId: (id: string | null) => void;
   replyMentionName: string | null;
   setReplyMentionName: (name: string | null) => void;
   replyText: string;
   setReplyText: (text: string) => void;
   replyAnonPassword: string;
   setReplyAnonPassword: (value: string) => void;
-  handleCreateComment: (parentId: number | null) => Promise<void>;
-  activeEditCommentId: number | null;
+  handleCreateComment: (parentId: string | null) => Promise<void>;
+  activeEditCommentId: string | null;
   editCommentText: string;
   setEditCommentText: (text: string) => void;
   editCommentPassword: string;
@@ -781,20 +826,19 @@ function CommentRow({
   handleStartEditComment: (comment: CommentItem) => void;
   handleCancelEditComment: () => void;
   handleUpdateComment: (comment: CommentItem) => Promise<void>;
-  activeDeleteCommentId: number | null;
+  activeDeleteCommentId: string | null;
   deleteCommentPassword: string;
   setDeleteCommentPassword: (password: string) => void;
   deleteCommentError: string;
   submittingDeleteComment: boolean;
-  handleStartDeleteComment: (commentId: number) => void;
+  handleStartDeleteComment: (commentId: string) => void;
   handleCancelDeleteComment: () => void;
   handleConfirmDeleteComment: (comment: CommentItem) => Promise<void>;
-  isAdmin: boolean;
-  handleLoadMoreReplies: (rootCommentId: number) => Promise<void>;
+  handleLoadMoreReplies: (rootCommentId: string) => Promise<void>;
   isLoadingReplies: boolean;
 }) {
   const canEdit = canEditComment(item, currentUserPublicId);
-  const canDelete = canDeleteComment(item, currentUserPublicId, isAdmin);
+  const canDelete = canDeleteComment(item);
   const isEditing = activeEditCommentId === item.commentId;
   const openReplyEditor = (target: CommentItem) => {
     if (activeReplyParentId === item.commentId && replyMentionName === getWriterName(target)) {
@@ -816,8 +860,6 @@ function CommentRow({
             {canDelete && (
               <CommentDeleteInline
                 comment={item}
-                currentUserPublicId={currentUserPublicId}
-                isAdmin={isAdmin}
                 isActive={activeDeleteCommentId === item.commentId}
                 onOpen={() => handleStartDeleteComment(item.commentId)}
                 onClose={handleCancelDeleteComment}
@@ -885,7 +927,6 @@ function CommentRow({
                 handleStartDeleteComment={handleStartDeleteComment}
                 handleCancelDeleteComment={handleCancelDeleteComment}
                 handleConfirmDeleteComment={handleConfirmDeleteComment}
-                isAdmin={isAdmin}
               />
             ))}
           </div>
@@ -972,7 +1013,6 @@ function ReplyRow({
   handleStartDeleteComment,
   handleCancelDeleteComment,
   handleConfirmDeleteComment,
-  isAdmin,
 }: {
   item: CommentItem;
   onReply: () => void;
@@ -987,18 +1027,17 @@ function ReplyRow({
   handleStartEditComment: (comment: CommentItem) => void;
   handleCancelEditComment: () => void;
   handleUpdateComment: (comment: CommentItem) => Promise<void>;
-  activeDeleteCommentId: number | null;
+  activeDeleteCommentId: string | null;
   deleteCommentPassword: string;
   setDeleteCommentPassword: (password: string) => void;
   deleteCommentError: string;
   submittingDeleteComment: boolean;
-  handleStartDeleteComment: (commentId: number) => void;
+  handleStartDeleteComment: (commentId: string) => void;
   handleCancelDeleteComment: () => void;
   handleConfirmDeleteComment: (comment: CommentItem) => Promise<void>;
-  isAdmin: boolean;
 }) {
   const canEdit = canEditComment(item, currentUserPublicId);
-  const canDelete = canDeleteComment(item, currentUserPublicId, isAdmin);
+  const canDelete = canDeleteComment(item);
 
   return (
     <div className="ml-5 border-l-2 border-black pl-5">
@@ -1011,8 +1050,6 @@ function ReplyRow({
           {canDelete && (
             <CommentDeleteInline
               comment={item}
-              currentUserPublicId={currentUserPublicId}
-              isAdmin={isAdmin}
               isActive={activeDeleteCommentId === item.commentId}
               onOpen={() => handleStartDeleteComment(item.commentId)}
               onClose={handleCancelDeleteComment}
@@ -1138,7 +1175,7 @@ function canEditComment(comment: CommentItem, currentUserPublicId: string | null
   return Boolean(currentUserPublicId && comment.writer?.publicId === currentUserPublicId);
 }
 
-function updateCommentContent(comments: CommentItem[], commentId: number, content: string) {
+function updateCommentContent(comments: CommentItem[], commentId: string, content: string) {
   return comments.map((comment) => {
     if (comment.commentId === commentId) return { ...comment, content };
     return {
@@ -1152,8 +1189,6 @@ function updateCommentContent(comments: CommentItem[], commentId: number, conten
 
 function CommentDeleteInline({
   comment,
-  currentUserPublicId,
-  isAdmin,
   isActive,
   onOpen,
   onClose,
@@ -1164,8 +1199,6 @@ function CommentDeleteInline({
   onConfirm,
 }: {
   comment: CommentItem;
-  currentUserPublicId: string | null;
-  isAdmin: boolean;
   isActive: boolean;
   onOpen: () => void;
   onClose: () => void;
@@ -1175,10 +1208,6 @@ function CommentDeleteInline({
   submitting: boolean;
   onConfirm: () => void;
 }) {
-  const isOwnerMember = !comment.isAnonymous && currentUserPublicId && comment.writer?.publicId === currentUserPublicId;
-  const isOwnerAnonMember = comment.isAnonymous && currentUserPublicId && comment.writer?.publicId === currentUserPublicId;
-  const requiresPassword = !isAdmin && !isOwnerMember && !isOwnerAnonMember;
-
   return (
     <div className="relative inline-flex items-center">
       <button
@@ -1199,7 +1228,7 @@ function CommentDeleteInline({
 
           {/* 시간 및 아이콘 바로 아래에 완벽하게 플로팅되는 팝오버 (레이아웃 밀림 0) */}
           <div className="absolute right-0 top-full mt-1.5 z-50 flex items-center bg-[#1c2e5c] border border-black shadow-xl rounded-xs">
-            {requiresPassword ? (
+            {comment.requiresDeletePassword ? (
               <input
                 type="password"
                 placeholder="비밀번호"
@@ -1264,9 +1293,6 @@ function formatCommentDate(dateString: string): string {
   }
 }
 
-function canDeleteComment(comment: CommentItem, currentUserPublicId: string | null, isAdmin: boolean): boolean {
-  if (comment.isDeleted) return false;
-  if (isAdmin) return true;
-  if (comment.isAnonymous) return true;
-  return Boolean(currentUserPublicId && comment.writer?.publicId === currentUserPublicId);
+function canDeleteComment(comment: CommentItem): boolean {
+  return comment.canDelete;
 }
diff --git a/frontend/tsconfig.tsbuildinfo b/frontend/tsconfig.tsbuildinfo
new file mode 100644
index 0000000..c29fe72
--- /dev/null
+++ b/frontend/tsconfig.tsbuildinfo
@@ -0,0 +1 @@
+{"fileNames":["./node_modules/typescript/lib/lib.es5.d.ts","./node_modules/typescript/lib/lib.es2015.d.ts","./node_modules/typescript/lib/lib.es2016.d.ts","./node_modules/typescript/lib/lib.es2017.d.ts","./node_modules/typescript/lib/lib.es2018.d.ts","./node_modules/typescript/lib/lib.es2019.d.ts","./node_modules/typescript/lib/lib.es2020.d.ts","./node_modules/typescript/lib/lib.es2021.d.ts","./node_modules/typescript/lib/lib.es2022.d.ts","./node_modules/typescript/lib/lib.es2023.d.ts","./node_modules/typescript/lib/lib.es2024.d.ts","./node_modules/typescript/lib/lib.es2025.d.ts","./node_modules/typescript/lib/lib.esnext.d.ts","./node_modules/typescript/lib/lib.dom.d.ts","./node_modules/typescript/lib/lib.dom.iterable.d.ts","./node_modules/typescript/lib/lib.es2015.core.d.ts","./node_modules/typescript/lib/lib.es2015.collection.d.ts","./node_modules/typescript/lib/lib.es2015.generator.d.ts","./node_modules/typescript/lib/lib.es2015.iterable.d.ts","./node_modules/typescript/lib/lib.es2015.promise.d.ts","./node_modules/typescript/lib/lib.es2015.proxy.d.ts","./node_modules/typescript/lib/lib.es2015.reflect.d.ts","./node_modules/typescript/lib/lib.es2015.symbol.d.ts","./node_modules/typescript/lib/lib.es2015.symbol.wellknown.d.ts","./node_modules/typescript/lib/lib.es2016.array.include.d.ts","./node_modules/typescript/lib/lib.es2016.intl.d.ts","./node_modules/typescript/lib/lib.es2017.arraybuffer.d.ts","./node_modules/typescript/lib/lib.es2017.date.d.ts","./node_modules/typescript/lib/lib.es2017.object.d.ts","./node_modules/typescript/lib/lib.es2017.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2017.string.d.ts","./node_modules/typescript/lib/lib.es2017.intl.d.ts","./node_modules/typescript/lib/lib.es2017.typedarrays.d.ts","./node_modules/typescript/lib/lib.es2018.asyncgenerator.d.ts","./node_modules/typescript/lib/lib.es2018.asynciterable.d.ts","./node_modules/typescript/lib/lib.es2018.intl.d.ts","./node_modules/typescript/lib/lib.es2018.promise.d.ts","./node_modules/typescript/lib/lib.es2018.regexp.d.ts","./node_modules/typescript/lib/lib.es2019.array.d.ts","./node_modules/typescript/lib/lib.es2019.object.d.ts","./node_modules/typescript/lib/lib.es2019.string.d.ts","./node_modules/typescript/lib/lib.es2019.symbol.d.ts","./node_modules/typescript/lib/lib.es2019.intl.d.ts","./node_modules/typescript/lib/lib.es2020.bigint.d.ts","./node_modules/typescript/lib/lib.es2020.date.d.ts","./node_modules/typescript/lib/lib.es2020.promise.d.ts","./node_modules/typescript/lib/lib.es2020.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2020.string.d.ts","./node_modules/typescript/lib/lib.es2020.symbol.wellknown.d.ts","./node_modules/typescript/lib/lib.es2020.intl.d.ts","./node_modules/typescript/lib/lib.es2020.number.d.ts","./node_modules/typescript/lib/lib.es2021.promise.d.ts","./node_modules/typescript/lib/lib.es2021.string.d.ts","./node_modules/typescript/lib/lib.es2021.weakref.d.ts","./node_modules/typescript/lib/lib.es2021.intl.d.ts","./node_modules/typescript/lib/lib.es2022.array.d.ts","./node_modules/typescript/lib/lib.es2022.error.d.ts","./node_modules/typescript/lib/lib.es2022.intl.d.ts","./node_modules/typescript/lib/lib.es2022.object.d.ts","./node_modules/typescript/lib/lib.es2022.string.d.ts","./node_modules/typescript/lib/lib.es2022.regexp.d.ts","./node_modules/typescript/lib/lib.es2023.array.d.ts","./node_modules/typescript/lib/lib.es2023.collection.d.ts","./node_modules/typescript/lib/lib.es2023.intl.d.ts","./node_modules/typescript/lib/lib.es2024.arraybuffer.d.ts","./node_modules/typescript/lib/lib.es2024.collection.d.ts","./node_modules/typescript/lib/lib.es2024.object.d.ts","./node_modules/typescript/lib/lib.es2024.promise.d.ts","./node_modules/typescript/lib/lib.es2024.regexp.d.ts","./node_modules/typescript/lib/lib.es2024.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2024.string.d.ts","./node_modules/typescript/lib/lib.es2025.collection.d.ts","./node_modules/typescript/lib/lib.es2025.float16.d.ts","./node_modules/typescript/lib/lib.es2025.intl.d.ts","./node_modules/typescript/lib/lib.es2025.iterator.d.ts","./node_modules/typescript/lib/lib.es2025.promise.d.ts","./node_modules/typescript/lib/lib.es2025.regexp.d.ts","./node_modules/typescript/lib/lib.esnext.array.d.ts","./node_modules/typescript/lib/lib.esnext.collection.d.ts","./node_modules/typescript/lib/lib.esnext.date.d.ts","./node_modules/typescript/lib/lib.esnext.decorators.d.ts","./node_modules/typescript/lib/lib.esnext.disposable.d.ts","./node_modules/typescript/lib/lib.esnext.error.d.ts","./node_modules/typescript/lib/lib.esnext.intl.d.ts","./node_modules/typescript/lib/lib.esnext.sharedmemory.d.ts","./node_modules/typescript/lib/lib.esnext.temporal.d.ts","./node_modules/typescript/lib/lib.esnext.typedarrays.d.ts","./node_modules/typescript/lib/lib.decorators.d.ts","./node_modules/typescript/lib/lib.decorators.legacy.d.ts","./node_modules/@types/react/global.d.ts","./node_modules/csstype/index.d.ts","./node_modules/@types/react/index.d.ts","./node_modules/next/dist/styled-jsx/types/css.d.ts","./node_modules/next/dist/styled-jsx/types/macro.d.ts","./node_modules/next/dist/styled-jsx/types/style.d.ts","./node_modules/next/dist/styled-jsx/types/global.d.ts","./node_modules/next/dist/styled-jsx/types/index.d.ts","./node_modules/next/dist/server/get-page-files.d.ts","./node_modules/@types/node/globals.typedarray.d.ts","./node_modules/@types/node/buffer.buffer.d.ts","./node_modules/@types/node/globals.d.ts","./node_modules/@types/node/web-globals/abortcontroller.d.ts","./node_modules/@types/node/web-globals/blob.d.ts","./node_modules/@types/node/web-globals/console.d.ts","./node_modules/@types/node/web-globals/crypto.d.ts","./node_modules/@types/node/web-globals/domexception.d.ts","./node_modules/@types/node/web-globals/encoding.d.ts","./node_modules/@types/node/web-globals/events.d.ts","./node_modules/undici-types/utility.d.ts","./node_modules/undici-types/header.d.ts","./node_modules/undici-types/readable.d.ts","./node_modules/undici-types/fetch.d.ts","./node_modules/undici-types/formdata.d.ts","./node_modules/undici-types/connector.d.ts","./node_modules/undici-types/client-stats.d.ts","./node_modules/undici-types/client.d.ts","./node_modules/undici-types/errors.d.ts","./node_modules/undici-types/dispatcher.d.ts","./node_modules/undici-types/global-dispatcher.d.ts","./node_modules/undici-types/global-origin.d.ts","./node_modules/undici-types/pool-stats.d.ts","./node_modules/undici-types/pool.d.ts","./node_modules/undici-types/handlers.d.ts","./node_modules/undici-types/balanced-pool.d.ts","./node_modules/undici-types/round-robin-pool.d.ts","./node_modules/undici-types/h2c-client.d.ts","./node_modules/undici-types/agent.d.ts","./node_modules/undici-types/dispatcher1-wrapper.d.ts","./node_modules/undici-types/mock-interceptor.d.ts","./node_modules/undici-types/mock-call-history.d.ts","./node_modules/undici-types/mock-agent.d.ts","./node_modules/undici-types/mock-client.d.ts","./node_modules/undici-types/mock-pool.d.ts","./node_modules/undici-types/snapshot-agent.d.ts","./node_modules/undici-types/mock-errors.d.ts","./node_modules/undici-types/proxy-agent.d.ts","./node_modules/undici-types/socks5-proxy-agent.d.ts","./node_modules/undici-types/env-http-proxy-agent.d.ts","./node_modules/undici-types/retry-handler.d.ts","./node_modules/undici-types/retry-agent.d.ts","./node_modules/undici-types/api.d.ts","./node_modules/undici-types/cache-interceptor.d.ts","./node_modules/undici-types/interceptors.d.ts","./node_modules/undici-types/util.d.ts","./node_modules/undici-types/cookies.d.ts","./node_modules/undici-types/patch.d.ts","./node_modules/undici-types/websocket.d.ts","./node_modules/undici-types/eventsource.d.ts","./node_modules/undici-types/diagnostics-channel.d.ts","./node_modules/undici-types/content-type.d.ts","./node_modules/undici-types/cache.d.ts","./node_modules/undici-types/index.d.ts","./node_modules/@types/node/web-globals/fetch.d.ts","./node_modules/@types/node/web-globals/importmeta.d.ts","./node_modules/@types/node/web-globals/messaging.d.ts","./node_modules/@types/node/web-globals/navigator.d.ts","./node_modules/@types/node/web-globals/performance.d.ts","./node_modules/@types/node/web-globals/storage.d.ts","./node_modules/@types/node/web-globals/streams.d.ts","./node_modules/@types/node/web-globals/timers.d.ts","./node_modules/@types/node/web-globals/url.d.ts","./node_modules/@types/node/assert.d.ts","./node_modules/@types/node/assert/strict.d.ts","./node_modules/@types/node/async_hooks.d.ts","./node_modules/@types/node/buffer.d.ts","./node_modules/@types/node/child_process.d.ts","./node_modules/@types/node/cluster.d.ts","./node_modules/@types/node/console.d.ts","./node_modules/@types/node/constants.d.ts","./node_modules/@types/node/crypto.d.ts","./node_modules/@types/node/dgram.d.ts","./node_modules/@types/node/diagnostics_channel.d.ts","./node_modules/@types/node/dns.d.ts","./node_modules/@types/node/dns/promises.d.ts","./node_modules/@types/node/domain.d.ts","./node_modules/@types/node/events.d.ts","./node_modules/@types/node/ffi.d.ts","./node_modules/@types/node/fs.d.ts","./node_modules/@types/node/fs/promises.d.ts","./node_modules/@types/node/http.d.ts","./node_modules/@types/node/http2.d.ts","./node_modules/@types/node/https.d.ts","./node_modules/@types/node/inspector.d.ts","./node_modules/@types/node/inspector.generated.d.ts","./node_modules/@types/node/inspector/promises.d.ts","./node_modules/@types/node/module.d.ts","./node_modules/@types/node/net.d.ts","./node_modules/@types/node/os.d.ts","./node_modules/@types/node/path.d.ts","./node_modules/@types/node/path/posix.d.ts","./node_modules/@types/node/path/win32.d.ts","./node_modules/@types/node/perf_hooks.d.ts","./node_modules/@types/node/process.d.ts","./node_modules/@types/node/punycode.d.ts","./node_modules/@types/node/querystring.d.ts","./node_modules/@types/node/quic.d.ts","./node_modules/@types/node/readline.d.ts","./node_modules/@types/node/readline/promises.d.ts","./node_modules/@types/node/repl.d.ts","./node_modules/@types/node/sea.d.ts","./node_modules/@types/node/sqlite.d.ts","./node_modules/@types/node/stream.d.ts","./node_modules/@types/node/stream/consumers.d.ts","./node_modules/@types/node/stream/iter.d.ts","./node_modules/@types/node/stream/promises.d.ts","./node_modules/@types/node/stream/web.d.ts","./node_modules/@types/node/string_decoder.d.ts","./node_modules/@types/node/test.d.ts","./node_modules/@types/node/test/reporters.d.ts","./node_modules/@types/node/timers.d.ts","./node_modules/@types/node/timers/promises.d.ts","./node_modules/@types/node/tls.d.ts","./node_modules/@types/node/trace_events.d.ts","./node_modules/@types/node/tty.d.ts","./node_modules/@types/node/url.d.ts","./node_modules/@types/node/util.d.ts","./node_modules/@types/node/util/types.d.ts","./node_modules/@types/node/v8.d.ts","./node_modules/@types/node/vm.d.ts","./node_modules/@types/node/wasi.d.ts","./node_modules/@types/node/worker_threads.d.ts","./node_modules/@types/node/zlib.d.ts","./node_modules/@types/node/zlib/iter.d.ts","./node_modules/@types/node/index.d.ts","./node_modules/@types/react/canary.d.ts","./node_modules/@types/react/experimental.d.ts","./node_modules/@types/react-dom/index.d.ts","./node_modules/@types/react-dom/canary.d.ts","./node_modules/@types/react-dom/experimental.d.ts","./node_modules/next/dist/lib/fallback.d.ts","./node_modules/next/dist/compiled/webpack/webpack.d.ts","./node_modules/next/dist/shared/lib/modern-browserslist-target.d.ts","./node_modules/next/dist/shared/lib/entry-constants.d.ts","./node_modules/next/dist/shared/lib/constants.d.ts","./node_modules/next/dist/lib/bundler.d.ts","./node_modules/next/dist/server/config.d.ts","./node_modules/next/dist/lib/load-custom-routes.d.ts","./node_modules/next/dist/shared/lib/image-config.d.ts","./node_modules/next/dist/build/webpack/plugins/subresource-integrity-plugin.d.ts","./node_modules/next/dist/server/body-streams.d.ts","./node_modules/next/dist/server/request/search-params.d.ts","./node_modules/next/dist/shared/lib/segment-cache/vary-params-decoding.d.ts","./node_modules/next/dist/server/app-render/vary-params.d.ts","./node_modules/next/dist/server/request/params.d.ts","./node_modules/next/dist/server/route-kind.d.ts","./node_modules/next/dist/server/route-definitions/route-definition.d.ts","./node_modules/next/dist/server/route-matches/route-match.d.ts","./node_modules/next/dist/client/components/app-router-headers.d.ts","./node_modules/next/dist/server/lib/cache-control.d.ts","./node_modules/next/dist/shared/lib/app-router-types.d.ts","./node_modules/next/dist/server/lib/cache-handlers/types.d.ts","./node_modules/next/dist/server/use-cache/use-cache-wrapper.d.ts","./node_modules/next/dist/server/resume-data-cache/cache-store.d.ts","./node_modules/next/dist/server/resume-data-cache/resume-data-cache.d.ts","./node_modules/next/dist/lib/constants.d.ts","./node_modules/next/dist/server/render-result.d.ts","./node_modules/next/dist/server/response-cache/types.d.ts","./node_modules/next/dist/server/response-cache/index.d.ts","./node_modules/@types/react/jsx-runtime.d.ts","./node_modules/next/dist/next-devtools/userspace/pages/pages-dev-overlay-setup.d.ts","./node_modules/next/dist/build/static-paths/types.d.ts","./node_modules/next/dist/server/route-definitions/app-page-route-definition.d.ts","./node_modules/next/dist/build/adapter/setup-node-env.external.d.ts","./node_modules/next/dist/server/instrumentation/types.d.ts","./node_modules/next/dist/lib/setup-exception-listeners.d.ts","./node_modules/next/dist/lib/worker.d.ts","./node_modules/next/dist/server/lib/experimental/ppr.d.ts","./node_modules/next/dist/lib/page-types.d.ts","./node_modules/next/dist/build/segment-config/app/app-segment-config.d.ts","./node_modules/next/dist/build/segment-config/pages/pages-segment-config.d.ts","./node_modules/next/dist/build/analysis/get-page-static-info.d.ts","./node_modules/next/dist/build/webpack/loaders/get-module-build-info.d.ts","./node_modules/next/dist/build/webpack/plugins/middleware-plugin.d.ts","./node_modules/next/dist/server/require-hook.d.ts","./node_modules/next/dist/server/node-polyfill-crypto.d.ts","./node_modules/next/dist/server/node-environment-baseline.d.ts","./node_modules/next/dist/server/node-environment-extensions/error-inspect.d.ts","./node_modules/next/dist/server/node-environment-extensions/console-file.d.ts","./node_modules/next/dist/server/node-environment-extensions/console-exit.d.ts","./node_modules/next/dist/server/node-environment-extensions/console-dim.external.d.ts","./node_modules/next/dist/server/node-environment-extensions/unhandled-rejection.external.d.ts","./node_modules/next/dist/server/node-environment-extensions/random.d.ts","./node_modules/next/dist/server/node-environment-extensions/date.d.ts","./node_modules/next/dist/server/node-environment-extensions/web-crypto.d.ts","./node_modules/next/dist/server/node-environment-extensions/node-crypto.d.ts","./node_modules/next/dist/server/node-environment-extensions/fast-set-immediate.external.d.ts","./node_modules/next/dist/server/node-environment.d.ts","./node_modules/next/dist/build/page-extensions-type.d.ts","./node_modules/next/dist/server/route-modules/app-page/module.compiled.d.ts","./node_modules/next/dist/server/route-definitions/app-route-route-definition.d.ts","./node_modules/next/dist/server/lib/i18n-provider.d.ts","./node_modules/next/dist/server/web/next-url.d.ts","./node_modules/next/dist/compiled/@edge-runtime/cookies/index.d.ts","./node_modules/next/dist/server/web/spec-extension/cookies.d.ts","./node_modules/next/dist/server/web/spec-extension/request.d.ts","./node_modules/next/dist/shared/lib/deep-readonly.d.ts","./node_modules/next/dist/server/lib/incremental-cache/index.d.ts","./node_modules/next/dist/shared/lib/router/utils/middleware-route-matcher.d.ts","./node_modules/next/dist/build/webpack/plugins/flight-manifest-plugin.d.ts","./node_modules/next/dist/build/webpack/plugins/next-font-manifest-plugin.d.ts","./node_modules/next/dist/server/route-definitions/locale-route-definition.d.ts","./node_modules/next/dist/server/route-definitions/pages-route-definition.d.ts","./node_modules/next/dist/shared/lib/mitt.d.ts","./node_modules/next/dist/client/with-router.d.ts","./node_modules/next/dist/client/router.d.ts","./node_modules/next/dist/client/route-loader.d.ts","./node_modules/next/dist/client/page-loader.d.ts","./node_modules/next/dist/shared/lib/bloom-filter.d.ts","./node_modules/next/dist/shared/lib/router/router.d.ts","./node_modules/next/dist/shared/lib/router-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/loadable-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/loadable.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/image-config-context.shared-runtime.d.ts","./node_modules/next/dist/client/components/readonly-url-search-params.d.ts","./node_modules/next/dist/shared/lib/hooks-client-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/head-manager-context.shared-runtime.d.ts","./node_modules/next/dist/client/flight-data-helpers.d.ts","./node_modules/next/dist/client/components/segment-cache/cache-key.d.ts","./node_modules/next/dist/client/components/router-reducer/fetch-server-response.d.ts","./node_modules/next/dist/client/components/segment-cache/types.d.ts","./node_modules/next/dist/shared/lib/segment-cache/segment-value-encoding.d.ts","./node_modules/next/dist/client/components/segment-cache/scheduler.d.ts","./node_modules/next/dist/client/components/segment-cache/cache-map.d.ts","./node_modules/next/dist/client/components/segment-cache/vary-path.d.ts","./node_modules/next/dist/client/components/segment-cache/cache.d.ts","./node_modules/next/dist/client/components/router-reducer/ppr-navigations.d.ts","./node_modules/next/dist/client/components/segment-cache/navigation.d.ts","./node_modules/next/dist/client/components/router-reducer/router-reducer-types.d.ts","./node_modules/next/dist/shared/lib/app-router-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/server-inserted-html.shared-runtime.d.ts","./node_modules/next/dist/server/route-modules/pages/vendored/contexts/entrypoints.d.ts","./node_modules/next/dist/server/route-modules/pages/module.compiled.d.ts","./node_modules/next/dist/build/templates/pages.d.ts","./node_modules/next/dist/server/route-modules/pages/module.d.ts","./node_modules/next/dist/server/render.d.ts","./node_modules/next/dist/build/webpack/plugins/pages-manifest-plugin.d.ts","./node_modules/next/dist/server/route-definitions/pages-api-route-definition.d.ts","./node_modules/next/dist/server/route-matches/pages-api-route-match.d.ts","./node_modules/next/dist/server/route-matchers/route-matcher.d.ts","./node_modules/next/dist/server/route-matcher-providers/route-matcher-provider.d.ts","./node_modules/next/dist/server/route-matcher-managers/route-matcher-manager.d.ts","./node_modules/next/dist/server/normalizers/normalizer.d.ts","./node_modules/next/dist/server/normalizers/locale-route-normalizer.d.ts","./node_modules/next/dist/server/normalizers/request/pathname-normalizer.d.ts","./node_modules/next/dist/server/normalizers/request/suffix.d.ts","./node_modules/next/dist/server/normalizers/request/rsc.d.ts","./node_modules/next/dist/server/normalizers/request/next-data.d.ts","./node_modules/next/dist/server/after/builtin-request-context.d.ts","./node_modules/next/dist/server/normalizers/request/segment-prefix-rsc.d.ts","./node_modules/next/dist/server/route-modules/pages/builtin/_error.d.ts","./node_modules/next/dist/server/load-default-error-components.d.ts","./node_modules/next/dist/server/base-server.d.ts","./node_modules/next/dist/server/after/after.d.ts","./node_modules/next/dist/server/after/after-context.d.ts","./node_modules/next/dist/server/use-cache/cache-life.d.ts","./node_modules/next/dist/server/app-render/work-async-storage-instance.d.ts","./node_modules/next/dist/server/lib/lazy-result.d.ts","./node_modules/next/dist/server/app-render/create-error-handler.d.ts","./node_modules/next/dist/shared/lib/action-revalidation-kind.d.ts","./node_modules/next/dist/server/app-render/work-async-storage.external.d.ts","./node_modules/next/dist/server/async-storage/work-store.d.ts","./node_modules/next/dist/server/web/http.d.ts","./node_modules/next/dist/client/components/hooks-server-context.d.ts","./node_modules/next/dist/server/route-modules/app-route/shared-modules.d.ts","./node_modules/next/dist/client/components/redirect-status-code.d.ts","./node_modules/next/dist/client/components/redirect-error.d.ts","./node_modules/next/dist/server/web/spec-extension/adapters/request-cookies.d.ts","./node_modules/next/dist/server/async-storage/draft-mode-provider.d.ts","./node_modules/next/dist/server/web/spec-extension/adapters/headers.d.ts","./node_modules/next/dist/server/app-render/cache-signal.d.ts","./node_modules/next/dist/server/app-render/instant-validation/boundary-tracking.d.ts","./node_modules/next/dist/server/app-render/instant-validation/instant-validation-error.d.ts","./node_modules/next/dist/shared/lib/router/utils/parse-relative-url.d.ts","./node_modules/next/dist/server/app-render/instant-validation/instant-samples.d.ts","./node_modules/next/dist/server/app-render/dynamic-rendering.d.ts","./node_modules/next/dist/server/app-render/work-unit-async-storage-instance.d.ts","./node_modules/next/dist/server/lib/implicit-tags.d.ts","./node_modules/next/dist/server/app-render/staged-rendering.d.ts","./node_modules/next/dist/server/app-render/work-unit-async-storage.external.d.ts","./node_modules/next/dist/build/templates/app-route.d.ts","./node_modules/next/dist/server/app-render/action-async-storage-instance.d.ts","./node_modules/next/dist/server/app-render/action-async-storage.external.d.ts","./node_modules/next/dist/server/route-modules/app-route/module.d.ts","./node_modules/next/dist/server/route-modules/app-route/module.compiled.d.ts","./node_modules/next/dist/build/segment-config/app/app-segments.d.ts","./node_modules/next/dist/build/get-supported-browsers.d.ts","./node_modules/next/dist/build/utils.d.ts","./node_modules/next/dist/build/rendering-mode.d.ts","./node_modules/next/dist/server/lib/router-utils/build-prefetch-segment-data-route.d.ts","./node_modules/next/dist/server/lib/cpu-profile.d.ts","./node_modules/next/dist/build/turborepo-access-trace/types.d.ts","./node_modules/next/dist/build/turborepo-access-trace/result.d.ts","./node_modules/next/dist/build/turborepo-access-trace/helpers.d.ts","./node_modules/next/dist/build/turborepo-access-trace/index.d.ts","./node_modules/next/dist/export/routes/types.d.ts","./node_modules/next/dist/export/types.d.ts","./node_modules/next/dist/export/worker.d.ts","./node_modules/next/dist/build/worker.d.ts","./node_modules/next/dist/build/index.d.ts","./node_modules/next/dist/lib/coalesced-function.d.ts","./node_modules/next/dist/server/lib/router-utils/types.d.ts","./node_modules/next/dist/trace/types.d.ts","./node_modules/next/dist/trace/trace.d.ts","./node_modules/next/dist/trace/shared.d.ts","./node_modules/next/dist/trace/index.d.ts","./node_modules/next/dist/build/load-jsconfig.d.ts","./node_modules/@next/env/dist/index.d.ts","./node_modules/next/dist/build/webpack/plugins/telemetry-plugin/use-cache-tracker-utils.d.ts","./node_modules/next/dist/build/webpack/plugins/telemetry-plugin/telemetry-plugin.d.ts","./node_modules/next/dist/telemetry/storage.d.ts","./node_modules/next/dist/build/build-context.d.ts","./node_modules/next/dist/build/webpack-config.d.ts","./node_modules/next/dist/build/swc/generated-native.d.ts","./node_modules/next/dist/build/define-env.d.ts","./node_modules/next/dist/build/swc/index.d.ts","./node_modules/next/dist/build/swc/types.d.ts","./node_modules/next/dist/server/dev/parse-version-info.d.ts","./node_modules/next/dist/next-devtools/shared/types.d.ts","./node_modules/next/dist/server/dev/dev-indicator-server-state.d.ts","./node_modules/next/dist/next-devtools/dev-overlay/cache-indicator.d.ts","./node_modules/next/dist/server/lib/parse-stack.d.ts","./node_modules/next/dist/next-devtools/server/shared.d.ts","./node_modules/next/dist/next-devtools/shared/stack-frame.d.ts","./node_modules/next/dist/next-devtools/dev-overlay/utils/get-error-by-type.d.ts","./node_modules/next/dist/next-devtools/dev-overlay/container/runtime-error/render-error.d.ts","./node_modules/next/dist/next-devtools/dev-overlay/shared.d.ts","./node_modules/next/dist/server/dev/debug-channel.d.ts","./node_modules/next/dist/server/dev/hot-reloader-types.d.ts","./node_modules/next/dist/server/web/spec-extension/fetch-event.d.ts","./node_modules/next/dist/server/web/spec-extension/response.d.ts","./node_modules/next/dist/build/segment-config/middleware/middleware-config.d.ts","./node_modules/next/dist/server/web/types.d.ts","./node_modules/next/dist/shared/lib/router/utils/parse-url.d.ts","./node_modules/next/dist/server/base-http/node.d.ts","./node_modules/next/dist/server/lib/async-callback-set.d.ts","./node_modules/next/dist/shared/lib/router/utils/route-regex.d.ts","./node_modules/next/dist/shared/lib/router/utils/route-matcher.d.ts","./node_modules/sharp/lib/index.d.ts","./node_modules/next/dist/server/image-optimizer.d.ts","./node_modules/next/dist/server/next-server.d.ts","./node_modules/next/dist/server/lib/types.d.ts","./node_modules/next/dist/server/lib/lru-cache.d.ts","./node_modules/next/dist/server/lib/dev-bundler-service.d.ts","./node_modules/next/dist/server/dev/static-paths-worker.d.ts","./node_modules/next/dist/server/dev/next-dev-server.d.ts","./node_modules/next/dist/server/next.d.ts","./node_modules/next/dist/server/lib/render-server.d.ts","./node_modules/next/dist/server/lib/router-server.d.ts","./node_modules/next/dist/shared/lib/router/utils/path-match.d.ts","./node_modules/next/dist/server/lib/router-utils/filesystem.d.ts","./node_modules/next/dist/server/lib/router-utils/setup-dev-bundler.d.ts","./node_modules/next/dist/server/lib/router-utils/router-server-context.d.ts","./node_modules/next/dist/server/route-modules/route-module.d.ts","./node_modules/next/dist/server/load-components.d.ts","./node_modules/next/dist/server/web/adapter.d.ts","./node_modules/next/dist/server/app-render/types.d.ts","./node_modules/next/dist/build/webpack/loaders/metadata/types.d.ts","./node_modules/next/dist/build/webpack/loaders/next-app-loader/index.d.ts","./node_modules/next/dist/server/lib/app-dir-module.d.ts","./node_modules/next/dist/server/app-render/app-render.d.ts","./node_modules/next/dist/server/route-modules/app-page/vendored/contexts/entrypoints.d.ts","./node_modules/next/dist/client/components/error-boundary.d.ts","./node_modules/next/dist/client/components/layout-router.d.ts","./node_modules/next/dist/client/components/render-from-template-context.d.ts","./node_modules/next/dist/client/components/client-page.d.ts","./node_modules/next/dist/client/components/client-segment.d.ts","./node_modules/next/dist/client/components/http-access-fallback/error-boundary.d.ts","./node_modules/next/dist/lib/metadata/types/alternative-urls-types.d.ts","./node_modules/next/dist/lib/metadata/types/extra-types.d.ts","./node_modules/next/dist/lib/metadata/types/metadata-types.d.ts","./node_modules/next/dist/lib/metadata/types/manifest-types.d.ts","./node_modules/next/dist/lib/metadata/types/opengraph-types.d.ts","./node_modules/next/dist/lib/metadata/types/twitter-types.d.ts","./node_modules/next/dist/lib/metadata/types/metadata-interface.d.ts","./node_modules/next/dist/lib/metadata/types/resolvers.d.ts","./node_modules/next/dist/lib/metadata/types/icons.d.ts","./node_modules/next/dist/lib/metadata/resolve-metadata.d.ts","./node_modules/next/dist/lib/metadata/metadata.d.ts","./node_modules/next/dist/lib/framework/boundary-components.d.ts","./node_modules/next/dist/server/app-render/rsc/preloads.d.ts","./node_modules/next/dist/server/app-render/rsc/postpone.d.ts","./node_modules/next/dist/server/app-render/rsc/taint.d.ts","./node_modules/next/dist/server/app-render/collect-segment-data.d.ts","./node_modules/next/dist/server/app-render/instant-validation/instant-validation.d.ts","./node_modules/next/dist/next-devtools/userspace/app/segment-explorer-node.d.ts","./node_modules/next/dist/server/app-render/entry-base.d.ts","./node_modules/next/dist/build/templates/app-page.d.ts","./node_modules/next/dist/server/route-modules/app-page/helpers/prerender-manifest-matcher.d.ts","./node_modules/@types/react/jsx-dev-runtime.d.ts","./node_modules/@types/react/compiler-runtime.d.ts","./node_modules/next/dist/server/route-modules/app-page/vendored/rsc/entrypoints.d.ts","./node_modules/@types/react-dom/client.d.ts","./node_modules/@types/react-dom/static.d.ts","./node_modules/@types/react-dom/server.d.ts","./node_modules/next/dist/server/route-modules/app-page/vendored/ssr/entrypoints.d.ts","./node_modules/next/dist/server/route-modules/app-page/module.d.ts","./node_modules/next/dist/server/request/fallback-params.d.ts","./node_modules/next/dist/server/web/spec-extension/image-response.d.ts","./node_modules/next/dist/server/web/spec-extension/user-agent.d.ts","./node_modules/next/dist/server/web/spec-extension/url-pattern.d.ts","./node_modules/next/dist/server/after/index.d.ts","./node_modules/next/dist/server/request/connection.d.ts","./node_modules/next/dist/server/web/exports/index.d.ts","./node_modules/next/dist/server/request-meta.d.ts","./node_modules/next/dist/cli/next-test.d.ts","./node_modules/next/dist/shared/lib/size-limit.d.ts","./node_modules/next/dist/server/config-shared.d.ts","./node_modules/next/dist/server/base-http/index.d.ts","./node_modules/next/dist/server/api-utils/index.d.ts","./node_modules/next/dist/build/adapter/build-complete.d.ts","./node_modules/next/dist/types.d.ts","./node_modules/next/dist/shared/lib/html-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/utils.d.ts","./node_modules/next/dist/pages/_app.d.ts","./node_modules/next/app.d.ts","./node_modules/next/dist/server/web/spec-extension/unstable-cache.d.ts","./node_modules/next/dist/server/web/spec-extension/revalidate.d.ts","./node_modules/next/dist/server/web/spec-extension/unstable-no-store.d.ts","./node_modules/next/dist/server/use-cache/cache-tag.d.ts","./node_modules/next/cache.d.ts","./node_modules/next/dist/pages/_document.d.ts","./node_modules/next/document.d.ts","./node_modules/next/dist/shared/lib/dynamic.d.ts","./node_modules/next/dynamic.d.ts","./node_modules/next/dist/pages/_error.d.ts","./node_modules/next/dist/client/components/catch-error.d.ts","./node_modules/next/dist/api/error.d.ts","./node_modules/next/error.d.ts","./node_modules/next/dist/shared/lib/head.d.ts","./node_modules/next/head.d.ts","./node_modules/next/dist/server/request/cookies.d.ts","./node_modules/next/dist/server/request/headers.d.ts","./node_modules/next/dist/server/request/draft-mode.d.ts","./node_modules/next/headers.d.ts","./node_modules/next/dist/shared/lib/get-img-props.d.ts","./node_modules/next/dist/client/image-component.d.ts","./node_modules/next/dist/shared/lib/image-external.d.ts","./node_modules/next/image.d.ts","./node_modules/next/dist/client/link.d.ts","./node_modules/next/link.d.ts","./node_modules/next/dist/client/components/unrecognized-action-error.d.ts","./node_modules/next/dist/client/components/redirect.d.ts","./node_modules/next/dist/client/components/not-found.d.ts","./node_modules/next/dist/client/components/forbidden.d.ts","./node_modules/next/dist/client/components/unauthorized.d.ts","./node_modules/next/dist/client/components/unstable-rethrow.server.d.ts","./node_modules/next/dist/client/components/unstable-rethrow.d.ts","./node_modules/next/dist/client/components/navigation.react-server.d.ts","./node_modules/next/dist/client/components/navigation.d.ts","./node_modules/next/navigation.d.ts","./node_modules/next/router.d.ts","./node_modules/next/dist/client/script.d.ts","./node_modules/next/script.d.ts","./node_modules/next/dist/compiled/@edge-runtime/primitives/url.d.ts","./node_modules/next/dist/compiled/@vercel/og/satori/index.d.ts","./node_modules/next/dist/compiled/@vercel/og/types.d.ts","./node_modules/next/server.d.ts","./node_modules/next/types/global.d.ts","./node_modules/next/types/compiled.d.ts","./node_modules/next/types.d.ts","./node_modules/next/index.d.ts","./node_modules/next/image-types/global.d.ts","./.next/types/routes.d.ts","./next-env.d.ts","./next.config.ts","./app/lib/api.ts","./app/lib/csrffetch.ts","./app/layout.tsx","./app/components/sitechrome.tsx","./app/page.tsx","./app/components/deleteconfirmmodal.tsx","./app/components/toasteditor.tsx","./app/components/toastviewer.tsx","./app/login/page.tsx","./app/posts/page.tsx","./app/posts/[publicid]/page.tsx","./app/posts/[publicid]/edit/page.tsx","./app/posts/anonymous/page.tsx","./app/posts/create/page.tsx","./app/profile/page.tsx","./app/resort/page.tsx","./app/signup/page.tsx","./.next/types/cache-life.d.ts","./.next/types/validator.ts","./.next/dev/types/cache-life.d.ts","./.next/dev/types/routes.d.ts","./.next/dev/types/validator.ts"],"fileIdsList":[[100,165,173,178,181,183,184,185,197,516,517,518,519,583],[100,165,173,178,181,183,184,185,197,583,585],[100,165,173,178,181,183,184,185,197,259,560,568,570,574,575,576,577,578,579,580,581,582,583,585,586],[100,165,173,178,181,183,184,185,197,516,517,518,519,585],[100,165,173,178,181,183,184,185,197,259,560,563,568,570,574,575,576,577,578,579,580,581,582,583,585],[92,100,165,173,178,181,183,184,185,197,259,583,585],[92,100,165,173,178,181,183,184,185,197,259,540,566,567,583,585],[100,165,173,178,181,183,184,185,197,259,558,561,583,585],[100,165,173,178,181,183,184,185,197,259,583,585],[100,165,173,178,181,183,184,185,197,259,566,583,585],[92,100,165,173,178,181,183,184,185,197,259,540,550,566,567,569,583,585],[92,100,165,173,178,181,183,184,185,197,259,540,566,569,583,585],[92,100,165,173,178,181,183,184,185,197,259,524,540,550,566,567,569,572,583,585],[92,100,165,173,178,181,183,184,185,197,259,524,540,550,566,567,569,571,573,583,585],[92,100,165,173,178,181,183,184,185,197,259,524,540,550,566,567,572,583,585],[92,100,165,173,178,181,183,184,185,197,259,540,550,566,569,583,585],[92,100,165,173,178,181,183,184,185,197,259,540,569,583,585],[92,100,165,173,178,181,183,184,185,197,259,569,583,585],[100,165,173,178,181,183,184,185,197,561,562,563,583,585],[100,165,173,178,181,183,184,185,197,259,561,583,585],[100,162,163,165,173,178,181,183,184,185,197,583,585],[100,164,165,173,178,181,183,184,185,197,583,585],[165,173,178,181,183,184,185,197,583,585],[100,165,173,178,181,183,184,185,197,206,583,585],[100,165,166,171,173,176,178,181,183,184,185,187,197,202,215,583,585],[100,165,166,167,173,176,178,181,183,184,185,197,583,585],[100,165,168,173,178,181,183,184,185,197,216,583,585],[100,165,169,170,173,178,181,183,184,185,188,197,583,585],[100,165,170,173,178,181,183,184,185,197,202,212,583,585],[100,165,171,173,176,178,181,183,184,185,187,197,583,585],[100,164,165,172,173,178,181,183,184,185,197,583,585],[100,165,173,174,178,181,183,184,185,197,583,585],[100,165,173,175,176,178,181,183,184,185,197,583,585],[100,164,165,173,176,178,181,183,184,185,197,583,585],[100,165,173,176,178,179,181,183,184,185,197,202,215,583,585],[100,165,173,176,178,179,181,183,184,185,197,202,204,206,583,585],[100,152,165,173,176,178,180,181,183,184,185,187,197,202,215,583,585],[100,165,173,176,178,180,181,183,184,185,187,197,202,212,215,583,585],[100,165,173,178,180,181,182,183,184,185,197,202,212,215,583,585],[99,100,101,102,103,104,105,106,107,108,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,583,585],[100,165,173,176,178,181,183,184,185,197,583,585],[100,165,173,178,181,183,185,197,583,585],[100,165,173,178,181,183,184,185,186,197,215,583,585],[100,165,173,176,178,181,183,184,185,187,197,202,583,585],[100,165,173,178,181,183,184,185,188,197,583,585],[100,165,173,178,181,183,184,185,189,197,583,585],[100,165,173,176,178,181,183,184,185,192,197,583,585],[100,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,583,585],[100,165,173,178,181,183,184,185,194,197,583,585],[100,165,173,178,181,183,184,185,195,197,583,585],[100,165,170,173,178,181,183,184,185,187,197,206,583,585],[100,165,173,176,178,181,183,184,185,197,198,583,585],[100,165,173,178,181,183,184,185,197,199,216,219,583,585],[100,165,173,176,178,181,183,184,185,197,202,204,205,206,583,585],[100,165,173,178,181,183,184,185,197,203,206,583,585],[100,165,173,176,178,181,183,184,185,197,202,204,583,585],[100,165,173,176,178,181,183,184,185,197,202,205,206,583,585],[100,165,173,178,181,183,184,185,197,206,216,583,585],[100,165,173,178,181,183,184,185,197,207,583,585],[100,162,165,173,178,181,183,184,185,197,202,209,215,583,585],[100,165,173,178,181,183,184,185,197,202,208,583,585],[100,165,173,176,178,181,183,184,185,197,210,211,583,585],[100,165,173,178,181,183,184,185,197,210,211,583,585],[100,165,170,173,178,181,183,184,185,187,197,202,212,583,585],[100,165,173,178,181,183,184,185,197,213,583,585],[100,165,173,178,181,183,184,185,187,197,214,583,585],[100,165,173,178,180,181,183,184,185,195,197,215,583,585],[100,165,173,178,181,183,184,185,197,216,217,583,585],[100,165,170,173,178,181,183,184,185,197,217,583,585],[100,165,173,178,181,183,184,185,197,202,218,583,585],[100,165,173,178,181,183,184,185,186,197,219,583,585],[100,165,173,178,181,183,184,185,197,220,583,585],[100,165,168,173,178,181,183,184,185,197,583,585],[100,165,170,173,178,181,183,184,185,197,583,585],[100,165,173,178,181,183,184,185,197,216,583,585],[100,152,165,173,178,181,183,184,185,197,583,585],[100,165,173,178,181,183,184,185,197,215,583,585],[100,165,173,178,181,183,184,185,197,221,583,585],[100,165,173,178,181,183,184,185,192,197,583,585],[100,165,173,178,181,183,184,185,197,211,583,585],[100,152,165,173,176,178,179,181,183,184,185,192,197,202,206,215,218,219,221,583,585],[100,165,173,178,181,183,184,185,197,202,222,583,585],[100,165,173,178,181,183,184,185,197,204,223,583,585],[92,96,100,165,173,178,181,183,184,185,197,225,226,227,229,511,556,583,585],[92,100,165,173,178,181,183,184,185,197,583,585],[92,96,100,165,173,178,181,183,184,185,197,225,226,227,228,492,511,556,583,585],[92,96,100,165,173,178,181,183,184,185,197,225,226,228,229,511,556,583,585],[92,100,165,173,178,181,183,184,185,197,229,492,493,583,585],[92,100,165,173,178,181,183,184,185,197,229,492,583,585],[92,96,100,165,173,178,181,183,184,185,197,226,227,228,229,511,556,583,585],[92,96,100,165,173,178,181,183,184,185,197,225,227,228,229,511,556,583,585],[90,91,100,165,173,178,181,183,184,185,197,583,585],[100,165,173,178,181,183,184,185,197,514,583,585],[100,165,173,178,181,183,184,185,197,516,517,518,519,583,585],[100,165,173,178,181,183,184,185,197,462,525,526,583,585],[100,165,173,178,181,183,184,185,197,234,235,237,249,273,388,399,507,583,585],[100,165,173,178,181,183,184,185,197,237,268,269,270,272,507,583,585],[100,165,173,178,181,183,184,185,197,237,405,407,409,410,412,507,509,583,585],[100,165,173,178,181,183,184,185,197,237,271,308,507,583,585],[100,165,173,178,181,183,184,185,197,235,237,248,249,255,261,266,387,388,389,398,507,509,583,585],[100,165,173,178,181,183,184,185,197,507,583,585],[100,165,173,178,181,183,184,185,197,244,250,269,289,384,583,585],[100,165,173,178,181,183,184,185,197,237,583,585],[100,165,173,178,181,183,184,185,197,230,244,250,583,585],[100,165,173,178,181,183,184,185,197,416,583,585],[100,165,173,178,181,183,184,185,197,413,414,416,583,585],[100,165,173,178,181,183,184,185,197,413,415,507,583,585],[100,165,173,178,180,181,183,184,185,197,289,486,504,583,585],[100,165,173,178,180,181,183,184,185,197,360,363,379,384,504,583,585],[100,165,173,178,180,181,183,184,185,197,332,504,583,585],[100,165,173,178,181,183,184,185,197,392,583,585],[100,165,173,178,181,183,184,185,197,391,392,393,583,585],[100,165,173,178,181,183,184,185,197,391,583,585],[98,100,165,173,178,180,181,183,184,185,197,230,237,249,255,261,267,269,273,274,287,288,355,385,386,399,507,511,583,585],[100,165,173,178,181,183,184,185,197,234,237,271,308,405,406,411,507,559,583,585],[100,165,173,178,181,183,184,185,197,271,559,583,585],[100,165,173,178,181,183,184,185,197,234,288,457,507,559,583,585],[100,165,173,178,181,183,184,185,197,559,583,585],[100,165,173,178,181,183,184,185,197,237,271,272,559,583,585],[100,165,173,178,181,183,184,185,197,408,559,583,585],[100,165,173,178,181,183,184,185,197,274,387,390,397,583,585],[92,100,165,173,178,181,183,184,185,197,462,583,585],[100,165,173,178,181,183,184,185,195,197,244,259,583,585],[100,165,173,178,181,183,184,185,197,244,259,583,585],[92,100,165,173,178,181,183,184,185,197,329,583,585],[92,100,165,173,178,181,183,184,185,197,250,259,462,583,585],[100,165,173,178,181,183,184,185,197,244,315,329,330,541,548,583,585],[100,165,173,178,181,183,184,185,197,314,542,543,544,545,547,583,585],[100,165,173,178,181,183,184,185,197,365,583,585],[100,165,173,178,181,183,184,185,197,365,366,583,585],[100,165,173,178,181,183,184,185,197,248,250,317,318,583,585],[100,165,173,178,181,183,184,185,197,250,324,325,583,585],[100,165,173,178,181,183,184,185,197,250,319,327,583,585],[100,165,173,178,181,183,184,185,197,324,583,585],[100,165,173,178,181,183,184,185,197,242,250,317,318,319,320,321,322,323,324,327,583,585],[100,165,173,178,181,183,184,185,197,250,317,324,325,326,328,583,585],[100,165,173,178,181,183,184,185,197,250,318,320,321,583,585],[100,165,173,178,181,183,184,185,197,318,320,323,325,583,585],[100,165,173,178,181,183,184,185,197,546,583,585],[100,165,173,178,181,183,184,185,197,250,583,585],[92,100,165,173,178,181,183,184,185,197,238,535,583,585],[92,100,165,173,178,181,183,184,185,197,215,583,585],[92,100,165,173,178,181,183,184,185,197,271,306,583,585],[92,100,165,173,178,181,183,184,185,197,271,399,583,585],[100,165,173,178,181,183,184,185,197,304,309,583,585],[92,100,165,173,178,181,183,184,185,197,305,513,583,585],[92,96,100,165,173,178,180,181,183,184,185,197,225,226,227,228,229,511,555,583,585],[100,165,173,178,180,181,183,184,185,197,250,583,585],[100,165,173,178,180,181,183,184,185,197,249,254,335,352,394,395,399,454,456,507,508,583,585],[100,165,173,178,181,183,184,185,197,287,396,583,585],[100,165,173,178,181,183,184,185,197,511,583,585],[100,165,173,178,181,183,184,185,197,236,583,585],[92,100,165,173,178,181,183,184,185,197,241,244,459,475,477,583,585],[100,165,173,178,181,183,184,185,195,197,244,459,474,475,476,558,583,585],[100,165,173,178,181,183,184,185,197,468,469,470,471,472,473,583,585],[100,165,173,178,181,183,184,185,197,470,583,585],[100,165,173,178,181,183,184,185,197,474,583,585],[100,165,173,178,181,183,184,185,197,259,423,424,426,583,585],[92,100,165,173,178,181,183,184,185,197,250,417,418,419,420,425,583,585],[100,165,173,178,181,183,184,185,197,423,425,583,585],[100,165,173,178,181,183,184,185,197,421,583,585],[100,165,173,178,181,183,184,185,197,422,583,585],[92,100,165,173,178,181,183,184,185,197,259,305,513,583,585],[92,100,165,173,178,181,183,184,185,197,259,512,513,583,585],[92,100,165,173,178,181,183,184,185,197,259,513,583,585],[100,165,173,178,181,183,184,185,197,352,353,583,585],[100,165,173,178,181,183,184,185,197,353,583,585],[100,165,173,178,180,181,183,184,185,197,508,513,583,585],[100,165,173,178,181,183,184,185,197,382,583,585],[100,164,165,173,178,181,183,184,185,197,381,583,585],[100,165,173,178,181,183,184,185,197,244,250,256,258,360,373,377,379,456,459,496,497,504,508,583,585],[100,165,173,178,181,183,184,185,197,250,299,321,583,585],[100,165,173,178,181,183,184,185,197,360,371,374,379,583,585],[92,100,165,173,178,181,183,184,185,197,241,244,360,363,379,382,416,463,464,465,466,467,478,479,480,481,482,483,484,485,559,583,585],[100,165,173,178,181,183,184,185,197,241,244,269,360,367,368,369,372,373,583,585],[100,165,173,178,181,183,184,185,197,202,250,269,371,378,459,460,504,583,585],[100,165,173,178,181,183,184,185,197,375,583,585],[100,165,173,178,180,181,183,184,185,195,197,238,250,254,264,296,297,300,352,355,420,454,455,496,507,508,509,511,559,583,585],[100,165,173,178,181,183,184,185,197,241,242,244,583,585],[100,165,173,178,181,183,184,185,197,360,583,585],[100,164,165,173,178,181,183,184,185,197,269,296,297,354,355,356,357,358,359,508,583,585],[100,165,173,178,181,183,184,185,197,379,583,585],[100,164,165,173,178,181,183,184,185,197,243,244,254,258,294,360,367,368,369,370,371,374,375,376,377,378,497,583,585],[100,165,173,178,180,181,183,184,185,197,294,295,367,508,509,583,585],[100,165,173,178,181,183,184,185,197,269,297,352,355,360,456,508,583,585],[100,165,173,178,180,181,183,184,185,197,507,509,583,585],[100,165,173,178,180,181,183,184,185,197,202,504,508,509,583,585],[100,165,173,178,180,181,183,184,185,195,197,230,244,249,256,258,261,264,271,291,296,297,298,299,300,335,336,338,341,343,346,347,348,349,351,399,454,456,504,507,508,509,583,585],[100,165,173,178,180,181,183,184,185,197,202,583,585],[100,165,173,178,181,183,184,185,197,237,238,239,267,504,505,506,511,513,559,583,585],[100,165,173,178,181,183,184,185,197,234,235,507,583,585],[100,165,173,178,181,183,184,185,197,428,583,585],[100,165,173,178,180,181,183,184,185,197,202,215,246,412,416,417,418,419,420,426,427,559,583,585],[100,165,173,178,181,183,184,185,195,197,215,230,244,246,258,261,297,336,341,351,352,405,432,433,434,440,443,444,454,456,504,507,583,585],[100,165,173,178,181,183,184,185,197,261,267,274,287,297,355,507,583,585],[100,165,173,178,180,181,183,184,185,197,215,238,249,258,297,438,504,507,583,585],[100,165,173,178,181,183,184,185,197,458,583,585],[100,165,173,178,180,181,183,184,185,197,428,441,442,451,583,585],[100,165,173,178,181,183,184,185,197,504,507,583,585],[100,165,173,178,181,183,184,185,197,357,497,583,585],[100,165,173,178,181,183,184,185,197,258,296,399,513,583,585],[100,165,173,178,180,181,183,184,185,195,197,236,341,401,405,434,440,443,446,504,583,585],[100,165,173,178,180,181,183,184,185,197,274,287,405,447,583,585],[100,165,173,178,181,183,184,185,197,237,298,399,449,507,509,583,585],[100,165,173,178,180,181,183,184,185,197,215,420,507,583,585],[100,165,173,178,180,181,183,184,185,197,271,298,399,400,401,410,428,448,450,507,583,585],[98,100,165,173,178,180,181,183,184,185,197,296,453,511,513,583,585],[100,165,173,178,181,183,184,185,197,350,454,583,585],[100,165,173,178,180,181,183,184,185,195,197,244,247,249,250,256,258,264,273,274,287,297,300,336,338,348,351,352,399,432,433,434,435,437,439,454,456,504,513,583,585],[100,165,173,178,180,181,183,184,185,197,202,274,440,445,451,504,583,585],[100,165,173,178,181,183,184,185,197,277,278,279,280,281,282,283,284,285,286,583,585],[100,165,173,178,181,183,184,185,197,291,342,583,585],[100,165,173,178,181,183,184,185,197,344,583,585],[100,165,173,178,181,183,184,185,197,342,583,585],[100,165,173,178,181,183,184,185,197,344,345,583,585],[100,165,173,178,180,181,183,184,185,197,248,249,250,254,255,508,583,585],[100,165,173,178,180,181,183,184,185,195,197,236,238,256,260,296,299,300,334,454,504,509,511,513,583,585],[100,165,173,178,180,181,183,184,185,195,197,215,240,247,248,258,260,297,452,497,503,508,583,585],[100,165,173,178,181,183,184,185,197,367,583,585],[100,165,173,178,181,183,184,185,197,368,583,585],[100,165,173,178,181,183,184,185,197,250,261,496,583,585],[100,165,173,178,181,183,184,185,197,369,583,585],[100,165,173,178,181,183,184,185,197,243,583,585],[100,165,173,178,181,183,184,185,197,245,257,583,585],[100,165,173,178,180,181,183,184,185,197,245,249,256,583,585],[100,165,173,178,181,183,184,185,197,252,257,583,585],[100,165,173,178,181,183,184,185,197,253,583,585],[100,165,173,178,181,183,184,185,197,245,246,583,585],[100,165,173,178,181,183,184,185,197,245,301,583,585],[100,165,173,178,181,183,184,185,197,245,583,585],[100,165,173,178,181,183,184,185,197,247,291,340,583,585],[100,165,173,178,181,183,184,185,197,339,583,585],[100,165,173,178,181,183,184,185,197,244,246,247,583,585],[100,165,173,178,181,183,184,185,197,247,337,583,585],[100,165,173,178,181,183,184,185,197,244,246,583,585],[100,165,173,178,181,183,184,185,197,296,399,583,585],[100,165,173,178,181,183,184,185,197,496,583,585],[100,165,173,178,180,181,183,184,185,197,215,256,258,262,296,399,453,456,459,460,461,487,488,491,495,497,504,508,583,585],[100,165,173,178,181,183,184,185,197,310,313,315,316,329,330,583,585],[92,100,165,173,178,181,183,184,185,197,227,229,259,489,490,583,585],[92,100,165,173,178,181,183,184,185,197,227,229,259,489,490,494,583,585],[100,165,173,178,181,183,184,185,197,383,583,585],[100,165,173,178,181,183,184,185,197,269,290,295,296,360,361,362,363,364,366,379,380,382,385,453,456,507,509,583,585],[100,165,173,178,181,183,184,185,197,329,583,585],[100,165,173,178,180,181,183,184,185,197,334,504,583,585],[100,165,173,178,181,183,184,185,197,334,583,585],[100,165,173,178,180,181,183,184,185,197,256,302,331,333,335,453,504,511,513,583,585],[100,165,173,178,181,183,184,185,197,310,311,312,313,315,316,329,330,512,583,585],[98,100,165,173,178,180,181,183,184,185,195,197,215,245,246,258,264,296,297,300,399,451,452,454,504,507,508,511,583,585],[100,165,173,178,181,183,184,185,197,241,244,251,583,585],[100,165,173,178,181,183,184,185,197,295,297,429,432,583,585],[100,165,173,178,181,183,184,185,197,295,430,498,499,500,501,502,583,585],[100,165,173,178,180,181,183,184,185,197,291,507,583,585],[100,165,173,178,180,181,183,184,185,197,583,585],[100,165,173,178,181,183,184,185,197,294,379,583,585],[100,165,173,178,181,183,184,185,197,293,583,585],[100,165,173,178,181,183,184,185,197,295,348,583,585],[100,165,173,178,181,183,184,185,197,292,294,507,583,585],[100,165,173,178,180,181,183,184,185,197,240,295,429,430,431,504,507,508,583,585],[92,100,165,173,178,181,183,184,185,197,244,250,328,583,585],[92,100,165,173,178,181,183,184,185,197,242,583,585],[100,165,173,178,181,183,184,185,197,232,233,583,585],[92,100,165,173,178,181,183,184,185,197,238,583,585],[92,100,165,173,178,181,183,184,185,197,244,314,583,585],[92,98,100,165,173,178,181,183,184,185,197,296,300,511,513,583,585],[100,165,173,178,181,183,184,185,197,238,535,536,583,585],[92,100,165,173,178,181,183,184,185,197,309,583,585],[92,100,165,173,178,181,183,184,185,195,197,215,236,303,305,307,308,513,583,585],[100,165,173,178,181,183,184,185,197,244,271,508,583,585],[100,165,173,178,181,183,184,185,197,244,436,583,585],[92,100,165,173,178,180,181,183,184,185,195,197,234,236,309,407,511,512,583,585],[92,100,165,173,178,181,183,184,185,197,225,226,227,228,229,511,556,583,585],[92,93,94,95,96,100,165,173,178,181,183,184,185,197,583,585],[100,165,173,178,181,183,184,185,197,402,403,404,583,585],[100,165,173,178,181,183,184,185,197,402,583,585],[92,96,100,165,173,178,180,181,182,183,184,185,195,197,224,225,226,227,228,229,230,236,264,269,446,474,509,510,513,556,583,585],[100,165,173,178,181,183,184,185,197,521,583,585],[100,165,173,178,181,183,184,185,197,523,583,585],[100,165,173,178,181,183,184,185,197,527,583,585],[100,165,173,178,181,183,184,185,197,529,583,585],[100,165,173,178,181,183,184,185,197,531,532,533,583,585],[100,165,173,178,181,183,184,185,197,537,583,585],[97,100,165,173,178,181,183,184,185,197,515,520,522,524,528,530,534,538,540,550,551,553,557,558,559,560,583,585],[100,165,173,178,181,183,184,185,197,539,583,585],[100,165,173,178,181,183,184,185,197,549,583,585],[100,165,173,178,181,183,184,185,197,305,583,585],[100,165,173,178,181,183,184,185,197,552,583,585],[100,164,165,173,178,181,183,184,185,197,295,429,430,432,498,499,501,502,554,556,583,585],[100,165,173,178,181,183,184,185,197,224,583,585],[100,165,173,178,181,183,184,185,197,202,224,583,585],[100,115,118,121,122,165,173,178,181,183,184,185,197,215,583,585],[100,118,165,173,178,181,183,184,185,197,202,215,583,585],[100,118,122,165,173,178,181,183,184,185,197,215,583,585],[100,165,173,178,181,183,184,185,197,202,583,585],[100,112,165,173,178,181,183,184,185,197,583,585],[100,116,165,173,178,181,183,184,185,197,583,585],[100,114,115,118,165,173,178,181,183,184,185,197,215,583,585],[100,165,173,178,181,183,184,185,187,197,212,583,585],[100,112,165,173,178,181,183,184,185,197,224,583,585],[100,114,118,165,173,178,181,183,184,185,187,197,215,583,585],[100,109,110,111,113,117,165,173,176,178,181,183,184,185,197,202,215,583,585],[100,118,165,173,178,181,183,184,185,197,583,585],[100,118,127,136,165,173,178,181,183,184,185,197,583,585],[100,110,116,165,173,178,181,183,184,185,197,583,585],[100,118,146,147,165,173,178,181,183,184,185,197,583,585],[100,110,113,118,165,173,178,181,183,184,185,197,206,215,224,583,585],[100,114,118,165,173,178,181,183,184,185,197,215,583,585],[100,109,165,173,178,181,183,184,185,197,583,585],[100,112,113,114,116,117,118,119,120,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,147,148,149,150,151,165,173,178,181,183,184,185,197,583,585],[100,118,139,142,165,173,178,181,183,184,185,197,583,585],[100,118,127,129,130,165,173,178,181,183,184,185,197,583,585],[100,116,118,129,131,165,173,178,181,183,184,185,197,583,585],[100,117,165,173,178,181,183,184,185,197,583,585],[100,110,112,118,165,173,178,181,183,184,185,197,583,585],[100,118,122,129,131,165,173,178,181,183,184,185,197,583,585],[100,122,165,173,178,181,183,184,185,197,583,585],[100,116,118,121,165,173,178,181,183,184,185,197,215,583,585],[100,110,114,118,127,165,173,178,181,183,184,185,197,583,585],[100,118,139,165,173,178,181,183,184,185,197,583,585],[100,131,165,173,178,181,183,184,185,197,583,585],[100,110,114,118,122,165,173,178,181,183,184,185,197,583,585],[100,112,118,146,165,173,178,181,183,184,185,197,206,221,224,583,585]],"fileInfos":[{"version":"bcd24271a113971ba9eb71ff8cb01bc6b0f872a85c23fdbe5d93065b375933cd","affectsGlobalScope":true,"impliedFormat":1},{"version":"3f88bedbeb09c6f5a6645cb24c7c55f1aa22d19ae96c8e6959cbd8b85a707bc6","impliedFormat":1},{"version":"7fe93b39b810eadd916be8db880dd7f0f7012a5cc6ffb62de8f62a2117fa6f1f","impliedFormat":1},{"version":"bb0074cc08b84a2374af33d8bf044b80851ccc9e719a5e202eacf40db2c31600","impliedFormat":1},{"version":"1a7daebe4f45fb03d9ec53d60008fbf9ac45a697fdc89e4ce218bc94b94f94d6","impliedFormat":1},{"version":"f94b133a3cb14a288803be545ac2683e0d0ff6661bcd37e31aaaec54fc382aed","impliedFormat":1},{"version":"f59d0650799f8782fd74cf73c19223730c6d1b9198671b1c5b3a38e1188b5953","impliedFormat":1},{"version":"8a15b4607d9a499e2dbeed9ec0d3c0d7372c850b2d5f1fb259e8f6d41d468a84","impliedFormat":1},{"version":"26e0fe14baee4e127f4365d1ae0b276f400562e45e19e35fd2d4c296684715e6","impliedFormat":1},{"version":"1e9332c23e9a907175e0ffc6a49e236f97b48838cc8aec9ce7e4cec21e544b65","impliedFormat":1},{"version":"3753fbc1113dc511214802a2342280a8b284ab9094f6420e7aa171e868679f91","impliedFormat":1},{"version":"999ca32883495a866aa5737fe1babc764a469e4cde6ee6b136a4b9ae68853e4b","impliedFormat":1},{"version":"17f13ecb98cbc39243f2eee1f16d45cd8ec4706b03ee314f1915f1a8b42f6984","impliedFormat":1},{"version":"d6b1eba8496bdd0eed6fc8a685768fe01b2da4a0388b5fe7df558290bffcf32f","affectsGlobalScope":true,"impliedFormat":1},{"version":"7f57fc4404ff020bc45b9c620aff2b40f700b95fe31164024c453a5e3c163c54","impliedFormat":1},{"version":"eadcffda2aa84802c73938e589b9e58248d74c59cb7fcbca6474e3435ac15504","affectsGlobalScope":true,"impliedFormat":1},{"version":"105ba8ff7ba746404fe1a2e189d1d3d2e0eb29a08c18dded791af02f29fb4711","affectsGlobalScope":true,"impliedFormat":1},{"version":"00343ca5b2e3d48fa5df1db6e32ea2a59afab09590274a6cccb1dbae82e60c7c","affectsGlobalScope":true,"impliedFormat":1},{"version":"ebd9f816d4002697cb2864bea1f0b70a103124e18a8cd9645eeccc09bdf80ab4","affectsGlobalScope":true,"impliedFormat":1},{"version":"2c1afac30a01772cd2a9a298a7ce7706b5892e447bb46bdbeef720f7b5da77ad","affectsGlobalScope":true,"impliedFormat":1},{"version":"7b0225f483e4fa685625ebe43dd584bb7973bbd84e66a6ba7bbe175ee1048b4f","affectsGlobalScope":true,"impliedFormat":1},{"version":"c0a4b8ac6ce74679c1da2b3795296f5896e31c38e888469a8e0f99dc3305de60","affectsGlobalScope":true,"impliedFormat":1},{"version":"3084a7b5f569088e0146533a00830e206565de65cae2239509168b11434cd84f","affectsGlobalScope":true,"impliedFormat":1},{"version":"c5079c53f0f141a0698faa903e76cb41cd664e3efb01cc17a5c46ec2eb0bef42","affectsGlobalScope":true,"impliedFormat":1},{"version":"32cafbc484dea6b0ab62cf8473182bbcb23020d70845b406f80b7526f38ae862","affectsGlobalScope":true,"impliedFormat":1},{"version":"fca4cdcb6d6c5ef18a869003d02c9f0fd95df8cfaf6eb431cd3376bc034cad36","affectsGlobalScope":true,"impliedFormat":1},{"version":"b93ec88115de9a9dc1b602291b85baf825c85666bf25985cc5f698073892b467","affectsGlobalScope":true,"impliedFormat":1},{"version":"f5c06dcc3fe849fcb297c247865a161f995cc29de7aa823afdd75aaaddc1419b","affectsGlobalScope":true,"impliedFormat":1},{"version":"b77e16112127a4b169ef0b8c3a4d730edf459c5f25fe52d5e436a6919206c4d7","affectsGlobalScope":true,"impliedFormat":1},{"version":"fbffd9337146eff822c7c00acbb78b01ea7ea23987f6c961eba689349e744f8c","affectsGlobalScope":true,"impliedFormat":1},{"version":"a995c0e49b721312f74fdfb89e4ba29bd9824c770bbb4021d74d2bf560e4c6bd","affectsGlobalScope":true,"impliedFormat":1},{"version":"c7b3542146734342e440a84b213384bfa188835537ddbda50d30766f0593aff9","affectsGlobalScope":true,"impliedFormat":1},{"version":"ce6180fa19b1cccd07ee7f7dbb9a367ac19c0ed160573e4686425060b6df7f57","affectsGlobalScope":true,"impliedFormat":1},{"version":"3f02e2476bccb9dbe21280d6090f0df17d2f66b74711489415a8aa4df73c9675","affectsGlobalScope":true,"impliedFormat":1},{"version":"45e3ab34c1c013c8ab2dc1ba4c80c780744b13b5676800ae2e3be27ae862c40c","affectsGlobalScope":true,"impliedFormat":1},{"version":"805c86f6cca8d7702a62a844856dbaa2a3fd2abef0536e65d48732441dde5b5b","affectsGlobalScope":true,"impliedFormat":1},{"version":"e42e397f1a5a77994f0185fd1466520691456c772d06bf843e5084ceb879a0ad","affectsGlobalScope":true,"impliedFormat":1},{"version":"f4c2b41f90c95b1c532ecc874bd3c111865793b23aebcc1c3cbbabcd5d76ffb0","affectsGlobalScope":true,"impliedFormat":1},{"version":"ab26191cfad5b66afa11b8bf935ef1cd88fabfcb28d30b2dfa6fad877d050332","affectsGlobalScope":true,"impliedFormat":1},{"version":"2088bc26531e38fb05eedac2951480db5309f6be3fa4a08d2221abb0f5b4200d","affectsGlobalScope":true,"impliedFormat":1},{"version":"cb9d366c425fea79716a8fb3af0d78e6b22ebbab3bd64d25063b42dc9f531c1e","affectsGlobalScope":true,"impliedFormat":1},{"version":"500934a8089c26d57ebdb688fc9757389bb6207a3c8f0674d68efa900d2abb34","affectsGlobalScope":true,"impliedFormat":1},{"version":"689da16f46e647cef0d64b0def88910e818a5877ca5379ede156ca3afb780ac3","affectsGlobalScope":true,"impliedFormat":1},{"version":"bc21cc8b6fee4f4c2440d08035b7ea3c06b3511314c8bab6bef7a92de58a2593","affectsGlobalScope":true,"impliedFormat":1},{"version":"7ca53d13d2957003abb47922a71866ba7cb2068f8d154877c596d63c359fed25","affectsGlobalScope":true,"impliedFormat":1},{"version":"54725f8c4df3d900cb4dac84b64689ce29548da0b4e9b7c2de61d41c79293611","affectsGlobalScope":true,"impliedFormat":1},{"version":"e5594bc3076ac29e6c1ebda77939bc4c8833de72f654b6e376862c0473199323","affectsGlobalScope":true,"impliedFormat":1},{"version":"2f3eb332c2d73e729f3364fcc0c2b375e72a121e8157d25a82d67a138c83a95c","affectsGlobalScope":true,"impliedFormat":1},{"version":"6f4427f9642ce8d500970e4e69d1397f64072ab73b97e476b4002a646ac743b1","affectsGlobalScope":true,"impliedFormat":1},{"version":"48915f327cd1dea4d7bd358d9dc7732f58f9e1626a29cc0c05c8c692419d9bb7","affectsGlobalScope":true,"impliedFormat":1},{"version":"b7bf9377723203b5a6a4b920164df22d56a43f593269ba6ae1fdc97774b68855","affectsGlobalScope":true,"impliedFormat":1},{"version":"db9709688f82c9e5f65a119c64d835f906efe5f559d08b11642d56eb85b79357","affectsGlobalScope":true,"impliedFormat":1},{"version":"4b25b8c874acd1a4cf8444c3617e037d444d19080ac9f634b405583fd10ce1f7","affectsGlobalScope":true,"impliedFormat":1},{"version":"37be57d7c90cf1f8112ee2636a068d8fd181289f82b744160ec56a7dc158a9f5","affectsGlobalScope":true,"impliedFormat":1},{"version":"a917a49ac94cd26b754ab84e113369a75d1a47a710661d7cd25e961cc797065f","affectsGlobalScope":true,"impliedFormat":1},{"version":"6d3261badeb7843d157ef3e6f5d1427d0eeb0af0cf9df84a62cfd29fd47ac86e","affectsGlobalScope":true,"impliedFormat":1},{"version":"195daca651dde22f2167ac0d0a05e215308119a3100f5e6268e8317d05a92526","affectsGlobalScope":true,"impliedFormat":1},{"version":"8b11e4285cd2bb164a4dc09248bdec69e9842517db4ca47c1ba913011e44ff2f","affectsGlobalScope":true,"impliedFormat":1},{"version":"0508571a52475e245b02bc50fa1394065a0a3d05277fbf5120c3784b85651799","affectsGlobalScope":true,"impliedFormat":1},{"version":"8f9af488f510c3015af3cc8c267a9e9d96c4dd38a1fdff0e11dc5a544711415b","affectsGlobalScope":true,"impliedFormat":1},{"version":"fc611fea8d30ea72c6bbfb599c9b4d393ce22e2f5bfef2172534781e7d138104","affectsGlobalScope":true,"impliedFormat":1},{"version":"0bd714129fca875f7d4c477a1a392200b0bcd13fb2e80928cd334b63830ea047","affectsGlobalScope":true,"impliedFormat":1},{"version":"e2c9037ae6cd2c52d80ceef0b3c5ffdb488627d71529cf4f63776daf11161c9a","affectsGlobalScope":true,"impliedFormat":1},{"version":"135d5cf4d345f59f1a9caadfafcd858d3d9cc68290db616cc85797224448cccc","affectsGlobalScope":true,"impliedFormat":1},{"version":"bc238c3f81c2984751932b6aab223cd5b830e0ac6cad76389e5e9d2ffc03287d","affectsGlobalScope":true,"impliedFormat":1},{"version":"4a07f9b76d361f572620927e5735b77d6d2101c23cdd94383eb5b706e7b36357","affectsGlobalScope":true,"impliedFormat":1},{"version":"7c4e8dc6ab834cc6baa0227e030606d29e3e8449a9f67cdf5605ea5493c4db29","affectsGlobalScope":true,"impliedFormat":1},{"version":"de7ba0fd02e06cd9a5bd4ab441ed0e122735786e67dde1e849cced1cd8b46b78","affectsGlobalScope":true,"impliedFormat":1},{"version":"6148e4e88d720a06855071c3db02069434142a8332cf9c182cda551adedf3156","affectsGlobalScope":true,"impliedFormat":1},{"version":"d63dba625b108316a40c95a4425f8d4294e0deeccfd6c7e59d819efa19e23409","affectsGlobalScope":true,"impliedFormat":1},{"version":"0568d6befee03dd435bed4fc25c4e46865b24bdcb8c563fdc21f580a2c301904","affectsGlobalScope":true,"impliedFormat":1},{"version":"30d62269b05b584741f19a5369852d5d34895aa2ac4fd948956f886d15f9cc0d","affectsGlobalScope":true,"impliedFormat":1},{"version":"f128dae7c44d8f35ee42e0a437000a57c9f06cc04f8b4fb42eebf44954d53dc8","affectsGlobalScope":true,"impliedFormat":1},{"version":"ffbe6d7b295306b2ba88030f65b74c107d8d99bdcf596ea99c62a02f606108b0","affectsGlobalScope":true,"impliedFormat":1},{"version":"996fb27b15277369c68a4ba46ed138b4e9e839a02fb4ec756f7997629242fd9f","affectsGlobalScope":true,"impliedFormat":1},{"version":"79b712591b270d4778c89706ca2cfc56ddb8c3f895840e477388f1710dc5eda9","affectsGlobalScope":true,"impliedFormat":1},{"version":"20884846cef428b992b9bd032e70a4ef88e349263f63aeddf04dda837a7dba26","affectsGlobalScope":true,"impliedFormat":1},{"version":"5fcab789c73a97cd43828ee3cc94a61264cf24d4c44472ce64ced0e0f148bdb2","affectsGlobalScope":true,"impliedFormat":1},{"version":"db59a81f070c1880ad645b2c0275022baa6a0c4f0acdc58d29d349c6efcf0903","affectsGlobalScope":true,"impliedFormat":1},{"version":"673294292640f5722b700e7d814e17aaf7d93f83a48a2c9b38f33cbc940ad8b0","affectsGlobalScope":true,"impliedFormat":1},{"version":"d786b48f934cbca483b3c6d0a798cb43bbb4ada283e76fb22c28e53ae05b9e69","affectsGlobalScope":true,"impliedFormat":1},{"version":"1ecb8e347cb6b2a8927c09b86263663289418df375f5e68e11a0ae683776978f","affectsGlobalScope":true,"impliedFormat":1},{"version":"142efd4ce210576f777dc34df121777be89eda476942d6d6663b03dcb53be3ff","affectsGlobalScope":true,"impliedFormat":1},{"version":"379bc41580c2d774f82e828c70308f24a005b490c25ba34d679d84bcf05c3d9d","affectsGlobalScope":true,"impliedFormat":1},{"version":"ed484fb2aa8a1a23d0277056ec3336e0a0b52f9b8d6a961f338a642faf43235d","affectsGlobalScope":true,"impliedFormat":1},{"version":"4ffedae1d1c2d53fdbca1c96d3c7dda544281f7d262f99b6880634f8fd8d9820","affectsGlobalScope":true,"impliedFormat":1},{"version":"83a730b125d477dd264df8ba479afab27a3dae7152b005c214ab94dc7ee44fd3","affectsGlobalScope":true,"impliedFormat":1},{"version":"1ce14b81c5cc821994aa8ec1d42b220dd41b27fcc06373bce3958af7421b77d4","affectsGlobalScope":true,"impliedFormat":1},{"version":"b3a048b3e9302ef9a34ef4ebb9aecfb28b66abb3bce577206a79fee559c230da","affectsGlobalScope":true,"impliedFormat":1},{"version":"7e29f41b158de217f94cb9676bf9cbd0cd9b5a46e1985141ed36e075c52bf6ad","affectsGlobalScope":true,"impliedFormat":1},{"version":"ac51dd7d31333793807a6abaa5ae168512b6131bd41d9c5b98477fc3b7800f9f","impliedFormat":1},{"version":"dc782ff85b2cb10075ecffc158af7bfb27ff97bf8491c917efea0c3d622d5ac4","impliedFormat":1},{"version":"acd8fd5090ac73902278889c38336ff3f48af6ba03aa665eb34a75e7ba1dccc4","impliedFormat":1},{"version":"d6258883868fb2680d2ca96bc8b1352cab69874581493e6d52680c5ffecdb6cc","impliedFormat":1},{"version":"1b61d259de5350f8b1e5db06290d31eaebebc6baafd5f79d314b5af9256d7153","impliedFormat":1},{"version":"f258e3960f324a956fc76a3d3d9e964fff2244ff5859dcc6ce5951e5413ca826","impliedFormat":1},{"version":"643f7232d07bf75e15bd8f658f664d6183a0efaca5eb84b48201c7671a266979","impliedFormat":1},{"version":"21da358700a3893281ce0c517a7a30cbd46be020d9f0c3f2834d0a8ad1f5fc75","impliedFormat":1},{"version":"0ccdaa19852d25ecd84eec365c3bfa16e7859cadecf6e9ca6d0dbbbee439743f","affectsGlobalScope":true,"impliedFormat":1},{"version":"cc2110f7decca6bfb9392e30421cfa1436479e4a6756e8fec6cbc22625d4f881","affectsGlobalScope":true,"impliedFormat":1},{"version":"f53a7652392cf26ebbe4e29fd0672aa87c93bd6d0241289c13fab87b9ac35c8a","affectsGlobalScope":true,"impliedFormat":1},{"version":"e5e01375c9e124a83b52ee4b3244ed1a4d214a6cfb54ac73e164a823a4a7860a","affectsGlobalScope":true,"impliedFormat":1},{"version":"f90ae2bbce1505e67f2f6502392e318f5714bae82d2d969185c4a6cecc8af2fc","affectsGlobalScope":true,"impliedFormat":1},{"version":"4b58e207b93a8f1c88bbf2a95ddc686ac83962b13830fe8ad3f404ffc7051fb4","affectsGlobalScope":true,"impliedFormat":1},{"version":"1fefabcb2b06736a66d2904074d56268753654805e829989a46a0161cd8412c5","affectsGlobalScope":true,"impliedFormat":1},{"version":"b00a630557d1622ad312633bdbfbdb9c6b7220d948dca9f899db30679f160074","affectsGlobalScope":true,"impliedFormat":1},{"version":"c18a99f01eb788d849ad032b31cafd49de0b19e083fe775370834c5675d7df8e","affectsGlobalScope":true,"impliedFormat":1},{"version":"5247874c2a23b9a62d178ae84f2db6a1d54e6c9a2e7e057e178cc5eea13757fc","affectsGlobalScope":true,"impliedFormat":1},{"version":"cdcf9ea426ad970f96ac930cd176d5c69c6c24eebd9fc580e1572d6c6a88f62c","impliedFormat":1},{"version":"88809d6c1b9c78d04a133646a6feb926def05a8774c308c7c93bc32ee163d271","impliedFormat":1},{"version":"156a859e21ef3244d13afeeba4e49760a6afa035c149dda52f0c45ea8903b338","impliedFormat":1},{"version":"3ac40516c33b87f751f7507346933081a26cdb8a3e11a6b3aa07d23f803c85db","impliedFormat":1},{"version":"615754924717c0b1e293e083b83503c0a872717ad5aa60ed7f1a699eb1b4ea5c","impliedFormat":1},{"version":"14e9acf826baba0ef4b5665704084896e7bcc06f65a9ab13af7e93d27d6b7069","impliedFormat":1},{"version":"68834d631c8838c715f225509cfc3927913b9cc7a4870460b5b60c8dbdb99baf","impliedFormat":1},{"version":"829bc57ee8f287b490ab5bbc5a962fca57e432c1e38ec680ecd3ecaf12800613","impliedFormat":1},{"version":"eec76bf6b9346f3f95fa402621b889489e96930e72295b0369022f332e9b4a6a","impliedFormat":1},{"version":"3a3ff14da53d5013f3e6d8c4ad55225e3649c08786c4421ce639c00d8d589b7d","impliedFormat":1},{"version":"ea6bc8de8b59f90a7a3960005fd01988f98fd0784e14bc6922dde2e93305ec7d","impliedFormat":1},{"version":"36107995674b29284a115e21a0618c4c2751b32a8766dd4cb3ba740308b16d59","impliedFormat":1},{"version":"914a0ae30d96d71915fc519ccb4efbf2b62c0ddfb3a3fc6129151076bc01dc60","impliedFormat":1},{"version":"38004e6801340cb890afb8cb5a9fc8972297e7f88ab94026e4b0b3c61fb32f8a","impliedFormat":1},{"version":"d243db6b25788f439e7e2f03c05688e92f46764351673bb0e7b2f3631232e186","impliedFormat":1},{"version":"4d327f7d72ad0918275cea3eee49a6a8dc8114ae1d5b7f3f5d0774de75f7439a","impliedFormat":1},{"version":"149f9a9e7f04e67afa0e2a49fc0ff421035c01d6b793cfcae7d2e9f6819431e2","impliedFormat":1},{"version":"e8a9dfa4c75ef6d25df8b40eaa9c31e0a69452aaf2ced4a3f4215dbdbaa876f4","impliedFormat":1},{"version":"a70af845a2eb9dd6e2723e319e14ea7fb28b129ec1361c21509b49305448c323","impliedFormat":1},{"version":"b53dc572d4f187904207ae1166652de47aab8eeb00c254d009cb226863076b56","impliedFormat":1},{"version":"0a60a292b89ca7218b8616f78e5bbd1c96b87e048849469cccb4355e98af959a","impliedFormat":1},{"version":"0b6e25234b4eec6ed96ab138d96eb70b135690d7dd01f3dd8a8ab291c35a683a","impliedFormat":1},{"version":"9666f2f84b985b62400d2e5ab0adae9ff44de9b2a34803c2c5bd3c8325b17dc0","impliedFormat":1},{"version":"40cd35c95e9cf22cfa5bd84e96408b6fcbca55295f4ff822390abb11afbc3dca","impliedFormat":1},{"version":"b1616b8959bf557feb16369c6124a97a0e74ed6f49d1df73bb4b9ddf68acf3f3","impliedFormat":1},{"version":"f501234c5aeeeb5d7659412335227466aaacf30b952372d60afeb21c02c96348","impliedFormat":1},{"version":"40b463c6766ca1b689bfcc46d26b5e295954f32ad43e37ee6953c0a677e4ae2b","impliedFormat":1},{"version":"9ac977503f15bf13ca7c82ad9a32a782f42d43e474824e8b3bffe228fd5f2639","impliedFormat":1},{"version":"8b91ff5bb912be3ea213cbcf0075aace1f5d4ff249a0d227ed673868cb7bfabc","impliedFormat":1},{"version":"80aae6afc67faa5ac0b32b5b8bc8cc9f7fa299cff15cf09cc2e11fd28c6ae29e","impliedFormat":1},{"version":"f473cd2288991ff3221165dcf73cd5d24da30391f87e85b3dd4d0450c787a391","impliedFormat":1},{"version":"499e5b055a5aba1e1998f7311a6c441a369831c70905cc565ceac93c28083d53","impliedFormat":1},{"version":"8aee8b6d4f9f62cf3776cda1305fb18763e2aade7e13cea5bbe699112df85214","impliedFormat":1},{"version":"98498b101803bb3dde9f76a56e65c14b75db1cc8bec5f4db72be541570f74fc5","impliedFormat":1},{"version":"7cb4f431a4591b0e23002bed805dc871a874dfed6b9a3994dce68a6df73e6739","impliedFormat":1},{"version":"5d0375ca7310efb77e3ef18d068d53784faf62705e0ad04569597ae0e755c401","impliedFormat":1},{"version":"59af37caec41ecf7b2e76059c9672a49e682c1a2aa6f9d7dc78878f53aa284d6","impliedFormat":1},{"version":"addf417b9eb3f938fddf8d81e96393a165e4be0d4a8b6402292f9c634b1cb00d","impliedFormat":1},{"version":"436d7b4543b340b0f3eef4310d524242e41369b9652aa9c70428767c4dcac455","impliedFormat":1},{"version":"adf27937dba6af9f08a68c5b1d3fce0ca7d4b960c57e6d6c844e7d1a8e53adae","impliedFormat":1},{"version":"12950411eeab8563b349cb7959543d92d8d02c289ed893d78499a19becb5a8cc","impliedFormat":1},{"version":"2e85db9e6fd73cfa3d7f28e0ab6b55417ea18931423bd47b409a96e4a169e8e6","impliedFormat":1},{"version":"c46e079fe54c76f95c67fb89081b3e399da2c7d109e7dca8e4b58d83e332e605","impliedFormat":1},{"version":"e99963ae1e3a48ca7a7958c02f3e88bb963eb7978c28b68ae6b8c9f03309d83c","impliedFormat":1},{"version":"c3f5289820990ab66b70c7fb5b63cb674001009ff84b13de40619619a9c8175f","affectsGlobalScope":true,"impliedFormat":1},{"version":"b3275d55fac10b799c9546804126239baf020d220136163f763b55a74e50e750","affectsGlobalScope":true,"impliedFormat":1},{"version":"fa68a0a3b7cb32c00e39ee3cd31f8f15b80cac97dce51b6ee7fc14a1e8deb30b","affectsGlobalScope":true,"impliedFormat":1},{"version":"1cf059eaf468efcc649f8cf6075d3cb98e9a35a0fe9c44419ec3d2f5428d7123","affectsGlobalScope":true,"impliedFormat":1},{"version":"6c36e755bced82df7fb6ce8169265d0a7bb046ab4e2cb6d0da0cb72b22033e89","affectsGlobalScope":true,"impliedFormat":1},{"version":"e7721c4f69f93c91360c26a0a84ee885997d748237ef78ef665b153e622b36c1","affectsGlobalScope":true,"impliedFormat":1},{"version":"7a93de4ff8a63bafe62ba86b89af1df0ccb5e40bb85b0c67d6bbcfdcf96bf3d4","affectsGlobalScope":true,"impliedFormat":1},{"version":"90e85f9bc549dfe2b5749b45fe734144e96cd5d04b38eae244028794e142a77e","affectsGlobalScope":true,"impliedFormat":1},{"version":"e0a5deeb610b2a50a6350bd23df6490036a1773a8a71d70f2f9549ab009e67ee","affectsGlobalScope":true,"impliedFormat":1},{"version":"594ae90cacd813fa392ff80d2e0a8eff4e41f4a136329a940e321399dd8895b4","impliedFormat":1},{"version":"d1f333ade8ff35a409b4984e1f11956fe11c61855b0c7e9b59f0313e48b40c4a","impliedFormat":1},{"version":"0224aa4b3464895d69c413a640a19ac2166778a74eb5eb3b36b021c72d42b274","impliedFormat":1},{"version":"2e6fca0024dd8a076a886d9ec031a936ea59ad878a25b944820495d92f8381dd","affectsGlobalScope":true,"impliedFormat":1},{"version":"177459cba484e2f1e08872a3d2fdbca3162d9d43ca5ec9dc0c946835b55f74be","impliedFormat":1},{"version":"2fbf504c4791f9d32cd766cfe6b605bcda63289b925401953a7900db9af85348","impliedFormat":1},{"version":"ed0fb633cae35948d9e144004299a4bdf1ab912667c787b7fbffcd6d8c7b92a2","impliedFormat":1},{"version":"1678b04557dca52feab73cc67610918a7f5e25bfdba3e7fa081acd625d93106d","impliedFormat":1},{"version":"010eccc3ce4a7ea2e546f6e58cf18c891a50fd3e2a3089f07b3b844230d19a12","impliedFormat":1},{"version":"2ea729503db9793f2691162fec3dd1118cab62e96d025f8eeb376d43ec293395","impliedFormat":1},{"version":"98fc7231d6c846a8ed19bdef026ddffe5e2182cc818be74899287421ad370a87","impliedFormat":1},{"version":"3a40b5d34e014017539acb92f04cf2bc0aa71e49efb33c66039df93be97842a1","impliedFormat":1},{"version":"2bc7aa4fba46df0bd495425a7c8201437a7d465f83854fac859df2d67f664df3","impliedFormat":1},{"version":"41d17e1ad9a002feb11c8cdd2777e5bbc0cdb1e3f595d237e4dded0b6949983b","impliedFormat":1},{"version":"8c7e618c2a91ea7f6b5cca272a295864e92c16413be8fc56a943e8c7d5320011","affectsGlobalScope":true,"impliedFormat":1},{"version":"79a85c64bf083c5f4dd7074e804d1000c0c47301b84d48417a224decd681be30","impliedFormat":1},{"version":"9f1e3a76d5f509b5579e567de522b402cb79e201c4f47dcd014451c0580b290d","impliedFormat":1},{"version":"4f1fd541f720030367b5d7ebfea7ae5f9edc8481422993b9a363f459c5412437","impliedFormat":1},{"version":"70f3f8b2dcaf7388f26731a59c79437813e3620b594903525a303cb2a7901016","impliedFormat":1},{"version":"62e8f884c3bc6dff6189b6e662ebe8b238a645938f2df7a97b8a82fca56773a4","impliedFormat":1},{"version":"2c2bdaa1d8ead9f68628d6d9d250e46ee8e81aa4898b4769a36956ae15e060fe","impliedFormat":1},{"version":"57a0d1b3d59063d4af2d3f8aac27cfe3c20a0f5d1faf0f8598ccf0b779637939","impliedFormat":1},{"version":"5ff4433a2deae4f85ab1377e90a7554ce6b47ae51c69a84ca30a6e22fae85834","impliedFormat":1},{"version":"82b91e4e42e6c41bc7fc1b6c2dc5eba6a2ba98375eb1f210e6ff6bba2d54177e","impliedFormat":1},{"version":"97234c5303866576f913d0ccae7d58d6322d9e803c7bf1228a3fda46ab8087b2","affectsGlobalScope":true,"impliedFormat":1},{"version":"93ecf87143cac7b9d05cffc1d6bdc075b7e4fdd48ff05f1fad85043f6ae678d3","impliedFormat":1},{"version":"6f200afcb82b3e9a54bed6db23f2edf2508cd266801257312c0f124b47f2bdb9","impliedFormat":1},{"version":"ec501101c2a96133a6c695f934c8f6642149cc728571b29cbb7b770984c1088e","impliedFormat":1},{"version":"b214ebcf76c51b115453f69729ee8aa7b7f8eccdae2a922b568a45c2d7ff52f7","impliedFormat":1},{"version":"429c9cdfa7d126255779efd7e6d9057ced2d69c81859bbab32073bad52e9ba76","impliedFormat":1},{"version":"39338f84e8c4d0e3de7b3c4a7024fb3925f42100eed5cbe73be58902799dff4d","impliedFormat":1},{"version":"fbf83eb33bf5e329527add92acc65da59323876c702ddccf5f4bf1e848c92369","affectsGlobalScope":true,"impliedFormat":1},{"version":"230763250f20449fa7b3c9273e1967adb0023dc890d4be1553faca658ee65971","impliedFormat":1},{"version":"c3e9078b60cb329d1221f5878e88cecfa3e74460550e605a58fcfb41a66029ff","impliedFormat":1},{"version":"515318bc6e656f75e9e34db625316bfafbafd800dfb1642574af93735a24ad38","impliedFormat":1},{"version":"441b9bb09013654aa3d050e68b06464d8959b473e85868249d9d18f692acd35b","impliedFormat":1},{"version":"bc18a1991ba681f03e13285fa1d7b99b03b67ee671b7bc936254467177543890","impliedFormat":1},{"version":"55246f15e33ff1e2e9e679b25fa9790a48db55dc63d567fe25fac8b6a0efe911","impliedFormat":1},{"version":"fa94bbf532b7af8f394b95fa310980d6e20bd2d4c871c6a6cb9f70f03750a44b","impliedFormat":1},{"version":"03b7804d69cecd66850abada858ed6d4a59001f8c228a9fe212306ee860a4ff6","impliedFormat":1},{"version":"5b26c4dd672d88336bb929787c9bfb55119e80ba89ec6dc923da1c063892843e","affectsGlobalScope":true,"impliedFormat":1},{"version":"7fa2214bb0d64701bc6f9ce8cde2fd2ff8c571e0b23065fa04a8a5a6beb91511","impliedFormat":1},{"version":"987fd1f85dc36f4b2c927aa3db814ac6b452e970f4f55d24ed4ecbb7df09be00","impliedFormat":1},{"version":"f12624a4a8d042b68914eac1b0a16571fc1c523173fcdf2517c65d191bd5a86c","impliedFormat":1},{"version":"b4769767f13a1692a66186e01c3aa186ff808d5ff72ed36eda8c37738fb2ac92","impliedFormat":1},{"version":"841983e39bd4cbb463be385e92fda11057cab368bf27100a801c492f1d86cbaa","impliedFormat":1},{"version":"683edfc4f2b411ebe04729cb6dc09ddd26fbac2c57771a6d7c55964af776e176","impliedFormat":1},{"version":"1ec3f3a5f04cc42df33274fbe5c0937d9a9e06f249a7a26288d7d54f0763ffd4","impliedFormat":1},{"version":"e4156ddb25aa0e3b5303d372f26957b36778f0f6bbd4326359269873295e3058","affectsGlobalScope":true,"impliedFormat":1},{"version":"cc1b433a84cae05ddc5672d4823170af78606ad21ecef60dbc4570190cbf1357","impliedFormat":1},{"version":"e47f532d6e1617833f13a5b0710c0089d402c89c2f2b54f324e5a20e418d287a","impliedFormat":1},{"version":"7f78cfb2b343838612c192cb251746e3a7c62ac7675726a47e130d9b213f6580","impliedFormat":1},{"version":"201db9cf1687fab1adf5282fcba861f382b32303dc4f67c89d59655e78a25461","impliedFormat":1},{"version":"8e2577e7262051fd3c5bd6ca2b2056d358ff8853565720f92455860824c25188","impliedFormat":1},{"version":"7ec8d7d483f7394f9da611b10d3a0e402f76ff5c991261e6ce43a15f81ca4258","impliedFormat":1},{"version":"bb9dbb4b2ad81e3e71ec5ba4314973718555b9d04ba2a17dfbf875efecb8e2c0","impliedFormat":1},{"version":"82c3cc48c692438e41b94d936b8acd75ca97b18c50fa1af8a0715eb9d07d18cd","impliedFormat":1},{"version":"045a210189ec63c5488410b33f9fca53d77d051599d0d6506d8048551399c5f3","impliedFormat":1},{"version":"99ab6d0d660ce4d21efb52288a39fd35bb3f556980ec5463b1ae8f304a3bbc85","impliedFormat":1},{"version":"632c45ccb4cdc2c3a80c7a36a63dd7763016e59cac5e07bfb3e37e3548957028","impliedFormat":1},{"version":"c9a2daf6cd1eb854cd5b9e424247c5e306692055738c2effd35f7871d942b76e","impliedFormat":1},{"version":"afa1c49f8e559e413d57343339db857d2a8159435cf9cf7d4deb41718fff1b88","impliedFormat":1},{"version":"e50a7130339a951e6da9e968ed5521b0997a5b0479e148914087213839b5474c","impliedFormat":1},{"version":"2beff543f6e9a9701df88daeee3cdd70a34b4a1c11cb4c734472195a5cb2af54","impliedFormat":1},{"version":"2e07abf27aa06353d46f4448c0bbac73431f6065eef7113128a5cd804d0c384d","impliedFormat":1},{"version":"be1cc4d94ea60cbe567bc29ed479d42587bf1e6cba490f123d329976b0fe4ee5","impliedFormat":1},{"version":"42bc0e1a903408137c3df2b06dfd7e402cdab5bbfa5fcfb871b22ebfdb30bd0b","impliedFormat":1},{"version":"9894dafe342b976d251aac58e616ac6df8db91fb9d98934ff9dd103e9e82578f","impliedFormat":1},{"version":"413df52d4ea14472c2fa5bee62f7a40abd1eb49be0b9722ee01ee4e52e63beb2","impliedFormat":1},{"version":"db6d2d9daad8a6d83f281af12ce4355a20b9a3e71b82b9f57cddcca0a8964a96","impliedFormat":1},{"version":"446a50749b24d14deac6f8843e057a6355dd6437d1fac4f9e5ce4a5071f34bff","impliedFormat":1},{"version":"182e9fcbe08ac7c012e0a6e2b5798b4352470be29a64fdc114d23c2bab7d5106","impliedFormat":1},{"version":"2f4e6b4d39426a1b85ecf4bdeb9dddbf4d9b3397d95d8555d46f925c9519ec7d","impliedFormat":1},{"version":"78a2869ad0cbf3f9045dda08c0d4562b7e1b2bfe07b19e0db072f5c3c56e9584","impliedFormat":1},{"version":"89d5d28d4f57e000b836ac273079be1b75710e28ce14750d081fb420d37e2ca5","impliedFormat":1},{"version":"fd4e24ccff3966390600d7f5d6aa1fed5a512e92ada735ea5fbc933d313ad3d3","impliedFormat":1},{"version":"b7cddfe1aa6b86b5fad3c9ccb30d05b3ccb165aebbf112f48d2d8a5f69dd98b1","impliedFormat":1},{"version":"a86f82d646a739041d6702101afa82dcb935c416dd93cbca7fd754fd0282ce1f","impliedFormat":1},{"version":"ad0d1d75d129b1c80f911be438d6b61bfa8703930a8ff2be2f0e1f8a91841c64","impliedFormat":1},{"version":"bd2c7ada3dee03653d3f601011d30072194bc3970cd93208f9588fbdc0c69347","impliedFormat":1},{"version":"e480da45d32313e7174b265674da504f075f59ef326852f0c5a5d863b438ae85","impliedFormat":1},{"version":"ad54850f61fcf5d014e11be80d2f46fea9265cfa7e77456da876f7833ef81769","impliedFormat":1},{"version":"6f7c9e8bd2b5b6a080b07080065f94900bd3c7e5ebbd3047bc33fcce2fab1dd8","impliedFormat":1},{"version":"3e7efde639c6a6c3edb9847b3f61e308bf7a69685b92f665048c45132f51c218","impliedFormat":1},{"version":"df45ca1176e6ac211eae7ddf51336dc075c5314bc5c253651bae639defd5eec5","impliedFormat":1},{"version":"8a0e762ceb20c7e72504feef83d709468a70af4abccb304f32d6b9bac1129b2c","impliedFormat":1},{"version":"da5950ee2a90721df6f3fba45f5d05308f7e4c35835392215dd2cd404505e2de","impliedFormat":1},{"version":"ce75b1aebb33d510ff28af960a9221410a3eaf7f18fc5f21f9404075fba77256","impliedFormat":1},{"version":"f42d5fed19610d485c646a0c430e768115567d078c7fc855c57b0c578b3d6cd3","impliedFormat":1},{"version":"ee8df1cb8d0faaca4013a1b442e99130769ce06f438d18d510fed95890067563","impliedFormat":1},{"version":"d5630f2ad9b4541e5ce891648121022f9412ecdca1820baa1f0104f70fd7eff7","impliedFormat":1},{"version":"4d15375ab13497104bc8fe56fdef2b5fd6853f29255737d23a33fa306ff7fd69","impliedFormat":1},{"version":"2cd3fc1d0d6a1e85baffd2d4f50f5efb192b5446eef567e97c94765402f0aad4","impliedFormat":1},{"version":"e4cbf2f1e89ecccaddd2c045e600ae41b732295953fb06247c7dcbc2d281ed30","impliedFormat":1},{"version":"6dcedaef57dff0d79a05ab0ab602cde74db803d1e765468bf91263786a383e1b","impliedFormat":1},{"version":"8c1697d90c394a6fd955b98eae01238eff628e129b987a68aea10f898a48e7da","impliedFormat":1},{"version":"7580e62139cb2b44a0270c8d01abcbfcba2819a02514a527342447fa69b34ef1","impliedFormat":1},{"version":"b838d4c72740eb0afd284bf7575b74c624b105eff2e8c7b4aeead57e7ac320ff","impliedFormat":1},{"version":"f374cb24e93e7798c4d9e83ff872fa52d2cdb36306392b840a6ddf46cb925cb6","impliedFormat":1},{"version":"d10d63718e1646c2279e3b33831f82c60e31f622b2b7020f1196409ca4c09242","impliedFormat":1},{"version":"106c6025f1d99fd468fd8bf6e5bda724e11e5905a4076c5d29790b6c3745e50c","impliedFormat":1},{"version":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","impliedFormat":1},{"version":"148679c6d0f449210a96e7d2e562d589e56fcde87f843a92808b3ff103f1a774","impliedFormat":1},{"version":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","impliedFormat":1},{"version":"02436d7e9ead85e09a2f8e27d5f47d9464bced31738dec138ca735390815c9f0","impliedFormat":1},{"version":"f8d5ff8eafd37499f2b6a98659dd9b45a321de186b8db6b6142faed0fea3de77","impliedFormat":1},{"version":"c86fe861cf1b4c46a0fb7d74dffe596cf679a2e5e8b1456881313170f092e3fa","impliedFormat":1},{"version":"a22dd55aa4d39906252000ab8e8a1b83b195eef7f4274eb51e457c1f11cf6580","impliedFormat":1},{"version":"540cc83ab772a2c6bc509fe1354f314825b5dba3669efdfbe4693ecd3048e34f","impliedFormat":1},{"version":"121b0696021ab885c570bbeb331be8ad82c6efe2f3b93a6e63874901bebc13e3","impliedFormat":1},{"version":"612d9da66bb046a9c1e2e8d026245ded881fc4b9f98cbfae714415d57ee0ae0b","impliedFormat":1},{"version":"32c2ad9494dad5d11b0564a619fee18f388db6c1e9e2cd3c360b3122549691eb","impliedFormat":1},{"version":"6c301d40aec56a74ec7bd7324e31a728dadf9bfba3e96def02938d3d973534ec","impliedFormat":1},{"version":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","impliedFormat":1},{"version":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","impliedFormat":1},{"version":"8e609bb71c20b858c77f0e9f90bb1319db8477b13f9f965f1a1e18524bf50881","impliedFormat":1},{"version":"8e609bb71c20b858c77f0e9f90bb1319db8477b13f9f965f1a1e18524bf50881","impliedFormat":1},{"version":"aa14cee20aa0db79f8df101fc027d929aec10feb5b8a8da3b9af3895d05b7ba2","impliedFormat":1},{"version":"493c700ac3bd317177b2eb913805c87fe60d4e8af4fb39c41f04ba81fae7e170","impliedFormat":1},{"version":"aeb554d876c6b8c818da2e118d8b11e1e559adbe6bf606cc9a611c1b6c09f670","impliedFormat":1},{"version":"acf5a2ac47b59ca07afa9abbd2b31d001bf7448b041927befae2ea5b1951d9f9","impliedFormat":1},{"version":"8e609bb71c20b858c77f0e9f90bb1319db8477b13f9f965f1a1e18524bf50881","impliedFormat":1},{"version":"d71291eff1e19d8762a908ba947e891af44749f3a2cbc5bd2ec4b72f72ea795f","impliedFormat":1},{"version":"c0480e03db4b816dff2682b347c95f2177699525c54e7e6f6aa8ded890b76be7","impliedFormat":1},{"version":"25a5f6fd3a2243c859eddc99ab5fba11d970af2fe7a5df9c32b7668f76f97b01","impliedFormat":1},{"version":"8d207e1f9d2c30d6f77dfa693f3827c3fbf0d89240297e10bdfe1041d433df68","impliedFormat":1},{"version":"b620391fe8060cf9bedc176a4d01366e6574d7a71e0ac0ab344a4e76576fcbb8","impliedFormat":1},{"version":"6ac6715916fa75a1f7ebdfeacac09513b4d904b667d827b7535e84ff59679aff","impliedFormat":1},{"version":"2652448ac55a2010a1f71dd141f828b682298d39728f9871e1cdf8696ef443fd","impliedFormat":1},{"version":"d682336018141807fb602709e2d95a192828fcb8d5ba06dda3833a8ea98f69e3","impliedFormat":1},{"version":"6124e973eab8c52cabf3c07575204efc1784aca6b0a30c79eb85fe240a857efa","impliedFormat":1},{"version":"0d891735a21edc75df51f3eb995e18149e119d1ce22fd40db2b260c5960b914e","impliedFormat":1},{"version":"3b414b99a73171e1c4b7b7714e26b87d6c5cb03d200352da5342ab4088a54c85","impliedFormat":1},{"version":"4fbd3116e00ed3a6410499924b6403cc9367fdca303e34838129b328058ede40","impliedFormat":1},{"version":"9c82171d836c47486074e4ca8e059735bf97b205e70b196535b5efd40cbe1bc5","impliedFormat":1},{"version":"48dcc919f76c040a999c0d46d2bf25ab089645ca21b837f120b222f56a86cd76","impliedFormat":1},{"version":"2f9c89cbb29d362290531b48880a4024f258c6033aaeb7e59fbc62db26819650","impliedFormat":1},{"version":"a365c4d3bed3be4e4e20793c999c51f5cd7e6792322f14650949d827fbcd170f","impliedFormat":1},{"version":"c5426dbfc1cf90532f66965a7aa8c1136a78d4d0f96d8180ecbfc11d7722f1a5","impliedFormat":1},{"version":"65a15fc47900787c0bd18b603afb98d33ede930bed1798fc984d5ebb78b26cf9","impliedFormat":1},{"version":"9d202701f6e0744adb6314d03d2eb8fc994798fc83d91b691b75b07626a69801","impliedFormat":1},{"version":"de9d2df7663e64e3a91bf495f315a7577e23ba088f2949d5ce9ec96f44fba37d","impliedFormat":1},{"version":"c7af78a2ea7cb1cd009cfb5bdb48cd0b03dad3b54f6da7aab615c2e9e9d570c5","impliedFormat":1},{"version":"1ee45496b5f8bdee6f7abc233355898e5bf9bd51255db65f5ff7ede617ca0027","impliedFormat":1},{"version":"273782b8454e78f6a8b30d2cfbf6860499c930595095fcc1689637115f0eddda","affectsGlobalScope":true,"impliedFormat":1},{"version":"3fbdd025f9d4d820414417eeb4107ffa0078d454a033b506e22d3a23bc3d9c41","affectsGlobalScope":true,"impliedFormat":1},{"version":"dba114fb6a32b355a9cfc26ca2276834d72fe0e94cd2c3494005547025015369","impliedFormat":1},{"version":"a8f8e6ab2fa07b45251f403548b78eaf2022f3c2254df3dc186cb2671fe4996d","affectsGlobalScope":true,"impliedFormat":1},{"version":"fa6c12a7c0f6b84d512f200690bfc74819e99efae69e4c95c4cd30f6884c526e","impliedFormat":1},{"version":"f1c32f9ce9c497da4dc215c3bc84b722ea02497d35f9134db3bb40a8d918b92b","impliedFormat":1},{"version":"b73c319af2cc3ef8f6421308a250f328836531ea3761823b4cabbd133047aefa","affectsGlobalScope":true,"impliedFormat":1},{"version":"e433b0337b8106909e7953015e8fa3f2d30797cea27141d1c5b135365bb975a6","impliedFormat":1},{"version":"9f9bb6755a8ce32d656ffa4763a8144aa4f274d6b69b59d7c32811031467216e","impliedFormat":1},{"version":"5c32bdfbd2d65e8fffbb9fbda04d7165e9181b08dad61154961852366deb7540","impliedFormat":1},{"version":"ddff7fc6edbdc5163a09e22bf8df7bef75f75369ebd7ecea95ba55c4386e2441","impliedFormat":1},{"version":"0c05e9842ec4f8b7bfebfd3ca61604bb8c914ba8da9b5337c4f25da427a005f2","impliedFormat":1},{"version":"faed7a5153215dbd6ebe76dfdcc0af0cfe760f7362bed43284be544308b114cf","impliedFormat":1},{"version":"7029e566b8df176f703fb59fd437a38670c7a0e02c58b2d66dfb5b2e2b2defdb","impliedFormat":1},{"version":"7f2aa4d4989a82530aaac3f72b3dceca90e9c25bee0b1a327e8a08a1262435ad","impliedFormat":1},{"version":"d96b39301d0ded3f1a27b47759676a33a02f6f5049bfcbde81e533fd10f50dcb","impliedFormat":1},{"version":"e9f147ecca73d9346a4c073432843c159ccbe50bdcb678a78f6da10eae2cecf4","impliedFormat":1},{"version":"de061f7d72bd65c06fc1419f841dfdcb29a8e22fe6fa527d1e6eb20b897d4de0","impliedFormat":1},{"version":"663beafc2446079574570cba86e9b15f986f908ddb1b01274509970126fee945","impliedFormat":1},{"version":"a3102887d5058bf4cb5b37fa6964c09e9527c42053b3b5c642b89878620748de","impliedFormat":1},{"version":"0aaaa1727edd29673d85c9b26d7ca4d54e5407a48586903c51b48b7f7d196f61","impliedFormat":1},{"version":"d35bca0b261bff02635758c48e8ab99c61c420d0dfabbcf467e847171d876b7d","impliedFormat":1},{"version":"3bc12c40d90c342ff88a3d876996c555ed5cbee5fe8c3308a240b321f401ee46","impliedFormat":1},{"version":"ba130768aae855a5477e9e148e5c879548e6e7ccbcc56fd1934c8a18ea5b7569","impliedFormat":1},{"version":"2e4f37ffe8862b14d8e24ae8763daaa8340c0df0b859d9a9733def0eee7562d9","impliedFormat":1},{"version":"d38530db0601215d6d767f280e3a3c54b2a83b709e8d9001acb6f61c67e965fc","impliedFormat":1},{"version":"6ac6715916fa75a1f7ebdfeacac09513b4d904b667d827b7535e84ff59679aff","impliedFormat":1},{"version":"b499af2054a037a162b3b72cd886f48bbf32a3502c865c6e29fac7d2ab3ce0b5","impliedFormat":1},{"version":"b83cb14474fa60c5f3ec660146b97d122f0735627f80d82dd03e8caa39b4388c","impliedFormat":1},{"version":"48773ca557b0319c2ee62ae249cf52a81709e8be139920d6479a66274de7c4ed","impliedFormat":1},{"version":"7274fbffbd7c9589d8d0ffba68157237afd5cecff1e99881ea3399127e60572f","impliedFormat":1},{"version":"b73cbf0a72c8800cf8f96a9acfe94f3ad32ca71342a8908b8ae484d61113f647","impliedFormat":1},{"version":"bae6dd176832f6423966647382c0d7ba9e63f8c167522f09a982f086cd4e8b23","impliedFormat":1},{"version":"20865ac316b8893c1a0cc383ccfc1801443fbcc2a7255be166cf90d03fac88c9","impliedFormat":1},{"version":"c9958eb32126a3843deedda8c22fb97024aa5d6dd588b90af2d7f2bfac540f23","impliedFormat":1},{"version":"461d0ad8ae5f2ff981778af912ba71b37a8426a33301daa00f21c6ccb27f8156","impliedFormat":1},{"version":"e927c2c13c4eaf0a7f17e6022eee8519eb29ef42c4c13a31e81a611ab8c95577","impliedFormat":1},{"version":"fcafff163ca5e66d3b87126e756e1b6dfa8c526aa9cd2a2b0a9da837d81bbd72","impliedFormat":1},{"version":"70246ad95ad8a22bdfe806cb5d383a26c0c6e58e7207ab9c431f1cb175aca657","impliedFormat":1},{"version":"f00f3aa5d64ff46e600648b55a79dcd1333458f7a10da2ed594d9f0a44b76d0b","impliedFormat":1},{"version":"772d8d5eb158b6c92412c03228bd9902ccb1457d7a705b8129814a5d1a6308fc","impliedFormat":1},{"version":"802e797bcab5663b2c9f63f51bdf67eff7c41bc64c0fd65e6da3e7941359e2f7","impliedFormat":1},{"version":"b01bd582a6e41457bc56e6f0f9de4cb17f33f5f3843a7cf8210ac9c18472fb0f","impliedFormat":1},{"version":"8b4327413e5af38cd8cb97c59f48c3c866015d5d642f28518e3a891c469f240e","impliedFormat":1},{"version":"4cceef18d7f088e797a463e90b7a9dad10c6bc667724b7686e3e740ae00122be","impliedFormat":1},{"version":"7ee86fbb3754388e004de0ef9e6505485ddfb3be7640783d6d015711c03d302d","impliedFormat":1},{"version":"cc1954b539604b1e562319119ac7e888172208b32ca873f9a357a92c826bd046","impliedFormat":1},{"version":"a67b87d0281c97dfc1197ef28dfe397fc2c865ccd41f7e32b53f647184cc7307","impliedFormat":1},{"version":"771ffb773f1ddd562492a6b9aaca648192ac3f056f0e1d997678ff97dbb6bf9b","impliedFormat":1},{"version":"43e96a3d5d1411ab40ba2f61d6a3192e58177bcf3b133a80ad2a16591611726d","impliedFormat":1},{"version":"232f70c0cf2b432f3a6e56a8dc3417103eb162292a9fd376d51a3a9ea5fbbf6f","impliedFormat":1},{"version":"bb8f2dbc03533abca2066ce4655c119bff353dd4514375beb93c08590c03e023","impliedFormat":1},{"version":"706dd95827e7ebaabda91d5db2b755233e0952d98570e9c032b0f066a15c1177","affectsGlobalScope":true,"impliedFormat":1},{"version":"0b103e9abfe82d14c0ad06a55d9f91d6747154ef7cacc73cf27ecad2bfb3afcf","impliedFormat":1},{"version":"cd9304972e6d616197fb44fce00540a904f38b54306a1951b5dbeaf3c01ab5bd","impliedFormat":1},{"version":"77438e2c397a3db78407621cfc57241a305b310ddea2c185f1d555248297f587","impliedFormat":1},{"version":"120599fd965257b1f4d0ff794bc696162832d9d8467224f4665f713a3119078b","impliedFormat":1},{"version":"43ba4f2fa8c698f5c304d21a3ef596741e8e85a810b7c1f9b692653791d8d97a","impliedFormat":1},{"version":"5433f33b0a20300cca35d2f229a7fc20b0e8477c44be2affeb21cb464af60c76","impliedFormat":1},{"version":"db036c56f79186da50af66511d37d9fe77fa6793381927292d17f81f787bb195","impliedFormat":1},{"version":"a6805fcafed712aea7759f8bc731014f9d22738c1d6ef9d43b8091d1d48346d5","impliedFormat":1},{"version":"c49469a5349b3cc1965710b5b0f98ed6c028686aa8450bcb3796728873eb923e","impliedFormat":1},{"version":"4a889f2c763edb4d55cb624257272ac10d04a1cad2ed2948b10ed4a7fda2a428","impliedFormat":1},{"version":"7bb79aa2fead87d9d56294ef71e056487e848d7b550c9a367523ee5416c44cfa","impliedFormat":1},{"version":"d88ea80a6447d7391f52352ec97e56b52ebec934a4a4af6e2464cfd8b39c3ba8","impliedFormat":1},{"version":"142617b3cdf902b69c6464c9fbd942b60ab3e733ca18c032b19e0f7e2adbefe8","impliedFormat":1},{"version":"0b603555f1881f87256ffd6344d3e3ed6d466c2e701eabf381f28be8c2125892","impliedFormat":1},{"version":"897e4f7662488e3ecc79e743bdd3b78f13bdb69a97851afa5b440c4211e32ea9","impliedFormat":1},{"version":"e2e1c6d3b2d93add5200bd7bc1a8cccb4e446836b2111ece45db8683a2c765de","impliedFormat":1},{"version":"251b03d5cd243854ce870d9a9a39f491faf69898c5d6b5eee28cc7649c57417b","impliedFormat":1},{"version":"27ff4196654e6373c9af16b6165120e2dd2169f9ad6abb5c935af5abd8c7938c","impliedFormat":1},{"version":"2c4de79f406d137390608e8c0a44fba2ff8e00bacfcae7c9d1781fef10e9440d","impliedFormat":1},{"version":"07ba23a10465791be5d22deaf5ef7de7658774ddff53721e5ea17fedea1bc721","impliedFormat":1},{"version":"dca8c645c5afeb03b1ecedbf16323f33e7d0afaa6256c8e047e6e38087a97f53","impliedFormat":1},{"version":"775f181bd4a533d6f8b5e55ec1d9f1624559720ae8a70e9432258da26b38d27c","impliedFormat":1},{"version":"796273b2edc72e78a04e86d7c58ae94d370ab93a0ddf40b1aa85a37a1c29ecd7","impliedFormat":1},{"version":"5df15a69187d737d6d8d066e189ae4f97e41f4d53712a46b2710ff9f8563ec9f","impliedFormat":1},{"version":"7715134a0cf07dd41a9da2895d708625a3a303a0385e355ecaaf0b8bfaef2550","impliedFormat":1},{"version":"6ac6715916fa75a1f7ebdfeacac09513b4d904b667d827b7535e84ff59679aff","impliedFormat":1},{"version":"622694a8522b46f6310c2a9b5d2530dde1e2854cb5829354e6d1ff8f371cf469","impliedFormat":1},{"version":"cd8ce8d68567f62dd580b3c3c37777ac3f5b81944c7417f5ea83030eab533385","impliedFormat":1},{"version":"e5c939d896565dcac0f6fbdbada11284e7728ef26a069561c09aa5aa4a788393","impliedFormat":1},{"version":"9e2739b32f741859263fdba0244c194ca8e96da49b430377930b8f721d77c000","impliedFormat":1},{"version":"a9e6c0ff3f8186fccd05752cf75fc94e147c02645087ac6de5cc16403323d870","impliedFormat":1},{"version":"49af4b52f0d4d2304c5f2c6fe5fab3e153e0acc38830d0202821b877c097dd02","impliedFormat":1},{"version":"49c346823ba6d4b12278c12c977fb3a31c06b9ca719015978cb145eb86da1c61","impliedFormat":1},{"version":"bfac6e50eaa7e73bb66b7e052c38fdc8ccfc8dbde2777648642af33cf349f7f1","impliedFormat":1},{"version":"92f7c1a4da7fbfd67a2228d1687d5c2e1faa0ba865a94d3550a3941d7527a45d","impliedFormat":1},{"version":"f53b120213a9289d9a26f5af90c4c686dd71d91487a0aa5451a38366c70dc64b","impliedFormat":1},{"version":"e68b8e5a1df7c1be2bc105141456ecba70215806e1c28bfbc5c12bfce4be6e68","impliedFormat":1},{"version":"511c8f02329808d47d00b859c532ae9115590048b17325a946c74dac48428650","impliedFormat":1},{"version":"57d67b72e06059adc5e9454de26bbfe567d412b962a501d263c75c2db430f40e","impliedFormat":1},{"version":"b5f9e66625783eefcbe3d2da074b2e7ba2066d61ce3fc6ef4f22805ad946cab4","impliedFormat":1},{"version":"e37115962d284b9f7a37c2bdd2add50f88365dde41f5e0ff591ffc48a8ec7575","impliedFormat":1},{"version":"6459054aabb306821a043e02b89d54da508e3a6966601a41e71c166e4ea1474f","impliedFormat":1},{"version":"bb37588926aba35c9283fe8d46ebf4e79ffe976343105f5c6d45f282793352b2","impliedFormat":1},{"version":"f89488602bec98a142072fae7ea5ba99431a569ff580c64b7be39896474799d8","impliedFormat":1},{"version":"bbbc47961f39a57df103cf4ca3bb8f8732b4b6678a18225a0aa76d59c466956c","impliedFormat":1},{"version":"2e6114a7dd6feeef85b2c80120fdbfb59a5529c0dcc5bfa8447b6996c97a69f5","impliedFormat":1},{"version":"2ffb043dc5163458e473b7010859f86e01dc4edffcae0a93d885d028b426a546","impliedFormat":1},{"version":"c8f004e6036aa1c764ad4ec543cf89a5c1893a9535c80ef3f2b653e370de45e6","impliedFormat":1},{"version":"dd80b1e600d00f5c6a6ba23f455b84a7db121219e68f89f10552c54ba46e4dc9","impliedFormat":1},{"version":"b064c36f35de7387d71c599bfcf28875849a1dbc733e82bd26cae3d1cd060521","impliedFormat":1},{"version":"05c7280d72f3ed26f346cbe7cbbbb002fb7f15739197cbbee6ab3fd1a6cb9347","impliedFormat":1},{"version":"8de9fe97fa9e00ec00666fa77ab6e91b35d25af8ca75dabcb01e14ad3299b150","impliedFormat":1},{"version":"04b7b2e0832dfd3c31e81df3975e8d8fda28e7ff999b0aa2932608a8f6661d5c","impliedFormat":1},{"version":"ca2d34c6ed5cbd3070b8b6f32f42ae54adcc6499c1e4b99f0a5798b3f27cc653","impliedFormat":1},{"version":"9ec68995e66dd6b9dac834bf5ae85fde802714ea2e82151a5d1d53ef01b463ef","impliedFormat":1},{"version":"5c4d626b4902f2ef8a1cc146d761d276cef988016dc674e3b98fbad70e64bc9f","impliedFormat":1},{"version":"fdfaa0aad899524962e2955287b5b991ffe3be50f64e02eb60c933ca44644a94","impliedFormat":1},{"version":"53c972a0f9bc3a4ec70fff7314123ea8cfcf75b3703046f767d2dc1eea87b2fb","impliedFormat":1},{"version":"f974e4a06953682a2c15d5bd5114c0284d5abf8bc0fe4da25cb9159427b70072","impliedFormat":1},{"version":"50256e9c31318487f3752b7ac12ff365c8949953e04568009c8705db802776fb","impliedFormat":1},{"version":"7d73b24e7bf31dfb8a931ca6c4245f6bb0814dfae17e4b60c9e194a631fe5f7b","impliedFormat":1},{"version":"d130c5f73768de51402351d5dc7d1b36eaec980ca697846e53156e4ea9911476","impliedFormat":1},{"version":"413586add0cfe7369b64979d4ec2ed56c3f771c0667fbde1bf1f10063ede0b08","impliedFormat":1},{"version":"06472528e998d152375ad3bd8ebcb69ff4694fd8d2effaf60a9d9f25a37a097a","impliedFormat":1},{"version":"7303b45138d2511035056a5901a1490ebdcbf055cbb1276f8629c5121cbe733e","impliedFormat":1},{"version":"27f874cd5327507eeff699a74567f60c1215b94509f4308633a7b01922471ed2","impliedFormat":1},{"version":"a401617604fa1f6ce437b81689563dfdc377069e4c58465dbd8d16069aede0a5","impliedFormat":1},{"version":"2c6cf04bc525caf6546e859e8ef10bfb9573837ec0bc5ec7b53a7b1b8ca72781","impliedFormat":1},{"version":"8695dec09ad439b0ceef3776ea68a232e381135b516878f0901ed2ea114fd0fe","impliedFormat":1},{"version":"304b44b1e97dd4c94697c3313df89a578dca4930a104454c99863f1784a54357","impliedFormat":1},{"version":"0a437ae178f999b46b6153d79095b60c42c996bc0458c04955f1c996dc68b971","impliedFormat":1},{"version":"74b2a5e5197bd0f2e0077a1ea7c07455bbea67b87b0869d9786d55104006784f","impliedFormat":1},{"version":"4a7baeb6325920044f66c0f8e5e6f1f52e06e6d87588d837bdf44feb6f35c664","impliedFormat":1},{"version":"87cc05fe13108f02e12da7e3efd8e360fef78d96a0c9e11408ea1b1b9fb3e03d","impliedFormat":1},{"version":"1abbf67c218d23c2ce76887caac2df6c7dab3d97ba2b65348432b876f510002a","impliedFormat":1},{"version":"1a82deef4c1d39f6882f28d275cad4c01f907b9b39be9cbc472fcf2cf051e05b","impliedFormat":1},{"version":"4b20fcf10a5413680e39f5666464859fc56b1003e7dfe2405ced82371ebd49b6","impliedFormat":1},{"version":"c06ef3b2569b1c1ad99fcd7fe5fba8d466e2619da5375dfa940a94e0feea899b","impliedFormat":1},{"version":"f7d628893c9fa52ba3ab01bcb5e79191636c4331ee5667ecc6373cbccff8ae12","impliedFormat":1},{"version":"1d879125d1ec570bf04bc1f362fdbe0cb538315c7ac4bcfcdf0c1e9670846aa6","impliedFormat":1},{"version":"5a16e93d5d53d987dddda1ec606c9821f6bd31d1bdf0635e05e3841312cefa8b","impliedFormat":1},{"version":"a6dba407fc287f1e25454e75028c91bbc00675f2d1c4e8b3edcc36c08611a486","impliedFormat":1},{"version":"d663134457d8d669ae0df34eabd57028bddc04fc444c4bc04bc5215afc91e1f4","impliedFormat":1},{"version":"e91f7b1344577a02f051b9b471f33044fef8334a76dc9e1de003d17595a5219b","impliedFormat":1},{"version":"c0723195c85e19656d6b5b9fdb81d3f3403c1ae4679e722c6ea058c516b38d12","impliedFormat":1},{"version":"b55eb9f72166093b5460d34b34f5d8699c968de3bc3fc696e40f2c93f2ebf650","impliedFormat":1},{"version":"71d9eb4c4e99456b78ae182fb20a5dfc20eb1667f091dbb9335b3c017dd1c783","impliedFormat":1},{"version":"cfa846a7b7847a1d973605fbb8c91f47f3a0f0643c18ac05c47077ebc72e71c7","impliedFormat":1},{"version":"1594da19968752a22b2ac48c2d0e60575700e745c577a8a4a676b841238ad5bb","impliedFormat":1},{"version":"e0cee12109e0a10a4c3d6769fcc7644b7c1ea7f52365bea51728f5af29f8a137","impliedFormat":1},{"version":"7d4254b4c6c67a29d5e7f65e67d72540480ac2cfb041ca484847f5ae70480b62","impliedFormat":1},{"version":"3536968defef8a75514f547ead5e2e9c1e984820290ec9b00c5fdfb6ef786535","impliedFormat":1},{"version":"d83773870080c30a230e322ce13a9c6f3398e8dacea4ea8a83e26370f3bac23e","impliedFormat":1},{"version":"dcfeaf98d66314fec29a9076c4290e45d0b196a65827becc19138e9c7b855f37","impliedFormat":1},{"version":"6849fe9210fe4946d5f085bfed36758f33dc6ae15a751338d178dd4daa017c46","impliedFormat":1},{"version":"888cda0fa66d7f74e985a3f7b1af1f64b8ff03eb3d5e80d051c3cbdeb7f32ab7","impliedFormat":1},{"version":"60681e13f3545be5e9477acb752b741eae6eaf4cc01658a25ec05bff8b82a2ef","impliedFormat":1},{"version":"ffae4e1e06aa848a1e4bcef162cd1c48e5909b26223515981310af9c036bdfc7","impliedFormat":1},{"version":"a57b1802794433adec9ff3fed12aa79d671faed86c49b09e02e1ac41b4f1d33a","impliedFormat":1},{"version":"34e16eb7c31768a11a08aebcfb3d70d7b8f0b016197e98d8419e566ceae6d6c8","impliedFormat":1},{"version":"f94ec1f7e4b709d26960306c9082a7a1b728a6e13089346aa48ba57c74cbf47e","impliedFormat":1},{"version":"9a11cb4033405e96c247cd5aa29790212aaffdd127869e8a5219103f0b389fd5","impliedFormat":1},{"version":"01479d9d5a5dda16d529b91811375187f61a06e74be294a35ecce77e0b9e8d6c","impliedFormat":1},{"version":"aff5213585cb72e94054dfe17250ff315f3569b3919d1ef1ad235f37c4ee894e","impliedFormat":1},{"version":"fb2ea35e1be6388d722d7725e2b49c697d34d9c890c3b96758faaeb86d35cef8","impliedFormat":1},{"version":"ce0df82a9ae6f914ba08409d4d883983cc08e6d59eb2df02d8e4d68309e7848b","impliedFormat":1},{"version":"1a4dc28334a926d90ba6a2d811ba0ff6c22775fcc13679521f034c124269fd40","impliedFormat":1},{"version":"f05315ff85714f0b87cc0b54bcd3dde2716e5a6b99aedcc19cad02bf2403e08c","impliedFormat":1},{"version":"5fad3b31fc17a5bc58095118a8b160f5260964787c52e7eb51e3d4fcf5d4a6f0","impliedFormat":1},{"version":"72105519d0390262cf0abe84cf41c926ade0ff475d35eb21307b2f94de985778","impliedFormat":1},{"version":"456006a6975b26c0a1785feddae165f6d307e2d601ffde27e21fc4a790e448a4","impliedFormat":1},{"version":"c857e0aae3f5f444abd791ec81206020fbcc1223e187316677e026d1c1d6fe08","impliedFormat":1},{"version":"ccf6dd45b708fb74ba9ed0f2478d4eb9195c9dfef0ff83a6092fa3cf2ff53b4f","impliedFormat":1},{"version":"1fe0d18b111e1145a7e7601855bccd4ca20f24e3b9a5aba6bb1fa9d1a7059170","impliedFormat":1},{"version":"5632c3c26d420c063eebe64c45b1248b9492a67bf44f1d0c57e9dc8f6cf449bb","impliedFormat":1},{"version":"0df5aa619ab12993a39ea6dae062ee46eadbb4d738916460e636ada52bced75b","impliedFormat":1},{"version":"8fca3039857709484e5893c05c1f9126ab7451fa6c29e19bb8c2411a2e937345","impliedFormat":1},{"version":"35069c2c417bd7443ae7c7cafd1de02f665bf015479fec998985ffbbf500628c","impliedFormat":1},{"version":"10ab7be91f87ebe8916b62cf28af2e45b5601fc7b0e311adf838f912c6b31dd8","impliedFormat":1},{"version":"bc636fbc08e0979ceb7eb0731a33000283d77a33b62e1f71ee65be50394e40ba","impliedFormat":1},{"version":"7e0b7f91c5ab6e33f511efc640d36e6f933510b11be24f98836a20a2dc914c2d","impliedFormat":1},{"version":"045b752f44bf9bbdcaffd882424ab0e15cb8d11fa94e1448942e338c8ef19fba","impliedFormat":1},{"version":"2894c56cad581928bb37607810af011764a2f511f575d28c9f4af0f2ef02d1ab","impliedFormat":1},{"version":"0a72186f94215d020cb386f7dca81d7495ab6c17066eb07d0f44a5bf33c1b21a","impliedFormat":1},{"version":"75bbd3be047d539988a0ff0b56384ef7a6a25f3b676ad96bee547d44c31622a7","impliedFormat":1},{"version":"42960001a776b089ade681ab5cfddc936e0afb0615133ec1841f3dee89d3e1bf","impliedFormat":1},{"version":"0aedb02516baf3e66b2c1db9fef50666d6ed257edac0f866ea32f1aa05aa474f","impliedFormat":1},{"version":"da47712b394d944328245482603bc6f416d3949b67c9392279caab595076b510","affectsGlobalScope":true,"impliedFormat":1},{"version":"37d0071d8f0a06dc55c2c5e0ec3391affd4fd107c53410bf358196ec0bf3923f","impliedFormat":1},{"version":"b213dad76ca37fd552274c9499056e1c0d9c1bd38a55bb7f68b22ba6b84c3ad7","impliedFormat":1},{"version":"c30436b130b6218b7714314dc41d3f459590db4bdf099eecd51cb1bda32109a8","impliedFormat":1},{"version":"20fa37b636fdcc1746ea0738f733d0aed17890d1cd7cb1b2f37010222c23f13e","impliedFormat":1},{"version":"d90b9f1520366d713a73bd30c5a9eb0040d0fb6076aff370796bc776fd705943","impliedFormat":1},{"version":"bc03c3c352f689e38c0ddd50c39b1e65d59273991bfc8858a9e3c0ebb79c023b","impliedFormat":1},{"version":"19df3488557c2fc9b4d8f0bac0fd20fb59aa19dec67c81f93813951a81a867f8","affectsGlobalScope":true,"impliedFormat":1},{"version":"b25350193e103ae90423c5418ddb0ad1168dc9c393c9295ef34980b990030617","affectsGlobalScope":true,"impliedFormat":1},{"version":"bef86adb77316505c6b471da1d9b8c9e428867c2566270e8894d4d773a1c4dc2","impliedFormat":1},{"version":"5a49adaef698b7ad7e6127949fa1b0bbd3d46b7cbd11c54e392a4dcdd51f5190","impliedFormat":1},{"version":"6ee598cdfdd0fa52039dca135b3dfff7b49035dc13292143e0a93843e3861967","impliedFormat":1},{"version":"27be6622e2922a1b412eb057faa854831b95db9db5035c3f6d4b677b902ab3b7","impliedFormat":1},{"version":"5c634644d45a1b6bc7b05e71e05e52ec04f3d73d9ac85d5927f647a5f965181a","impliedFormat":1},{"version":"2489bf04d77dc025ba67f49f1a56eb24b9db477d5ff88123d887e163ed1776aa","impliedFormat":1},{"version":"63a7595a5015e65262557f883463f934904959da563b4f788306f699411e9bac","impliedFormat":1},{"version":"4ba137d6553965703b6b55fd2000b4e07ba365f8caeb0359162ad7247f9707a6","impliedFormat":1},{"version":"0b77b819b5417775fccb20c678293cf614c054a5b1a65421a5b933a9124ba998","impliedFormat":1},{"version":"eb5acb58487367e502d994b57e2c58255d8241f481ea8efa8e79af23af3f41c2","impliedFormat":1},{"version":"9252d498a77517aab5d8d4b5eb9d71e4b225bbc7123df9713e08181de63180f6","impliedFormat":1},{"version":"b1f1d57fde8247599731b24a733395c880a6561ec0c882efaaf20d7df968c5af","impliedFormat":1},{"version":"f282cb0bc62e0cc771d4c2e7ece6359a5f4a3dff664584e97476fd37154816bb","impliedFormat":1},{"version":"35e6379c3f7cb27b111ad4c1aa69538fd8e788ab737b8ff7596a1b40e96f4f90","impliedFormat":1},{"version":"1fffe726740f9787f15b532e1dc870af3cd964dbe29e191e76121aa3dd8693f2","impliedFormat":1},{"version":"5a3ea721d03a361ccbdd7390ccd75f6e84cbca3a3f01f4b331ecc9af31890c49","impliedFormat":1},{"version":"e7dfaee4af38d45b1cab8a1ee0b3bc1f85ddcf64545ed391d675d78ae6526274","affectsGlobalScope":true,"impliedFormat":1},{"version":"e8daa443eaf9a27fd382cc1f8ebe30330c0f4d89511cfb469166874806751d35","impliedFormat":1},{"version":"af48e58339188d5737b608d41411a9c054685413d8ae88b8c1d0d9bfabdf6e7e","impliedFormat":1},{"version":"616775f16134fa9d01fc677ad3f76e68c051a056c22ab552c64cc281a9686790","impliedFormat":1},{"version":"65c24a8baa2cca1de069a0ba9fba82a173690f52d7e2d0f1f7542d59d5eb4db0","impliedFormat":1},{"version":"f9fe6af238339a0e5f7563acee3178f51db37f32a2e7c09f85273098cee7ec49","impliedFormat":1},{"version":"1de8c302fd35220d8f29dea378a4ae45199dc8ff83ca9923aca1400f2b28848a","impliedFormat":1},{"version":"77e71242e71ebf8528c5802993697878f0533db8f2299b4d36aa015bae08a79c","impliedFormat":1},{"version":"98a787be42bd92f8c2a37d7df5f13e5992da0d967fab794adbb7ee18370f9849","impliedFormat":1},{"version":"332248ee37cca52903572e66c11bef755ccc6e235835e63d3c3e60ddda3e9b93","impliedFormat":1},{"version":"94e8cc88ae2ef3d920bb3bdc369f48436db123aa2dc07f683309ad8c9968a1e1","impliedFormat":1},{"version":"4545c1a1ceca170d5d83452dd7c4994644c35cf676a671412601689d9a62da35","impliedFormat":1},{"version":"320f4091e33548b554d2214ce5fc31c96631b513dffa806e2e3a60766c8c49d9","impliedFormat":1},{"version":"a2d648d333cf67b9aeac5d81a1a379d563a8ffa91ddd61c6179f68de724260ff","impliedFormat":1},{"version":"d90d5f524de38889d1e1dbc2aeef00060d779f8688c02766ddb9ca195e4a713d","impliedFormat":1},{"version":"07ed3ddab975995eea41b22f3010506fb9f5fb301d04820b07d7a1aee5477d7c","impliedFormat":1},{"version":"969d8b0965849f4bae7cab0ba90bd1e1220e95999c2c6f01117fa7500901c017","impliedFormat":1},{"version":"6ec840ee5e2bc103f557fe38b1d585ee250540468713d7634ee066de372bf332","impliedFormat":1},{"version":"b0309e1eda99a9e76f87c18992d9c3689b0938266242835dd4611f2b69efe456","impliedFormat":1},{"version":"47699512e6d8bebf7be488182427189f999affe3addc1c87c882d36b7f2d0b0e","impliedFormat":1},{"version":"6ceb10ca57943be87ff9debe978f4ab73593c0c85ee802c051a93fc96aaf7a20","impliedFormat":1},{"version":"1de3ffe0cc28a9fe2ac761ece075826836b5a02f340b412510a59ba1d41a505a","impliedFormat":1},{"version":"e46d6cc08d243d8d0d83986f609d830991f00450fb234f5b2f861648c42dc0d8","impliedFormat":1},{"version":"1c0a98de1323051010ce5b958ad47bc1c007f7921973123c999300e2b7b0ecc0","impliedFormat":1},{"version":"ff863d17c6c659440f7c5c536e4db7762d8c2565547b2608f36b798a743606ca","impliedFormat":1},{"version":"5412ad0043cd60d1f1406fc12cb4fb987e9a734decbdd4db6f6acf71791e36fe","impliedFormat":1},{"version":"ad036a85efcd9e5b4f7dd5c1a7362c8478f9a3b6c3554654ca24a29aa850a9c5","impliedFormat":1},{"version":"fedebeae32c5cdd1a85b4e0504a01996e4a8adf3dfa72876920d3dd6e42978e7","impliedFormat":1},{"version":"e297c0a524edee7677939122f90027bfbe5f2698939d9a85728e5044b39c7124","impliedFormat":1},{"version":"cdf21eee8007e339b1b9945abf4a7b44930b1d695cc528459e68a3adc39a622e","impliedFormat":1},{"version":"bc9ee0192f056b3d5527bcd78dc3f9e527a9ba2bdc0a2c296fbc9027147df4b2","impliedFormat":1},{"version":"b62381cae176db34f003cc6172ee8f3e0122014889d66391aa73698105cf4934","impliedFormat":1},{"version":"1d9c0a9a6df4e8f29dc84c25c5aa0bb1da5456ebede7a03e03df08bb8b27bae6","impliedFormat":1},{"version":"84380af21da938a567c65ef95aefb5354f676368ee1a1cbb4cae81604a4c7d17","impliedFormat":1},{"version":"1af3e1f2a5d1332e136f8b0b95c0e6c0a02aaabd5092b36b64f3042a03debf28","impliedFormat":1},{"version":"30d8da250766efa99490fc02801047c2c6d72dd0da1bba6581c7e80d1d8842a4","impliedFormat":1},{"version":"03566202f5553bd2d9de22dfab0c61aa163cabb64f0223c08431fb3fc8f70280","impliedFormat":1},{"version":"41eb514d9ce0a6e87957f08a4b7af70d93f87637f37dee706e2d92a6601c25a9","impliedFormat":1},{"version":"e7765aa8bcb74a38b3230d212b4547686eb9796621ffb4367a104451c3f9614f","impliedFormat":1},{"version":"1de80059b8078ea5749941c9f863aa970b4735bdbb003be4925c853a8b6b4450","impliedFormat":1},{"version":"1d079c37fa53e3c21ed3fa214a27507bda9991f2a41458705b19ed8c2b61173d","impliedFormat":1},{"version":"5bf5c7a44e779790d1eb54c234b668b15e34affa95e78eada73e5757f61ed76a","impliedFormat":1},{"version":"5835a6e0d7cd2738e56b671af0e561e7c1b4fb77751383672f4b009f4e161d70","impliedFormat":1},{"version":"4b7f74b772140395e7af67c4841be1ab867c11b3b82a51b1aeb692822b76c872","impliedFormat":1},{"version":"7bd01f0f28cd3aeb2046274d85208e245965f6f2948edf4f7b2057bcf9f22ccc","impliedFormat":99},{"version":"d2f2cf2b8cc92bea913cda4a076e0f790b23a21e84f989d12f0116a7fe3906e0","impliedFormat":99},{"version":"6de125ea94866c736c6d58d68eb15272cf7d1020a5b459fea1c660027eca9a90","affectsGlobalScope":true,"impliedFormat":1},{"version":"f5b20bc288ee49989c95b20847fc93b96bf61cc0845598897a6a53a967dd7d07","affectsGlobalScope":true,"impliedFormat":1},{"version":"064ac1c2ac4b2867c2ceaa74bbdce0cb6a4c16e7c31a6497097159c18f74aa7c","impliedFormat":1},{"version":"3dc14e1ab45e497e5d5e4295271d54ff689aeae00b4277979fdd10fa563540ae","impliedFormat":1},{"version":"d3b315763d91265d6b0e7e7fa93cfdb8a80ce7cdd2d9f55ba0f37a22db00bdb8","impliedFormat":1},{"version":"b789bf89eb19c777ed1e956dbad0925ca795701552d22e68fd130a032008b9f9","impliedFormat":1},{"version":"cdc033b655504d624ba38376b4aa42c6728124136a05616c2a92c73c405b888e","affectsGlobalScope":true},"4e4da12aa061aac172fb1bcb48e9b6e4b293080d2f494327925fdba8f39632ac","ab4c61f6ee100ae43610a18512f1ebcec842bb2405431e1009266173f21cf772",{"version":"86513d00f1f18e6bcb5251a8614e86c50019a799d8453541af4ee87920da836b","signature":"502643407c1fffbd3c1666cbc640c97762e57d034a6044696b0336cae3063029"},"f37cb4b40d6d91251e04bad773ea20f66b330841fda3a426522013408a9ea5f2","812eb1d6350a68b60f119bd82bdc6d52bbd269fabdb5bc8428a3bcacde19379c","03733ca468f136954f0f7470128c437598ae4a9ffd9957a8fefa1c55946a5022","eded2185c4e0fbd2c22b74f915f326b43fc748871d8c5922e2cddf37181fecd1","f2a09abeb61d0177c75a7e46dc4da7e2c0dcc1e9fe32b36403912e77b0523dd3","30e068f3f2d0f0f2ccdf04d74ff44eab6f24d1a587769acc56ab886ef0190adb","a167fcf0107be911c45f7a8a944f79c2ab334e6a3bb36aa946178ccebc569f36","4755acb39ed98a992e6672d0604f1a405cb0b339e250b067b44e462b44ceeb38","d63134e9874d38f4e58a6e1224f83126943fbeddca7c25e03f8dcb195069bd33",{"version":"d4242bfbf3142a11308145c89ae632eac1b21fb55357229a93cb4cbebf7766c5","signature":"68f8ef912191b3e581443dbcee00f66d0de64028e4c7cf957ad44ea96e8072bd"},"2e33070803a51f8ad04ffae4fea385b12d6304394cec081ee05eadabe5c574c7","dc158a32c5fe218f21ecc866ec34ceef0298ab5e46948bd1d2b1373e9f69ee43","9a06605ea65d25544a609fa551ed5a7105d3d11d4e1c10beb002ab4c4740395b","957f9bcf684e07c1c0153d4703fc7e910f749a4eac2ba3c92910679fc0d74aa9","ef54008dba174a7162b7614a0df5cda74cd7edb1a07abf879295285d5a611911","e9ec5a13eeeb013dc0566783aba2e86ce324b05655742e03fe1f46131b939f14","d1986184a09a52db8228cb2bb2a61a8c05c9354e5b93cec8e2628d8579c892d7","31e93140a35e4f02cb913848c0aa57b90880dcc4db917f765afb97168115bd52","d1986184a09a52db8228cb2bb2a61a8c05c9354e5b93cec8e2628d8579c892d7",{"version":"cdc033b655504d624ba38376b4aa42c6728124136a05616c2a92c73c405b888e","affectsGlobalScope":true},"73dd9ffc1d234b24365f0925bd1f1985ee4679adf1dea49871a45ddb1960ae5b"],"root":[[563,587]],"options":{"allowJs":false,"esModuleInterop":true,"jsx":4,"module":99,"skipLibCheck":true,"strict":true,"target":4},"referencedMap":[[585,1],[586,2],[587,3],[583,4],[563,2],[584,5],[571,6],[569,7],[572,6],[573,6],[568,8],[566,9],[567,10],[574,11],[570,12],[577,13],[576,14],[578,12],[579,15],[575,16],[580,17],[581,18],[582,11],[564,19],[565,20],[407,2],[162,21],[163,21],[164,22],[100,23],[165,24],[166,25],[167,26],[168,27],[169,28],[170,29],[171,30],[172,31],[173,32],[174,32],[175,33],[176,34],[177,2],[178,35],[179,36],[101,2],[99,2],[180,37],[181,38],[182,39],[224,40],[183,41],[184,42],[185,41],[186,43],[187,44],[188,45],[189,46],[190,46],[191,46],[192,47],[193,48],[194,49],[195,50],[196,51],[197,52],[198,52],[199,53],[200,2],[201,2],[202,54],[203,55],[204,56],[205,57],[206,58],[207,59],[208,60],[209,61],[210,62],[211,63],[212,64],[213,65],[214,66],[215,67],[216,68],[217,69],[218,70],[219,71],[220,72],[102,41],[103,2],[104,73],[105,74],[106,2],[107,75],[108,2],[153,76],[154,77],[155,78],[156,78],[157,79],[158,2],[159,24],[160,80],[161,77],[221,81],[222,82],[223,83],[228,84],[492,85],[229,86],[227,87],[494,88],[493,89],[225,90],[490,2],[226,91],[90,2],[92,92],[489,85],[259,85],[91,2],[515,93],[520,94],[527,95],[510,96],[263,2],[271,97],[411,98],[414,99],[386,2],[399,100],[406,101],[288,2],[388,2],[269,2],[385,102],[431,103],[270,2],[261,104],[413,105],[415,106],[416,107],[487,108],[380,109],[333,110],[393,111],[394,112],[392,113],[391,2],[387,114],[412,115],[272,116],[457,2],[458,117],[299,118],[273,119],[300,118],[336,118],[239,118],[409,120],[408,2],[398,121],[505,2],[248,2],[526,122],[465,123],[466,124],[462,125],[544,2],[363,2],[467,6],[463,126],[549,127],[548,128],[543,2],[314,2],[366,129],[365,2],[542,130],[464,85],[319,131],[326,132],[328,133],[318,2],[323,134],[325,135],[327,136],[322,137],[320,2],[324,138],[545,2],[541,2],[547,139],[546,2],[317,140],[536,141],[539,142],[307,143],[306,144],[305,145],[552,85],[304,146],[293,2],[554,2],[555,85],[556,147],[231,2],[395,148],[396,149],[397,150],[235,2],[400,2],[255,151],[230,2],[479,85],[237,152],[478,153],[477,154],[468,2],[469,2],[476,2],[471,2],[474,155],[470,2],[472,156],[475,157],[473,156],[268,2],[265,2],[266,118],[420,2],[425,158],[426,159],[424,160],[422,161],[423,162],[418,2],[485,6],[260,6],[514,163],[521,164],[525,165],[354,166],[353,2],[348,2],[501,167],[509,168],[381,169],[382,170],[460,171],[370,2],[483,172],[358,85],[375,173],[486,174],[371,2],[374,175],[372,2],[484,176],[481,177],[480,2],[482,2],[378,2],[456,178],[243,179],[356,180],[360,181],[376,182],[379,183],[368,184],[361,185],[508,186],[434,187],[352,188],[240,189],[507,190],[236,191],[427,192],[419,2],[428,193],[445,194],[417,2],[444,195],[98,2],[439,196],[264,2],[459,197],[435,2],[249,2],[251,2],[390,2],[443,198],[267,2],[291,199],[377,200],[297,201],[357,2],[442,2],[421,2],[447,202],[448,203],[389,2],[450,204],[452,205],[451,206],[401,2],[441,189],[454,207],[351,208],[440,209],[446,210],[276,2],[280,2],[279,2],[278,2],[283,2],[277,2],[286,2],[285,2],[282,2],[281,2],[284,2],[287,211],[275,2],[343,212],[342,2],[347,213],[344,214],[346,215],[349,213],[345,214],[256,216],[335,217],[504,218],[502,2],[531,219],[533,220],[497,221],[532,222],[244,223],[241,223],[274,2],[258,224],[257,225],[253,226],[254,227],[262,228],[290,228],[301,228],[337,229],[302,229],[246,230],[245,2],[341,231],[340,232],[339,233],[338,234],[247,235],[488,236],[289,237],[496,238],[461,239],[491,240],[495,241],[384,242],[383,243],[364,244],[350,245],[332,246],[334,247],[331,248],[453,249],[355,2],[519,2],[252,250],[455,251],[503,252],[362,2],[292,253],[369,254],[367,255],[294,256],[429,257],[498,2],[295,258],[430,258],[517,2],[516,2],[518,2],[500,2],[499,2],[432,259],[359,2],[329,260],[250,261],[308,2],[234,262],[296,2],[523,85],[233,2],[535,263],[316,85],[529,6],[315,264],[512,265],[313,263],[238,2],[537,266],[311,85],[312,85],[303,2],[232,2],[310,267],[309,268],[298,269],[373,50],[433,50],[449,2],[437,270],[436,2],[321,140],[242,2],[330,85],[506,151],[513,271],[93,85],[96,272],[97,273],[94,85],[95,2],[410,74],[405,274],[404,2],[403,275],[402,2],[511,276],[522,277],[524,278],[528,279],[530,280],[534,281],[562,282],[538,282],[561,283],[540,284],[550,285],[551,286],[553,287],[557,288],[560,151],[559,2],[558,289],[438,290],[88,2],[89,2],[14,2],[15,2],[17,2],[16,2],[2,2],[18,2],[19,2],[20,2],[21,2],[22,2],[23,2],[24,2],[25,2],[3,2],[26,2],[27,2],[4,2],[28,2],[32,2],[29,2],[30,2],[31,2],[33,2],[34,2],[35,2],[5,2],[36,2],[37,2],[38,2],[39,2],[6,2],[43,2],[40,2],[41,2],[42,2],[44,2],[7,2],[45,2],[50,2],[51,2],[46,2],[47,2],[48,2],[49,2],[8,2],[55,2],[52,2],[53,2],[54,2],[56,2],[9,2],[57,2],[58,2],[59,2],[61,2],[60,2],[62,2],[63,2],[10,2],[64,2],[65,2],[66,2],[11,2],[67,2],[68,2],[69,2],[70,2],[71,2],[72,2],[12,2],[73,2],[74,2],[75,2],[76,2],[77,2],[1,2],[78,2],[79,2],[13,2],[80,2],[81,2],[82,2],[83,2],[84,2],[85,2],[86,2],[87,2],[127,291],[141,292],[124,293],[142,294],[151,295],[115,296],[116,297],[114,298],[150,289],[145,299],[149,300],[118,301],[128,302],[138,303],[117,304],[148,305],[112,306],[113,299],[119,302],[120,2],[126,307],[123,302],[110,308],[152,309],[143,310],[131,311],[130,302],[132,312],[135,313],[129,314],[133,315],[146,289],[121,316],[122,317],[136,318],[111,294],[140,319],[139,302],[125,317],[134,320],[137,321],[144,2],[109,2],[147,322]],"affectedFilesPendingEmit":[587,584,571,569,572,573,568,566,567,574,570,577,576,578,579,575,580,581,582,565],"version":"6.0.3"}
\ No newline at end of file