test: expand exporter/css/a11y/i18n regressions and add e2e skip-link focus check

Reviewed-on: #2
Co-authored-by: Jaybe <master@jaybe.dev>
Co-committed-by: Jaybe <master@jaybe.dev>

.gitea/workflows/auto-label.yml

@@ -1,37 +0,0 @@
-name: Auto Label PR
-
-on:
-  pull_request:
-    types: [opened, synchronize, reopened]
-
-jobs:
-  add-automerge-label:
-    runs-on: [macos, host]
-    steps:
-      - name: Add 'automerge' label to PR
-        env:
-          CI_TOKEN: ${{ secrets.CI_TOKEN }}
-          GITEA_BASE_URL: https://gitea.jaybe.dev
-          PR_NUMBER: ${{ github.event.pull_request.number }}
-          REPO: ${{ github.repository }}
-        run: |
-          set -euo pipefail
-          if [ -z "${CI_TOKEN:-}" ]; then
-            echo "CI_TOKEN not set; skipping labeling"; exit 0; fi
-          OWNER=$(echo "$REPO" | cut -d'/' -f1)
-          NAME=$(echo "$REPO" | cut -d'/' -f2)
-          echo "Resolving existing label id for 'automerge' in $OWNER/$NAME (no creation)"
-          curl -sS -o /tmp/labels.json -H "Authorization: token ${CI_TOKEN}" \
-            "${GITEA_BASE_URL}/api/v1/repos/${OWNER}/${NAME}/labels?limit=1000" || true
-          # Extract all ids whose name == automerge, prefer the smallest id (oldest)
-          LID=$(tr '\n' ' ' < /tmp/labels.json | \
-            grep -o '"id":[0-9][0-9]*[^\}]*"name":"automerge"' | \
-            sed -E 's/.*"id":([0-9]+).*/\1/' | sort -n | head -n1 || true)
-          if [ -z "${LID:-}" ]; then
-            echo "No existing 'automerge' label found; skipping labeling"; exit 0; fi
-          echo "Labeling PR #$PR_NUMBER with id $LID"
-          curl -sS -X POST \
-            -H "Content-Type: application/json" \
-            -H "Authorization: token ${CI_TOKEN}" \
-            "${GITEA_BASE_URL}/api/v1/repos/${OWNER}/${NAME}/issues/${PR_NUMBER}/labels" \
-            -d '{"labels":['"${LID}"']}' || true

.gitea/workflows/auto-pr.yml

@@ -1,76 +0,0 @@
-name: Auto PR
-
-on:
-  push:
-    branches:
-      - 'feat/**'
-
-jobs:
-  open-pr:
-    runs-on: [macos, host]
-    steps:
-      - name: Create Pull Request via Gitea API
-        env:
-          CI_TOKEN: ${{ secrets.CI_TOKEN }}
-          GITEA_BASE_URL: https://gitea.jaybe.dev
-          REPO: ${{ github.repository }}
-          HEAD_BRANCH: ${{ github.ref_name }}
-          BASE_BRANCH: main
-        run: |
-          set -euo pipefail
-          if [ -z "${CI_TOKEN:-}" ]; then
-            echo "GITEA_TOKEN not set; skipping auto-pr"; exit 0; fi
-          OWNER=$(echo "$REPO" | cut -d'/' -f1)
-          NAME=$(echo "$REPO" | cut -d'/' -f2)
-          TITLE="auto: PR for $HEAD_BRANCH"
-          BODY="Automated PR created on push to $HEAD_BRANCH"
-          echo "Creating PR $HEAD_BRANCH -> $BASE_BRANCH for $OWNER/$NAME"
-          HTTP_CODE=$(curl -sS -o /tmp/pr_resp.json -w "%{http_code}" -X POST \
-            -H "Content-Type: application/json" \
-            -H "Authorization: token ${CI_TOKEN}" \
-            "${GITEA_BASE_URL}/api/v1/repos/${OWNER}/${NAME}/pulls" \
-            -d "{\"head\":\"${HEAD_BRANCH}\",\"base\":\"${BASE_BRANCH}\",\"title\":\"${TITLE}\",\"body\":\"${BODY}\"}") || true
-          echo "API status: $HTTP_CODE"
-          if [ "$HTTP_CODE" = "201" ]; then
-            echo "PR created"; cat /tmp/pr_resp.json
-            PR_NUMBER=$(cat /tmp/pr_resp.json | sed -n 's/.*"number":\([0-9]*\).*/\1/p' | head -n1)
-          else
-            echo "PR not created (possibly exists). Response:"; cat /tmp/pr_resp.json || true
-          fi
-
-          # Retry to resolve PR number by listing open PRs and matching head/base
-          i=0
-          while [ -z "${PR_NUMBER:-}" ] && [ $i -lt 10 ]; do
-            i=$((i+1))
-            echo "[retry $i] Resolving PR number for $HEAD_BRANCH -> $BASE_BRANCH"
-            curl -sS -o /tmp/pr_list.json -H "Authorization: token ${CI_TOKEN}" \
-              "${GITEA_BASE_URL}/api/v1/repos/${OWNER}/${NAME}/pulls?state=open" || true
-            # Extract PR number matching head.ref==HEAD_BRANCH and base.ref==BASE_BRANCH
-            PR_NUMBER=$(awk -v hb="$HEAD_BRANCH" -v bb="$BASE_BRANCH" 'BEGIN{RS="},"; pr=""} {
-              if($0 ~ /\"head\":\{[^}]*\"ref\":\"" hb "\"/ && $0 ~ /\"base\":\{[^}]*\"ref\":\"" bb "\"/){
-                if (match($0, /\"number\":([0-9]+)/, m)) { print m[1]; exit }
-              }
-            }' /tmp/pr_list.json)
-            if [ -z "${PR_NUMBER:-}" ]; then sleep 2; fi
-          done
-
-          if [ -n "${PR_NUMBER:-}" ]; then
-            echo "Resolving existing label id for 'automerge' in $OWNER/$NAME (no creation)"
-            curl -sS -o /tmp/labels.json -H "Authorization: token ${CI_TOKEN}" \
-              "${GITEA_BASE_URL}/api/v1/repos/${OWNER}/${NAME}/labels?limit=1000" || true
-            LID=$(tr '\n' ' ' < /tmp/labels.json | \
-              grep -o '"id":[0-9][0-9]*[^\}]*"name":"automerge"' | \
-              sed -E 's/.*"id":([0-9]+).*/\1/' | sort -n | head -n1 || true)
-            if [ -n "${LID:-}" ]; then
-              echo "Adding 'automerge' (id=$LID) label to PR #$PR_NUMBER"
-              curl -sS -X POST \
-                -H "Content-Type: application/json" \
-                -H "Authorization: token ${CI_TOKEN}" \
-                "${GITEA_BASE_URL}/api/v1/repos/${OWNER}/${NAME}/issues/${PR_NUMBER}/labels" \
-                -d '{"labels":['"${LID}"']}' || true
-            else
-              echo "No existing 'automerge' label found; skipping label add"
-            fi
-          else
-            echo "PR number could not be determined; skipping label add"
-          fi

.gitea/workflows/ci.yml

@@ -42,41 +42,3 @@ jobs:
           path: playwright-report
           if-no-files-found: ignore
           retention-days: 3
-
-      - name: Auto-merge PR on green
-        if: ${{ github.event_name == 'pull_request' }}
-        env:
-          CI_TOKEN: ${{ secrets.CI_TOKEN }}
-          GITEA_BASE_URL: https://gitea.jaybe.dev
-          PR_NUMBER: ${{ github.event.pull_request.number }}
-          REPO: ${{ github.repository }}
-        run: |
-          set -euo pipefail
-          if [ -z "${CI_TOKEN:-}" ]; then
-            echo "CI_TOKEN not set; skipping auto-merge"; exit 0; fi
-          OWNER=$(echo "$REPO" | cut -d'/' -f1)
-          NAME=$(echo "$REPO" | cut -d'/' -f2)
-          echo "Checking labels for PR #$PR_NUMBER on $OWNER/$NAME"
-          LABELS_JSON=$(curl -sS -X GET \
-            -H "Authorization: token ${CI_TOKEN}" \
-            "${GITEA_BASE_URL}/api/v1/repos/${OWNER}/${NAME}/issues/${PR_NUMBER}")
-          echo "labels payload (first 200 chars):"; echo "$LABELS_JSON" | cut -c1-200 || true
-          if ! echo "$LABELS_JSON" | grep -qi '"name":"automerge"'; then
-            echo "Label 'automerge' not present; skipping merge"; exit 0; fi
-          echo "Label 'automerge' present; proceeding to merge"
-          # ensure PR is open
-          PR_JSON=$(curl -sS -X GET \
-            -H "Authorization: token ${CI_TOKEN}" \
-            "${GITEA_BASE_URL}/api/v1/repos/${OWNER}/${NAME}/pulls/${PR_NUMBER}")
-          STATE=$(echo "$PR_JSON" | sed -n 's/.*"state":"\([^"]*\)".*/\1/p')
-          echo "PR state: ${STATE:-unknown}"
-          if [ "${STATE:-}" != "open" ]; then
-            echo "PR state is not open; skipping merge"; exit 0; fi
-          echo "Merging PR #$PR_NUMBER for $OWNER/$NAME"
-          HTTP_CODE=$(curl -sS -o /tmp/merge_resp.json -w "%{http_code}" -X POST \
-            -H "Content-Type: application/json" \
-            -H "Authorization: token ${CI_TOKEN}" \
-            "${GITEA_BASE_URL}/api/v1/repos/${OWNER}/${NAME}/pulls/${PR_NUMBER}/merge" \
-            -d '{"Do":"merge","MergeMessage":"auto-merge: CI green"}' || true)
-          echo "merge http: $HTTP_CODE"
-          echo "merge resp:"; cat /tmp/merge_resp.json || true

.gitignore

@@ -39,4 +39,3 @@ yarn-error.log*
 # typescript
 *.tsbuildinfo
 next-env.d.ts
-MAIN_PLAN.md

MAIN_PLAN.md

@@ -0,0 +1,237 @@
+# 메인플랜: 랜딩 페이지 빌더
+
+## 목표
+- 비개발자도 사용 가능한 단일 페이지 랜딩 페이지 빌더.
+- 결과물: 정적 ZIP(HTML/CSS/JS) 다운로드. 이미지: 외부 URL 또는 로컬 업로드(서버 저장 없음, ZIP에 패키징). 폰트는 외부 CDN 허용.
+- 폼: 다양한 필드 타입(파일 업로드 제외), 커스텀 name, action URL 설정. action 미지정 시 Google Sheets 저장.
+- 다국어 지원(i18n), 접근성 준수, SEO/OG 메타, 분석 스니펫 삽입.
+
+## 확정 요구사항
+- 단일 페이지 기준.
+- 이미지: 외부 URL 또는 로컬 업로드 허용(서버 저장 없음, ZIP 패키징). CDN 허용(예: Google Fonts 등).
+- 폼 필드 타입: 텍스트/이메일/전화/셀렉트/라디오/체크박스/텍스트에어리어/날짜 등(파일 업로드는 추후).
+- 검증 규칙 필요. 스팸 방지: 기본(honeypot, 제출지연 타임스탬프).
+- 제출 경로: 1) 사용자가 action URL 지정 → 2) 미지정 시 Google Sheets.
+  - 기본: Google Apps Script 웹앱 템플릿 가이드 제공(사용자 배포 URL 사용)。
+  - 대안: 서비스계정 + Google Sheets API(선택).
+- 다국어 지원 필요. 접근성 준수. SEO/OG 포함. 분석 스니펫 삽입 기능 필요.
+- 스택: React 기반. Next.js(App Router) + TS + Tailwind + shadcn/ui 권장.
+
+## 아키텍처 개요
+- 빌더 앱: Next.js(App Router, TS), Tailwind, shadcn/ui, dnd-kit, Zustand.
+- 도메인 스키마: Page → Section[] → Block[] → Form(fields, validation, actionUrl) → Theme.
+- 에셋 매니저: 사용자가 업로드한 이미지를 메모리/브라우저에서 관리, 파일명 해싱 후 `assets/` 경로로 참조 재작성.
+- HTML Exporter: JSON 스키마 → 정적 HTML/CSS/JS 생성. 로컬 업로드 이미지는 `assets/`로 참조, 외부 URL은 그대로 유지.
+- 제출 경로: action 사용 또는 Google Sheets(기본 Apps Script 템플릿 제공).
+- i18n: next-intl. a11y: Testing Library + axe-core 스모크. SEO/OG 메타 생성.
+- 내보내기: ZIP(브라우저 JSZip 우선). 필요 시 서버(API Route) 대안 제공. 로컬 업로드 이미지는 ZIP 내 `assets/` 폴더에 파일로 포함.
+
+## UI/UX 리디자인 계획(합의안)
+- **정보 구조(3패널)**
+  - 좌: 컴포넌트 패널(Hero/FAQ/CTA + Form 프리셋)
+  - 중: 캔버스(dnd-kit, 섹션/필드 배치·정렬·삭제)
+  - 우: 인스펙터(선택 요소 속성/검증/스타일 편집)
+- **상단 툴바**: 언어, 테마, 프리셋, Export ZIP
+- **프리뷰**: 실시간 렌더, 반응형 뷰포트 토글
+- **계약 고정**: 스키마(섹션/폼/검증), 상태 인터페이스, Exporter 입·출력
+
+### 단계별 TDD 진행
+1) 레이아웃 스캐폴딩(shadcn/ui) + 접근성 라벨링 테스트
+2) dnd 캔버스 1차: 섹션 드래그 정렬/삭제 테스트 → 최소 구현
+3) 인스펙터 1차: 선택 섹션/필드 기본 속성 편집 테스트 → 연동
+4) 컴포넌트 패널: 카드 추가(섹션/필드 프리셋) 테스트 → 드래그 추가
+5) 프리뷰 강화: 실시간 반영/뷰포트 토글 스모크 테스트
+
+### 현재 상태(MVP)
+- 섹션 추가/삭제, 폼 필드 구성(옵션/필수/패턴/최대길이), i18n, ZIP Export, 로컬 에셋 포함 동작 확인
+- Next.js 16: `middleware` → `proxy` 마이그레이션 완료
+- dnd 상호작용 테스트 및 구현 안정화(정렬/삭제 버튼 폴백 포함)
+- 섹션 프리셋 확장: Features/Testimonials 카드 추가 및 프리뷰/Exporter 스텁 반영 완료
+- SEO/Analytics/OG 인스펙터 추가 및 프리뷰 반영
+- Exporter: og:image 메타 태그 반영 및 테스트 추가
+- a11y: jest-axe 스모크 테스트 통과(FormBuilderPanel), dnd-kit 라이브 리전/안내 존재 검증
+- 라벨-id 매핑 강화(중앙 입력/인스펙터/FAQ/CTA/Features/Testimonials)
+- 프리뷰 뷰포트 토글(Desktop/Mobile) + localStorage 영속화
+- Features/Testimonials 인스펙터 편집 UI(리스트 추가/삭제/편집) + 테스트
+- Exporter 타입 보강(any 제거) 및 CSS 보강(Features/Testimonials)
+- E2E(Playwright):
+  - 기본 플로우(섹션 추가→편집→프리뷰→Export 클릭)
+  - dnd 키보드 폴백(Up/Down) 재정렬
+  - SEO/Analytics/OG 프리뷰 반영 검증
+  - Export ZIP 메타(SEO/OG/Analytics) 검증(테스트 훅 사용)
+  - 프리뷰 뷰포트 토글(aria-pressed/키보드 접근) 검증
+
+### a11y/반응형 정책(Exporter)
+- 문서 내비게이션: skip link, `<main id="main" role="main">` 적용
+- 섹션 식별: `aria-labelledby` + 섹션 헤딩 id(features/testimonials/faq)
+- 이미지 대체텍스트: hero img `alt` = heading 파생
+- 포커스 표시: 포커스 가능한 요소 outline 표시
+- 반응형: 모바일 컨테이너 패딩 축소, grid 자동 칼럼, `prefers-reduced-motion` 준수
+
+### 최근 보강 내역(접근성/테스트)
+- 인스펙터 입력에 `aria-describedby` 연결(SEO/Analytics/OG/Hero/CTA)
+- SEO/Analytics/OG/Hero/CTA/FAQ 헬프텍스트 추가
+- Exporter 구조 스냅샷 강화: `<main>` 내부 섹션/폼 포함 검증
+- Exporter CSS 토큰 스냅샷: skip-link/focus outline/반응형/모션 감소 토큰 존재 검증
+- Features/Testimonials `aria-labelledby`/헤딩 id 일치 검증 추가
+- Exporter 헤딩 레벨 일관성 전수 테스트(hero=h1, others=h2, FAQ=h3) 추가
+- Exporter 색상/타이포그래피 토큰 스모크 테스트 추가
+- Exporter(Form): helptext ↔ aria-describedby 연결 TDD 완료
+  - 각 필드 `id=field-<name>`와 `<label for>` 연결
+  - `help`가 있을 경우 `id=field-<name>-help` 요소 생성 및 컨트롤에 `aria-describedby` 부여
+  - 라디오 그룹은 `fieldset`에 `aria-describedby` 적용, 옵션별 `id/htmlFor` 연결
+- next-intl 기본 timeZone 설정: `Asia/Seoul`로 ENVIRONMENT_FALLBACK 경고 제거
+- a11y 색/폰트 최소 기준 스모크(본문 컬러/폰트 패밀리/모바일 h1 폰트 크기) 추가
+- CTA 섹션에 `aria-labelledby` + `<h2 id="cta-heading">` 추가(헤딩 레벨 일관성)
+- 전체 테스트 그린(유닛/컴포넌트/E2E)
+- Inspector a11y 스모크: SEO/Analytics/OG 입력과 헬프텍스트의 `aria-describedby` 연결 검증
+- Exporter CSS 스모크: 본문 텍스트 컬러/포커스 outline/모바일 h1 폰트 크기/MQ 토큰 존재 검증
+- FAQ 인스펙터 Q/A 입력 `aria-describedby`(ins-faq-help) 연결 보강
+- Inspector 키보드 UX 스모크: Features/Testimonials 항목 추가( Space/Enter ) 검증 추가
+- Inspector 키보드 UX 스모크: Features/Testimonials 항목 삭제(Remove) Enter/Space 검증 추가
+- 인스펙터 Remove 버튼 키보드 처리(onKeyDown/onKeyUp) 반영
+- Exporter 회귀 스냅샷: heading/ARIA/반응형 토큰 통합 검증 추가
+ - Preview 토글 ARIA 회귀 스냅샷(Desktop/Mobile: aria-pressed/controls/describedby)
+ - Exporter CSS 토큰 회귀 확대(:root --primary, body font, skip-link base/focus, focus outline, reduced-motion)
+ - 컴포넌트 i18n 회귀 스냅샷(en/ko 주요 라벨/버튼 키 존재)
+ - 섹션 a11y 자동 검증 템플릿(testUtils/sectionA11y) 도입 및 템플릿 테스트 추가
+ - 신규 섹션 추가: Benefits
+  - 스키마 확장(`benefits`): props.items:string[]
+  - Exporter 렌더 추가: `<section class="benefits" aria-labelledby>`, `<h2 id="benefits-heading">`, 리스트 렌더
+  - 테스트: sections.benefits.test.ts (h2/aria-labelledby/리스트 아이템 검증)
+- 섹션 회귀 스냅샷(benefits 포함) 보강: sections.regression.benefits.test.ts 추가(ARIA/헤딩/리스트 구조 전수 검증)
+- 섹션 회귀 스냅샷(CTA/Testimonials): sections.regression.cta-testimonials.test.ts 추가(figure/blockquote/figcaption, CTA 링크 클래스/URL 검증)
+- 섹션 회귀 스냅샷(Features/FAQ): sections.regression.features-faq.test.ts 추가(리스트/클래스/아이템 수 검증)
+- Exporter 이스케이프 회귀: sections.escape.regression.test.ts 추가(특수문자 <, >, &, ") 안전 이스케이프 검증)
+- 인스펙터 a11y 자동 체크 헬퍼 도입: components/testUtils/inspectorA11y.ts + 템플릿 테스트 2종(InspectorA11y.template/sections)
+- i18n 회귀 확장: Sidebar Add 버튼군(en/ko) 라벨 스모크(i18n.sidebar.actions.test.tsx)
+- E2E 스모크: 프리뷰/Export 마커(heading/ARIA/반응형 CSS) 존재 검증 추가
+- SEO description 기본값 설정으로 Export 스키마 안정화
+- 프리뷰 토글 버튼에 `aria-controls="preview-container"` 추가로 제어 영역 명시
+- 프리뷰 토글에 sr-only 설명 추가 및 두 토글 버튼 `aria-describedby` 연결
+- SectionCanvas 제어 버튼 `aria-label` 스모크(Select/Up/Down/Remove) 추가
+- CSS focus-visible 토큰 스모크(3px solid + HEX 컬러) 추가
+- 인스펙터 Add 버튼 title 보조 힌트 추가(Features/Testimonials/FAQ) 및 일관성 테스트
+- SectionCanvas 버튼 title/aria-label 일관성 스모크
+- 전역 버튼 네이밍 일관성 보강: Inspector Add/Remove 및 SectionCanvas Select/Up/Down/Remove의 title/aria-label 일치 확인 및 스모크 완료
+- a11y 커버리지 최종 점검: 전 섹션 인스펙터 입력 aria-describedby 연결 확인(체크리스트 충족)
+
+### 다음 작업(계획)
+- Exporter 헤딩 레벨 일관성 테스트: hero는 h1, 나머지 섹션은 h2, FAQ 항목은 h3 검증
+- a11y 색/폰트 최소 기준 스모크: 대비/폰트크기 관련 CSS 토큰/규칙 존재 여부 스냅샷
+
+### Inspector a11y 커버리지 체크리스트
+- [x] Hero: `Hero Heading` 입력 `aria-describedby` → `ins-hero-heading-help`
+- [x] CTA: `CTA Text`/`CTA Href` 입력 `aria-describedby` → `ins-cta-text-help`/`ins-cta-href-help`
+- [x] FAQ: `FAQ Q n`/`FAQ A n` 입력 `aria-describedby` → `ins-faq-help`
+- [x] Features: `Feature n` 입력 `aria-describedby` → `ins-features-help`
+- [x] Testimonials: `Author n`/`Quote n` 입력 `aria-describedby` → `ins-testimonials-help`
+- [x] Preview 토글: sr-only 설명(`preview-toggle-help`)과 버튼 `aria-describedby` 연결, `aria-controls="preview-container"`
+
+### CI/테스트 실행
+- 유닛/컴포넌트: `npm test` (Vitest)
+- E2E: `npm run test:e2e` (Playwright)
+- 로컬 개발 서버는 Playwright 설정에서 자동 기동(webServer: `npm run dev`)
+- GitHub Actions 워크플로: `.github/workflows/ci.yml`
+  - Node 20 + `npm ci`
+  - Vitest 실행 → Playwright 브라우저 설치(`npx playwright install --with-deps`) → E2E 실행
+
+### CI 최종 점검
+- main/master 브랜치 푸시/PR 시 워크플로 자동 실행 확인
+- 새로 추가된 테스트(헤딩 레벨 전수, 색/폰트 스모크) CI 통합 확인
+- 작업 브랜치 푸시 완료: `chore/ci-verify-a11y-headings` (원격: origin)
+- PR 생성 및 Actions 결과 기록 예정(base: main)
+- CI verification note: 러너 온라인 이후, 사소 변경으로 CI 트리거 검증 예정
+  - CI rerun: 워크플로 재실행용 ping 커밋
+
+#### 결과: CI 통과 (self-hosted Gitea Actions)
+- PR: https://gitea.jaybe.dev/jaybe/landing-builder/pulls/2
+- 러너: self-hosted, labels: [macos, host]
+- 테스트: Unit/Component + E2E 총 7/7 green
+- 수정 요약(E2E 포커스):
+  - 초기 포커스 선점 방지: `body` 클릭으로 포커스 부여
+  - 스킵링크 등 선행 포커서블 회피: Desktop 버튼에 명시적 `focus()`
+  - 키보드 시나리오: Tab → Mobile 포커스 확인 → Space로 토글 → Shift+Tab → Enter
+
+#### 머지 상태
+- 머지 방식: Squash and merge
+- 브랜치 정리: `feat/ci-verify-run` 삭제 완료
+
+### 다음 스프린트 후보 과제
+- Exporter 회귀 스냅샷 보강(폼 토큰/검증 토큰 범위 확대)
+- 인스펙터 신규 섹션 추가 시 a11y 베이스라인 재사용 가이드 마련
+- 버튼 네이밍 일관성 전수 스캔 스모크 범위 확대
+  - node 20 + npm ci
+  - Vitest 실행 → Playwright 브라우저 설치 → E2E 실행
+
+## 마일스톤
+1. 스캐폴딩 및 테스트 환경 구성
+2. 스키마 정의(Zod) 및 HTML Exporter TDD
+3. 컴포넌트/상태관리(Zustand) 및 인스펙터 기본 기능
+4. 접근성/키보드 네비게이션 강화 및 테스트 안정화
+5. CI/CD(Self-hosted Gitea) 연동 및 그린 검증
+
+## 릴리스
+### v0.1.0
+- CI 검증 완료(Self-hosted Gitea runner, labels: [macos, host])
+- E2E 안정화: 초기 포커스 이슈 제거(Desktop 명시 focus), 스킵링크 고려
+- Exporter(Form) a11y: helptext ↔ aria-describedby, id/htmlFor 연결, 라디오 fieldset 설명 연결
+- i18n: en/ko 중첩 구조, 누락 키 보강(builder.action.*, builder.form.*)
+- next-intl: 기본 timeZone=Asia/Seoul 설정으로 ENVIRONMENT_FALLBACK 경고 제거
+- 태그: v0.1.0
+
+## 접근성 베이스라인 가이드(신규 섹션/인스펙터 적용 규칙)
+- **레이블 연결**: 모든 입력은 `id=ins-...` 또는 `id=field-...` 부여, `<label for>`로 연결
+- **헬프텍스트 연결**: 헬프 요소 `id=...-help` 생성, 입력에 `aria-describedby`로 연결
+- **라디오 그룹**: 개별 `<input>` 대신 `<fieldset>`에 `aria-describedby` 적용, 옵션은 `id/htmlFor`로 연결
+- **버튼 네이밍**: 보이는 텍스트 또는 `aria-label`로 안정적 접근 가능한 이름 제공
+- **키보드 활성화**: Enter/Space 활성(onClick와 동일 동작), `focus-visible` 스타일 유지
+- **스킵링크**: `<a class="skip-link">` 제공, 포커스 시 화면 내 표시
+- **헤딩 레벨**: hero=h1, 1뎁스 섹션=h2, FAQ 항목=h3 일관성 유지
+- **미리보기 토글**: 토글 버튼에 `aria-pressed`, `aria-controls`, `aria-describedby` 연결
+- **i18n 키**: 중첩 객체 구조, 신규 키 추가 시 en/ko 동시 보강
+- **테스트 원칙**: TDD로 유닛/컴포넌트/E2E 및 스냅샷 추가. 포커스/ARIA/토큰 스모크 포함
+
+### 적용 가이드(신규 섹션 추가 시)
+- **1) 섹션 구현**: `<section class="<name>" aria-labelledby="<name>-heading">`와 `<h2 id="<name>-heading">` 구성
+- **2) 인스펙터 입력**: `id=ins-...`, `<label for>`, 헬프텍스트 `...-help` + `aria-describedby` 연결
+- **3) Exporter 반영**: 섹션 렌더 함수에 위 구조/속성 부여
+- **4) 테스트 추가**:
+  - 공통 템플릿 사용: `lib/exporter/testUtils/sectionA11y.ts` → `assertSectionA11y(html)`
+  - 샘플: `lib/exporter/sectionA11y.template.test.ts` 참고하여 새 섹션 추가해 검증
+  - 필요 시 개별 스냅샷/스모크: 헤딩/ARIA/키보드/토큰 추가 검증
+
+## 다음 단계(E2E 초안)
+- 시나리오: 섹션 추가(Hero/FAQ/Features/Testimonials/CTA) → 인스펙터 편집 → Export ZIP 생성 → HTML 메타/섹션/폼 렌더 확인
+- 환경: Playwright
+- 체크리스트: 
+  - 섹션 추가/정렬/삭제 동작
+  - 인스펙터 편집 반영(미리보기/Export HTML)
+  - i18n 라벨 안정성(data-testid 사용)
+  - a11y 스모크 무결성 유지
+
+## TDD 전략
+- 각 기능 단위로: 실패 테스트 작성 → 최소 구현 → 리팩터 → 커버리지 확인.
+- 단위: Vitest + Testing Library + jsdom. E2E: Playwright.
+- 접근성: axe-core 스모크 테스트.
+
+## 작업 보드(요약)
+- 스키마/도메인(Zod)
+- HTML Exporter
+- 에셋 매니저
+- 폼 엔진
+- Sheets 연동
+- 빌더 UI
+- 내보내기 ZIP
+- i18n
+- a11y/SEO/OG/Analytics
+
+## 오류/버그 기록
+- [2025-11-13 22:55] BuilderClientPage 렌더 중 ref 접근 경고 / useRef.current를 렌더 중 참조하여 ESLint 경고 발생 / FormBuilderPanel 통합 시 `useRef(createFormStore())` 사용 / `useMemo(() => createFormStore(), [])`로 스토어 인스턴스 고정하고 `useSyncExternalStore`에 직접 주입하여 해결 / 렌더 중 ref 접근 금지 원칙 재확인
+- [2025-11-14 09:35] Vitest 로그에서 i18n 누락 메시지 경고 확인(en: `builder.action.addSelect/addRadio`, `builder.form.actionUrl/honeypot/minSeconds`) → `messages/en.json`에 키 존재 여부 점검 및 누락 보완 후 재실행, 모든 테스트 그린 유지
+- [2025-11-14 09:45] 프리뷰 텍스트 매칭 불안정으로 테스트 실패 → `data-testid` 기반 안정화(`preview-seo-title` 등) 및 텍스트 매칭 지점 `Title:`→`Locale:`로 조정, 전면 그린
+
+## 의사결정 기록(ADR)
+- [YYYY-MM-DD] Next.js(App Router) 채택: 생태계/배포/서버리스/SEO 편의성.
+- [YYYY-MM-DD] Sheets 기본 방안: Apps Script 웹앱 템플릿(사용자 편의/트래픽 분산).
+- [YYYY-MM-DD] 로컬 이미지 업로드 허용: 서버 저장 없이 ZIP에 `assets/`로 패키징(브라우저 JSZip 우선).

components/BuilderClientPage.tsx

@@ -6,7 +6,6 @@ import { pageSchema, type Page } from '@/lib/schema/page'
 import { exportPage } from '@/lib/exporter/html'
 import { AssetManager } from '@/lib/assets/assetManager'
 import { buildZip } from '@/lib/exporter/zip'
-import { buildExtrasForPage } from '@/lib/exporter/extras'
 import type { Section } from '@/lib/state/store'
 import { createFormStore, type FormState } from '@/lib/state/formStore'
 import FormBuilderPanel from '@/components/FormBuilderPanel'
@@ -48,9 +47,6 @@ export default function BuilderClientPage() {
   const [ogImage, setOgImage] = useState<string>('')
   const [ga4MeasurementId, setGa4MeasurementId] = useState<string>('')
   const [metaPixelId, setMetaPixelId] = useState<string>('')
-  // Export Options (minimal set for tests)
-  const [manifestName, setManifestName] = useState<string>('')
-  const [robotsDisallow, setRobotsDisallow] = useState<string>('')
   const [viewport, setViewport] = useState<'desktop' | 'mobile'>(() => {
     if (typeof window !== 'undefined') {
       try {
@@ -186,23 +182,10 @@ export default function BuilderClientPage() {
         }
       }
     } catch {}
-  }, [pageData, am, manifestName, robotsDisallow])
+  }, [pageData, am])
 
   const doExport = useCallback(async () => {
-    let valid: Page
-    try {
-      valid = pageSchema.parse(pageData)
-    } catch {
-      const fixed: Page = {
-        ...pageData,
-        form: {
-          actionUrl: pageData.form?.actionUrl ?? '',
-          fields: pageData.form?.fields ?? [],
-          spamProtection: pageData.form?.spamProtection ?? { honeypotFieldName: '_hp', minSubmitSeconds: 2 },
-        },
-      } as Page
-      valid = pageSchema.parse(fixed)
-    }
+    const valid = pageSchema.parse(pageData)
     const exported = exportPage(valid, { assetManager: am ?? undefined })
     try {
       if (typeof window !== 'undefined') {
@@ -213,19 +196,9 @@ export default function BuilderClientPage() {
       }
     } catch {}
     const assets = am ? am.toZipStructure() : {}
-    // Build minimal overrides for extras
-    const manifestOverride: { name?: string } = {}
-    if (manifestName && manifestName.trim().length > 0) manifestOverride.name = manifestName.trim()
-    const robotsTextOverride = (() => {
-      const lines = (robotsDisallow || '').split(/\n+/).map((s) => s.trim()).filter((s) => s.length > 0)
-      if (lines.length === 0) return undefined
-      const disallowLines = lines.map((l) => (l.startsWith('Disallow:') ? l : `Disallow: ${l}`))
-      return `User-agent: *\n${disallowLines.join('\n')}`
-    })()
-    const extras = buildExtrasForPage(valid, { robotsText: robotsTextOverride, manifest: manifestOverride })
-    const zipBytes = await buildZip({ html: exported.html, css: exported.css, js: exported.js, assets, extras })
+    const zipBytes = await buildZip({ html: exported.html, css: exported.css, js: exported.js, assets })
     download('landing.zip', zipBytes)
-  }, [pageData, am, manifestName, robotsDisallow])
+  }, [pageData, am])
 
   return (
     <div className="p-6 space-y-6">
@@ -293,31 +266,6 @@ export default function BuilderClientPage() {
         right={
           <div className="space-y-3">
             <button className="bg-emerald-600 text-white rounded px-4 py-2 w-full" onClick={doExport}>{t('builder.action.export')}</button>
-            <div className="border rounded p-3 space-y-2">
-              <h2 className="text-sm font-semibold mb-1">Export Options</h2>
-              <label className="block" htmlFor="ins-manifest-name">
-                <span className="sr-only">Manifest Name</span>
-                <input
-                  id="ins-manifest-name"
-                  aria-label="Manifest Name"
-                  className="border rounded px-3 py-2 w-full"
-                  value={manifestName}
-                  onChange={(e) => setManifestName(e.target.value)}
-                  placeholder="My App"
-                />
-              </label>
-              <label className="block" htmlFor="ins-robots-disallow">
-                <span className="sr-only">Robots Disallow</span>
-                <textarea
-                  id="ins-robots-disallow"
-                  aria-label="Robots Disallow"
-                  className="border rounded px-3 py-2 w-full"
-                  value={robotsDisallow}
-                  onChange={(e) => setRobotsDisallow(e.target.value)}
-                  placeholder="/admin\n/secret"
-                />
-              </label>
-            </div>
             <div className="border rounded p-3 space-y-2">
               <h2 className="text-sm font-semibold mb-1">SEO / Analytics</h2>
               <label className="block" htmlFor="ins-seo-title">

components/ExportOptions.ui.test.tsx

@@ -1,46 +0,0 @@
-import { describe, it, expect, vi } from 'vitest'
-import { render, screen, fireEvent } from '@testing-library/react'
-import BuilderClientPage from '@/components/BuilderClientPage'
-
-vi.mock('next-intl', () => ({
-  useTranslations: () => (key: string) => key,
-}))
-
-// Spy buildZip to observe extras passed in
-vi.mock('@/lib/exporter/zip', async (orig) => {
-  const mod = await (orig as any)()
-  return {
-    ...mod,
-    buildZip: vi.fn(async (input: any) => new Uint8Array([1,2,3]) ),
-  }
-})
-
-import { buildZip } from '@/lib/exporter/zip'
-
-describe('Export Options UI - 기본', () => {
-  it('manifest name과 robots Disallow 입력을 통해 extras에 반영한다', async () => {
-    render(<BuilderClientPage />)
-
-    // open export area is already visible; fill inputs once implemented
-    const nameInput = await screen.findByLabelText('Manifest Name', { exact: false })
-    fireEvent.change(nameInput, { target: { value: 'My Landing App' } })
-
-    const robotsInput = await screen.findByLabelText('Robots Disallow', { exact: false })
-    fireEvent.change(robotsInput, { target: { value: '/secret\n/admin' } })
-
-    const btn = await screen.findByRole('button', { name: /builder.action.export/i })
-    await fireEvent.click(btn)
-
-    expect(buildZip).toHaveBeenCalled()
-    const arg = (buildZip as any).mock.calls[0][0]
-    expect(arg.extras).toBeTruthy()
-    const extras = arg.extras as Record<string, Uint8Array>
-    const robots = Buffer.from(extras['robots.txt']).toString('utf8')
-    expect(robots).toContain('Disallow: /secret')
-    expect(robots).toContain('Disallow: /admin')
-
-    const manifestStr = Buffer.from(extras['site.webmanifest']).toString('utf8')
-    const manifest = JSON.parse(manifestStr)
-    expect(manifest.name).toBe('My Landing App')
-  })
-})

lib/exporter/a11yResponsive.test.ts

@@ -41,7 +41,7 @@ describe('Exporter a11y/responsive enhancements', () => {
   test('hero image alt derives from heading', () => {
     const out = exportPage(makePage())
     expect(out.html).toContain('<h1 id="hero-heading">Welcome</h1>')
-    expect(out.html).toMatch(/<img[^>]*src="https:\/\/example\.com\/img\.png"[^>]*alt="Welcome"[^>]*\/>/)
+    expect(out.html).toContain('<img src="https://example.com/img.png" alt="Welcome" />')
   })
 
   test('responsive and a11y CSS tokens exist', () => {

lib/exporter/cta.edge-cases.test.ts

@@ -1,32 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { exportPage } from '@/lib/exporter/html'
-import { pageSchema, type Page } from '@/lib/schema/page'
-
-function makePage(overrides: Partial<Page> = {}): Page {
-  const base: Page = {
-    title: 'CTA Edge',
-    locale: 'en',
-    theme: { primaryColor: '#2563eb', fontFamily: 'Inter' },
-    sections: [
-      { type: 'cta', props: { text: '   ', href: '#' } },
-      { type: 'features', props: { items: ['One'] } },
-    ] as Page['sections'],
-    form: { actionUrl: '', fields: [], spamProtection: { honeypotFieldName: '_hp', minSubmitSeconds: 2 } },
-    analytics: { ga4MeasurementId: '', metaPixelId: '', customHeadHtml: '' },
-    seo: { title: 't', description: 'd' },
-  }
-  return pageSchema.parse({ ...base, ...overrides })
-}
-
-describe('Exporter - CTA edge cases', () => {
-  it('drops CTA section when text is whitespace-only', () => {
-    const out = exportPage(makePage())
-    expect(out.html).not.toContain('<section class="cta"')
-    expect(out.html).not.toContain('<a class="btn-cta"')
-  })
-
-  it('renders CTA when text is valid after trimming', () => {
-    const out = exportPage(makePage({ sections: [ { type: 'cta', props: { text: '  Buy Now  ', href: '#' } } ] as Page['sections'] }))
-    expect(out.html).toContain('<a class="btn-cta" href="#">Buy Now</a>')
-  })
-})

lib/exporter/darkContrast.hover.tokens.test.ts

@@ -1,30 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { exportPage } from '@/lib/exporter/html'
-import { pageSchema, type Page } from '@/lib/schema/page'
-
-function makePage(): Page {
-  return pageSchema.parse({
-    title: 'Dark Contrast Hover',
-    locale: 'en',
-    theme: { primaryColor: '#2563eb', fontFamily: 'Inter' },
-    sections: [
-      { type: 'hero', props: { heading: 'Welcome', subheading: 'Sub', imageUrl: 'https://img.example/h.png' } },
-      { type: 'cta', props: { text: 'Call', href: '#' } },
-    ],
-    form: { actionUrl: '', fields: [], spamProtection: { honeypotFieldName: '_hp', minSubmitSeconds: 2 } },
-    seo: { title: 't', description: 'd' },
-  })
-}
-
-describe('Exporter - dark mode hover/cta tokens', () => {
-  it('adds link hover underline and ensures btn-cta readable in dark', () => {
-    const out = exportPage(makePage())
-    const css = out.css
-
-    // underline on hover for links in dark for clearer affordance
-    expect(css).toMatch(/@media \(prefers-color-scheme: dark\)[\s\S]*a:hover\{[^}]*text-decoration:underline/i)
-
-    // btn-cta has readable foreground/background in dark
-    expect(css).toMatch(/@media \(prefers-color-scheme: dark\)[\s\S]*\.btn-cta\{[^}]*background:[^;]+;[^}]*color:#fff/i)
-  })
-})

lib/exporter/darkContrast.tokens.test.ts

@@ -1,37 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { exportPage } from '@/lib/exporter/html'
-import { pageSchema, type Page } from '@/lib/schema/page'
-
-function makePage(): Page {
-  return pageSchema.parse({
-    title: 'Dark Contrast',
-    locale: 'en',
-    theme: { primaryColor: '#2563eb', fontFamily: 'Inter' },
-    sections: [
-      { type: 'hero', props: { heading: 'Welcome', subheading: 'Sub', imageUrl: 'https://img.example/h.png' } },
-      { type: 'faq', props: { items: [{ q: 'Q', a: 'A' }] } },
-      { type: 'cta', props: { text: 'Go', href: '#' } },
-    ],
-    form: { actionUrl: '', fields: [], spamProtection: { honeypotFieldName: '_hp', minSubmitSeconds: 2 } },
-    seo: { title: 't', description: 'd' },
-  })
-}
-
-describe('Exporter - dark mode contrast tokens', () => {
-  it('includes dark mode tokens that improve contrast for links/buttons/faq text', () => {
-    const out = exportPage(makePage())
-    const css = out.css
-
-    // dark mode block exists
-    expect(css).toMatch(/@media \(prefers-color-scheme: dark\)/)
-
-    // link color token in dark
-    expect(css).toMatch(/@media \(prefers-color-scheme: dark\)[\s\S]*a\{[^}]*color:#93c5fd/i)
-
-    // button keeps readable foreground/background in dark
-    expect(css).toMatch(/@media \(prefers-color-scheme: dark\)[\s\S]*button\{[^}]*background:[^;]+;[^}]*color:#fff/i)
-
-    // faq answer text brighter in dark
-    expect(css).toMatch(/@media \(prefers-color-scheme: dark\)[\s\S]*\.faq-a\{[^}]*color:#cbd5e1/i)
-  })
-})

lib/exporter/extras.overrides.test.ts

@@ -1,45 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { pageSchema, type Page } from '@/lib/schema/page'
-import { buildExtrasForPage } from '@/lib/exporter/extras'
-
-function makePage(): Page {
-  return pageSchema.parse({
-    title: 'Overrides',
-    locale: 'en',
-    theme: { primaryColor: '#2563eb', fontFamily: 'Inter' },
-    sections: [ { type: 'hero', props: { heading: 'Hello', subheading: 'World', imageUrl: 'https://img/h.png' } } ],
-    form: { actionUrl: '', fields: [], spamProtection: { honeypotFieldName: '_hp', minSubmitSeconds: 2 } },
-    seo: { title: 't', description: 'd' },
-  })
-}
-
-describe('extras 오버라이드', () => {
-  it('robots.txt Disallow 오버라이드가 반영된다', () => {
-    const page = makePage()
-    const extras = buildExtrasForPage(page, { robotsText: 'User-agent: *\nDisallow: /admin\nDisallow: /private' })
-    const robots = Buffer.from(extras['robots.txt']).toString('utf8')
-    expect(robots).toContain('User-agent: *')
-    expect(robots).toContain('Disallow: /admin')
-    expect(robots).toContain('Disallow: /private')
-  })
-
-  it('manifest 필드 오버라이드(name/short_name/start_url/display/theme_color)가 반영된다', () => {
-    const page = makePage()
-    const extras = buildExtrasForPage(page, {
-      manifest: {
-        name: 'My App',
-        short_name: 'MyApp',
-        start_url: '/start',
-        display: 'minimal-ui',
-        theme_color: '#123abc',
-      },
-    })
-    const manifestStr = Buffer.from(extras['site.webmanifest']).toString('utf8')
-    const manifest = JSON.parse(manifestStr)
-    expect(manifest.name).toBe('My App')
-    expect(manifest.short_name).toBe('MyApp')
-    expect(manifest.start_url).toBe('/start')
-    expect(manifest.display).toBe('minimal-ui')
-    expect(manifest.theme_color).toBe('#123abc')
-  })
-})

lib/exporter/extras.ts

@@ -1,64 +0,0 @@
-import type { Page } from '@/lib/schema/page'
-
-export type ExtrasOverrides = {
-  robotsText?: string
-  manifest?: Partial<{
-    name: string
-    short_name: string
-    start_url: string
-    display: string
-    theme_color: string
-  }>
-}
-
-function toBytes(s: string): Uint8Array {
-  return new TextEncoder().encode(s)
-}
-
-function buildRobots(base?: string): string {
-  if (base && base.trim().length > 0) return base
-  return 'User-agent: *\n'
-}
-
-function deriveManifest(page: Page) {
-  const name = page.title || 'Landing'
-  const short_name = name.length > 12 ? name.slice(0, 12) : name
-  const start_url = '/'
-  const display = 'standalone'
-  const theme_color = page.theme?.primaryColor || '#0ea5e9'
-  return { name, short_name, start_url, display, theme_color }
-}
-
-export function buildExtrasForPage(page: Page, overrides?: ExtrasOverrides): Record<string, Uint8Array> {
-  const out: Record<string, Uint8Array> = {}
-
-  // robots.txt
-  const robotsText = buildRobots(overrides?.robotsText)
-  out['robots.txt'] = toBytes(robotsText)
-
-  // site.webmanifest
-  const manifestBase = deriveManifest(page)
-  const manifestMerged = { ...manifestBase, ...(overrides?.manifest || {}) }
-  const manifestJson = JSON.stringify(manifestMerged, null, 2)
-  out['site.webmanifest'] = toBytes(manifestJson)
-
-  // Google Sheets 템플릿: actionUrl 미지정 시 포함
-  const action = page.form?.actionUrl?.trim()
-  const hasAction = !!(action && action.length > 0)
-  if (!hasAction) {
-    const code = `/**
- * Google Apps Script Web App for form submissions
- * - Deploy as Web App and set URL as form action if needed.
- */
-function doPost(e){
-  // TODO: handle submission to Google Sheets
-  return ContentService.createTextOutput('OK')
-}
-`
-    const readme = `Google Sheets Apps Script Template\n\n1) Apps Script에서 새 프로젝트를 만들고 아래 Code.gs를 붙여넣으세요.\n2) 배포 > 웹 앱으로 배포 후 URL을 복사해 사용하세요.`
-    out['sheets/Code.gs'] = toBytes(code)
-    out['sheets/README.txt'] = toBytes(readme)
-  }
-
-  return out
-}

lib/exporter/font.optimization.test.ts

@@ -1,29 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { exportPage } from '@/lib/exporter/html'
-import { pageSchema, type Page } from '@/lib/schema/page'
-
-function makePage(): Page {
-  return pageSchema.parse({
-    title: 'Font Opt',
-    locale: 'en',
-    theme: { primaryColor: '#2563eb', fontFamily: 'Inter' },
-    sections: [ { type: 'hero', props: { heading: 'Hello', subheading: 'World', imageUrl: 'https://img/h.png' } } ],
-    form: { actionUrl: '', fields: [], spamProtection: { honeypotFieldName: '_hp', minSubmitSeconds: 2 } },
-    seo: { title: 't', description: 'd' },
-  })
-}
-
-describe('폰트 최적화', () => {
-  it('head에 Google Fonts preconnect 링크가 포함된다', () => {
-    const page = makePage()
-    const out = exportPage(page)
-    expect(out.html).toContain('<link rel="preconnect" href="https://fonts.googleapis.com"')
-    expect(out.html).toContain('<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin')
-  })
-
-  it('CSS에 system-ui 폴백이 포함된다', () => {
-    const page = makePage()
-    const out = exportPage(page)
-    expect(out.css).toMatch(/font-family:[^;]*system-ui/i)
-  })
-})

lib/exporter/hero.edge-cases.test.ts

@@ -1,31 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { exportPage } from '@/lib/exporter/html'
-import { pageSchema, type Page } from '@/lib/schema/page'
-
-function makePage(overrides: Partial<Page> = {}): Page {
-  const base: Page = {
-    title: 'Hero Edge',
-    locale: 'en',
-    theme: { primaryColor: '#2563eb', fontFamily: 'Inter' },
-    sections: [
-      { type: 'hero', props: { heading: 'Welcome', subheading: '   ', imageUrl: 'https://img.example/h.png' } },
-    ] as Page['sections'],
-    form: { actionUrl: '', fields: [], spamProtection: { honeypotFieldName: '_hp', minSubmitSeconds: 2 } },
-    analytics: { ga4MeasurementId: '', metaPixelId: '', customHeadHtml: '' },
-    seo: { title: 't', description: 'd' },
-  }
-  return pageSchema.parse({ ...base, ...overrides })
-}
-
-describe('Exporter - hero edge cases', () => {
-  it('omits subheading when whitespace-only', () => {
-    const out = exportPage(makePage())
-    expect(out.html).toContain('<h1 id="hero-heading">Welcome</h1>')
-    expect(out.html).not.toMatch(/<div class="text">[\s\S]*<p>\s*<\/p>/)
-  })
-
-  it('trims subheading content', () => {
-    const out = exportPage(makePage({ sections: [ { type: 'hero', props: { heading: 'Welcome', subheading: '  Hello world  ', imageUrl: 'https://img.example/h.png' } } ] as Page['sections'] }))
-    expect(out.html).toContain('<p>Hello world</p>')
-  })
-})

lib/exporter/html.ts

@@ -5,12 +5,7 @@ export type Exported = { html: string; css: string; js: string }
 export type ExportOptions = { assetManager?: AssetManager }
 
 function renderFaq(section: { props: { items: Array<{ q: string; a: string }> } }) {
-  const itemsRaw: Array<{ q: string; a: string }> = Array.isArray(section.props.items) ? section.props.items : []
-  const isBlank = (s: string | undefined | null) => !s || s.trim().length === 0
-  const items = itemsRaw
-    .map((it) => ({ q: (it.q || '').trim(), a: (it.a || '').trim() }))
-    // drop when both question and answer are blank
-    .filter((it) => !(isBlank(it.q) && isBlank(it.a)))
+  const items: Array<{ q: string; a: string }> = Array.isArray(section.props.items) ? section.props.items : []
   return `
     <section class="faq" aria-labelledby="faq-heading">
       <div class="container">
@@ -32,9 +27,7 @@ function renderFaq(section: { props: { items: Array<{ q: string; a: string }> }
 }
 
 function renderFeatures(section: { props: { items: string[] } }) {
-  const items: string[] = (Array.isArray(section.props?.items) ? section.props.items : [])
-    .map((s) => String(s ?? '').trim())
-    .filter((s) => s.length > 0)
+  const items: string[] = Array.isArray(section.props?.items) ? section.props.items : []
   return `
     <section class="features" aria-labelledby="features-heading">
       <div class="container">
@@ -48,9 +41,7 @@ function renderFeatures(section: { props: { items: string[] } }) {
 }
 
 function renderBenefits(section: { props: { items: string[] } }) {
-  const items: string[] = (Array.isArray(section.props?.items) ? section.props.items : [])
-    .map((s) => String(s ?? '').trim())
-    .filter((s) => s.length > 0)
+  const items: string[] = Array.isArray(section.props?.items) ? section.props.items : []
   return `
     <section class="benefits" aria-labelledby="benefits-heading">
       <div class="container">
@@ -64,12 +55,9 @@ function renderBenefits(section: { props: { items: string[] } }) {
 }
 
 function renderTestimonials(section: { props: { items: Array<{ author: string; quote: string }> } }) {
-  const items: Array<{ author: string; quote: string }> = (Array.isArray(section.props?.items)
+  const items: Array<{ author: string; quote: string }> = Array.isArray(section.props?.items)
     ? section.props.items
-    : [])
-    .map((it) => ({ author: (it.author || '').trim(), quote: (it.quote || '').trim() }))
-    // drop when both are blank
-    .filter((it) => !(it.author.length === 0 && it.quote.length === 0))
+    : []
   return `
     <section class="testimonials" aria-labelledby="testimonials-heading">
       <div class="container">
@@ -78,8 +66,8 @@ function renderTestimonials(section: { props: { items: Array<{ author: string; q
           .map(
             (it) => `
           <figure class="testimonial">
-            <blockquote>“${escapeHtml(it.quote)}”</blockquote>
-            ${it.author.length > 0 ? `<figcaption>— ${escapeHtml(it.author)}</figcaption>` : ''}
+            <blockquote>“${escapeHtml(it.quote || '')}”</blockquote>
+            <figcaption>— ${escapeHtml(it.author || '')}</figcaption>
           </figure>`
           )
           .join('')}
@@ -89,9 +77,7 @@ function renderTestimonials(section: { props: { items: Array<{ author: string; q
 }
 
 function renderCta(section: { props: { text: string; href?: string } }) {
-  const href = section.props.href
-  const text = (section.props.text || '').trim()
-  if (text.length === 0) return ''
+  const { text, href } = section.props
   return `
     <section class="cta" aria-labelledby="cta-heading">
       <div class="container">
@@ -110,9 +96,7 @@ const escapeHtml = (s: string) =>
     .replaceAll('"', '&quot;')
 
 function renderHero(section: { props: { heading: string; subheading?: string; imageUrl: string } }, opts?: ExportOptions) {
-  const { heading } = section.props
-  const subheadingRaw = section.props.subheading
-  const subheading = subheadingRaw ? subheadingRaw.trim() : ''
+  const { heading, subheading } = section.props
   const am = opts?.assetManager
   const imageUrlRaw: string = section.props.imageUrl
   const imageUrl = am ? am.rewriteUrl(imageUrlRaw) : imageUrlRaw
@@ -121,10 +105,10 @@ function renderHero(section: { props: { heading: string; subheading?: string; im
       <div class="container">
         <div class="text">
           <h1 id="hero-heading">${escapeHtml(heading)}</h1>
-          ${subheading.length > 0 ? `<p>${escapeHtml(subheading)}</p>` : ''}
+          ${subheading ? `<p>${escapeHtml(subheading)}</p>` : ''}
         </div>
         <div class="media">
-          <img src="${escapeHtml(imageUrl)}" alt="${escapeHtml(heading)}" loading="lazy" decoding="async" />
+          <img src="${escapeHtml(imageUrl)}" alt="${escapeHtml(heading)}" />
         </div>
       </div>
     </section>
@@ -253,8 +237,6 @@ function buildHead(page: Page) {
   return `
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <link rel="canonical" href="/" />
-    <link rel="preconnect" href="https://fonts.googleapis.com" />
     <title>${escapeHtml(page.seo.title)}</title>
     <meta name="description" content="${escapeHtml(page.seo.description)}" />
     <meta property="og:title" content="${escapeHtml(page.seo.title)}" />
@@ -279,20 +261,17 @@ function buildCss(page: Page) {
   button:focus, a:focus, input:focus, select:focus, textarea:focus{ outline: 3px solid #2563eb; outline-offset:2px }
   .faq-list{ list-style:none; padding:0; margin:0 }
   .faq-item{ margin: .75rem 0 }
-  .faq-q{ font-size: 1rem; font-weight:600; overflow-wrap:anywhere }
-  .faq-a{ color:#334155; overflow-wrap:anywhere }
+  .faq-q{ font-size: 1rem; font-weight:600; }
+  .faq-a{ color:#334155 }
   .btn-cta{ background: var(--primary); color:#fff; padding:.75rem 1rem; border-radius:.5rem; display:inline-block; text-decoration:none }
   .features{ background:#f8fafc }
   .features-list{ list-style:none; padding:0; margin:0; display:grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: .75rem }
-  .feature-item{ background:#fff; border:1px solid #e2e8f0; border-radius:.5rem; padding:.75rem; overflow-wrap:anywhere }
-  .benefits-list{ list-style:none; padding:0; margin:0 }
-  .benefit-item{ overflow-wrap:anywhere }
+  .feature-item{ background:#fff; border:1px solid #e2e8f0; border-radius:.5rem; padding:.75rem }
   .testimonials{ background:#ffffff }
   .testimonial{ border-left:4px solid var(--primary); padding:.5rem 1rem; margin: .75rem 0; background:#fefefe }
-  .testimonial blockquote{ margin:0; font-style:italic; color:#1f2937; overflow-wrap:anywhere }
+  .testimonial blockquote{ margin:0; font-style:italic; color:#1f2937 }
   .testimonial figcaption{ color:#475569; margin-top:.25rem }
   @media (max-width: 640px){ .container{ padding: 1rem } h1{ font-size: 1.5rem } }
-  @media (prefers-color-scheme: dark){ body{ color:#e5e7eb; background:#0b1020 } .feature-item{ background:#0f172a; border-color:#1f2937 } a{ color:#93c5fd } a:hover{ text-decoration:underline } button{ background: var(--primary); color:#fff } .btn-cta{ background: var(--primary); color:#fff } .faq-a{ color:#cbd5e1 } }
   @media (prefers-reduced-motion: reduce){ *{ transition: none !important; animation: none !important } }
   `
 }
@@ -303,17 +282,6 @@ function buildJs() {
   (function(){
     var ts = document.querySelector('input[name="_ts"]');
     if(ts){ ts.value = String(Date.now()); }
-    // Ensure skip-link moves focus into main for a11y
-    var skip = document.querySelector('a.skip-link');
-    var main = document.getElementById('main');
-    if (skip && main) {
-      skip.addEventListener('click', function(){
-        if (!main.hasAttribute('tabindex')) {
-          main.setAttribute('tabindex', '-1');
-        }
-        main.focus();
-      });
-    }
   })();
   `
 }

lib/exporter/manifest.robots.auto.test.ts

@@ -1,32 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { pageSchema, type Page } from '@/lib/schema/page'
-import { buildExtrasForPage } from '@/lib/exporter/extras'
-
-function makePage(): Page {
-  return pageSchema.parse({
-    title: 'Auto Extras',
-    locale: 'en',
-    theme: { primaryColor: '#2563eb', fontFamily: 'Inter' },
-    sections: [ { type: 'hero', props: { heading: 'Hello', subheading: 'World', imageUrl: 'https://img/h.png' } } ],
-    form: { actionUrl: '', fields: [], spamProtection: { honeypotFieldName: '_hp', minSubmitSeconds: 2 } },
-    seo: { title: 't', description: 'd' },
-  })
-}
-
-describe('extras 자동 생성', () => {
-  it('robots.txt와 site.webmanifest가 extras에 포함된다', () => {
-    const page = makePage()
-    const extras = buildExtrasForPage(page)
-    const keys = Object.keys(extras)
-    expect(keys).toContain('robots.txt')
-    expect(keys).toContain('site.webmanifest')
-
-    const robots = Buffer.from(extras['robots.txt']).toString('utf8')
-    expect(robots).toContain('User-agent: *')
-
-    const manifestStr = Buffer.from(extras['site.webmanifest']).toString('utf8')
-    const manifest = JSON.parse(manifestStr)
-    expect(manifest.start_url).toBeDefined()
-    expect(manifest.display).toBeDefined()
-  })
-})

lib/exporter/sections.edge-cases.test.ts

@@ -1,57 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { exportPage } from '@/lib/exporter/html'
-import { pageSchema, type Page } from '@/lib/schema/page'
-
-function makePage(overrides: Partial<Page> = {}): Page {
-  const base: Page = {
-    title: 'Edge',
-    locale: 'en',
-    theme: { primaryColor: '#2563eb', fontFamily: 'Inter' },
-    sections: [
-      { type: 'features', props: { items: ['One', '   ', '   ', 'Two'] } },
-      { type: 'benefits', props: { items: ['A', '   ', '   ', 'B'] } },
-      { type: 'faq', props: { items: [
-        { q: '  ', a: '   ' },
-        { q: 'Valid Q', a: '   ' },
-        { q: 'Another', a: 'Answer' },
-      ] } },
-      { type: 'testimonials', props: { items: [
-        { author: '  ', quote: '   ' },
-        { author: 'Jane', quote: '  Great product   ' },
-      ] } },
-    ] as Page['sections'],
-    form: { actionUrl: '', fields: [], spamProtection: { honeypotFieldName: '_hp', minSubmitSeconds: 2 } },
-    analytics: { ga4MeasurementId: '', metaPixelId: '', customHeadHtml: '' },
-    seo: { title: 't', description: 'd' },
-  }
-  return pageSchema.parse({ ...base, ...overrides })
-}
-
-describe('Exporter - sections edge cases', () => {
-  it('filters out whitespace-only items and keeps valid ones', () => {
-    const out = exportPage(makePage())
-    const html = out.html
-
-    // features: only One, Two
-    expect(html).toContain('<li class="feature-item">One</li>')
-    expect(html).toContain('<li class="feature-item">Two</li>')
-    expect(html).not.toMatch(/<li class="feature-item"><\/li>/)
-
-    // benefits: only A, B
-    expect(html).toContain('<li class="benefit-item">A</li>')
-    expect(html).toContain('<li class="benefit-item">B</li>')
-
-    // faq: drop fully empty, keep items even if answer empty when question is valid
-    expect(html).toContain('<h3 class="faq-q">Valid Q</h3>')
-    // testimonials: drop fully empty, keep trimmed quote
-    expect(html).toContain('<blockquote>“Great product”</blockquote>')
-  })
-
-  it('adds word-break tokens to avoid overflow for long words', () => {
-    const out = exportPage(makePage())
-    const css = out.css
-    expect(css).toMatch(/\.feature-item\{[\s\S]*(?:word-break:break-word|overflow-wrap:anywhere)/i)
-    expect(css).toMatch(/\.benefit-item\{[\s\S]*(?:word-break:break-word|overflow-wrap:anywhere)/i)
-    expect(css).toMatch(/\.testimonial blockquote\{[\s\S]*(?:word-break:break-word|overflow-wrap:anywhere)/i)
-  })
-})

lib/exporter/sections.edge-phase3.test.ts

@@ -1,40 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { exportPage } from '@/lib/exporter/html'
-import { pageSchema, type Page } from '@/lib/schema/page'
-
-function makePage(overrides: Partial<Page> = {}): Page {
-  const base: Page = {
-    title: 'Edge P3',
-    locale: 'en',
-    theme: { primaryColor: '#2563eb', fontFamily: 'Inter' },
-    sections: [
-      { type: 'faq', props: { items: [ { q: 'VeryVeryVeryVeryVeryLongWordWithoutSpaces', a: 'AnotherSuperLongUnbreakableWord' } ] } },
-      { type: 'testimonials', props: { items: [
-        { author: '   ', quote: 'Great!' },
-        { author: 'Alice', quote: 'Nice' },
-      ] } },
-    ] as Page['sections'],
-    form: { actionUrl: '', fields: [], spamProtection: { honeypotFieldName: '_hp', minSubmitSeconds: 2 } },
-    analytics: { ga4MeasurementId: '', metaPixelId: '', customHeadHtml: '' },
-    seo: { title: 't', description: 'd' },
-  }
-  return pageSchema.parse({ ...base, ...overrides })
-}
-
-describe('Exporter - phase3 edge cases', () => {
-  it('omits testimonial author line when author is blank', () => {
-    const out = exportPage(makePage())
-    const html = out.html
-    // First item author blank -> no figcaption for that blockquote
-    expect(html).toMatch(/<blockquote>“Great!\”<\/blockquote>[\s\S]*?<\/figure>/)
-    // Ensure the next item with author renders figcaption
-    expect(html).toMatch(/<figcaption>— Alice<\/figcaption>/)
-  })
-
-  it('adds word-break/overflow-wrap for FAQ q/a to avoid overflow', () => {
-    const out = exportPage(makePage())
-    const css = out.css
-    expect(css).toMatch(/\.faq-q\{[\s\S]*(?:overflow-wrap:anywhere|word-break:break-word)/i)
-    expect(css).toMatch(/\.faq-a\{[\s\S]*(?:overflow-wrap:anywhere|word-break:break-word)/i)
-  })
-})

lib/exporter/seoPerf.tokens.test.ts

@@ -1,34 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { exportPage } from '@/lib/exporter/html'
-import { pageSchema, type Page } from '@/lib/schema/page'
-
-function makePage(): Page {
-  return pageSchema.parse({
-    title: 'SEO/Perf',
-    locale: 'en',
-    theme: { primaryColor: '#0ea5e9', fontFamily: 'Inter' },
-    sections: [
-      { type: 'hero', props: { heading: 'Welcome', subheading: 'Sub', imageUrl: 'https://img.example/hero.png' } },
-    ],
-    form: { actionUrl: '', fields: [], spamProtection: { honeypotFieldName: '_hp', minSubmitSeconds: 2 } },
-    seo: { title: 'SEO', description: 'Desc' },
-  })
-}
-
-describe('Exporter - small SEO/Perf improvements', () => {
-  it('includes canonical link and dark mode tokens; hero image lazy/async', () => {
-    const out = exportPage(makePage())
-    const html = out.html
-    const css = out.css
-
-    // canonical link present in head
-    expect(html).toMatch(/<link[^>]+rel="canonical"/)
-
-    // hero image has loading/decoding attributes
-    expect(html).toMatch(/<img[^>]*loading="lazy"/)
-    expect(html).toMatch(/<img[^>]*decoding="async"/)
-
-    // dark mode media query token exists
-    expect(css).toMatch(/@media \(prefers-color-scheme: dark\)/)
-  })
-})

lib/exporter/zip.ts

@@ -5,8 +5,6 @@ export type BuildZipInput = {
   css: string
   js: string
   assets?: Record<string, Uint8Array>
-  // root-level extra files like favicon.ico, site.webmanifest, robots.txt
-  extras?: Record<string, Uint8Array>
 }
 
 export async function buildZip(input: BuildZipInput): Promise<Uint8Array> {
@@ -21,22 +19,6 @@ export async function buildZip(input: BuildZipInput): Promise<Uint8Array> {
       zip.file(path, buf as unknown as Buffer)
     }
   }
-  if (input.extras) {
-    // validate manifest if present
-    if (Object.prototype.hasOwnProperty.call(input.extras, 'site.webmanifest')) {
-      try {
-        const manifestBytes = input.extras['site.webmanifest']
-        const manifestStr = Buffer.from(manifestBytes).toString('utf8')
-        JSON.parse(manifestStr)
-      } catch {
-        throw new Error('Invalid site.webmanifest JSON')
-      }
-    }
-    for (const [path, bytes] of Object.entries(input.extras)) {
-      const buf = Buffer.from(bytes)
-      zip.file(path, buf as unknown as Buffer)
-    }
-  }
   const content = await zip.generateAsync({ type: 'uint8array' })
   return content
 }

lib/exporter/zip.validation.integrated.test.ts

@@ -1,53 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import JSZip from 'jszip'
-import { exportPage } from '@/lib/exporter/html'
-import { buildZip } from '@/lib/exporter/zip'
-import { AssetManager } from '@/lib/assets/assetManager'
-import { pageSchema, type Page } from '@/lib/schema/page'
-
-function makePageWithLocalAsset(): { page: Page; am: AssetManager } {
-  const am = new AssetManager({ maxBytes: 1024 * 1024, allowedExts: ['png','svg','jpg','jpeg','webp'] })
-  // simulate adding a local image and referencing it by original name via local: prefix
-  const bytes = new Uint8Array([7,8,9])
-  // add as "hero.png"
-  am.add({ name: 'hero.png', type: 'image/png', bytes })
-
-  const base: Page = pageSchema.parse({
-    title: 'Integrated ZIP',
-    locale: 'en',
-    theme: { primaryColor: '#2563eb', fontFamily: 'Inter' },
-    sections: [
-      { type: 'hero', props: { heading: 'Hello', subheading: 'World', imageUrl: 'local:hero.png' } },
-      { type: 'cta', props: { text: 'Go', href: '#' } },
-    ],
-    form: { actionUrl: '', fields: [], spamProtection: { honeypotFieldName: '_hp', minSubmitSeconds: 2 } },
-    analytics: { ga4MeasurementId: 'G-TEST', metaPixelId: '', customHeadHtml: '' },
-    seo: { title: 't', description: 'd' },
-  })
-  return { page: base, am }
-}
-
-describe('Export ZIP 통합 검증', () => {
-  it('exportPage 출력 + buildZip 결과에서 assets 경로/메타가 보존된다', async () => {
-    const { page, am } = makePageWithLocalAsset()
-    const out = exportPage(page, { assetManager: am })
-    const assets = am.toZipStructure()
-    const zipBytes = await buildZip({ html: out.html, css: out.css, js: out.js, assets })
-
-    const zip = await JSZip.loadAsync(zipBytes)
-    const names = Object.keys(zip.files)
-    // assets 파일이 존재해야 함
-    const assetKey = Object.keys(assets)[0]
-    expect(names).toContain(assetKey)
-
-    // index.html에 canonical/meta/ga4 스니펫 보존
-    const html = await zip.files['index.html'].async('string')
-    expect(html).toMatch(/<link rel="canonical" href="\//)
-    expect(html).toMatch(/<meta name="description" content="d"/)
-    expect(html).toMatch(/gtag\('config', 'G-TEST'\)/)
-
-    // hero 이미지가 재작성된 경로를 사용한다
-    const match = html.match(/<img[^>]*src="([^"]+)"/)
-    expect(match && match[1]).toBe(assetKey)
-  })
-})

lib/exporter/zip.validation.meta.test.ts

@@ -1,28 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import JSZip from 'jszip'
-import { buildZip } from '@/lib/exporter/zip'
-
-describe('Export ZIP 메타 보존 검증', () => {
-  it('index.html의 SEO/OG/Analytics 메타가 그대로 보존된다', async () => {
-    const html = `<!DOCTYPE html><html><head>
-      <meta charset="utf-8" />
-      <link rel="canonical" href="/" />
-      <meta name="description" content="desc" />
-      <meta property="og:title" content="OT" />
-      <meta property="og:description" content="OD" />
-      <script>window.dataLayer=[];function gtag(){dataLayer.push(arguments);}gtag('js',new Date());</script>
-    </head><body>ok</body></html>`
-    const css = 'body{color:#222}'
-    const js = 'console.log("ok")'
-
-    const zipBytes = await buildZip({ html, css, js, assets: {} })
-    const zip = await JSZip.loadAsync(zipBytes)
-    const htmlContent = await zip.files['index.html'].async('string')
-
-    expect(htmlContent).toMatch(/<link rel="canonical" href="\//)
-    expect(htmlContent).toMatch(/<meta name="description" content="desc"/)
-    expect(htmlContent).toMatch(/<meta property="og:title" content="OT"/)
-    expect(htmlContent).toMatch(/<meta property="og:description" content="OD"/)
-    expect(htmlContent).toMatch(/window\.dataLayer=\[\];/)
-  })
-})

lib/exporter/zip.validation.phase4.test.ts

@@ -1,53 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import JSZip from 'jszip'
-import { buildZip } from '@/lib/exporter/zip'
-import type { BuildZipInput } from '@/lib/exporter/zip'
-
-const TE = new TextEncoder()
-
-describe('Export ZIP 검증 강화 4차: 루트 파일(favicon/manifest/robots)', () => {
-  it('루트 파일들을 포함한다: favicon.ico / site.webmanifest / robots.txt', async () => {
-    const manifest = {
-      name: 'Landing Builder',
-      short_name: 'LB',
-      start_url: '/',
-      display: 'standalone',
-      icons: [{ src: '/favicon.png', sizes: '512x512', type: 'image/png' }],
-    }
-    const input: BuildZipInput = {
-      html: '<!DOCTYPE html><html><head><title>a</title></head><body>ok</body></html>',
-      css: 'body{color:#111}',
-      js: 'console.log("ok")',
-      assets: {},
-      extras: {
-        'favicon.ico': new Uint8Array([0, 1, 2, 3]),
-        'site.webmanifest': TE.encode(JSON.stringify(manifest)),
-        'robots.txt': TE.encode('User-agent: *\nDisallow:'),
-      },
-    }
-    const zipBytes = await buildZip(input)
-
-    const zip = await JSZip.loadAsync(zipBytes)
-    const names = Object.keys(zip.files)
-    expect(names).toContain('favicon.ico')
-    expect(names).toContain('site.webmanifest')
-    expect(names).toContain('robots.txt')
-
-    const robots = await zip.files['robots.txt'].async('string')
-    expect(robots).toMatch(/User-agent: \*/)
-
-    const parsed = JSON.parse(await zip.files['site.webmanifest'].async('string'))
-    expect(parsed.name).toBe('Landing Builder')
-    expect(parsed.icons[0].type).toBe('image/png')
-  })
-
-  it('잘못된 manifest JSON이면 실패한다', async () => {
-    const badInput: BuildZipInput = {
-        html: '<!DOCTYPE html><html><head><title>a</title></head><body>ok</body></html>',
-        css: 'body{color:#111}',
-        js: 'console.log("ok")',
-        extras: { 'site.webmanifest': TE.encode('{ invalid json') },
-      }
-    await expect(buildZip(badInput)).rejects.toThrow()
-  })
-})

lib/exporter/zip.validation.phase5.test.ts

@@ -1,39 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { buildZip } from '@/lib/exporter/zip'
-import { exportPage } from '@/lib/exporter/html'
-import { pageSchema, type Page } from '@/lib/schema/page'
-import { buildExtrasForPage } from '@/lib/exporter/extras'
-
-function makePage(): Page {
-  return pageSchema.parse({
-    title: 'ZIP Phase5',
-    locale: 'en',
-    theme: { primaryColor: '#2563eb', fontFamily: 'Inter' },
-    sections: [ { type: 'hero', props: { heading: 'Hello', subheading: 'World', imageUrl: 'https://img/h.png' } } ],
-    form: { actionUrl: '', fields: [], spamProtection: { honeypotFieldName: '_hp', minSubmitSeconds: 2 } },
-    seo: { title: 't', description: 'd' },
-  })
-}
-
-describe('ZIP 검증 Phase5', () => {
-  it('robots.txt 베이스라인과 site.webmanifest JSON 파싱 검증', async () => {
-    const page = makePage()
-    const extras = buildExtrasForPage(page)
-
-    // baseline robots
-    const robots = Buffer.from(extras['robots.txt']).toString('utf8')
-    expect(robots).toContain('User-agent: *')
-
-    // manifest JSON parseable
-    const manifestStr = Buffer.from(extras['site.webmanifest']).toString('utf8')
-    const manifest = JSON.parse(manifestStr)
-    expect(manifest && typeof manifest === 'object').toBe(true)
-    expect(manifest.start_url).toBeDefined()
-    expect(manifest.display).toBeDefined()
-
-    // ZIP build should succeed
-    const out = exportPage(page)
-    const zipBytes = await buildZip({ html: out.html, css: out.css, js: out.js, assets: {}, extras })
-    expect(zipBytes.byteLength).toBeGreaterThan(0)
-  })
-})

lib/exporter/zip.validation.test.ts

@@ -1,44 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import JSZip from 'jszip'
-import { buildZip } from '@/lib/exporter/zip'
-
-const TE = new TextEncoder()
-
-describe('Export ZIP 검증 강화', () => {
-  it('assets가 비어있을 때 index.html/styles.css/app.js만 포함한다', async () => {
-    const zipBytes = await buildZip({
-      html: '<!DOCTYPE html><html><head><title>a</title></head><body>ok</body></html>',
-      css: 'body{color:#111}',
-      js: 'console.log("ok")',
-      assets: {},
-    })
-    const zip = await JSZip.loadAsync(zipBytes)
-    const names = Object.keys(zip.files).sort()
-    expect(names).toEqual(['app.js','index.html','styles.css'])
-  })
-
-  it('assets가 있으면 모든 파일을 그대로 포함한다(서브폴더 포함)', async () => {
-    const assets = {
-      'assets/img/logo.png': new Uint8Array([0,1,2,3]),
-      'assets/svg/icon.svg': TE.encode('<svg></svg>'),
-      'assets/fonts/inter.woff2': new Uint8Array([4,5,6]),
-    }
-    const zipBytes = await buildZip({
-      html: '<!DOCTYPE html><html><head><title>a</title></head><body>ok</body></html>',
-      css: 'body{color:#111}',
-      js: 'console.log("ok")',
-      assets,
-    })
-    const zip = await JSZip.loadAsync(zipBytes)
-    const names = Object.keys(zip.files)
-    expect(names).toContain('index.html')
-    expect(names).toContain('styles.css')
-    expect(names).toContain('app.js')
-    expect(names).toContain('assets/img/logo.png')
-    expect(names).toContain('assets/svg/icon.svg')
-    expect(names).toContain('assets/fonts/inter.woff2')
-
-    const logo = await zip.files['assets/img/logo.png'].async('uint8array')
-    expect(Array.from(logo)).toEqual([0,1,2,3])
-  })
-})

tests/e2e/export-focus-outline.e2e.ts

@@ -1,42 +0,0 @@
-import { test, expect } from '@playwright/test'
-
-type WindowWithExport = Window & {
-  __exportPreview?: () => { html: string; css: string; js: string }
-}
-
-const builderUrl = '/en/builder'
-
-// Verify that focus outline tokens from CSS are applied in a real browser context
-// by focusing the submit button in the exported page and inspecting computed styles.
-test('Exported page shows 3px solid outline color on focused button', async ({ page, context }) => {
-  await page.goto(builderUrl)
-  // Minimal content to export
-  await page.getByTestId('card-hero').click()
-
-  await page.waitForFunction(() => Boolean((window as unknown as WindowWithExport).__exportPreview), { timeout: 5000 })
-  const exported = await page.evaluate(() => (window as unknown as WindowWithExport).__exportPreview?.() ?? null)
-  expect(exported).not.toBeNull()
-
-  const preview = await context.newPage()
-  await preview.setContent(exported!.html)
-  await preview.addStyleTag({ content: exported!.css })
-
-  const submit = preview.locator('button[type="submit"]')
-  await expect(submit).toHaveCount(1)
-  await submit.focus()
-
-  // Read computed style in the page context
-  const style = await preview.evaluate(() => {
-    const el = document.querySelector('button[type="submit"]') as HTMLElement | null
-    if (!el) return null
-    const cs = window.getComputedStyle(el)
-    return { outlineWidth: cs.outlineWidth, outlineStyle: cs.outlineStyle, outlineColor: cs.outlineColor }
-  })
-  expect(style).not.toBeNull()
-  // Expect 3px solid and brand color (#2563eb => rgb(37, 99, 235))
-  expect(style!.outlineWidth).toBe('3px')
-  expect(style!.outlineStyle).toBe('solid')
-  expect(style!.outlineColor.replace(/\s+/g, '')).toMatch(/rgb\(37,99,235\)|#2563eb/i)
-
-  await preview.close()
-})

tests/e2e/export-tab-order.e2e.ts

@@ -1,49 +0,0 @@
-import { test, expect } from '@playwright/test'
-
-type WindowWithExport = Window & {
-  __exportPreview?: () => { html: string; css: string; js: string }
-}
-
-const builderUrl = '/en/builder'
-
-// Verify tab order after activating the skip-link: focus should move into <main>
-// Then the first Tab should reach a focusable descendant (e.g., form submit button)
-test('Skip-link Enter moves focus into main; next Tab reaches first focusable', async ({ page, context }) => {
-  await page.goto(builderUrl)
-  await page.getByTestId('card-hero').click()
-
-  await page.waitForFunction(() => Boolean((window as unknown as WindowWithExport).__exportPreview), { timeout: 5000 })
-  const exported = await page.evaluate(() => (window as unknown as WindowWithExport).__exportPreview?.() ?? null)
-  expect(exported).not.toBeNull()
-
-  const preview = await context.newPage()
-  await preview.setContent(exported!.html)
-  await preview.addStyleTag({ content: exported!.css })
-
-  const skip = preview.locator('a.skip-link')
-  await expect(skip).toHaveCount(1)
-  await skip.focus()
-  await expect(skip).toBeFocused()
-
-  // Activate skip-link
-  await preview.keyboard.press('Enter')
-
-  // Focus should be inside #main or on #main
-  const focusedInMain = await preview.evaluate(() => {
-    const main = document.getElementById('main')!
-    const active = document.activeElement as HTMLElement | null
-    if (!active) return false
-    return active === main || main.contains(active)
-  })
-  expect(focusedInMain).toBeTruthy()
-
-  // Press Tab and expect a focusable inside main (submit button) to receive focus
-  await preview.keyboard.press('Tab')
-  const isSubmitFocused = await preview.evaluate(() => {
-    const active = document.activeElement as HTMLElement | null
-    return !!active && active.tagName.toLowerCase() === 'button' && (active as HTMLButtonElement).type === 'submit'
-  })
-  expect(isSubmitFocused).toBeTruthy()
-
-  await preview.close()
-})