release: v1.0.0 정식 배포

기능 변경 없이 버전만 1.0.0 으로 승격(config 파일 지원, fabric meta 설치,
다운로드 오류 URL 표시 등 0.4.x 누적 기능 포함).

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

README.md

@@ -3,8 +3,8 @@
 마인크래프트 음악퀴즈를 한 번에 배포·관리할 수 있도록 만든 통합 프로젝트입니다.
 
 - **관리 사이트** — 음악퀴즈 정보(JSON)와 음악·사진 목록, 데이터팩 출력을 한 곳에서 운영.
-- **음악퀴즈 간편설치기 (`.exe`)** — `manifest.json` 기반으로 사용자가 마인크래프트 본체·서버·모드를 자동 설치.
+- **음악퀴즈 간편설치기 (`.exe`)** — `manifest.json` 기반으로 마인크래프트 본체·모드·(멀티 호스트면)서버를 자동 설치. 서버용 JDK 자동 탐색·설치와 `run.bat` 자바 경로 보정, 완료 단계에서 최종 리소스팩 선택 설치까지 처리.
-- **리소스팩 간편설치기 (`.exe`)** — 음악퀴즈 음악·표지를 yt-dlp 로 받아 painting variant 텍스처 리소스팩으로 패키징.
+- **리소스팩 간편설치기 (`.exe`)** — 음악퀴즈 음악·표지를 yt-dlp 로 받아 painting variant 텍스처 리소스팩으로 패키징(429/403 재시도·동시 다운로드).
 - **간편포트포워딩 (`.exe`)** — 원하는 포트를 입력해 UPnP 로 개방. 프로그램을 켜 두는 동안만 열려 있고 창을 닫으면 자동으로 닫힙니다.
 - **음악퀴즈 파일제거 (`.exe`)** — 설치기들이 만든 게임 폴더·캐시와 런처 프로필을 휴지통 이동 또는 완전 삭제로 한 번에 정리.
 
@@ -29,28 +29,40 @@
 
 ## 핵심 컨셉
 
-설치기는 사용자의 `%APPDATA%\.minecraft` 를 더럽히지 않기 위해 **`.mc_custom`** 을 별도 게임 디렉터리로 사용합니다.
+설치기는 사용자의 평소 마인크래프트와 음악퀴즈 설정이 섞이지 않도록 **`.mc_custom`** 을 별도 게임 디렉터리(gameDir)로 씁니다. 단, 마인크래프트 **런처는 게임 실행에 필요한 공용 데이터(`versions` / `libraries` / `assets` / `runtime`)를 런처 폴더(`.minecraft`)에서 찾으므로**, 이 데이터(바닐라 + fabric)는 `.minecraft` 에 둡니다. 그중 `assets` / `libraries` / `versions` 세 폴더만 `.mc_custom` 에 junction 링크하고(게임이 gameDir 기준으로 찾아도 되도록), `runtime`(JRE)은 링크하지 않고 런처가 `.minecraft\runtime` 에서 직접 씁니다. 게임 데이터(모드/세이브/리소스팩)만 `.mc_custom` 에 별도로 둡니다.
 
 ```
 %APPDATA%\
-├─ .minecraft\           ← 원래 마인크래프트 폴더(공용 자원: assets, libraries, versions, runtime)
+├─ .minecraft\           ← 런처 폴더. 게임 실행에 필요한 공용 데이터는 반드시 여기에 있어야 함
-└─ .mc_custom\           ← 음악퀴즈 전용 게임 폴더(설치기가 자동 생성)
+│  ├─ assets\            ← 에셋(사운드/번역/스킨 등)
+│  ├─ libraries\         ← 자바 라이브러리(바닐라 + fabric)  ※ assets 밖의 형제 폴더
+│  ├─ versions\          ← 버전 JSON(바닐라 + fabric-loader-*)  ※ fabric 은 여기에 설치
+│  ├─ runtime\           ← 런처 번들 JRE(런처가 직접 사용)
+│  └─ launcher_profiles.json  ← 음악퀴즈 프로필(gameDir=.mc_custom)을 추가/갱신
+└─ .mc_custom\           ← 음악퀴즈 전용 게임 폴더(gameDir). 설치기가 자동 생성
    ├─ mods\              ← 음악퀴즈가 지정한 모드(.jar)
-   ├─ resourcepacks\     ← 리소스팩(.zip)
+   ├─ resourcepacks\     ← 리소스팩(.zip). 최종 리소스팩도 여기에 저장
    ├─ saves\             ← 단일 맵 .zip 압축 해제 결과
-   ├─ assets\  (junction → .minecraft\assets)
+   ├─ jdk\               ← 설치기가 자동 설치한 JDK(temurin-<버전>)
-   ├─ libraries\ (junction → .minecraft\libraries)
+   ├─ assets\ · libraries\ · versions\  ← `.minecraft` 로의 junction 링크(공용 데이터)
-   ├─ versions\ (junction → .minecraft\versions)
+   └─ options.txt 등     ← `.minecraft` 최상위 설정 파일을 복사해 사용
-   ├─ options.txt 등     ← `.minecraft` 의 최상위 설정 파일을 복사해 사용
-   └─ launcher_profiles  ← 실제 파일은 `.minecraft\launcher_profiles.json` 을 수정해 gameDir=.mc_custom 으로 지정
 ```
 
-이렇게 분리해 두면 사용자가 평소 쓰던 마인크래프트와 음악퀴즈 설정이 섞이지 않고, 음악퀴즈만 삭제해도 본체에는 영향이 없습니다.
+이렇게 분리해 두면 음악퀴즈만 삭제해도(파일제거 도구) 본체 마인크래프트에는 영향이 없습니다. fabric 을 `.mc_custom` 이 아닌 `.minecraft` 에 설치하는 이유는, 게임 폴더에 설치하면 바닐라 버전/라이브러리가 빠져 런처가 "Unable to prepare assets for download" 로 실패하기 때문입니다(자세한 흐름은 [`docs/installer.md`](docs/installer.md)).
 
 > **폴더 이름 바꾸기.** 기본값은 `.mc_custom` 이지만 `.env` / `.env.build` 의 `MC_CUSTOM_DIR` 로 다른 이름을 지정할 수 있습니다. 설치기·리소스팩설치기·파일제거기가 모두 이 값을 공유하므로, 값을 바꾸면 세 exe 를 같은 값으로 다시 빌드해야 서로 같은 폴더를 가리킵니다. (경로 구분자 `/ \` 와 `..` 는 무시되어 항상 `%APPDATA%` 바로 아래 단일 폴더가 됩니다.)
 
 ---
 
+## 간편설치기 동작 요약
+
+- **JDK(서버용)** — 탐색 순서: ① `.mc_custom\jdk`(설치기 자동 설치분)에 JDK 가 있으면 먼저 사용 → ② 없으면 환경변수(`JAVA_HOME`/`JDK_HOME`)의 JDK 가 **권장 버전(`recommendedJdk`)** 이면 사용 → ③ 그래도 없으면 `C:\Program Files\Java` 에서 권장 버전을 찾아 사용. 권장 버전을 어디서도 못 찾으면 환경변수 자바(없으면 Program Files 자바)로 폴백하고 "권장과 다름" 경고를 띄웁니다. 아무 JDK 도 없으면 Adoptium Temurin(권장 버전)을 `.mc_custom\jdk` 에 자동 설치합니다.
+- **서버 `run.bat`** — 서버 zip 의 `run.bat` 이 시스템 PATH 의 낡은 자바를 쓰지 않도록, 준비/선택한 JDK 의 `java` 를 쓰도록 자동 수정합니다(자동 설치 JDK 는 `%APPDATA%` 전개형 경로라 한글 사용자명에도 안전).
+- **최종 리소스팩** — 완료 단계에서 "리소스팩을 설치하시겠습니까?"(예/아니요). 예 → 최종 리소스팩 약관 동의 → `/file/resourcepacks/outputs/` 에서 진행률과 함께 다운로드. `finalResourcepackPath` 가 `"."` 이면 이 질문을 건너뜁니다.
+- **약관 표시 대상** — 사이트 약관마다 표시 위치(설치기 / 리소스팩 설치기 / 최종 리소스팩)를 개별 토글합니다.
+
+---
+
 ## 빠른 시작
 
 전제: Node.js 18+, npm. 윈도우 빌드를 만들 때만 추가로 Electron 의 PE 서명·아이콘 도구가 필요합니다.
@@ -128,21 +140,27 @@ npm run dist:win:rp:dev     # (개발자용) 음악퀴즈 리소스팩설치기
     "loaderVersion": "0.16.10"
   },
   "modsFolder": "mq-v1",
-  "resourcepackPath": "mq-v1.zip",
+  "resourcepackPath": "mq-v1-base.zip",
+  "finalResourcepackPath": "mq-v1.zip",
+  "outputPackName": "음악퀴즈 v1 리소스팩",
   "mapPath": "mq-v1-map.zip",
   "serverPath": "mq-v1-server.zip",
   "serverMinRam": 4096,
   "serverMaxRam": 8192,
   "clientMinRam": 4096,
-  "clientRecommendedRam": 8192
+  "clientRecommendedRam": 8192,
+  "recommendedJdk": 25
 }
 ```
 
 - `platform.type` = `vanilla` / `forge` / `fabric` / `neoforge`.
-- `fabric` 은 `loaderVersion` 만 지정하면 설치기가 최신 fabric-installer 로 자동 CLI 설치합니다.
+- `fabric` 은 `loaderVersion` 만 지정하면 설치기가 최신 fabric-installer 로 `.minecraft` 에 자동 CLI 설치합니다.
 - 나머지(forge/neoforge) 는 `platform.downloadUrl` 에 설치 jar URL.
 - `modsFolder` → `/file/mods/<폴더>/` 의 모든 `.jar` 를 자동으로 받습니다.
-- `serverPath` / `mapPath` / `resourcepackPath` → `/file/servers/`, `/file/maps/`, `/file/resourcepacks/` 아래 zip 파일명.
+- `serverPath` / `mapPath` / `resourcepackPath` → `/file/servers/`, `/file/maps/`, `/file/resourcepacks/` 아래 zip 파일명. `resourcepackPath` 는 리소스팩 설치기의 **베이스** 팩입니다.
+- `finalResourcepackPath` → `/file/resourcepacks/outputs/` 의 **최종 리소스팩** zip. 간편설치기 완료 단계에서 사용자가 선택 설치합니다. `"."` 이면 없음(질문 자체를 건너뜀). 최종 리소스팩이 지정되면 간편설치기는 중복인 베이스 리소스팩을 받지 않습니다.
+- `outputPackName` → 리소스팩 설치기가 만들 zip 이름/마인크래프트 목록 제목.
+- `recommendedJdk` → 서버 실행 권장 JDK 메이저(사이트 편집기의 Adoptium 목록에서 선택). 설치기가 이 버전을 우선 탐색하고 없으면 자동 설치합니다.
 
 ### `/file/list/<key>.json` — 음악·사진 목록 (리소스팩 설치기용)
 
@@ -184,12 +202,14 @@ minecraft_launcher/
 │  ├─ servers/             서버 zip
 │  ├─ maps/                맵 zip
 │  ├─ mods/<폴더>/         모드 jar 묶음 (index.json 자동 생성)
-│  ├─ resourcepacks/       리소스팩 zip
+│  ├─ resourcepacks/       베이스 리소스팩 zip
+│  │  └─ outputs/          최종 리소스팩 zip (간편설치기 완료 단계용)
 │  ├─ platforms/           Forge / NeoForge 설치 jar
 │  └─ list/<key>.json      음악·사진 목록
 ├─ docs/                   사용·운영 문서
 ├─ manifest.json           사이트 루트 매니페스트 (자동 관리)
-├─ account.json            관리자 계정 (절대 외부 노출 금지)
+├─ account.json            관리자 계정 시드/레거시(추적됨). 실제 운영 계정은 아래 우선
+├─ account.local.json      실제 운영 계정(해시 비밀번호, .gitignore, 0600). 없으면 account.json 을 시드로 사용
 ├─ package.json
 └─ tsconfig.{,server,installer,installer-rp,installer-pf,installer-uninstall}.json
 ```

docs/installer.md

@@ -28,10 +28,14 @@
 
 ### 3-2. JDK 확인
 
-- 각 음악퀴즈(pack)는 사이트 편집기에서 **권장 JDK 버전**(예: Java 25)을 지정합니다. 설치기는 이 권장 버전을 기준으로 동작합니다.
+- 각 음악퀴즈(pack)는 사이트 편집기에서 **권장 JDK 버전**(예: Java 25)을 지정합니다. 편집기 목록은 Adoptium(Temurin)에서 실제 배포되는 버전을 불러오며, "자세히 보기"로 비-LTS·스냅샷까지 확인할 수 있습니다. 설치기는 이 권장 버전을 기준으로 동작합니다.
-- 탐색 순서: **① 권장 JDK 자동 설치 위치(`%APPDATA%\jdk\temurin-<권장>`) 를 가장 먼저** 확인 → 없으면 **② 컴퓨터의 JDK(`JAVA_HOME` / `JDK_HOME` / `C:\Program Files\Java`)** 를 확인.
+- 탐색 순서:
-- 최신 마인크래프트 서버는 특정 자바 버전 이상을 요구합니다(예: 서버 번들러 class file 69.0 = Java 25). 그보다 낮은 자바는 있어도 `UnsupportedClassVersionError` 로 서버가 뜨지 않으므로, 자동 탐색은 **권장 버전 미만을 "없음"으로 처리**해 자동 설치로 유도합니다. 직접 선택/입력한 경로도 "다음" 에서 버전을 검증해 미만이면 진행을 막습니다.
+  1. **설치기 자동 설치 위치 `%APPDATA%\.mc_custom\jdk`**(구버전 `%APPDATA%\jdk` 호환)에 JDK 가 있으면 **가장 먼저 사용**합니다(권장 버전이면 그대로, 혹시 다른 버전이면 경고).
-- **자동 설치** 버튼을 누르면 Adoptium Temurin(권장 버전) Windows x64 zip 을 받아 `%APPDATA%\jdk\temurin-<권장>\` 에 풀어 사용합니다.
+  2. 없으면 **환경변수(`JAVA_HOME` / `JDK_HOME`)** 의 JDK 가 **권장 버전이면** 사용합니다.
+  3. 그래도 없으면 **기본 폴더 `C:\Program Files\Java`** 에서 **권장 버전**을 찾아 사용합니다.
+  4. 권장 버전을 어디서도 못 찾으면 **환경변수 자바(없으면 Program Files 자바)로 폴백**하고, "권장 버전과 달라 서버가 정상 실행되지 않을 수 있다"는 **경고**를 띄웁니다.
+- 직접 선택/입력한 경로도 "다음" 에서 검증해, 권장과 다르면 경고 후 동의(확인) 시에만 진행합니다(무조건 차단이 아니라 경고+동의). 아무 JDK 도 없으면 자동 설치로 유도합니다.
+- **자동 설치** 버튼을 누르면 Adoptium Temurin(권장 버전) Windows x64 zip 을 받아 **`%APPDATA%\.mc_custom\jdk\temurin-<권장>\`** 에 풀어 사용합니다. (`.mc_custom` 안에 두므로 "음악퀴즈 파일제거" 도구로 한 번에 정리됩니다. `MC_CUSTOM_DIR` 로 폴더명을 바꾼 경우 그 폴더 아래 `jdk`.)
 - 설치 중 같은 버튼이 "설치 취소" 로 바뀌고, 누르면 다운로드를 즉시 중단하고 부분 파일을 정리합니다.
 - 서버 zip 의 `run.bat` 이 시스템 PATH 의 `java` 를 그대로 쓰면 낡은 자바로 실행돼 실패할 수 있어, 설치기가 준비/선택한 JDK 의 `java` 를 쓰도록 `run.bat` 을 자동으로 수정합니다(자동 설치 JDK 는 `%APPDATA%` 전개형 경로라 한글 사용자명에도 안전).
 
@@ -74,9 +78,9 @@
 2. `.minecraft` 최상위 설정 파일(`options.txt`, `optionsof.txt`, `servers.dat`, `usercache.json`, …) 을 `.mc_custom` 으로 복사. 이미 같은 이름이 있으면 보존.
 3. 플랫폼 설치:
    - `vanilla` → 건너뜀.
-   - `fabric` → Adoptium 자동 설치 → 최신 fabric-installer.jar 다운로드 → `java -jar fabric-installer.jar client -mcversion X -loader Y -dir .mc_custom -noprofile` 자동 실행.
+   - `fabric` → fabric-installer(자바 필요) 를 돌리지 않고, fabric meta 에서 버전 프로필 JSON 을 직접 받아 `.minecraft\versions\fabric-loader-Y-X\fabric-loader-Y-X.json` 으로 저장한다(`https://meta.fabricmc.net/v2/versions/loader/<mc>/<loader>/profile/json`). 자바가 없어도 되므로 "spawn java ENOENT" 나 바닐라 선행 실행이 필요 없다. 라이브러리는 프로필 JSON 에 적힌 maven url 을 보고 런처가 실행 시 자동으로 받는다. (fabric 버전/라이브러리는 런처 폴더 `.minecraft` 에 있어야 런처가 찾으며, `.mc_custom` 에 두면 "Unable to prepare assets for download" 로 실패한다.)
    - `forge` / `neoforge` → `platform.downloadUrl` 의 설치 jar 다운로드(사용자가 직접 실행하거나 마인크래프트 런처가 인식).
-4. `modsFolder` 의 모든 `.jar` 와 `resourcepackPath` zip, `mapPath` zip 을 자동 다운로드.
+4. `modsFolder` 의 모든 `.jar` 와 `resourcepackPath` zip, `mapPath` zip, `configPath` zip 을 자동 다운로드. (`configPath` zip 은 `.mc_custom` 루트에 그대로 풀려 `config/` 등이 배치됨)
 5. `.minecraft\{assets,libraries,versions}` 를 `.mc_custom\{assets,libraries,versions}` 로 junction 링크. (없으면 "Unable to prepare assets for download" 오류로 마인크래프트가 실패하기 때문)
 6. `.minecraft\launcher_profiles.json` 에 해당 음악퀴즈 이름의 프로필을 추가/갱신:
    - `gameDir` = `%APPDATA%\.mc_custom`

installer/renderer.js

@@ -136,6 +136,8 @@ function renderStep1() {
         tt('step1.subtitle', { mc: pack.pack.mcVersion, platform: pack.pack.platform.type }) + '</small>'
       if (state.selectedPackKey === pack.key) btn.classList.add('selected')
       btn.addEventListener('click', function () {
+        // 팩이 바뀌면 최종 리소스팩 처리 상태를 초기화(새 팩의 설치 여부를 다시 묻도록).
+        if (state.selectedPackKey !== pack.key) state.finalRpHandled = false
         state.selectedPackKey = pack.key
         nextBtn.disabled = false
         renderList()
@@ -235,7 +237,10 @@ function showAgreementError(message) {
 // 약관을 한 건씩 페이지로 보여준다. 각 약관마다 "해당 약관에 동의합니다" 체크가 있고,
 // 끝까지 스크롤해 읽어야 체크할 수 있으며, [다음] 을 누르면 다음 약관 페이지가 화면
 // 맨 위에서부터 나온다. 마지막 약관까지 동의하면 다음 단계(step2)로 진행한다.
-function renderAgreementWithKinds(KINDS) {
+function renderAgreementWithKinds(KINDS, opts) {
+  opts = opts || {}
+  var onComplete = opts.onComplete || renderStep2 // 마지막 약관 동의 후
+  var onBack = opts.onBack || renderStep1 // 첫 약관에서 뒤로
   var idx = 0
   var accepted = {} // kind -> true (뒤로 갔다 와도 동의 상태 유지)
   var cache = {} // kind -> 렌더된 HTML
@@ -293,11 +298,11 @@ function renderAgreementWithKinds(KINDS) {
         msg.classList.add('error')
         return
       }
-      if (isLast) renderStep2()
+      if (isLast) onComplete()
       else { idx++; renderCurrent() }
     })
     section.querySelector('#back').addEventListener('click', function () {
-      if (idx === 0) renderStep1()
+      if (idx === 0) onBack()
       else { idx--; renderCurrent() }
     })
 
@@ -641,13 +646,17 @@ function renderSubStep32(host, back, done) {
   autoBtn.addEventListener('click', async function () {
     if (installing) return
     var detect = await installerApi.detectJdk(recommendedJdk)
-    if (detect.found) {
+    if (detect.found && detect.match) {
       input.value = detect.path
-      msg.textContent = detect.source === 'recommended'
+      msg.textContent = tt('step3.sub32.foundRecommended', { path: detect.path, major: recommendedJdk })
-        ? tt('step3.sub32.foundRecommended', { path: detect.path, major: recommendedJdk })
-        : tt('step3.sub32.found', { path: detect.path })
       msg.classList.remove('error')
       msg.classList.add('success')
+    } else if (detect.found) {
+      // 권장 버전이 아닌 다른 JDK 를 찾음 → 경고와 함께 채워 넣는다.
+      input.value = detect.path
+      msg.textContent = tt('step3.sub32.foundMismatch', { path: detect.path, major: detect.major, required: recommendedJdk })
+      msg.classList.remove('success')
+      msg.classList.add('error')
     } else {
       msg.textContent = tt('step3.sub32.notFound', { major: recommendedJdk })
       msg.classList.remove('success')
@@ -703,21 +712,31 @@ function renderSubStep32(host, back, done) {
       msg.classList.add('error')
       return
     }
-    // 직접 입력/선택한 JDK 도 서버 실행에 충분한 버전(Java 25+)인지 검증한다.
+    // 직접 입력/선택한 JDK 를 확인한다. 자바를 못 읽으면 진행을 막고, 권장과 다른
-    // 너무 낮으면 run.bat 이 그 자바를 써도 UnsupportedClassVersionError 로 서버가 안 뜬다.
+    // 버전이면 "정상 실행이 안 될 수 있다"는 경고를 띄운 뒤 사용자가 동의하면 진행한다.
     nextBtn.disabled = true
     msg.classList.remove('success', 'error')
     msg.textContent = tt('step3.sub32.verifying')
+    var required = recommendedJdk
     try {
       var v = await installerApi.verifyJdk(val, recommendedJdk)
-      if (!v || !v.ok) {
+      required = (v && v.required) || recommendedJdk
+      if (!v || !v.major) {
         msg.classList.add('error')
-        msg.textContent = (v && v.major)
+        msg.textContent = tt('step3.sub32.versionUnknown')
-          ? tt('step3.sub32.versionTooLow', { major: v.major, required: (v && v.required) || recommendedJdk })
-          : tt('step3.sub32.versionUnknown')
         nextBtn.disabled = false
         return
       }
+      if (!v.match) {
+        // 권장 버전과 다름 → 경고 후 동의 시에만 계속.
+        var proceed = window.confirm(tt('step3.sub32.mismatchConfirm', { major: v.major, required: required }))
+        if (!proceed) {
+          msg.classList.add('error')
+          msg.textContent = tt('step3.sub32.foundMismatch', { path: val, major: v.major, required: required })
+          nextBtn.disabled = false
+          return
+        }
+      }
     } catch (err) {
       msg.classList.add('error')
       msg.textContent = tt('step3.sub32.versionUnknown')
@@ -732,10 +751,13 @@ function renderSubStep32(host, back, done) {
     var detect = await installerApi.detectJdk(recommendedJdk)
     if (detect.found && !input.value) {
       input.value = detect.path
-      msg.textContent = detect.source === 'recommended'
+      if (detect.match) {
-        ? tt('step3.sub32.foundRecommended', { path: detect.path, major: recommendedJdk })
+        msg.textContent = tt('step3.sub32.foundRecommended', { path: detect.path, major: recommendedJdk })
-        : tt('step3.sub32.autoDetected', { path: detect.path })
+        msg.classList.add('success')
-      msg.classList.add('success')
+      } else {
+        msg.textContent = tt('step3.sub32.foundMismatch', { path: detect.path, major: detect.major, required: recommendedJdk })
+        msg.classList.add('error')
+      }
     } else if (!detect.found) {
       msg.textContent = tt('step3.sub32.notFoundHint', { major: recommendedJdk })
     }
@@ -1039,9 +1061,160 @@ function renderSubStep42(host, back, done) {
   })()
 }
 
+// 최종 리소스팩 설치 여부 질문 (예/아니요).
+function renderResourcepackPrompt() {
+  setActiveStep(5)
+  clearPage()
+  var section = document.createElement('section')
+  section.className = 'page'
+  section.innerHTML =
+    '<h2>' + tt('resourcepack.promptHeading') + '</h2>' +
+    '<p class="formMessage">' + escapeHtml(tt('resourcepack.promptBody')) + '</p>' +
+    '<div class="actionRow">' +
+    '  <button class="secondaryBtn" id="rpNo">' + tt('resourcepack.no') + '</button>' +
+    '  <button class="primaryBtn" id="rpYes">' + tt('resourcepack.yes') + '</button>' +
+    '</div>'
+  pageHost.appendChild(section)
+  section.querySelector('#rpNo').addEventListener('click', function () {
+    state.finalRpHandled = true
+    renderStep5()
+  })
+  section.querySelector('#rpYes').addEventListener('click', renderResourcepackTerms)
+}
+
+// "예" → 최종 리소스팩 다운로드 약관(showInFinalResourcepack) 동의 → 다운로드.
+function renderResourcepackTerms() {
+  setActiveStep(5)
+  clearPage()
+  var loading = document.createElement('section')
+  loading.className = 'page'
+  loading.innerHTML = '<h2>' + tt('agreement.heading') + '</h2><p class="formMessage">' + tt('agreement.loading') + '</p>'
+  pageHost.appendChild(loading)
+  installerApi.getFinalTermsList().then(function (res) {
+    if (!res || !res.ok) {
+      showResourcepackTermsError((res && res.message) || 'unknown')
+      return
+    }
+    var terms = (res.terms || []).map(function (t) { return { id: t.kind, tab: t.label } })
+    if (terms.length === 0) {
+      // 표시할 약관이 없으면 약관 단계를 건너뛰고 바로 다운로드.
+      downloadFinalResourcepack()
+      return
+    }
+    clearPage()
+    renderAgreementWithKinds(terms, { onComplete: downloadFinalResourcepack, onBack: renderResourcepackPrompt })
+  }).catch(function (err) {
+    showResourcepackTermsError(err && err.message ? err.message : 'unknown')
+  })
+}
+
+function showResourcepackTermsError(message) {
+  clearPage()
+  var section = document.createElement('section')
+  section.className = 'page'
+  section.innerHTML =
+    '<h2>' + tt('agreement.heading') + '</h2>' +
+    '<p class="formMessage error">' + escapeHtml(tt('agreement.listLoadFailed', { message: message })) + '</p>' +
+    '<div class="actionRow">' +
+    '  <button class="secondaryBtn" id="back">' + tt('common.back') + '</button>' +
+    '  <button class="primaryBtn" id="retry">' + tt('agreement.retry') + '</button>' +
+    '</div>'
+  pageHost.appendChild(section)
+  section.querySelector('#back').addEventListener('click', renderResourcepackPrompt)
+  section.querySelector('#retry').addEventListener('click', renderResourcepackTerms)
+}
+
+// 약관 동의 후 최종 리소스팩 실제 다운로드 → 완료되면 완료 화면으로.
+function downloadFinalResourcepack() {
+  setActiveStep(5)
+  clearPage()
+  var section = document.createElement('section')
+  section.className = 'page'
+  section.innerHTML =
+    '<h2>' + tt('resourcepack.downloadHeading') + '</h2>' +
+    '<div class="formMessage" id="rpMsg">' + tt('resourcepack.downloading') + '</div>' +
+    '<div id="rpBarWrap" style="margin-top:10px;height:16px;background:rgba(255,255,255,0.08);border:1px solid var(--border,#30363d);border-radius:8px;overflow:hidden;">' +
+    '  <div id="rpBar" style="height:100%;width:0%;background:var(--accent,#6cf);transition:width 0.15s;"></div>' +
+    '</div>' +
+    '<div class="formMessage" id="rpPercent" style="margin-top:6px;">0%</div>' +
+    '<div class="actionRow" id="rpActions" hidden></div>'
+  pageHost.appendChild(section)
+  var msg = section.querySelector('#rpMsg')
+  var actions = section.querySelector('#rpActions')
+  var bar = section.querySelector('#rpBar')
+  var barWrap = section.querySelector('#rpBarWrap')
+  var percentEl = section.querySelector('#rpPercent')
+
+  // 다운로드 진행률(퍼센트) 구독. 완료/실패 시 해제.
+  var unsubscribe = null
+  if (installerApi.onFinalResourcepackProgress) {
+    unsubscribe = installerApi.onFinalResourcepackProgress(function (info) {
+      if (info && info.percent >= 0) {
+        bar.style.width = info.percent + '%'
+        percentEl.textContent = info.percent + '%'
+      } else if (info) {
+        // 전체 크기를 모르면 받은 용량(MB)만 표시.
+        percentEl.textContent = (info.loaded / 1048576).toFixed(1) + ' MB'
+      }
+    })
+  }
+  function stopProgress() { if (unsubscribe) { unsubscribe(); unsubscribe = null } }
+
+  function proceed() { stopProgress(); state.finalRpHandled = true; renderStep5() }
+
+  installerApi.installFinalResourcepack().then(function (res) {
+    stopProgress()
+    if (res && res.ok) {
+      bar.style.width = '100%'
+      percentEl.textContent = '100%'
+      if (res.applied === false) {
+        // 다운로드는 됐지만 자동 적용(options.txt) 실패 → 직접 켜라고 경고.
+        msg.textContent = tt('resourcepack.downloadDoneNotApplied', { message: res.applyMessage || '' })
+        msg.classList.add('error')
+      } else {
+        msg.textContent = tt('resourcepack.downloadDone')
+        msg.classList.add('success')
+      }
+      actions.innerHTML = '<button class="primaryBtn" id="rpNext">' + tt('common.next') + '</button>'
+      actions.querySelector('#rpNext').addEventListener('click', proceed)
+    } else {
+      barWrap.hidden = true
+      percentEl.hidden = true
+      msg.textContent = tt('resourcepack.downloadFailed', { message: (res && res.message) || 'unknown' })
+      msg.classList.add('error')
+      actions.innerHTML =
+        '<button class="secondaryBtn" id="rpRetry">' + tt('agreement.retry') + '</button>' +
+        '<button class="primaryBtn" id="rpSkip">' + tt('common.next') + '</button>'
+      actions.querySelector('#rpRetry').addEventListener('click', downloadFinalResourcepack)
+      actions.querySelector('#rpSkip').addEventListener('click', proceed)
+    }
+    actions.hidden = false
+  }).catch(function (err) {
+    stopProgress()
+    barWrap.hidden = true
+    percentEl.hidden = true
+    msg.textContent = tt('resourcepack.downloadFailed', { message: (err && err.message) ? err.message : String(err) })
+    msg.classList.add('error')
+    actions.innerHTML =
+      '<button class="secondaryBtn" id="rpRetry">' + tt('agreement.retry') + '</button>' +
+      '<button class="primaryBtn" id="rpSkip">' + tt('common.next') + '</button>'
+    actions.querySelector('#rpRetry').addEventListener('click', downloadFinalResourcepack)
+    actions.querySelector('#rpSkip').addEventListener('click', proceed)
+    actions.hidden = false
+  })
+}
+
 function renderStep5() {
   setActiveStep(5)
   clearPage()
+  // 최종 리소스팩(finalResourcepackPath)이 "." 이 아니고 아직 처리하지 않았으면,
+  // 완료 화면 전에 "리소스팩을 설치하시겠습니까?" 를 먼저 묻는다.
+  var selPack = state.packs.find(function (p) { return p.key === state.selectedPackKey })
+  var finalRp = (selPack && selPack.pack && selPack.pack.finalResourcepackPath) ? selPack.pack.finalResourcepackPath : '.'
+  if (finalRp !== '.' && !state.finalRpHandled) {
+    renderResourcepackPrompt()
+    return
+  }
   var section = document.createElement('section')
   section.className = 'page'
   // 서버 마무리 액션 (바로가기/서버 실행) 은 step3 를 거친 호스트 만 노출한다.

locales/installer-rp/ko-kr.json

@@ -94,6 +94,7 @@
     "musicTrackDone": "{{idx}}번 노래 완료: {{name}}",
     "musicTrackSkip": "{{idx}}번 노래는 이전에 받아둠 → 건너뜀(이어받기)",
     "musicRefreshRetry": "{{count}}곡 다운로드 실패 → yt-dlp/ffmpeg 최신 버전으로 재설치 후 실패한 곡만 재시도",
+    "musicTrackRetryWait": "{{idx}}번 노래 재시도 {{attempt}}회차 — 유튜브 속도제한(403) 회피로 {{secs}}초 대기 후 다시 시도",
     "ytdlpReinstall": "yt-dlp.exe 최신 버전으로 강제 재설치 중…",
     "ffmpegReinstall": "ffmpeg.exe 최신 버전으로 강제 재설치 중…",
     "imageStart": "사진 다운로드 시작 ({{total}}장)",

locales/installer/ko-kr.json

@@ -93,6 +93,8 @@
       "recommended": "권장 JDK: Java {{major}} (이 음악퀴즈 서버 실행용)",
       "found": "JDK 발견: {{path}}",
       "foundRecommended": "권장 JDK(Java {{major}}) 발견: {{path}}",
+      "foundMismatch": "⚠ 권장(Java {{required}})이 아닌 Java {{major}} 를 찾았습니다: {{path}} — 권장 버전과 달라 서버가 정상 실행되지 않을 수 있습니다. 권장 버전을 쓰려면 \"자동 설치\" 를 누르세요.",
+      "mismatchConfirm": "선택한 Java {{major}} 는 권장 버전(Java {{required}})과 다릅니다. 권장 버전과 달라 서버가 정상 실행되지 않을 수 있습니다. 이대로 계속하시겠습니까?",
       "autoDetected": "JDK 자동 탐색됨: {{path}}",
       "notFound": "서버 실행에 필요한 Java {{major}} 이상을 찾지 못했습니다(낮은 버전이 설치돼 있어도 서버가 뜨지 않습니다). \"자동 설치\" 를 눌러 설치하거나 직접 선택해 주세요.",
       "notFoundHint": "Java {{major}} 이상을 찾지 못했습니다. \"자동 설치\" 를 누르면 Temurin {{major}} 를 받아 설치합니다.",
@@ -158,6 +160,17 @@
       "failed": "설치 실패: {{message}}"
     }
   },
+  "resourcepack": {
+    "promptHeading": "리소스팩 설치",
+    "promptBody": "이 음악퀴즈의 최종 리소스팩을 설치하시겠습니까? 설치하면 마인크래프트에서 자동으로 적용됩니다.",
+    "yes": "예",
+    "no": "아니요",
+    "downloadHeading": "최종 리소스팩 다운로드",
+    "downloading": "최종 리소스팩을 다운로드하는 중…",
+    "downloadDone": "최종 리소스팩 다운로드 완료. 마인크래프트를 켜면 자동으로 적용됩니다.",
+    "downloadDoneNotApplied": "최종 리소스팩은 받았지만 자동 적용에 실패했습니다({{message}}). 마인크래프트 설정 → 리소스팩에서 직접 켜주세요.",
+    "downloadFailed": "최종 리소스팩 다운로드 실패: {{message}}"
+  },
   "step5": {
     "heading": "설치 완료",
     "summary": "",
@@ -195,14 +208,17 @@
     "jdkBusy": "이미 JDK 설치가 진행 중입니다.",
     "javaExeMissing": "설치 후 java 실행 파일을 찾지 못했습니다: {{path}}",
     "javaSpawnFailed": "Java 실행 실패: {{message}}",
+    "javaNotFoundRunVanilla": "자바를 찾지 못해 설치를 진행할 수 없습니다. 먼저 마인크래프트 런처에서 [{{version}}] 바닐라를 한 번 실행해 자바 런타임을 받은 다음, 이 설치기를 다시 시도해 주세요.",
     "fabricInstallerExit": "fabric-installer 종료 코드 {{code}}{{detail}}",
     "fabricLoaderRequired": "Fabric 로더 버전이 음악퀴즈에 지정되지 않았습니다. 관리 사이트에서 platform.loaderVersion 을 설정해 주세요.",
     "fabricInstallerListEmpty": "Fabric installer 목록을 받지 못했습니다.",
+    "fabricProfileInvalid": "Fabric 버전 프로필을 읽지 못했습니다: {{message}}",
     "portAllocFail": "포트를 할당할 수 없습니다.",
     "parseResponseFailed": "응답 파싱 실패: {{snippet}}"
   },
   "log": {
     "manifestDownload": "manifest 다운로드: {{url}}",
+    "downloadRetry": "다운로드 일시 오류({{reason}}) — {{attempt}}번째 재시도, {{secs}}초 후",
     "packLoadFail": "pack 로드 실패 ({{file}}): {{message}}",
     "packsLoaded": "로드된 음악퀴즈: {{count}}개",
     "selectedPack": "선택: {{key}}",
@@ -217,8 +233,10 @@
     "labelExtract": "{{label}} 압축 해제: {{dir}}",
     "labelServerFile": "서버 파일",
     "labelMap": "맵",
+    "labelConfigFile": "config 파일",
     "skipServerZip": "서버 파일(serverPath)이 비어 있어 서버 zip 다운로드를 건너뜁니다.",
     "skipMapZip": "맵 다운로드를 건너뜁니다 (mapPath 비어 있음 또는 참가자 모드).",
+    "skipConfigZip": "config 파일(configPath)이 비어 있어 config zip 다운로드를 건너뜁니다.",
     "cleanupInstallerMap": "이전 설치에서 풀어둔 맵 {{count}}개를 정리합니다.",
     "mapInstalledAs": "맵을 saves/{{name}} 으로 설치했습니다.",
     "clearMods": "기존 mods 폴더({{dir}})를 비우고 새로 받습니다.",
@@ -228,6 +246,11 @@
     "modDownload": "모드 다운로드: {{file}}",
     "skipResourcepack": "resourcepackPath가 비어 있어 리소스팩 다운로드를 건너뜁니다.",
     "resourcepackDownload": "리소스팩 다운로드: {{url}}",
+    "skipBaseForFinal": "최종 리소스팩이 등록돼 있어 베이스 리소스팩은 건너뜁니다(설치 마지막에 최종 리소스팩만 받음).",
+    "finalResourcepackDownload": "최종 리소스팩 다운로드: {{url}}",
+    "finalResourcepackSaved": "최종 리소스팩 저장: {{path}}",
+    "finalResourcepackApplied": "최종 리소스팩을 options.txt 에 등록해 자동 적용되게 했습니다: {{name}}",
+    "finalResourcepackApplyFail": "최종 리소스팩 자동 적용 실패(마인크래프트에서 직접 켜주세요): {{message}}",
     "serverInstallPath": "서버 설치 경로: {{path}}",
     "runBatJavaPatched": "run.bat 이 설치기가 준비한 자바를 쓰도록 수정했습니다: {{java}}",
     "runBatJavaSkip": "설치기가 준비한 JDK 를 찾지 못해 run.bat 의 자바 경로는 그대로 둡니다(시스템 자바 사용).",
@@ -260,6 +283,7 @@
     "platformSaved": "플랫폼 설치파일 저장: {{path}} (사용자가 직접 실행하거나 마인크래프트 런처에서 인식할 수 있습니다.)",
     "platformSkipped": "플랫폼 설치 건너뜀. 바닐라로 진행합니다.",
     "fabricFetchInstallerList": "Fabric installer 최신 버전 조회 중...",
+    "fabricProfileFetch": "Fabric 버전 프로필 다운로드: {{url}}",
     "fabricInstallerDownload": "Fabric installer {{version}} 다운로드: {{url}}",
     "javaUsed": "Java 사용: {{path}}",
     "fabricInstallStart": "Fabric 자동 설치 시작: {{mc}} / loader {{loader}} → {{dir}}",
@@ -274,9 +298,11 @@
     "settingCopyFail": "설정 복사 실패 ({{name}}): {{message}}",
     "settingCopySummary": "기존 마인크래프트 설정 복사: 새로 복사 {{copied}}개 / 동기화(options 류 덮어쓰기) {{synced}}개 / 보존(이미 존재) {{skipped}}개.",
     "settingCopyError": "기존 설정 복사 중 오류: {{message}}",
-    "runtimeDirMissing": ".minecraft/{{dir}} 가 없습니다. 마인크래프트 런처를 한 번 실행한 뒤 다시 시도해주세요.",
+    "runtimeDirMissing": ".minecraft/{{dir}} 가 없어 공용 링크를 만들 수 없습니다(런처가 이 폴더에 직접 받게 됩니다).",
+    "runtimeDirCreated": ".mc_custom/{{dir}} 폴더를 새로 만들었습니다(런처가 여기에 직접 다운로드).",
     "runtimeDirExists": ".mc_custom/{{dir}} 가 실제 폴더로 이미 존재 — 건너뜀.",
     "runtimeLinkCreated": "링크 생성: .mc_custom/{{dir}} → .minecraft/{{dir}}",
+    "runtimeLinkReplaced": "불완전한 .mc_custom/{{dir}} 폴더를 .minecraft/{{dir}} 링크로 교체했습니다(바닐라 데이터 포함).",
     "runtimeLinkFail": "링크 생성 실패 ({{dir}}): {{message}}",
     "shortcutCreated": "바로가기 생성: {{path}}",
     "shortcutFailed": "바로가기 생성 실패",

locales/server/ko-kr.json

@@ -117,7 +117,7 @@
     "platformDownloadUrl": "플랫폼 설치파일 URL",
     "platformDownloadHint": "도메인 없이 입력하면 manifest.json 도메인의 <code>/file/platforms/&lt;파일명&gt;</code>으로 해석됩니다.",
     "platformLoaderVersion": "Fabric Loader 버전",
-    "platformLoaderHint": "선택한 마인크래프트 버전 기준 Fabric Loader 목록입니다. 설치기는 최신 fabric-installer 를 받아 자동으로 CLI 설치합니다.",
+    "platformLoaderHint": "선택한 마인크래프트 버전 기준 Fabric Loader 목록입니다. 설치기는 자바 없이 Fabric Meta 의 프로필 JSON 을 받아 .minecraft/versions 에 직접 저장합니다.",
     "platformLoaderEmpty": "호환 로더 없음",
     "platformLoaderPickMc": "마인크래프트 버전을 먼저 선택하세요",
     "platformLoaderLoadFailed": "로더 목록 로드 실패: {{message}}",
@@ -126,15 +126,24 @@
     "clientMinRam": "클라이언트 최소 램 (MB)",
     "clientRecommendedRam": "클라이언트 권장 램 (MB)",
     "recommendedJdk": "권장 JDK (서버 실행용)",
-    "recommendedJdkHint": "설치기가 이 버전을 우선 찾고, 없으면 자동 설치합니다. 서버가 요구하는 자바 버전에 맞춰 고르세요(최신 마인크래프트는 보통 Java 25).",
+    "recommendedJdkHint": "설치기가 이 버전을 우선 찾고, 없으면 자동 설치합니다. 서버가 요구하는 자바 버전에 맞춰 고르세요(최신 마인크래프트는 보통 Java 25). 목록은 Adoptium(Temurin)에서 실제 배포되는 버전을 불러옵니다.",
+    "jdkShowDetails": "자세히 보기 (모든 버전·스냅샷)",
+    "jdkDetailsGa": "정식(GA)",
+    "jdkDetailsEa": "개발 스냅샷(EA)",
+    "jdkDetailsNone": "상세 버전 정보를 불러오지 못했습니다.",
+    "jdkLtsSuffix": " (LTS)",
     "mapPath": "맵 파일 (.zip)",
     "mapPathHint": "/file/maps/ 아래 zip 파일 이름.",
+    "configPath": "config 파일 (.zip)",
+    "configPathHint": "/file/configs/ 아래 zip 파일 이름. 게임 폴더 루트에 그대로 풀립니다(보통 zip 안에 config/ 폴더).",
     "serverPath": "서버 파일 (.zip)",
     "serverPathHint": "/file/servers/ 아래 zip 파일 이름. 멀티 모드 전용.",
     "modsFolder": "모드 폴더 이름",
     "modsFolderHint": "/file/mods/&lt;폴더이름&gt;/ 안의 모든 .jar을 자동으로 받습니다. 비워두면 모드를 받지 않습니다.",
     "resourcepackPath": "베이스 리소스팩 (.zip)",
     "resourcepackHint": "/file/resourcepacks/ 아래 .zip 파일 이름. 리소스팩 설치기가 이 zip 위에 음악·사진을 얹어 최종 리소스팩을 만듭니다. 비워두면 처음부터 새로 만듭니다.",
+    "finalResourcepackPath": "최종 리소스팩 (.zip)",
+    "finalResourcepackHint": "/file/resourcepacks/outputs/ 아래 .zip 파일 이름. 간편설치기 마지막에 사용자가 선택 설치할 수 있습니다. 없음으로 하려면 \".\" 만 입력하세요.",
     "outputPackName": "생성되는 리소스팩 이름",
     "outputPackNamePlaceholder": "예: 음악퀴즈 테스트팩",
     "outputPackNameHint": "리소스팩 설치기가 만들어 내는 zip 파일 이름이자, 마인크래프트 리소스팩 목록의 제목이 됩니다. 비워두면 파일이름_resourcepack 형태로 자동 지정됩니다. Windows 파일명 금지 문자(\\ / : * ? \" &lt; &gt; |)는 자동으로 _ 로 바뀝니다.",
@@ -171,8 +180,10 @@
     "visibilityHeading": "표시 대상 (중복 선택 가능)",
     "visibilityInstaller": "설치기에 표시",
     "visibilityInstallerRp": "리소스팩 설치기에 표시",
+    "visibilityFinalResourcepack": "최종 리소스팩에 표시",
     "visibilityInstallerShort": "설치기",
     "visibilityInstallerRpShort": "리소스팩",
+    "visibilityFinalResourcepackShort": "최종팩",
     "addHeading": "약관 추가",
     "kindLabel": "식별자",
     "kindPlaceholder": "예: privacy",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "minecraft-music-quiz-installer",
-  "version": "0.4.6",
+  "version": "1.0.0",
   "description": "마인크래프트 음악퀴즈 간편설치기 + 관리 사이트",
   "main": "dist/installer/main.js",
   "scripts": {

public/termsEditor.js

@@ -17,6 +17,7 @@
   var tabBtns = document.querySelectorAll('.tabBar .tabBtn')
   var visInstaller = document.getElementById('visInstaller')
   var visInstallerRp = document.getElementById('visInstallerRp')
+  var visFinalResourcepack = document.getElementById('visFinalResourcepack')
 
   editor.value = INITIAL || ''
   var dirty = false
@@ -28,6 +29,7 @@
   // 토글이 바뀌어도 dirty 표시. 저장 시 함께 전송된다.
   if (visInstaller) visInstaller.addEventListener('change', function () { setDirty(true) })
   if (visInstallerRp) visInstallerRp.addEventListener('change', function () { setDirty(true) })
+  if (visFinalResourcepack) visFinalResourcepack.addEventListener('change', function () { setDirty(true) })
 
   // ─── markdown 미리 보기용 미니 렌더러 ────────────────────────────────
   // 정식 markdown 파서는 아니지만, 본 편집기가 만들어 내는 형태(#, ##, ###,
@@ -171,6 +173,7 @@
     var payload = { content: editor.value }
     if (visInstaller) payload.showInInstaller = !!visInstaller.checked
     if (visInstallerRp) payload.showInInstallerRp = !!visInstallerRp.checked
+    if (visFinalResourcepack) payload.showInFinalResourcepack = !!visFinalResourcepack.checked
     fetch('/op/agreement/' + encodeURIComponent(PACK_KEY) + '/' + encodeURIComponent(TERM_KIND), {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },

src/installer-rp/main.ts

@@ -77,10 +77,10 @@ function pickMusicConcurrency(): number {
  */
 const MUSIC_START_STAGGER_MS = 2000
 
-/** 사진(썸네일) 다운로드 사이 최소 간격(ms). i.ytimg.com 429(rate limit) 를 유발하지 않도록 순차 요청을 살짝 벌린다. */
+/** 사진(썸네일) 동시 다운로드 상한. 순차 대신 병렬로 받아 속도를 높인다. 429 는 images.ts 의 지수 백오프 재시도가 흡수한다. */
-const IMAGE_REQUEST_INTERVAL_MS = 800
+const IMAGE_CONCURRENCY_CAP = 8
-/** 음악(yt-dlp) 단계 직후엔 유튜브가 IP 를 일시 throttle 할 수 있어, 사진 단계 전 잠깐 쉬어 429 를 피한다. */
+/** 음악(yt-dlp) 단계 직후 유튜브 IP throttle 이 남아 있을 수 있어, 사진 단계 전 아주 잠깐만 쉰다. */
-const IMAGE_PHASE_COOLDOWN_MS = 4000
+const IMAGE_PHASE_COOLDOWN_MS = 1000
 
 const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms))
 
@@ -493,11 +493,25 @@ ipcMain.handle('rp:install:start', async (): Promise<{ resourcepackPath: string
       await refreshBinariesOnce()
       throwIfCancelled()
       nextMusicStartAt = Date.now()
+      // 403(Forbidden)은 대개 유튜브의 일시적 rate-limit 이라, 곡마다 점점 더 오래
+      // 쉬면서 여러 번 다시 시도한다(마지막 시도에서만 에러 진행률 표시).
+      const MAX_TRACK_RETRIES = 3
       for (const i of failed) {
         throwIfCancelled()
-        await acquireMusicStartSlot()
+        let ok = false
-        throwIfCancelled()
+        for (let attempt = 1; attempt <= MAX_TRACK_RETRIES; attempt++) {
-        const ok = await tryDownloadTrack(i, true)
+          throwIfCancelled()
+          if (attempt > 1) {
+            const waitMs = Math.min(20000, 3000 * attempt)
+            sendLog(t('log.musicTrackRetryWait', { idx: i + 1, attempt, secs: Math.round(waitMs / 1000) }))
+            await sleep(waitMs)
+            throwIfCancelled()
+          }
+          await acquireMusicStartSlot()
+          throwIfCancelled()
+          ok = await tryDownloadTrack(i, attempt === MAX_TRACK_RETRIES)
+          if (ok) break
+        }
         if (!ok) {
           throwIfCancelled()
           const idx = i + 1
@@ -516,58 +530,72 @@ ipcMain.handle('rp:install:start', async (): Promise<{ resourcepackPath: string
       sendLog(t('log.imageCooldown', { secs: Math.round(IMAGE_PHASE_COOLDOWN_MS / 1000) }))
       await sleep(IMAGE_PHASE_COOLDOWN_MS)
     }
-    let imageRequests = 0
+    // 여러 장을 동시에 받아 속도를 높인다(순차+딜레이 대신 워커 풀). 유튜브 429 는
-    for (let i = 0; i < imageTotal; i++) {
+    // 각 다운로드의 지수 백오프 재시도(images.ts)가 흡수하고, 첫 하드 실패를 만나면
-      throwIfCancelled()
+    // 새 작업 배정을 멈춘 뒤 워커가 모두 끝나면 그 오류를 던진다.
-      const entry = pack.list.images[i]
+    const images = pack.list.images
-      const idx = i + 1
+    let imageNext = 0
-      // 이전 시도에서 이미 정규화해둔 사진은 건너뛴다(이어받기).
+    let imageError: Error | null = null
-      const coverPath = path.join(paintingDir, coverFileName(idx))
+    async function imageWorker(): Promise<void> {
-      if (await fileExists(coverPath)) {
+      while (true) {
-        sendLog(t('log.imageSkip', { idx }))
+        if (state.cancelRequested || imageError) return
-        sendProgress({ phase: 'item', kind: 'image', index: idx, total: imageTotal, percent: 100, status: 'done' })
+        const i = imageNext++
-        continue
+        if (i >= imageTotal) return
-      }
+        const idx = i + 1
-      // 실제 네트워크 요청을 하는 사진들 사이에만 간격을 둔다(건너뛴 것 사이엔 대기 없음).
+        const entry = images[i]
-      if (imageRequests > 0) await sleep(IMAGE_REQUEST_INTERVAL_MS + Math.floor(Math.random() * 300))
+        const coverPath = path.join(paintingDir, coverFileName(idx))
-      imageRequests++
+        // 이전 시도에서 이미 정규화해둔 사진은 건너뛴다(이어받기).
-      sendLog(t('log.imageDownloading', { idx }))
+        if (await fileExists(coverPath)) {
-      sendProgress({ phase: 'item', kind: 'image', index: idx, total: imageTotal, percent: 10, status: 'running' })
+          sendLog(t('log.imageSkip', { idx }))
-      let buf: Buffer
+          sendProgress({ phase: 'item', kind: 'image', index: idx, total: imageTotal, percent: 100, status: 'done' })
-      try {
+          continue
-        buf = await downloadImage(entry.url, (info) => {
+        }
-          const secs = Math.ceil(info.delayMs / 1000)
+        sendLog(t('log.imageDownloading', { idx }))
-          sendLog(t('log.imageRetry', { idx, attempt: info.attempt, code: info.code ?? '-', secs }))
+        sendProgress({ phase: 'item', kind: 'image', index: idx, total: imageTotal, percent: 10, status: 'running' })
-          sendProgress({
+        let buf: Buffer
-            phase: 'item', kind: 'image', index: idx, total: imageTotal, percent: 10, status: 'running',
+        try {
-            message: t('progress.imageRetry', { code: info.code ?? '-', secs })
+          buf = await downloadImage(entry.url, (info) => {
+            const secs = Math.ceil(info.delayMs / 1000)
+            sendLog(t('log.imageRetry', { idx, attempt: info.attempt, code: info.code ?? '-', secs }))
+            sendProgress({
+              phase: 'item', kind: 'image', index: idx, total: imageTotal, percent: 10, status: 'running',
+              message: t('progress.imageRetry', { code: info.code ?? '-', secs })
+            })
           })
-        })
+        } catch (err) {
-      } catch (err) {
+          // 부분 생성됐을 수 있는 커버 파일 제거(이어받기 시 완성본 오인 방지).
-        // 부분 생성됐을 수 있는 커버 파일 제거(이어받기 시 완성본 오인 방지).
+          await fsp.rm(coverPath, { force: true }).catch(() => {})
-        await fsp.rm(coverPath, { force: true }).catch(() => {})
+          const rawMsg = (err as Error).message
-        const rawMsg = (err as Error).message
+          // 429(rate limit)는 유튜브가 IP 를 일시 차단한 것. 잠시 뒤 다시 시도하면
-        // 429(rate limit)는 유튜브가 IP 를 일시 차단한 것. 잠시 뒤 다시 시도하면
+          // 이미 받은 사진은 건너뛰고 이어받는다는 안내를 덧붙인다.
-        // 이미 받은 사진은 건너뛰고 이어받는다는 안내를 덧붙인다.
+          const msg = /429/.test(rawMsg) ? `${rawMsg} — ${t('errors.imageRateLimitHint')}` : rawMsg
-        const msg = /429/.test(rawMsg) ? `${rawMsg} — ${t('errors.imageRateLimitHint')}` : rawMsg
+          sendProgress({ phase: 'item', kind: 'image', index: idx, total: imageTotal, percent: 0, status: 'error', message: msg })
-        sendProgress({ phase: 'item', kind: 'image', index: idx, total: imageTotal, percent: 0, status: 'error', message: msg })
+          if (!imageError) imageError = new Error(t('errors.imageDownloadFailed', { idx, message: msg }))
-        throw new Error(t('errors.imageDownloadFailed', { idx, message: msg }))
+          return
+        }
+        if (state.cancelRequested || imageError) return
+        sendProgress({ phase: 'item', kind: 'image', index: idx, total: imageTotal, percent: 60, status: 'running' })
+        try {
+          await normalizeToCover(buf, coverPath)
+        } catch (err) {
+          // 변환 중 부분 생성된 PNG 제거(이어받기 시 완성본 오인 방지).
+          await fsp.rm(coverPath, { force: true }).catch(() => {})
+          sendProgress({ phase: 'item', kind: 'image', index: idx, total: imageTotal, percent: 0, status: 'error', message: (err as Error).message })
+          if (!imageError) imageError = new Error(t('errors.imageNormalizeFailed', { idx, message: (err as Error).message }))
+          return
+        }
+        sendLog(t('log.imageDone', { idx, name: path.basename(coverPath) }))
+        sendProgress({ phase: 'item', kind: 'image', index: idx, total: imageTotal, percent: 100, status: 'done' })
       }
-      throwIfCancelled()
-      sendProgress({ phase: 'item', kind: 'image', index: idx, total: imageTotal, percent: 60, status: 'running' })
-      const outPath = coverPath
-      try {
-        await normalizeToCover(buf, outPath)
-      } catch (err) {
-        // 변환 중 부분 생성된 PNG 제거(이어받기 시 완성본 오인 방지).
-        await fsp.rm(coverPath, { force: true }).catch(() => {})
-        sendProgress({ phase: 'item', kind: 'image', index: idx, total: imageTotal, percent: 0, status: 'error', message: (err as Error).message })
-        throw new Error(t('errors.imageNormalizeFailed', { idx, message: (err as Error).message }))
-      }
-      sendLog(t('log.imageDone', { idx, name: path.basename(outPath) }))
-      sendProgress({ phase: 'item', kind: 'image', index: idx, total: imageTotal, percent: 100, status: 'done' })
     }
 
+    const imageWorkerCount = Math.min(IMAGE_CONCURRENCY_CAP, Math.max(1, imageTotal), Math.max(concurrency, 4))
+    const imageWorkers: Promise<void>[] = []
+    for (let w = 0; w < imageWorkerCount; w++) imageWorkers.push(imageWorker())
+    await Promise.all(imageWorkers)
+    throwIfCancelled()
+    if (imageError) throw imageError
+
     // 2-4. 베이스 리소스팩 다운로드 (있을 때만)
     throwIfCancelled()
     let baseZipPath: string | undefined
@@ -688,8 +716,37 @@ app.whenReady().then(() => {
   })
 })
 
+// 종료 시 임시 파일(.temp) 정리. 예전엔 window-all-closed 에서 fsp.rm 을 fire-and-forget
+// 으로 호출하고 곧바로 app.quit() 해서, 삭제가 끝나기 전에 프로세스가 죽어 미리 받아둔
+// 내용이 남곤 했다. 또 '재시도 중' 이면 yt-dlp/ffmpeg 자식이 파일을 잠가 삭제가 실패한다.
+// → 자식을 먼저 죽여 잠금을 풀고, 삭제가 끝날 때까지 종료를 미룬 뒤 실제로 종료한다.
+let rpExitCleanupDone = false
+async function cleanupTempOnExit(): Promise<void> {
+  state.cancelRequested = true
+  for (const child of state.activeChildren) {
+    try { if (!child.killed) child.kill() } catch { /* noop */ }
+  }
+  const tempDir = path.join(getMcCustomDir(), '.temp')
+  // 자식 종료로 파일 잠금이 풀릴 시간을 주며 몇 번 재시도.
+  for (let attempt = 0; attempt < 3; attempt++) {
+    await new Promise((r) => setTimeout(r, attempt === 0 ? 200 : 400))
+    try {
+      await fsp.rm(tempDir, { recursive: true, force: true })
+      if (!fs.existsSync(tempDir)) return
+    } catch { /* 잠금 등 — 다음 시도 */ }
+  }
+}
+
+app.on('before-quit', (event) => {
+  if (rpExitCleanupDone) return
+  event.preventDefault()
+  void cleanupTempOnExit().finally(() => {
+    rpExitCleanupDone = true
+    app.quit()
+  })
+})
+
 app.on('window-all-closed', () => {
-  // 강제 종료 시에도 임시 파일은 정리.
+  // app.quit() → before-quit 에서 임시 파일을 정리한 뒤 실제 종료.
-  fsp.rm(path.join(getMcCustomDir(), '.temp'), { recursive: true, force: true }).catch(() => {})
   if (process.platform !== 'darwin') app.quit()
 })

src/installer-rp/music.ts

@@ -38,6 +38,17 @@ export function downloadMusicTrack(opts: DownloadMusicOptions): Promise<string>
       // 단일 파일이 아니라 HLS/DASH fragmented 스트림일 때 청크를 병렬로.
       // 일반 progressive 다운로드에는 영향 없음.
       '--concurrent-fragments', '5',
+      // 유튜브가 미디어 스트림에 간헐적으로 403(Forbidden) 을 준다(특히 두 번째 곡부터
+      // throttle/클라이언트 이슈). yt-dlp 가 스스로 재시도·재추출하도록 해서 한 번의
+      // 403 으로 곡 전체가 실패하지 않게 한다.
+      '--retries', '10',
+      '--fragment-retries', '10',
+      '--extractor-retries', '3',
+      '--retry-sleep', 'http:exp=1:30',
+      '--socket-timeout', '30',
+      // 특정 플레이어 클라이언트(예: android_vr)의 스트림 URL 이 403 되는 경우가 있어
+      // 여러 클라이언트를 함께 시도한다. 하나가 막혀도 다른 클라이언트 포맷으로 받는다.
+      '--extractor-args', 'youtube:player_client=default,web_safari,tv,ios',
       // 진행률 표시 안정화 (yt-dlp 가 \r 대신 새 줄로 출력).
       '--newline',
       '--extract-audio',

src/installer/main.ts

@@ -109,29 +109,61 @@ process.on('unhandledRejection', (reason) => {
   try { sendLog(t('log.internalError', { message: reason instanceof Error ? reason.message : String(reason) })) } catch {}
 })
 
-function fetchBuffer(url: string): Promise<Buffer> {
+// 너무 빠르게/자주 요청해 생기는 일시적 오류(429 Too Many Requests, 5xx, 네트워크
+// 끊김/타임아웃 등)는 잠깐 쉬고 몇 번 다시 시도한다. 403 도 일부 CDN 이 rate-limit 에
+// 쓰므로 포함. 그 외 4xx(404 등)나 재시도 소진 시에는 그대로 실패.
+const DOWNLOAD_TRANSIENT_CODES = new Set([403, 408, 425, 429, 500, 502, 503, 504])
+const DOWNLOAD_MAX_RETRIES = 3
+const DOWNLOAD_MAX_BACKOFF_MS = 30000
+
+/** Retry-After 헤더(초 또는 HTTP-date) → 대기 ms. 못 읽으면 null. */
+function parseRetryAfterMs(h: string | string[] | undefined): number | null {
+  if (!h) return null
+  const v = Array.isArray(h) ? h[0] : h
+  const secs = Number(v)
+  if (Number.isFinite(secs)) return Math.min(DOWNLOAD_MAX_BACKOFF_MS, Math.max(0, secs * 1000))
+  const date = Date.parse(v)
+  if (!Number.isNaN(date)) return Math.min(DOWNLOAD_MAX_BACKOFF_MS, Math.max(0, date - Date.now()))
+  return null
+}
+
+function fetchBuffer(url: string, redirects = 0, attempt = 0): Promise<Buffer> {
   return new Promise((resolve, reject) => {
     const target = new URL(url)
     const transport = target.protocol === 'https:' ? https : http
+    const retryLater = (headerDelay: number | null, reason: string): void => {
+      const backoff = Math.min(DOWNLOAD_MAX_BACKOFF_MS, 1000 * 2 ** attempt) + Math.floor(Math.random() * 500)
+      const delay = headerDelay ?? backoff
+      sendLog(t('log.downloadRetry', { reason, attempt: attempt + 1, secs: Math.ceil(delay / 1000) }))
+      sleep(delay).then(() => fetchBuffer(url, redirects, attempt + 1).then(resolve, reject))
+    }
     const request = transport.get(target, { timeout: 30000 }, (response) => {
-      if (response.statusCode === 301 || response.statusCode === 302) {
+      const code = response.statusCode ?? 0
-        const redirect = response.headers.location
+      if ((code === 301 || code === 302 || code === 303 || code === 307 || code === 308) && response.headers.location) {
-        if (redirect) {
-          response.resume()
-          fetchBuffer(new URL(redirect, target).toString()).then(resolve, reject)
-          return
-        }
-      }
-      if ((response.statusCode ?? 0) >= 400) {
         response.resume()
-        reject(new Error(`HTTP ${response.statusCode}`))
+        if (redirects > 8) { reject(new Error(`HTTP ${code} (too many redirects)`)); return }
+        fetchBuffer(new URL(response.headers.location, target).toString(), redirects + 1, attempt).then(resolve, reject)
+        return
+      }
+      if (DOWNLOAD_TRANSIENT_CODES.has(code) && attempt < DOWNLOAD_MAX_RETRIES) {
+        response.resume()
+        retryLater(parseRetryAfterMs(response.headers['retry-after']), `HTTP ${code}`)
+        return
+      }
+      if (code >= 400) {
+        response.resume()
+        reject(new Error(`HTTP ${code}: ${url}`))
         return
       }
       const chunks: Buffer[] = []
       response.on('data', (chunk: Buffer) => chunks.push(chunk))
       response.on('end', () => resolve(Buffer.concat(chunks)))
     })
-    request.on('error', reject)
+    request.on('error', (err) => {
+      // 연결 끊김/리셋 등 네트워크 오류도 몇 번은 재시도.
+      if (attempt < DOWNLOAD_MAX_RETRIES) { retryLater(null, (err as Error).message); return }
+      reject(err)
+    })
     request.on('timeout', () => request.destroy(new Error(t('errors.requestTimeout'))))
   })
 }
@@ -223,6 +255,125 @@ ipcMain.handle('terms:list', async (): Promise<{ ok: boolean; terms?: Array<{ ki
   }
 })
 
+// 최종 리소스팩 다운로드용 약관 목록. index.json 에서 showInFinalResourcepack=true 만 추린다.
+ipcMain.handle('terms:listFinal', async (): Promise<{ ok: boolean; terms?: Array<{ kind: string; label: string }>; message?: string }> => {
+  if (!state.selectedKey) return { ok: false, message: 'pack not selected' }
+  try {
+    const url = `${state.baseUrl}/manifest/terms/${encodeURIComponent(state.selectedKey)}/index.json`
+    const buf = await fetchBuffer(url)
+    const parsed = JSON.parse(buf.toString('utf8')) as { terms?: unknown }
+    const items = Array.isArray(parsed.terms) ? parsed.terms : []
+    const terms: Array<{ kind: string; label: string }> = []
+    for (const it of items) {
+      if (!it || typeof it !== 'object') continue
+      const entry = it as Record<string, unknown>
+      if (entry.showInFinalResourcepack !== true) continue
+      const kind = typeof entry.kind === 'string' ? entry.kind : ''
+      const label = typeof entry.label === 'string' ? entry.label : ''
+      if (!TERM_KIND_RE.test(kind) || label.length === 0) continue
+      terms.push({ kind, label })
+    }
+    return { ok: true, terms }
+  } catch (error) {
+    return { ok: false, message: (error as Error).message }
+  }
+})
+
+// 최종 리소스팩(zip)을 /file/resourcepacks/outputs/ 에서 받아 .mc_custom/resourcepacks/ 에 저장.
+ipcMain.handle('finalResourcepack:install', async (): Promise<{ ok: boolean; path?: string; message?: string; applied?: boolean; applyMessage?: string }> => {
+  const pack = state.selectedKey ? state.packs.get(state.selectedKey) : undefined
+  if (!pack) return { ok: false, message: t('errors.packNotFound2') }
+  const finalName = pack.pack.finalResourcepackPath
+  if (!finalName || finalName === '.') return { ok: false, message: 'no final resourcepack' }
+  let dest = ''
+  try {
+    const cleaned = path.basename(finalName.replace(/^\/+/, ''))
+    const url = `${state.baseUrl}/file/resourcepacks/outputs/${encodeURIComponent(cleaned)}`
+    const destDir = path.join(getAppDataDir(), getMcCustomDirName(), 'resourcepacks')
+    dest = path.join(destDir, cleaned)
+    await fsp.mkdir(destDir, { recursive: true })
+    sendLog(t('log.finalResourcepackDownload', { url }))
+    // 진행률(퍼센트)을 렌더러로 흘려보내며 스트리밍 다운로드.
+    let lastPct = -1
+    const controller = new AbortController()
+    await downloadStream(url, dest, controller.signal, (loaded, total) => {
+      const percent = total > 0 ? Math.min(100, Math.max(0, Math.floor((loaded / total) * 100))) : -1
+      if (percent !== lastPct) {
+        lastPct = percent
+        if (mainWindow && !mainWindow.isDestroyed()) {
+          mainWindow.webContents.send('finalResourcepack:progress', { loaded, total, percent })
+        }
+      }
+    })
+    sendLog(t('log.finalResourcepackSaved', { path: dest }))
+    // 마인크래프트에서 직접 고르지 않아도 켜지도록 options.txt 의 resourcePacks 에 등록.
+    const gameDir = path.join(getAppDataDir(), getMcCustomDirName())
+    try {
+      await enableResourcePackInOptions(gameDir, cleaned)
+      sendLog(t('log.finalResourcepackApplied', { name: cleaned }))
+      return { ok: true, path: dest, applied: true }
+    } catch (err) {
+      // 다운로드는 됐지만 자동 적용(options.txt)에 실패 → 성공으로 숨기지 말고 렌더러가
+      // 경고를 띄우도록 applied=false 로 알린다(사용자가 직접 켤 수 있게).
+      const msg = (err as Error).message
+      sendLog(t('log.finalResourcepackApplyFail', { message: msg }))
+      return { ok: true, path: dest, applied: false, applyMessage: msg }
+    }
+  } catch (error) {
+    // 실패 시 부분/0바이트 zip 이 마인크래프트 리소스팩 목록에 깨진 채로 남지 않도록 삭제.
+    if (dest) await fsp.rm(dest, { force: true }).catch(() => {})
+    return { ok: false, message: (error as Error).message }
+  }
+})
+
+/**
+ * gameDir 의 options.txt 의 resourcePacks 목록에 `file/<packFileName>` 을 추가해,
+ * 마인크래프트를 켜면 해당 리소스팩이 자동으로 적용되게 한다. (목록 마지막 = 최상위 우선)
+ * options.txt 가 없으면 해당 한 줄만 새로 만든다(나머지 옵션은 게임이 기본값으로 채움).
+ * incompatibleResourcePacks 목록에 있으면 제거해 실제로 켜지게 한다.
+ */
+async function enableResourcePackInOptions(gameDir: string, packFileName: string): Promise<void> {
+  const optionsPath = path.join(gameDir, 'options.txt')
+  const entry = `file/${packFileName}`
+  let content = ''
+  try { content = await fsp.readFile(optionsPath, 'utf8') } catch { content = '' }
+  const lines = content.length ? content.split(/\r?\n/) : []
+  // 파일이 \n 으로 끝났으면 split 결과 마지막에 빈 문자열이 생기므로 제거.
+  if (lines.length > 0 && lines[lines.length - 1] === '') lines.pop()
+
+  const parseList = (line: string, key: string): string[] => {
+    const m = line.match(new RegExp(`^${key}:\\s*\\[(.*)\\]\\s*$`))
+    if (!m) return []
+    try {
+      const arr = JSON.parse(`[${m[1]}]`) as unknown[]
+      return arr.filter((x): x is string => typeof x === 'string')
+    } catch {
+      return []
+    }
+  }
+
+  const rpIdx = lines.findIndex((l) => l.startsWith('resourcePacks:'))
+  if (rpIdx >= 0) {
+    const items = parseList(lines[rpIdx], 'resourcePacks')
+    if (!items.includes(entry)) items.push(entry)
+    lines[rpIdx] = `resourcePacks:${JSON.stringify(items)}`
+  } else {
+    lines.push(`resourcePacks:${JSON.stringify([entry])}`)
+  }
+
+  // 호환불가 목록에 들어가 있으면 빼서 실제로 적용되게 한다.
+  const incIdx = lines.findIndex((l) => l.startsWith('incompatibleResourcePacks:'))
+  if (incIdx >= 0) {
+    const items = parseList(lines[incIdx], 'incompatibleResourcePacks')
+    const filtered = items.filter((x) => x !== entry)
+    if (filtered.length !== items.length) {
+      lines[incIdx] = `incompatibleResourcePacks:${JSON.stringify(filtered)}`
+    }
+  }
+
+  await fsp.writeFile(optionsPath, `${lines.join('\n')}\n`, 'utf8')
+}
+
 ipcMain.handle('packs:select', async (_event, packKey: string) => {
   if (!state.packs.has(packKey)) {
     throw new Error(t('errors.packNotFound'))
@@ -297,51 +448,141 @@ function findJavaExeInHome(candidate: string): string {
   return ''
 }
 
-/** javaExe 로부터 JDK 홈 디렉터리를 되돌린다(<home>/bin/java.exe → <home>). */
+/** %appdata%/<.mc_custom>. 자동 설치 JDK 는 이 폴더 아래 jdk/ 에 둔다. */
-function homeFromJavaExe(javaExe: string, fallbackHome: string): string {
+function customRootDir(): string {
-  return path.basename(path.dirname(javaExe)) === 'bin'
+  return path.join(getAppDataDir(), getMcCustomDirName())
-    ? path.dirname(path.dirname(javaExe))
-    : fallbackHome
 }
 
+/** 설치기 자동 설치 JDK 의 루트(.mc_custom/jdk). */
+function installerJdkRoot(): string {
+  return path.join(customRootDir(), 'jdk')
+}
+
+/** dir(또는 그 한 단계 하위 jdk-* 폴더)에서 java 를 찾아 실제 JDK 홈(<home>/bin/java)을 돌려준다. 없으면 ''. */
+function resolveJdkHome(dir: string): string {
+  const javaExe = findJavaExeInHome(dir)
+  if (!javaExe) return ''
+  // findJavaExeInHome 은 항상 <home>/bin/java(.exe) 를 돌려준다 → 상위 두 단계가 홈.
+  return path.basename(path.dirname(javaExe)) === 'bin' ? path.dirname(path.dirname(javaExe)) : dir
+}
+
+/**
+ * parent 아래에서 JDK 홈들을 모두 찾는다. parent 자신, 그리고 각 하위 폴더를 검사하되,
+ * Adoptium zip 처럼 한 단계 더 감싼 `jdk-*` 하위까지 resolveJdkHome 으로 풀어낸다.
+ * (예: .mc_custom/jdk/temurin-25/jdk-25.0.3+9/bin/java.exe)
+ */
+function jdkHomesUnder(parent: string): string[] {
+  const out: string[] = []
+  const add = (h: string): void => { if (h) out.push(h) }
+  add(resolveJdkHome(parent))
+  try {
+    for (const entry of fs.readdirSync(parent)) {
+      add(resolveJdkHome(path.join(parent, entry)))
+    }
+  } catch {
+    /* 폴더 없음 등 무시 */
+  }
+  return out
+}
+
+interface JdkEntry { home: string; major: number }
+
+/** 홈 목록 → {home, major} 목록(중복/버전0 제거). */
+function homesToEntries(homes: string[]): JdkEntry[] {
+  const javaName = process.platform === 'win32' ? 'java.exe' : 'java'
+  const seen = new Set<string>()
+  const out: JdkEntry[] = []
+  for (const home of homes) {
+    const key = home.toLowerCase()
+    if (seen.has(key)) continue
+    seen.add(key)
+    const major = getJavaMajor(path.join(home, 'bin', javaName))
+    if (major > 0) out.push({ home, major })
+  }
+  return out
+}
+
+/** 설치기 자동 설치 위치(.mc_custom/jdk, 구버전 %APPDATA%/jdk 호환)의 JDK 들. */
+function mcCustomJdkEntries(): JdkEntry[] {
+  const homes: string[] = []
+  for (const base of [installerJdkRoot(), path.join(getAppDataDir(), 'jdk')]) {
+    homes.push(...jdkHomesUnder(base))
+  }
+  return homesToEntries(homes)
+}
+
+/** 환경변수(JAVA_HOME/JDK_HOME)에 등록된 JDK 들. */
+function envJdkEntries(): JdkEntry[] {
+  const homes: string[] = []
+  for (const env of [process.env.JAVA_HOME, process.env.JDK_HOME]) {
+    if (env) {
+      const h = resolveJdkHome(env)
+      if (h) homes.push(h)
+    }
+  }
+  return homesToEntries(homes)
+}
+
+/** 기본 자바 설치 위치 C:\Program Files\Java 아래의 JDK 들. */
+function programFilesJdkEntries(): JdkEntry[] {
+  return homesToEntries(jdkHomesUnder('C:\\Program Files\\Java'))
+}
+
+// JDK 탐색 우선순위(요청 사양):
+//   ① .mc_custom/jdk(설치기가 설치해둔 위치)가 있으면 먼저 사용 — 권장 버전이면 그대로,
+//      혹시 다른 버전이면 경고(match=false).
+//   ② 환경변수(JAVA_HOME/JDK_HOME) 가 권장 버전이면 사용.
+//   ③ 기본 폴더 C:\Program Files\Java 에 권장 버전이 있으면 사용.
+//   ④ 없으면 환경변수 자바로 폴백하고 "권장과 다름" 경고(match=false).
+//      (환경변수 자바도 없으면 Program Files 자바로 폴백, 그것도 없으면 not found → 자동 설치 유도.)
 ipcMain.handle('jdk:detect', async (_event, recommendedInput?: number) => {
   const required = normalizeRecommendedJdk(recommendedInput)
+  const recommended = (entries: JdkEntry[]): JdkEntry | undefined => entries.find((e) => e.major === required)
+  const best = (entries: JdkEntry[]): JdkEntry => entries.slice().sort((a, b) => b.major - a.major)[0]
 
-  // 1) 권장 JDK(설치기가 자동 설치하는 위치)를 가장 먼저 찾는다.
+  // ① .mc_custom/jdk 우선.
-  const recommendedHome = path.join(getAppDataDir(), 'jdk', jdkDirName(required))
+  const mc = mcCustomJdkEntries()
-  const recJava = findJavaExeInHome(recommendedHome)
+  if (mc.length > 0) {
-  if (recJava && getJavaMajor(recJava) >= required) {
+    const rec = recommended(mc)
-    return { found: true, path: homeFromJavaExe(recJava, recommendedHome), source: 'recommended', major: required }
+    if (rec) return { found: true, path: rec.home, major: required, match: true }
+    const b = best(mc)
+    return { found: true, path: b.home, major: b.major, match: false }
   }
 
-  // 2) 없으면 컴퓨터의 JDK(JAVA_HOME/JDK_HOME/Program Files)를 확인한다.
+  // ② 환경변수 JDK 가 권장 버전이면 사용.
-  //    권장 버전 미만은 서버 실행에 부족하므로(UnsupportedClassVersionError) "없음" 처리.
+  const env = envJdkEntries()
-  const candidates: string[] = []
+  const envRec = recommended(env)
-  if (process.env.JAVA_HOME) candidates.push(process.env.JAVA_HOME)
+  if (envRec) return { found: true, path: envRec.home, major: required, match: true }
-  if (process.env.JDK_HOME) candidates.push(process.env.JDK_HOME)
+
-  candidates.push('C:\\Program Files\\Java')
+  // ③ 기본 폴더(Program Files\Java)에 권장 버전이 있으면 사용.
-  for (const candidate of candidates) {
+  const pf = programFilesJdkEntries()
-    if (!candidate) continue
+  const pfRec = recommended(pf)
-    const javaExe = findJavaExeInHome(candidate)
+  if (pfRec) return { found: true, path: pfRec.home, major: required, match: true }
-    if (!javaExe) continue
+
-    const major = getJavaMajor(javaExe)
+  // ④ 폴백: 환경변수 자바 → (없으면) Program Files 자바 + 경고.
-    if (major < required) continue
+  if (env.length > 0) {
-    return { found: true, path: homeFromJavaExe(javaExe, candidate), source: 'system', major }
+    const b = best(env)
+    return { found: true, path: b.home, major: b.major, match: false }
   }
-  return { found: false, path: '', major: required }
+  if (pf.length > 0) {
+    const b = best(pf)
+    return { found: true, path: b.home, major: b.major, match: false }
+  }
+  return { found: false, path: '', major: required, match: false }
 })
 
-// 사용자가 직접 입력/선택한 JDK 경로가 서버 실행에 충분한 버전인지 확인한다.
+// 사용자가 직접 입력/선택한 JDK 경로의 자바 버전을 확인한다.
-//   ok=true  → major >= 요구 버전(25).
+//   major=0        → 경로에서 java 를 못 찾거나 버전을 못 읽음(진행 차단용).
-//   major=0  → 경로에서 java 를 못 찾거나 버전을 못 읽음(실행 실패 등).
+//   match=true     → 권장 버전과 정확히 일치.
-ipcMain.handle('jdk:verify', async (_event, jdkPath: string, recommendedInput?: number): Promise<{ ok: boolean; major: number; required: number }> => {
+//   match=false    → 다른 버전(진행은 허용하되 렌더러가 경고를 띄운다).
+ipcMain.handle('jdk:verify', async (_event, jdkPath: string, recommendedInput?: number): Promise<{ ok: boolean; major: number; required: number; match: boolean }> => {
   const required = normalizeRecommendedJdk(recommendedInput)
   const javaExe = jdkPath ? findJavaExeInHome(jdkPath) : ''
   const major = javaExe ? getJavaMajor(javaExe) : 0
-  return { ok: major >= required, major, required }
+  return { ok: major > 0, major, required, match: major === required }
 })
 
-// ── JDK 자동 설치(Temurin 25, 취소 가능) ──────────────────────────────
+// ── JDK 자동 설치(권장 버전 Temurin, .mc_custom/jdk 에 설치, 취소 가능) ──────
 interface JdkInstallState {
   controller: AbortController | null
   destDir: string | null
@@ -386,7 +627,7 @@ function downloadStream(
         res.resume()
         fileStream.close(() => {
           signal.removeEventListener('abort', onAbort)
-          if (!settled) { settled = true; reject(new Error(`HTTP ${sc}`)) }
+          if (!settled) { settled = true; reject(new Error(`HTTP ${sc}: ${url}`)) }
         })
         return
       }
@@ -423,10 +664,11 @@ ipcMain.handle('jdk:install', async (_event, recommendedInput?: number): Promise
   jdkInstall.inProgress = true
   const controller = new AbortController()
   jdkInstall.controller = controller
-  const tmpRoot = path.join(getAppDataDir(), 'jdk-cache')
+  // 자동 설치 JDK 는 .mc_custom/jdk 아래에 둔다(파일제거기가 .mc_custom 통째로 정리 가능).
+  const tmpRoot = path.join(installerJdkRoot(), '.cache')
   await fsp.mkdir(tmpRoot, { recursive: true })
   const tempZip = path.join(tmpRoot, `${jdkDirName(required)}-${Date.now()}.zip`)
-  const destDir = path.join(getAppDataDir(), 'jdk', jdkDirName(required))
+  const destDir = path.join(installerJdkRoot(), jdkDirName(required))
   jdkInstall.destDir = destDir
   try {
     // Adoptium API v3: latest GA JDK(Windows x64). 본문은 307 로 GitHub 릴리즈로 리다이렉트.
@@ -523,6 +765,20 @@ async function downloadServerZip(pack: PackDefinition, targetDir: string): Promi
   await downloadAndExtractZip(url, t('log.labelServerFile'), targetDir)
 }
 
+/**
+ * config zip 을 게임 폴더(.mc_custom) 루트에 그대로 풀어 넣는다.
+ * zip 안에 `config/` 폴더가 들어 있으면 `.mc_custom/config/` 로 배치된다.
+ * configPath 가 비어 있으면 건너뛴다.
+ */
+async function downloadConfigZip(pack: PackDefinition, customRoot: string): Promise<void> {
+  if (!pack.configPath) {
+    sendLog(t('log.skipConfigZip'))
+    return
+  }
+  const url = resolveManifestRelative(pack.configPath, 'configs')
+  await downloadAndExtractZip(url, t('log.labelConfigFile'), customRoot)
+}
+
 /**
  * 설치러가 saves/ 에 풀어놓은 최상위 폴더(또는 파일) 목록을 기록하는 마커 파일.
  * 재설치 시 잔여물을 안전하게 정리하고, 싱글→참가자 전환 시에도
@@ -1159,7 +1415,7 @@ ipcMain.handle('client:install', async (_event, payload: ClientInstallPayload) =
     await copyMinecraftUserSettings(customRoot)
 
     if (payload.installPlatform && pack.pack.platform.type === 'fabric') {
-      await installFabricLoader(pack.pack, customRoot)
+      await installFabricLoader(pack.pack)
     } else if (payload.installPlatform && pack.pack.platform.type !== 'vanilla' && pack.pack.platform.downloadUrl) {
       const platformUrl = resolveManifestRelative(pack.pack.platform.downloadUrl, 'platforms')
       const cacheDir = path.join(customRoot, 'platform-cache')
@@ -1173,7 +1429,13 @@ ipcMain.handle('client:install', async (_event, payload: ClientInstallPayload) =
     }
 
     await downloadModsFolder(pack.pack, customRoot)
-    await downloadResourcepackZip(pack.pack, customRoot)
+    // 최종 리소스팩이 등록돼 있으면(finalResourcepackPath !== "."), 완성본을 설치 마지막에
+    // 따로 받으므로 베이스 리소스팩은 받지 않는다("최종 리소스팩만 다운로드").
+    if (pack.pack.finalResourcepackPath && pack.pack.finalResourcepackPath !== '.') {
+      sendLog(t('log.skipBaseForFinal'))
+    } else {
+      await downloadResourcepackZip(pack.pack, customRoot)
+    }
 
     if (payload.skipMap) {
       // 참가자 모드: 이전 설치 흐름에서 설치러가 풀어둔 맵이 있다면 제거한다.
@@ -1184,6 +1446,9 @@ ipcMain.handle('client:install', async (_event, payload: ClientInstallPayload) =
       await downloadMapZip(pack.pack, customRoot)
     }
 
+    // config zip 은 게임 폴더(.mc_custom) 루트에 그대로 풀어 config/ 등을 배치한다.
+    await downloadConfigZip(pack.pack, customRoot)
+
     // 런처가 .mc_custom 을 gameDir 로 잡아도 assets/libraries/versions 를
     // 찾을 수 있도록 .minecraft 의 해당 폴더로 junction 링크.
     await linkMinecraftRuntimeDirs(customRoot)
@@ -1198,153 +1463,45 @@ ipcMain.handle('client:install', async (_event, payload: ClientInstallPayload) =
   }
 })
 
-interface FabricInstallerMeta {
+async function installFabricLoader(pack: PackDefinition): Promise<void> {
-  url: string
-  version: string
-  stable: boolean
-}
-
-async function installFabricLoader(pack: PackDefinition, customRoot: string): Promise<void> {
   const loaderVersion = pack.platform.loaderVersion
   if (!loaderVersion) {
     throw new Error(t('errors.fabricLoaderRequired'))
   }
 
-  // 0) 이미 설치돼 있으면 건너뛴다. fabric-installer 는 매번 jar 를 지우고
+  // fabric 은 .minecraft(런처 폴더)에 설치한다. gameDir(.mc_custom)에 설치하면 바닐라 버전/
-  //    다시 쓰려고 시도해서, 마인크래프트나 다른 프로세스가 그 파일을 잡고
+  // 라이브러리가 빠져 런처가 "Unable to prepare assets for download" 로 실패한다.
-  //    있으면 FileSystemException 으로 실패한다. 결과 파일이 그대로 있으면
+  const mcRoot = path.join(getAppDataDir(), '.minecraft')
-  //    재실행할 필요가 없으므로 그냥 통과.
   const versionId = `fabric-loader-${loaderVersion}-${pack.mcVersion}`
-  const versionDir = path.join(customRoot, 'versions', versionId)
+  const versionDir = path.join(mcRoot, 'versions', versionId)
-  const versionJar = path.join(versionDir, `${versionId}.jar`)
   const versionJson = path.join(versionDir, `${versionId}.json`)
-  if (fs.existsSync(versionJar) && fs.existsSync(versionJson)) {
+  if (fs.existsSync(versionJson)) {
     sendLog(t('log.fabricAlreadyInstalled', { id: versionId, dir: versionDir }))
     return
   }
 
-  // 1) 최신 fabric-installer 메타데이터 조회.
+  // fabric-installer(자바 필요) 를 돌리는 대신, fabric meta 에서 버전 프로필 JSON 을 직접
-  sendLog(t('log.fabricFetchInstallerList'))
+  // 받아 versions/<id>/<id>.json 에 쓴다. 자바가 없어도 되므로 "spawn java ENOENT" 가
-  const installerList = await fetchJson<FabricInstallerMeta[]>('https://meta.fabricmc.net/v2/versions/installer')
+  // 사라지고, 바닐라를 미리 실행할 필요도 없다. 라이브러리는 프로필 JSON 의 각 library 에
-  if (!installerList || installerList.length === 0) {
+  // 적힌 maven url 을 보고 런처가 실행 시 자동으로 받는다.
-    throw new Error(t('errors.fabricInstallerListEmpty'))
+  const profileUrl =
-  }
+    `https://meta.fabricmc.net/v2/versions/loader/${encodeURIComponent(pack.mcVersion)}/${encodeURIComponent(loaderVersion)}/profile/json`
-  const latest = installerList.find((item) => item.stable) || installerList[0]
+  sendLog(t('log.fabricProfileFetch', { url: profileUrl }))
-  sendLog(t('log.fabricInstallerDownload', { version: latest.version, url: latest.url }))
+  const buf = await fetchBuffer(profileUrl)
-
+  let profileId = ''
-  // 2) installer jar 캐시.
-  const cacheDir = path.join(customRoot, 'platform-cache')
-  await fsp.mkdir(cacheDir, { recursive: true })
-  const installerJar = path.join(cacheDir, `fabric-installer-${latest.version}.jar`)
-  await downloadFile(latest.url, installerJar)
-
-  // 3) Java 실행파일 확보.
-  const javaCmd = await findJavaExecutable()
-  sendLog(t('log.javaUsed', { path: javaCmd }))
-
-  // 4) fabric-installer CLI 자동 실행.
-  //    client 모드 + -noprofile: launcher_profiles.json 은 우리 코드가 직접 갱신하므로 fabric-installer 가 덮어쓰지 않게 한다.
-  //    JVM stdout 인코딩 강제 UTF-8:
-  //      한국 윈도우의 시스템 codepage 는 cp949(MS949) 라서 fabric-installer 가
-  //      한글을 cp949 로 stdout 에 쓰면 우리가 utf-8 로 디코드해서 깨져 보인다.
-  //      `file.encoding` 은 default Charset, `stdout/stderr.encoding` 은
-  //      System.out/err 의 PrintStream 인코딩(Java 18+). 둘 다 지정하면
-  //      구버전·신버전 JDK 모두에서 안전.
-  const args = [
-    '-Dfile.encoding=UTF-8',
-    '-Dstdout.encoding=UTF-8',
-    '-Dstderr.encoding=UTF-8',
-    '-jar', installerJar,
-    'client',
-    '-mcversion', pack.mcVersion,
-    '-loader', loaderVersion,
-    '-dir', customRoot,
-    '-noprofile'
-  ]
-  sendLog(t('log.fabricInstallStart', { mc: pack.mcVersion, loader: loaderVersion, dir: customRoot }))
-  await runJavaProcess(javaCmd, args)
-  sendLog(t('log.fabricInstallDone'))
-}
-
-async function findJavaExecutable(): Promise<string> {
-  const javaName = process.platform === 'win32' ? 'java.exe' : 'java'
-
-  // 1) JAVA_HOME 우선.
-  const javaHome = process.env.JAVA_HOME
-  if (javaHome) {
-    const exe = path.join(javaHome, 'bin', javaName)
-    if (fs.existsSync(exe)) return exe
-  }
-
-  // 2) 마인크래프트 런처가 번들한 자바 런타임. .minecraft\runtime\<name>\<os>\<name>\bin\java.exe 구조.
   try {
-    const runtimeBase = path.join(getAppDataDir(), '.minecraft', 'runtime')
+    const parsed = JSON.parse(buf.toString('utf8')) as { id?: unknown }
-    if (fs.existsSync(runtimeBase)) {
+    if (typeof parsed.id === 'string') profileId = parsed.id
-      const priority = [
+  } catch (err) {
-        'java-runtime-delta',
+    throw new Error(t('errors.fabricProfileInvalid', { message: (err as Error).message }))
-        'java-runtime-gamma',
-        'java-runtime-beta',
-        'java-runtime-alpha',
-        'java-runtime-legacy',
-        'jre-legacy'
-      ]
-      const names = await fsp.readdir(runtimeBase)
-      const sorted = names.slice().sort((a, b) => {
-        const ia = priority.indexOf(a)
-        const ib = priority.indexOf(b)
-        if (ia === -1 && ib === -1) return 0
-        if (ia === -1) return 1
-        if (ib === -1) return -1
-        return ia - ib
-      })
-      for (const name of sorted) {
-        const dir = path.join(runtimeBase, name)
-        try {
-          const osDirs = await fsp.readdir(dir)
-          for (const osDir of osDirs) {
-            const exe = path.join(dir, osDir, name, 'bin', javaName)
-            if (fs.existsSync(exe)) return exe
-          }
-        } catch {
-          // skip
-        }
-      }
-    }
-  } catch {
-    // skip
   }
-
+  if (!profileId) {
-  // 3) PATH 폴백.
+    throw new Error(t('errors.fabricProfileInvalid', { message: 'missing id' }))
-  return javaName
+  }
-}
+  await fsp.mkdir(versionDir, { recursive: true })
-
+  // 받은 바이트를 그대로 저장(무손실). 프로필의 id 는 versionId 와 동일하다.
-function runJavaProcess(cmd: string, args: string[]): Promise<void> {
+  await fsp.writeFile(versionJson, buf)
-  return new Promise((resolve, reject) => {
+  sendLog(t('log.fabricInstallDone'))
-    const child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true })
-    let stderrTail = ''
-    const emitLines = (chunk: Buffer, prefix: string) => {
-      const text = chunk.toString('utf8')
-      text.split(/\r?\n/).forEach((line) => {
-        if (line.trim().length === 0) return
-        sendLog(`  ${prefix} ${line}`)
-      })
-    }
-    child.stdout?.on('data', (chunk: Buffer) => emitLines(chunk, '[fabric]'))
-    child.stderr?.on('data', (chunk: Buffer) => {
-      stderrTail += chunk.toString('utf8')
-      if (stderrTail.length > 4000) stderrTail = stderrTail.slice(-4000)
-      emitLines(chunk, '[fabric-err]')
-    })
-    child.on('error', (err) => reject(new Error(t('errors.javaSpawnFailed', { message: err.message }))))
-    child.on('close', (code) => {
-      if (code === 0) {
-        resolve()
-      } else {
-        const detail = stderrTail.trim().split(/\r?\n/).slice(-3).join(' | ')
-        reject(new Error(t('errors.fabricInstallerExit', { code: code ?? '', detail: detail ? ' — ' + detail : '' })))
-      }
-    })
-  })
 }
 
 function deriveFileName(url: string): string {
@@ -1567,13 +1724,39 @@ async function linkMinecraftRuntimeDirs(customRoot: string): Promise<void> {
     const src = path.join(mcRoot, dir)
     const dst = path.join(customRoot, dir)
     if (!fs.existsSync(src)) {
+      // .minecraft 에 원본이 없으면(바닐라를 한 번도 안 받았거나 런처가 다른 위치를 쓰는
+      // 환경) 링크를 만들 수 없다. 이때 그냥 건너뛰면 .mc_custom/<dir> 이 아예 없어
+      // 런처가 "Unable to prepare assets for download" 로 실패한다. 빈 폴더라도 만들어
+      // 런처가 그 gameDir 에 직접 받아갈 수 있게 한다(없을 때만).
       sendLog(t('log.runtimeDirMissing', { dir }))
+      try {
+        if (!fs.existsSync(dst)) {
+          await fsp.mkdir(dst, { recursive: true })
+          sendLog(t('log.runtimeDirCreated', { dir }))
+        }
+      } catch (err) {
+        sendLog(t('log.runtimeLinkFail', { dir, message: (err as Error).message }))
+      }
       continue
     }
     let existing: import('node:fs').Stats | null = null
     try { existing = await fsp.lstat(dst) } catch { existing = null }
     if (existing) {
       if (existing.isSymbolicLink()) continue // 이미 링크됨
+      // versions/libraries 가 실제 폴더면, 예전 버전이 gameDir 에 fabric 을 설치하며 만든
+      // 불완전한(바닐라 누락) 폴더일 수 있다. .minecraft 의 완전한 데이터로 링크되도록
+      // 교체한다. 이 두 폴더는 런처가 관리하는 데이터라 삭제해도 세이브/리소스팩 같은
+      // 사용자 데이터 손실은 없다. (assets 는 받아둔 에셋 보존을 위해 그대로 둔다.)
+      if (dir === 'versions' || dir === 'libraries') {
+        try {
+          await fsp.rm(dst, { recursive: true, force: true })
+          await fsp.symlink(src, dst, 'junction')
+          sendLog(t('log.runtimeLinkReplaced', { dir }))
+        } catch (err) {
+          sendLog(t('log.runtimeLinkFail', { dir, message: (err as Error).message }))
+        }
+        continue
+      }
       sendLog(t('log.runtimeDirExists', { dir }))
       continue
     }

src/installer/preload.ts

@@ -17,6 +17,12 @@ const api = {
   // 메인 인스톨러용 약관 목록 (사이트의 visibility 토글에 따라 필터링됨)
   getTermsList: (): Promise<{ ok: boolean; terms?: Array<{ kind: string; label: string }>; message?: string }> =>
     ipcRenderer.invoke('terms:list'),
+  // 최종 리소스팩 다운로드용 약관 목록 (showInFinalResourcepack 필터)
+  getFinalTermsList: (): Promise<{ ok: boolean; terms?: Array<{ kind: string; label: string }>; message?: string }> =>
+    ipcRenderer.invoke('terms:listFinal'),
+  // 최종 리소스팩 다운로드 실행. applied=false 면 다운로드는 됐지만 자동 적용 실패.
+  installFinalResourcepack: (): Promise<{ ok: boolean; path?: string; message?: string; applied?: boolean; applyMessage?: string }> =>
+    ipcRenderer.invoke('finalResourcepack:install'),
 
   // 3-1
   pickFolder: (): Promise<string | null> => ipcRenderer.invoke('dialog:pickFolder'),
@@ -24,9 +30,9 @@ const api = {
     ipcRenderer.invoke('install:validatePath', target),
 
   // 3-2
-  detectJdk: (recommendedJdk?: number): Promise<{ found: boolean; path: string; source?: string; major?: number }> =>
+  detectJdk: (recommendedJdk?: number): Promise<{ found: boolean; path: string; major: number; match: boolean }> =>
     ipcRenderer.invoke('jdk:detect', recommendedJdk),
-  verifyJdk: (jdkPath: string, recommendedJdk?: number): Promise<{ ok: boolean; major: number; required: number }> =>
+  verifyJdk: (jdkPath: string, recommendedJdk?: number): Promise<{ ok: boolean; major: number; required: number; match: boolean }> =>
     ipcRenderer.invoke('jdk:verify', jdkPath, recommendedJdk),
   installJdk: (recommendedJdk?: number): Promise<{ ok: boolean; path?: string; message?: string }> =>
     ipcRenderer.invoke('jdk:install', recommendedJdk),
@@ -68,6 +74,15 @@ const api = {
     const listener = (_event: unknown, line: string) => handler(line)
     ipcRenderer.on('log', listener)
     return () => ipcRenderer.removeListener('log', listener)
+  },
+
+  // 최종 리소스팩 다운로드 진행률 구독. 반환값을 호출하면 구독 해제.
+  onFinalResourcepackProgress: (
+    handler: (info: { loaded: number; total: number; percent: number }) => void
+  ): (() => void) => {
+    const listener = (_event: unknown, info: { loaded: number; total: number; percent: number }) => handler(info)
+    ipcRenderer.on('finalResourcepack:progress', listener)
+    return () => ipcRenderer.removeListener('finalResourcepack:progress', listener)
   }
 }
 

src/server/routes/op.ts

@@ -28,6 +28,7 @@ import {
 } from '../../shared/store.js'
 import { hashPassword, isHashed, verifyPassword } from '../password.js'
 import { fetchReleaseVersions } from '../../shared/mojang.js'
+import { fetchJdkAvailability, fetchJdkReleaseNames } from '../../shared/jdkVersions.js'
 import { fetchPlaylistEntries, fetchVideoMeta, YtDlpUnavailableError } from '../youtube.js'
 import { requireAuth } from '../middleware/auth.js'
 import type { PackDefinition, PackList } from '../../shared/types.js'
@@ -196,6 +197,31 @@ opRouter.get('/op/dashboard/:packName', requireAuth, async (req, res, next) => {
   }
 })
 
+// ─── /op/jdk-versions ───────────────────────────────────────────────────
+// Adoptium(Temurin) 에서 실제 배포되는 JDK 메이저 목록을 프록시(브라우저 직접 호출은
+// CORS 로 막힘). 편집기의 "권장 JDK" 드롭다운을 이 결과로 채운다.
+opRouter.get('/op/jdk-versions', requireAuth, async (_req, res, next) => {
+  try {
+    res.json(await fetchJdkAvailability())
+  } catch (error) {
+    next(error)
+  }
+})
+
+// 특정 메이저의 상세 릴리스 이름(GA + EA 스냅샷). "자세히 보기" 에서 사용.
+opRouter.get('/op/jdk-versions/:major', requireAuth, async (req, res, next) => {
+  try {
+    const major = Number(req.params.major)
+    if (!Number.isInteger(major) || major < 8 || major > 99) {
+      res.status(400).json({ error: 'invalid major' })
+      return
+    }
+    res.json(await fetchJdkReleaseNames(major))
+  } catch (error) {
+    next(error)
+  }
+})
+
 // ─── /op/list ──────────────────────────────────────────────────────────
 // 음악퀴즈를 카드 한 줄로 표시. 카드 클릭 → /op/list/:packName
 opRouter.get('/op/list', requireAuth, async (req, res, next) => {
@@ -509,6 +535,7 @@ opRouter.get('/op/agreement/:packName/:kind', requireAuth, async (req, res, next
       label: entry.label,
       showInInstaller: entry.showInInstaller,
       showInInstallerRp: entry.showInInstallerRp,
+      showInFinalResourcepack: entry.showInFinalResourcepack,
       content
     })
   } catch (error) {
@@ -536,10 +563,12 @@ opRouter.post('/op/agreement/:packName/:kind', requireAuth, async (req, res, nex
     if (
       typeof req.body?.showInInstaller === 'boolean'
       || typeof req.body?.showInInstallerRp === 'boolean'
+      || typeof req.body?.showInFinalResourcepack === 'boolean'
     ) {
       await setTermVisibility(packKey, kind, {
         showInInstaller: req.body.showInInstaller === true,
-        showInInstallerRp: req.body.showInInstallerRp === true
+        showInInstallerRp: req.body.showInInstallerRp === true,
+        showInFinalResourcepack: req.body.showInFinalResourcepack === true
       })
     }
     res.json({ ok: true })
@@ -567,6 +596,7 @@ opRouter.post('/op/dashboard/:packName', requireAuth, async (req, res, next) =>
       } as PackDefinition['platform'] & { loaderVersion?: string },
       modsFolder: pickFirstValue(req.body.modsFolder),
       resourcepackPath: pickFirstValue(req.body.resourcepackPath),
+      finalResourcepackPath: pickFirstValue(req.body.finalResourcepackPath),
       outputPackName: pickFirstValue(req.body.outputPackName),
       serverMinRam: Number(pickFirstValue(req.body.serverMinRam)),
       serverMaxRam: Number(pickFirstValue(req.body.serverMaxRam)),
@@ -574,6 +604,7 @@ opRouter.post('/op/dashboard/:packName', requireAuth, async (req, res, next) =>
       clientRecommendedRam: Number(pickFirstValue(req.body.clientRecommendedRam)),
       recommendedJdk: Number(pickFirstValue(req.body.recommendedJdk)),
       mapPath: pickFirstValue(req.body.mapPath),
+      configPath: pickFirstValue(req.body.configPath),
       serverPath: pickFirstValue(req.body.serverPath)
     }
 

src/shared/jdkVersions.ts

@@ -0,0 +1,118 @@
+import https from 'node:https'
+
+// Adoptium(Temurin) API 로부터 실제 배포되는 JDK 버전을 가져온다. 설치기가 이 벤더를
+// 쓰므로 사이트의 "권장 JDK" 목록도 같은 소스에서 채운다(하드코딩 금지). 네트워크
+// 실패 시에는 정적 폴백을 돌려줘 편집기가 항상 동작하도록 한다.
+
+const AVAILABLE_URL = 'https://api.adoptium.net/v3/info/available_releases'
+const CACHE_TTL_MS = 6 * 60 * 60 * 1000 // 6시간
+
+const FALLBACK_MAJORS = [8, 11, 17, 21, 25]
+const FALLBACK_LTS = [8, 11, 17, 21, 25]
+
+export interface JdkAvailability {
+  /** 배포되는 모든 메이저(예: 8,11,17,21,25,26). 내림차순. */
+  available: number[]
+  /** LTS 메이저만(예: 8,11,17,21,25). 내림차순. */
+  lts: number[]
+  mostRecentLts: number
+  mostRecentFeature: number
+}
+
+export interface JdkReleaseNames {
+  major: number
+  /** 정식(GA) 릴리스 이름들(예: jdk-25.0.3+9). */
+  ga: string[]
+  /** 개발 스냅샷(EA) 릴리스 이름들(예: jdk-25.0.4+6-ea-beta). */
+  ea: string[]
+}
+
+let availCache: { data: JdkAvailability; at: number } | null = null
+const releaseNamesCache = new Map<number, { data: JdkReleaseNames; at: number }>()
+
+function fetchJson<T>(url: string): Promise<T> {
+  return new Promise((resolve, reject) => {
+    const request = https.get(url, { timeout: 8000, headers: { accept: 'application/json' } }, (response) => {
+      const code = response.statusCode ?? 0
+      if (code !== 200) {
+        response.resume()
+        reject(new Error(`Adoptium HTTP ${code}`))
+        return
+      }
+      const chunks: Buffer[] = []
+      response.on('data', (c: Buffer) => chunks.push(c))
+      response.on('end', () => {
+        try {
+          resolve(JSON.parse(Buffer.concat(chunks).toString('utf8')) as T)
+        } catch (error) {
+          reject(error as Error)
+        }
+      })
+    })
+    request.on('error', reject)
+    request.on('timeout', () => request.destroy(new Error('Adoptium timeout')))
+  })
+}
+
+const sortDesc = (nums: number[]): number[] => [...new Set(nums)].sort((a, b) => b - a)
+
+export async function fetchJdkAvailability(): Promise<JdkAvailability> {
+  if (availCache && Date.now() - availCache.at < CACHE_TTL_MS) return availCache.data
+  try {
+    const raw = await fetchJson<{
+      available_releases?: number[]
+      available_lts_releases?: number[]
+      most_recent_lts?: number
+      most_recent_feature_release?: number
+    }>(AVAILABLE_URL)
+    const available = sortDesc(
+      (Array.isArray(raw.available_releases) ? raw.available_releases : FALLBACK_MAJORS).filter((n) => Number.isInteger(n))
+    )
+    const lts = sortDesc(
+      (Array.isArray(raw.available_lts_releases) ? raw.available_lts_releases : FALLBACK_LTS).filter((n) => Number.isInteger(n))
+    )
+    const data: JdkAvailability = {
+      available,
+      lts,
+      mostRecentLts: Number(raw.most_recent_lts) || (lts[0] ?? 21),
+      mostRecentFeature: Number(raw.most_recent_feature_release) || (available[0] ?? 25)
+    }
+    availCache = { data, at: Date.now() }
+    return data
+  } catch {
+    return (
+      availCache?.data ?? {
+        available: sortDesc(FALLBACK_MAJORS),
+        lts: sortDesc(FALLBACK_LTS),
+        mostRecentLts: 25,
+        mostRecentFeature: 25
+      }
+    )
+  }
+}
+
+async function fetchReleaseNames(major: number, type: 'ga' | 'ea'): Promise<string[]> {
+  const url =
+    `https://api.adoptium.net/v3/assets/feature_releases/${major}/${type}` +
+    '?architecture=x64&image_type=jdk&os=windows&vendor=eclipse&page_size=10'
+  try {
+    const arr = await fetchJson<Array<{ release_name?: string }>>(url)
+    if (!Array.isArray(arr)) return []
+    const names: string[] = []
+    for (const r of arr) {
+      if (typeof r?.release_name === 'string' && !names.includes(r.release_name)) names.push(r.release_name)
+    }
+    return names
+  } catch {
+    return []
+  }
+}
+
+export async function fetchJdkReleaseNames(major: number): Promise<JdkReleaseNames> {
+  const cached = releaseNamesCache.get(major)
+  if (cached && Date.now() - cached.at < CACHE_TTL_MS) return cached.data
+  const [ga, ea] = await Promise.all([fetchReleaseNames(major, 'ga'), fetchReleaseNames(major, 'ea')])
+  const data: JdkReleaseNames = { major, ga, ea }
+  releaseNamesCache.set(major, { data, at: Date.now() })
+  return data
+}

src/shared/store.ts

@@ -47,6 +47,7 @@ export function defaultPackDefinition(name: string): PackDefinition {
     platform: { type: 'vanilla' },
     modsFolder: '',
     resourcepackPath: '',
+    finalResourcepackPath: '.',
     outputPackName: '',
     serverMinRam: 2048,
     serverMaxRam: 4096,
@@ -54,6 +55,7 @@ export function defaultPackDefinition(name: string): PackDefinition {
     clientRecommendedRam: 4096,
     recommendedJdk: DEFAULT_JDK_MAJOR,
     mapPath: '',
+    configPath: '',
     serverPath: ''
   }
 }
@@ -80,17 +82,28 @@ function sanitizeFolderName(input: unknown): string {
 const ALLOWED_LOADERS: LoaderType[] = ['vanilla', 'forge', 'fabric', 'neoforge']
 
 /**
- * 사이트에서 고를 수 있고 설치기가 자동 설치할 수 있는 JDK 메이저 버전 목록(LTS).
+ * 편집기 드롭다운의 정적 폴백 목록(LTS). 실제 목록은 Adoptium API 에서 가져오며,
+ * 네트워크 실패 시에만 이 값을 쓴다.
  * 마인크래프트 버전대별: 8(구버전) / 11(1.17) / 17(1.18~1.20.4) / 21(1.20.5~) / 25(최신).
  */
 export const SUPPORTED_JDK_MAJORS: number[] = [8, 11, 17, 21, 25]
 /** recommendedJdk 미지정/이상값일 때의 기본 권장 버전. */
 export const DEFAULT_JDK_MAJOR = 25
 
-/** 입력값을 허용된 JDK 메이저로 보정. 목록 밖이면 기본값. */
+/**
+ * 입력값을 JDK 메이저로 보정. 특정 목록에 얽매이지 않고 실제 배포되는 자바 메이저
+ * 범위(8~99)면 허용하고, 벗어나면 기본값. (목록은 Adoptium 에서 동적으로 온다.)
+ */
 export function normalizeRecommendedJdk(input: unknown): number {
   const n = Math.floor(Number(input))
-  return SUPPORTED_JDK_MAJORS.includes(n) ? n : DEFAULT_JDK_MAJOR
+  return Number.isFinite(n) && n >= 8 && n <= 99 ? n : DEFAULT_JDK_MAJOR
+}
+
+/** "최종 리소스팩" 값 보정. 빈 값/`.` 은 "없음"을 뜻하는 `.` 으로, 그 외는 zip 파일명으로. */
+export function normalizeFinalResourcepack(input: unknown): string {
+  const raw = typeof input === 'string' ? input.trim() : ''
+  if (raw === '' || raw === '.') return '.'
+  return sanitizeZipFileName(raw)
 }
 
 export function normalizePackDefinition(input: Partial<PackDefinition> & Record<string, unknown>): PackDefinition {
@@ -121,6 +134,7 @@ export function normalizePackDefinition(input: Partial<PackDefinition> & Record<
     },
     modsFolder: sanitizeFolderName(input.modsFolder),
     resourcepackPath: sanitizeZipFileName(input.resourcepackPath),
+    finalResourcepackPath: normalizeFinalResourcepack(input.finalResourcepackPath),
     // 표시명은 사용자 입력을 보존(공백/마침표 trim 만). 파일명 안전 처리는 설치기 측에서.
     outputPackName: typeof input.outputPackName === 'string' ? input.outputPackName.trim() : '',
     serverMinRam: clampNumber(input.serverMinRam, fallback.serverMinRam),
@@ -129,6 +143,7 @@ export function normalizePackDefinition(input: Partial<PackDefinition> & Record<
     clientRecommendedRam: clampNumber(input.clientRecommendedRam, fallback.clientRecommendedRam),
     recommendedJdk: normalizeRecommendedJdk(input.recommendedJdk),
     mapPath: sanitizeZipFileName(input.mapPath),
+    configPath: sanitizeZipFileName(input.configPath),
     serverPath: sanitizeZipFileName(input.serverPath)
   }
 }
@@ -389,12 +404,13 @@ const DEFAULT_TERM_SEEDS: Array<{
   label: string
   showInInstaller: boolean
   showInInstallerRp: boolean
+  showInFinalResourcepack: boolean
 }> = [
-  { kind: 'map',          label: '맵 약관',           showInInstaller: true,  showInInstallerRp: false },
+  { kind: 'map',          label: '맵 약관',           showInInstaller: true,  showInInstallerRp: false, showInFinalResourcepack: false },
-  { kind: 'mod',          label: '모드 약관',         showInInstaller: true,  showInInstallerRp: false },
+  { kind: 'mod',          label: '모드 약관',         showInInstaller: true,  showInInstallerRp: false, showInFinalResourcepack: false },
-  { kind: 'installer',    label: '설치기 약관',       showInInstaller: true,  showInInstallerRp: false },
+  { kind: 'installer',    label: '설치기 약관',       showInInstaller: true,  showInInstallerRp: false, showInFinalResourcepack: false },
-  { kind: 'resourcepack', label: '리소스팩 약관',     showInInstaller: false, showInInstallerRp: true  },
+  { kind: 'resourcepack', label: '리소스팩 약관',     showInInstaller: false, showInInstallerRp: true,  showInFinalResourcepack: true  },
-  { kind: 'installer-rp', label: '리소스팩 설치기 약관', showInInstaller: false, showInInstallerRp: true  }
+  { kind: 'installer-rp', label: '리소스팩 설치기 약관', showInInstaller: false, showInInstallerRp: true,  showInFinalResourcepack: false }
 ]
 
 const TERM_KIND_RE = /^[a-z0-9][a-z0-9-]{0,31}$/
@@ -407,6 +423,7 @@ export interface TermEntry {
   label: string
   showInInstaller: boolean
   showInInstallerRp: boolean
+  showInFinalResourcepack: boolean
 }
 
 interface TermsMeta {
@@ -498,7 +515,8 @@ async function ensureMetaInitialized(dir: string, dirWasJustCreated: boolean): P
       meta.terms[seed.kind] = {
         label: seed.label,
         showInInstaller: seed.showInInstaller,
-        showInInstallerRp: seed.showInInstallerRp
+        showInInstallerRp: seed.showInInstallerRp,
+        showInFinalResourcepack: seed.showInFinalResourcepack
       }
       changed = true
     }
@@ -539,10 +557,11 @@ async function ensureMetaInitialized(dir: string, dirWasJustCreated: boolean): P
     terms[seed.kind] = {
       label: seed.label,
       showInInstaller: seed.showInInstaller,
-      showInInstallerRp: seed.showInInstallerRp
+      showInInstallerRp: seed.showInInstallerRp,
+      showInFinalResourcepack: seed.showInFinalResourcepack
     }
   }
-  // 구 스키마의 사용자 정의 약관은 양쪽 인스톨러에 보이도록 기본값으로.
+  // 구 스키마의 사용자 정의 약관은 양쪽 인스톨러에 보이도록 기본값으로(최종 리소스팩은 기본 off).
   for (const [k, label] of Object.entries(oldCustomLabels)) {
     if (terms[k]) continue
     try {
@@ -550,7 +569,7 @@ async function ensureMetaInitialized(dir: string, dirWasJustCreated: boolean): P
     } catch {
       continue
     }
-    terms[k] = { label, showInInstaller: true, showInInstallerRp: true }
+    terms[k] = { label, showInInstaller: true, showInInstallerRp: true, showInFinalResourcepack: false }
   }
   await fsp.writeFile(metaPath, `${JSON.stringify({ terms }, null, 2)}\n`, 'utf8')
 }
@@ -571,7 +590,8 @@ async function loadTermsMeta(packKey: string): Promise<TermsMeta> {
         result.terms[k] = {
           label,
           showInInstaller: entry.showInInstaller === true,
-          showInInstallerRp: entry.showInInstallerRp === true
+          showInInstallerRp: entry.showInInstallerRp === true,
+          showInFinalResourcepack: entry.showInFinalResourcepack === true
         }
       }
     }
@@ -596,6 +616,7 @@ export interface TermItem {
   label: string
   showInInstaller: boolean
   showInInstallerRp: boolean
+  showInFinalResourcepack: boolean
 }
 
 /**
@@ -629,7 +650,8 @@ export async function listTermsWithLabels(packKey: string): Promise<TermItem[]>
       kind: seed.kind,
       label: entry.label,
       showInInstaller: entry.showInInstaller,
-      showInInstallerRp: entry.showInInstallerRp
+      showInInstallerRp: entry.showInInstallerRp,
+      showInFinalResourcepack: entry.showInFinalResourcepack
     })
     seen.add(seed.kind)
   }
@@ -643,7 +665,8 @@ export async function listTermsWithLabels(packKey: string): Promise<TermItem[]>
       kind,
       label: entry.label,
       showInInstaller: entry.showInInstaller,
-      showInInstallerRp: entry.showInInstallerRp
+      showInInstallerRp: entry.showInInstallerRp,
+      showInFinalResourcepack: entry.showInFinalResourcepack
     })
   }
   return items
@@ -662,7 +685,7 @@ export async function getTermEntry(packKey: string, kind: string): Promise<TermE
 export async function setTermVisibility(
   packKey: string,
   kind: string,
-  visibility: { showInInstaller: boolean; showInInstallerRp: boolean }
+  visibility: { showInInstaller: boolean; showInInstallerRp: boolean; showInFinalResourcepack: boolean }
 ): Promise<void> {
   if (!isTermKind(kind)) throw new Error('invalid term kind')
   const meta = await loadTermsMeta(packKey)
@@ -670,6 +693,7 @@ export async function setTermVisibility(
   if (!entry) throw new Error('term not found')
   entry.showInInstaller = !!visibility.showInInstaller
   entry.showInInstallerRp = !!visibility.showInInstallerRp
+  entry.showInFinalResourcepack = !!visibility.showInFinalResourcepack
   await saveTermsMeta(packKey, meta)
 }
 
@@ -719,7 +743,8 @@ export async function createTerm(packKey: string, kind: string, label: string):
   meta.terms[kind] = {
     label: cleanLabel,
     showInInstaller: seed ? seed.showInInstaller : true,
-    showInInstallerRp: seed ? seed.showInInstallerRp : true
+    showInInstallerRp: seed ? seed.showInInstallerRp : true,
+    showInFinalResourcepack: seed ? seed.showInFinalResourcepack : false
   }
   await saveTermsMeta(packKey, meta)
 }

src/shared/types.ts

@@ -14,8 +14,14 @@ export interface PackDefinition {
   platform: PackPlatform
   /** /file/mods/<modsFolder>/ 폴더 안의 모든 .jar을 자동 다운로드. */
   modsFolder: string
-  /** /file/resourcepacks/<resourcepackPath> 의 단일 .zip을 그대로 다운로드. */
+  /** /file/resourcepacks/<resourcepackPath> 의 단일 .zip을 그대로 다운로드(리소스팩 설치기의 베이스). */
   resourcepackPath: string
+  /**
+   * 간편설치기 마지막에 선택 설치하는 "최종 리소스팩" zip 파일 이름.
+   * /file/resourcepacks/outputs/<finalResourcepackPath> 에서 받는다.
+   * `"."` 이면 없음(설치 여부 질문 자체를 건너뜀). 기본값은 `"."`.
+   */
+  finalResourcepackPath: string
   /**
    * 리소스팩 설치기가 만들어 내는 최종 zip 파일의 이름(확장자 제외).
    * 빈 문자열이면 설치기가 `<packKey>_resourcepack` 형식으로 기본 이름을 만든다.
@@ -35,6 +41,11 @@ export interface PackDefinition {
   recommendedJdk: number
   /** /file/maps/<mapPath> 에서 받아 .mc_custom/saves 로 풀 zip 파일 이름. */
   mapPath: string
+  /**
+   * /file/configs/<configPath> 에서 받아 게임 폴더(.mc_custom) 루트에 그대로 푸는 zip
+   * 파일 이름. 보통 zip 안에 `config/` 폴더를 담는다. 빈 문자열이면 받지 않는다.
+   */
+  configPath: string
   /** /file/servers/<serverPath> 에서 받아 서버 설치 경로로 풀 zip 파일 이름. */
   serverPath: string
 }

views/op/editor.ejs

@@ -82,11 +82,13 @@
         </label>
         <label>
           <span><%= t('editor.recommendedJdk') %></span>
-          <select name="recommendedJdk" required>
+          <select name="recommendedJdk" id="recommendedJdk" data-current="<%= pack.recommendedJdk %>" required>
-            <% jdkOptions.forEach(function (major) { %>
+            <option value="<%= pack.recommendedJdk %>" selected>Java <%= pack.recommendedJdk %></option>
-              <option value="<%= major %>" <%= major === pack.recommendedJdk ? 'selected' : '' %>>Java <%= major %></option>
-            <% }) %>
           </select>
+          <label class="muted" style="font-weight:normal;display:flex;align-items:center;gap:6px;margin-top:4px;">
+            <input type="checkbox" id="jdkShowDetails" style="width:auto;" /> <%= t('editor.jdkShowDetails') %>
+          </label>
+          <div id="jdkDetails" class="muted" hidden style="margin-top:4px;font-size:12px;line-height:1.6;word-break:break-all;"></div>
           <small class="muted"><%= t('editor.recommendedJdkHint') %></small>
         </label>
         <label>
@@ -94,6 +96,11 @@
           <input name="mapPath" value="<%= pack.mapPath %>" placeholder="my-map.zip" pattern=".+\.zip" />
           <small class="muted"><%= t('editor.mapPathHint') %></small>
         </label>
+        <label>
+          <span><%= t('editor.configPath') %></span>
+          <input name="configPath" value="<%= pack.configPath %>" placeholder="my-config.zip" pattern=".+\.zip" />
+          <small class="muted"><%= t('editor.configPathHint') %></small>
+        </label>
         <label>
           <span><%= t('editor.serverPath') %></span>
           <input name="serverPath" value="<%= pack.serverPath %>" placeholder="my-server.zip" pattern=".+\.zip" />
@@ -117,6 +124,11 @@
           <input name="outputPackName" value="<%= pack.outputPackName %>" placeholder="<%= t('editor.outputPackNamePlaceholder') %>" />
           <small class="muted"><%= t('editor.outputPackNameHint') %></small>
         </label>
+        <label class="fullSpan">
+          <span><%= t('editor.finalResourcepackPath') %></span>
+          <input name="finalResourcepackPath" value="<%= pack.finalResourcepackPath %>" placeholder="my-pack.zip  ( . = 없음 )" />
+          <small class="muted"><%= t('editor.finalResourcepackHint') %></small>
+        </label>
       </div>
 
       <button class="primaryButton" type="submit"><%= t('common.save') %></button>
@@ -135,6 +147,83 @@
     function formatLoaderLoadFailed(message) {
       return I18N.loaderLoadFailedPrefix.replace('__M__', message)
     }
+    var JDK = {
+      current: <%= pack.recommendedJdk %>,
+      fallback: <%- JSON.stringify(jdkOptions) %>,
+      detailsGa: <%- JSON.stringify(t('editor.jdkDetailsGa')) %>,
+      detailsEa: <%- JSON.stringify(t('editor.jdkDetailsEa')) %>,
+      detailsLoading: <%- JSON.stringify(t('common.loading')) %>,
+      detailsNone: <%- JSON.stringify(t('editor.jdkDetailsNone')) %>,
+      ltsSuffix: <%- JSON.stringify(t('editor.jdkLtsSuffix')) %>
+    }
+  </script>
+  <script>
+    (function () {
+      var sel = document.getElementById('recommendedJdk')
+      var details = document.getElementById('jdkDetails')
+      var toggle = document.getElementById('jdkShowDetails')
+      if (!sel || !toggle) return
+      var current = Number(sel.getAttribute('data-current')) || JDK.current
+      var avail = null // { available:[], lts:[] }
+
+      function rebuild() {
+        var availList, ltsList
+        if (avail) { availList = avail.available; ltsList = avail.lts }
+        else { availList = JDK.fallback.slice().sort(function (a, b) { return b - a }); ltsList = availList }
+        var ltsSet = {}
+        ltsList.forEach(function (m) { ltsSet[m] = true })
+        var list = toggle.checked ? availList.slice() : ltsList.slice()
+        if (list.indexOf(current) < 0) list = [current].concat(list)
+        var seen = {}, html = ''
+        list.forEach(function (m) {
+          if (seen[m]) return
+          seen[m] = true
+          var label = 'Java ' + m + (ltsSet[m] ? JDK.ltsSuffix : '')
+          html += '<option value="' + m + '"' + (m === current ? ' selected' : '') + '>' + label + '</option>'
+        })
+        sel.innerHTML = html
+        sel.value = String(current)
+      }
+
+      function escHtml(s) {
+        return String(s).replace(/[&<>"']/g, function (c) {
+          return c === '&' ? '&amp;' : c === '<' ? '&lt;' : c === '>' ? '&gt;' : c === '"' ? '&quot;' : '&#39;'
+        })
+      }
+      function detailRow(label, names) {
+        return '<div><strong>' + escHtml(label) + ':</strong> ' +
+          names.slice(0, 6).map(escHtml).join(', ') + '</div>'
+      }
+      function loadDetails(major) {
+        details.hidden = false
+        details.textContent = JDK.detailsLoading
+        fetch('/op/jdk-versions/' + major)
+          .then(function (r) { if (!r.ok) throw new Error('HTTP ' + r.status); return r.json() })
+          .then(function (d) {
+            // release_name 은 외부 API 값이라 반드시 escape 후 삽입(관리 페이지 XSS 방지).
+            var html = ''
+            if (d.ga && d.ga.length) html += detailRow(JDK.detailsGa, d.ga)
+            if (d.ea && d.ea.length) html += detailRow(JDK.detailsEa, d.ea)
+            details.innerHTML = html || escHtml(JDK.detailsNone)
+          })
+          .catch(function () { details.textContent = JDK.detailsNone })
+      }
+
+      sel.addEventListener('change', function () {
+        current = Number(sel.value)
+        if (toggle.checked) loadDetails(current)
+      })
+      toggle.addEventListener('change', function () {
+        rebuild()
+        if (toggle.checked) loadDetails(current)
+        else { details.hidden = true; details.innerHTML = '' }
+      })
+
+      fetch('/op/jdk-versions')
+        .then(function (r) { if (!r.ok) throw new Error('HTTP ' + r.status); return r.json() })
+        .then(function (d) { avail = d; rebuild() })
+        .catch(function () { rebuild() })
+    })()
   </script>
   <script>
     (function () {

views/op/terms-pack.ejs

@@ -87,6 +87,7 @@
               <span class="visibilityBadges">
                 <span class="visibilityBadge <%= item.showInInstaller ? '' : 'off' %>"><%= t('terms.visibilityInstallerShort') %></span>
                 <span class="visibilityBadge <%= item.showInInstallerRp ? '' : 'off' %>"><%= t('terms.visibilityInstallerRpShort') %></span>
+                <span class="visibilityBadge <%= item.showInFinalResourcepack ? '' : 'off' %>"><%= t('terms.visibilityFinalResourcepackShort') %></span>
               </span>
             </div>
             <div class="termsRowSub"><%= item.kind %>.md</div>

views/op/termsEditor.ejs

@@ -36,10 +36,14 @@
         <input type="checkbox" id="visInstaller" <%= showInInstaller ? 'checked' : '' %> />
         <span><%= t('terms.visibilityInstaller') %></span>
       </label>
-      <label style="display:inline-flex; align-items:center; gap:6px;">
+      <label style="display:inline-flex; align-items:center; gap:6px; margin-right:18px;">
         <input type="checkbox" id="visInstallerRp" <%= showInInstallerRp ? 'checked' : '' %> />
         <span><%= t('terms.visibilityInstallerRp') %></span>
       </label>
+      <label style="display:inline-flex; align-items:center; gap:6px;">
+        <input type="checkbox" id="visFinalResourcepack" <%= showInFinalResourcepack ? 'checked' : '' %> />
+        <span><%= t('terms.visibilityFinalResourcepack') %></span>
+      </label>
     </fieldset>
 
     <p class="muted" style="font-size:12px;"><%= t('terms.slashHint') %></p>