v0.4.30: gate /videoStick behind OP (level 2) permission

The other /video* commands already require Permissions.COMMANDS_GAMEMASTER
(level 2 — the standard OP threshold for cheats), but /videoStick was
missing the gate so any player could spawn a video stick item. Apply the
same requires() check used elsewhere so only OP players, the server
console, and command blocks can run it.

.gitignore

@@ -1,5 +1,6 @@
 .gradle/
 build/
+dist/
 out/
 .idea/
 .vscode/

README.md

@@ -3,7 +3,7 @@
 마인크래프트 안에서 임의의 동영상 URL을 벽·바닥·천장에 평면으로 재생하는 Fabric 모드.
 
 - 모드 ID: `video_player`
-- 현재 버전: **0.4.3**
+- 현재 버전: **0.4.12**
 - 마인크래프트 버전: **26.1.2**
 - 필요 Java: **25** (마인크래프트 26.x 가 요구함)
 
@@ -51,91 +51,23 @@ Fabric은 마인크래프트에 모드 기능을 추가해 주는 로더입니
      https://cdn.modrinth.com/data/P7dR8mSH/versions/Sy2Bq7Xc/fabric-api-0.149.0%2B26.1.2.jar
    - 더 최신 빌드를 찾을 땐: https://modrinth.com/mod/fabric-api/versions → 페이지에서 게임 버전 필터 `26.1.2` 를 직접 선택. (URL 파라미터 필터가 듣지 않는 경우가 있어서 페이지 안에서 한 번 더 확인하는 게 안전합니다.)
    - 받은 `fabric-api-0.149.0+26.1.2.jar` 를 `mods` 폴더에 넣습니다.
-2. **video_player** (이 모드)
+2. **video_player** (이 모드, 0.4.12 부터 JavaCV 가 jar 안에 포함됨)
    - 다운로드: https://git.tkrmagid.kr/tkrmagid/mc_video_player_mod/releases
-   - `video_player-0.4.3.jar` 를 다운로드해서 같은 `mods` 폴더에 넣습니다.
+   - 자신의 OS·CPU 에 맞는 jar **한 개** 만 받아서 `mods` 폴더에 넣으면 됩니다 (별도 JavaCV 설치 불필요):
+     - Windows 64bit: `video_player-windows-x86_64-0.4.12.jar` (~32MB)
+     - macOS Intel: `video_player-macosx-x86_64-0.4.12.jar` (~24MB)
+     - macOS Apple Silicon (M1/M2/M3/M4): `video_player-macosx-arm64-0.4.12.jar` (~21MB)
+     - Linux 64bit: `video_player-linux-x86_64-0.4.12.jar` (~27MB)
+   - 자기 OS 가 헷갈리면: Windows 는 거의 다 `windows-x86_64`, 인텔맥은 `macosx-x86_64`, 애플 실리콘 맥은 `macosx-arm64`, 리눅스는 `linux-x86_64`.
 
-이전 버전(`video_player-0.4.0.jar`, `0.4.2.jar`, `0.3.x.jar` 등)이 mods 폴더에 남아있다면 **반드시 삭제**하세요. 두 개가 같이 있으면 마인크래프트가 충돌로 켜지지 않습니다.
+이전 버전(`video_player-0.4.0.jar`, `0.4.2.jar`, `0.4.3.jar`, `0.3.x.jar` 등)이 mods 폴더에 남아있다면 **반드시 삭제**하세요. 두 개가 같이 있으면 마인크래프트가 충돌로 켜지지 않습니다. 0.4.7 이하에서 쓰던 JVM 인수(`-Xbootclasspath/a:...javacv...`) 도 0.4.12 부터는 **빼주세요** — 모드 jar 안에 같은 JavaCV 가 들어있어서 부트클래스패스의 것과 충돌해 검은 화면이 날 수 있습니다.
 
-### STEP 5. 영상 재생 라이브러리 (JavaCV) 설치
-
-여기까지만 하면 마인크래프트는 켜지지만, 영상 자리에 검은 판만 보입니다. 진짜 영상을 재생하려면 **JavaCV** 라는 디코더 라이브러리가 필요합니다.
-
-> 솔직한 안내: 마인크래프트 공식 런처는 mods 폴더에 들어있는 일반 라이브러리 jar를 자동으로 읽어 주지 않습니다. 그래서 JavaCV 설치 절차가 조금 번거롭습니다. 가장 쉬운 길과 공식 런처에서 동작시키는 길 두 가지를 안내합니다.
-
-#### 5-A. 가장 쉬운 길: Prism Launcher 로 갈아타기 (선택)
-
-공식 런처 대신 무료 오픈소스 런처인 **Prism Launcher** 를 쓰면 클릭 몇 번으로 JavaCV를 라이브러리로 추가할 수 있습니다. 게임 자체는 같고, 정품 마인크래프트 계정으로 로그인하는 것도 동일합니다.
-
-1. https://prismlauncher.org/download/ 에서 다운로드 → 설치
-2. Prism에서 인스턴스 → 마인크래프트 26.1.2 + Fabric Loader 0.19.2 선택해서 생성
-3. 인스턴스 우클릭 → **Edit** → 왼쪽의 **Version** 탭 → **Add to Minecraft.jar** 버튼
-4. 아래 STEP 5-B 의 1번 항목에서 받은 JavaCV jar 5개를 한꺼번에 선택해서 추가
-5. **Launch** 로 실행
-
-이 방법이 가장 안정적이고 빠릅니다.
-
-#### 5-B. 공식 런처에서 동작시키기
-
-공식 런처를 계속 쓰고 싶다면 아래 절차를 따르세요.
-
-1. **JavaCV 1.5.13 다운로드**
-   - 다운로드 링크: https://github.com/bytedeco/javacv/releases/download/1.5.13/javacv-platform-1.5.13-bin.zip (2026-02-22 릴리스, FFmpeg 8.0.1 동봉)
-   - 압축을 풀고 `javacv-platform-1.5.13-bin` 폴더 안에서 **다음 jar 5개**를 골라 둡니다 (다른 파일은 안 씁니다):
-     - `javacv.jar`
-     - `javacpp.jar`
-     - 자신의 OS에 맞는 **javacpp 네이티브 jar** (이게 빠지면 검은 화면 — JNI bridge `jnijavacpp` 로딩에 꼭 필요):
-       - Windows 64bit: `javacpp-1.5.13-windows-x86_64.jar`
-       - macOS Intel: `javacpp-1.5.13-macosx-x86_64.jar`
-       - macOS Apple Silicon (M1/M2/M3/M4): `javacpp-1.5.13-macosx-arm64.jar`
-       - Linux 64bit: `javacpp-1.5.13-linux-x86_64.jar`
-     - `ffmpeg.jar`
-     - 자신의 OS에 맞는 **ffmpeg 네이티브 jar**:
-       - Windows 64bit: `ffmpeg-8.0.1-1.5.13-windows-x86_64.jar`
-       - macOS Intel: `ffmpeg-8.0.1-1.5.13-macosx-x86_64.jar`
-       - macOS Apple Silicon (M1/M2/M3/M4): `ffmpeg-8.0.1-1.5.13-macosx-arm64.jar`
-       - Linux 64bit: `ffmpeg-8.0.1-1.5.13-linux-x86_64.jar`
-
-2. **이 5개 jar 를 게임이 읽도록 등록**
-   - 가장 안전한 위치: `.minecraft/libraries/javacv/` 폴더를 새로 만들고 5개 jar를 거기에 복사하세요. (긴 파일명이 부담스러우면 `javacpp-1.5.13-windows-x86_64.jar` → `javacpp-windows-x86_64.jar`, `ffmpeg-8.0.1-1.5.13-windows-x86_64.jar` → `ffmpeg-windows-x86_64.jar` 식으로 짧게 rename해도 됩니다. 아래 예시는 짧은 이름 기준.)
-   - 그 다음, 공식 런처에서 fabric 프로필 옆 **편집** 또는 **설치 설정** → 화면 아래쪽 **"JVM 인수"** (Java arguments) 칸을 켜고 기존 인수 **끝**에 한 칸 띄우고 다음 한 줄을 추가합니다.
-
-     ⚠ **반드시 절대경로(`C:\Users\...`)로 적어주세요.** 마인크래프트 공식 런처는 JVM 인수의 `%APPDATA%`·`%USERPROFILE%` 같은 환경변수를 풀어주지 않고 글자 그대로 Java 에 넘깁니다. 그러면 boot classpath 가 빈 상태가 되어 영상이 안 나옵니다.
-
-     Windows (사용자명 `홍길동` 예시):
-     ```
-     -Xbootclasspath/a:C:\Users\홍길동\AppData\Roaming\.minecraft\libraries\javacv\javacv.jar;C:\Users\홍길동\AppData\Roaming\.minecraft\libraries\javacv\javacpp.jar;C:\Users\홍길동\AppData\Roaming\.minecraft\libraries\javacv\javacpp-windows-x86_64.jar;C:\Users\홍길동\AppData\Roaming\.minecraft\libraries\javacv\ffmpeg.jar;C:\Users\홍길동\AppData\Roaming\.minecraft\libraries\javacv\ffmpeg-windows-x86_64.jar
-     ```
-     (`C:\Users\<본인 윈도우 사용자명>\AppData\Roaming\` 부분을 본인 사용자 폴더로 바꾸세요. 윈도우키+R → `cmd` → `echo %APPDATA%` 로 정확한 경로 확인 가능.)
-
-     macOS (Apple Silicon 예시):
-     ```
-     -Xbootclasspath/a:/Users/사용자이름/Library/Application Support/minecraft/libraries/javacv/javacv.jar:/Users/사용자이름/Library/Application Support/minecraft/libraries/javacv/javacpp.jar:/Users/사용자이름/Library/Application Support/minecraft/libraries/javacv/javacpp-macosx-arm64.jar:/Users/사용자이름/Library/Application Support/minecraft/libraries/javacv/ffmpeg.jar:/Users/사용자이름/Library/Application Support/minecraft/libraries/javacv/ffmpeg-macosx-arm64.jar
-     ```
-
-     Linux:
-     ```
-     -Xbootclasspath/a:/home/사용자이름/.minecraft/libraries/javacv/javacv.jar:/home/사용자이름/.minecraft/libraries/javacv/javacpp.jar:/home/사용자이름/.minecraft/libraries/javacv/javacpp-linux-x86_64.jar:/home/사용자이름/.minecraft/libraries/javacv/ffmpeg.jar:/home/사용자이름/.minecraft/libraries/javacv/ffmpeg-linux-x86_64.jar
-     ```
-
-     주의:
-     - Windows는 jar 사이를 **세미콜론(`;`)** 으로 구분합니다.
-     - macOS/Linux는 **콜론(`:`)** 으로 구분합니다.
-     - 경로에 띄어쓰기가 있으면(특히 macOS의 `Application Support`) 전체 인수를 큰따옴표로 감싸세요.
-     - `사용자이름` 부분은 실제 자신의 사용자 폴더 이름으로 바꾸세요.
-     - `javacpp-...` 와 `ffmpeg-...` 부분의 jar 이름은 OS에 맞춰 1번에서 고른 그 파일명 그대로 적습니다 (zip 안에는 `javacpp-1.5.13-windows-x86_64.jar`, `ffmpeg-8.0.1-1.5.13-windows-x86_64.jar` 같은 긴 이름으로 들어 있고, 위 예시는 짧게 rename한 것 기준입니다).
-     - **5개 모두** 적어야 합니다. `javacpp-<os>.jar` (네이티브) 가 빠지면 JNI bridge 가 로딩 안 돼서 영상이 검게만 보입니다.
-
-3. 저장 후 **플레이** 를 누르면 영상이 재생됩니다.
-
-> 절차가 너무 번거롭다고 느끼면 **5-A 의 Prism Launcher** 를 권장합니다. 동일한 jar 를 클릭으로 끌어다 놓기만 하면 끝납니다.
-
-### STEP 6. 잘 설치됐는지 확인
+### STEP 5. 잘 설치됐는지 확인
 
 게임 안에서 채팅창에 `/videostick` 을 입력하세요. 정상이라면:
 
 - 인벤토리에 **비디오 스틱** 아이템이 들어옵니다 (보라/검정 missing-texture 가 아니라 작대기 모양 아이콘).
-- 보라/검정 missing texture 가 나오면 **STEP 4** 에서 이전 버전 jar(`video_player-0.4.0.jar` / `0.4.1.jar` 등)가 mods 폴더에 같이 남아있는 경우입니다. 다 지우고 `0.4.3` 만 남기고 다시 시작하세요. (0.4.1 이하는 Fabric 26.1.2 model 로더가 unprefixed `item/generated` parent 를 거부해서 스틱 아이콘이 missing-model 큐브로 보입니다 — 0.4.2 에서 수정됨.)
+- 보라/검정 missing texture 가 나오면 **STEP 4** 에서 이전 버전 jar(`video_player-0.4.0.jar` / `0.4.1.jar` 등)가 mods 폴더에 같이 남아있는 경우입니다. 다 지우고 `0.4.12` 만 남기고 다시 시작하세요. (0.4.1 이하는 Fabric 26.1.2 model 로더가 unprefixed `item/generated` parent 를 거부해서 스틱 아이콘이 missing-model 큐브로 보입니다 — 0.4.2 에서 수정됨.)
 
 ---
 
@@ -164,25 +96,92 @@ Fabric은 마인크래프트에 모드 기능을 추가해 주는 로더입니
 | 명령 | 설명 |
 | --- | --- |
 | `/videostick` | 비디오 스틱 아이템을 인벤토리에 지급 |
-| `/videoplace <url> [w] [h] [loop] [autoplay]` | 정조준한 블록 면에 즉시 영상 배치 |
-| `/videodelete` | 정조준한 블록 면의 영상 제거 |
+| `/videoplace <pos> <facing> <w> <h> <url>` | 좌표에 영상 앵커를 즉시 배치 |
+| `/videodelete <pos>` | 좌표의 영상 앵커 제거 |
+| `/videomute <pos> <on\|off>` | 영상의 음소거 켜고/끄기 |
+| `/videopreload <url>` | URL 을 미리 받아 디스크 캐시에 저장 (자세한 내용은 아래) |
+
+`/videoplace`, `/videodelete`, `/videomute`, `/videopreload` 는 기본적으로 OP(권한 레벨 2) 가 필요하므로 **커맨드 블럭에서도 그대로 호출 가능합니다**. 커맨드 블럭은 기본이 권한 레벨 2 라 별도 설정 없이 동작합니다.
+
+### `/videopreload` — 영상 미리 로딩 (스터터 제거)
+
+스트리밍 URL 을 라이브로 받으면서 재생하면 네트워크가 잠깐 느려질 때 끊김이 생깁니다. `/videopreload <url>` 을 미리 한번 실행하면 클라이언트가 백그라운드에서 URL 을 통째로 다운로드해서 `.minecraft/video_player_cache/` 폴더에 저장해 두고, 같은 URL 로 영상이 재생될 때 인터넷이 아니라 그 로컬 파일을 사용합니다 (= 끊김 없음).
+
+```
+/videopreload https://video.example.com/foo.mp4
+```
+
+특징:
+
+- **커맨드 블럭에서 사용 가능** — 예: 압력판 → 커맨드 블럭 `/videopreload <url>` 으로 트리거하면 플레이어가 영상 영역에 다가가기 전에 미리 다운로드 시작
+- 명령은 서버에서 실행되지만, 다운로드는 각 **클라이언트**(접속해 있는 모든 플레이어)가 자기 PC 에 받습니다
+- 이미 받아둔 URL 은 재요청해도 다시 다운로드 안 함 (URL 의 SHA-256 으로 캐싱)
+- 한 파일당 상한 512 MB
+- 캐시 폴더가 너무 커지면 직접 `.minecraft/video_player_cache/` 안의 파일을 삭제해도 됩니다 (그러면 다음 사용 시 다시 받아옴)
+
+> 영상 삭제 시 소리가 안 멎던 문제는 0.4.4 에서 수정되었습니다 (앵커 블록이 사라지면 디코더 / 오디오 라인을 즉시 강제 종료). 0.4.5 에서는 `BLOCK_ENTITY_UNLOAD` 이벤트가 누락되는 엣지케이스를 대비해 매 틱마다 BE 존재를 한 번 더 검증합니다.
+
+> 0.4.5 부터 다운로드 시작 / 완료 / 실패가 채팅창에 표시됩니다. 커맨드블럭으로 `/videopreload` 후 `/videoplace` 를 이어 실행할 때는 `[videopreload] 완료` 메시지를 본 뒤에 재생해야 로컬 파일에서 재생됩니다 (그 전에 재생하면 일반 스트리밍으로 떨어집니다).
+
+> 0.4.5 부터 오디오 거리 감쇠가 **판때기 중앙**을 기준으로 계산됩니다. 예전엔 앵커 블록(보통 화면 모서리)을 기준으로 측정해서 큰 화면일수록 소리가 한쪽에서 들리는 느낌이었습니다.
+
+### 서버 config 로 자동 프리로드 (0.4.6+)
+
+서버에 모드를 넣고 한 번 실행하면 `<서버폴더>/config/video_player.json` 가 자동 생성됩니다. 이 파일에 자주 쓰는 영상 URL 을 적어두면, 플레이어가 접속할 때마다 서버가 자동으로 그 URL 들의 프리로드 요청을 보냅니다 (= `/videopreload` 를 사람마다 친 것과 같음).
+
+기본 생성된 파일 예시:
+
+```json
+{
+  "_comment": "preload_urls: HTTP(S) video URLs broadcast to every player on join. ...",
+  "preload_urls": []
+}
+```
+
+사용 예시 — 인트로 영상과 BGM 영상을 모든 접속자가 미리 받도록:
+
+```json
+{
+  "preload_urls": [
+    "https://video.example.com/intro.mp4",
+    "https://video.example.com/bgm-loop.webm"
+  ]
+}
+```
+
+규칙:
+
+- 각 URL 은 `http://` 또는 `https://` 시작, 256자 이하 (그 외는 무시되고 서버 로그에 WARN)
+- 파일 수정 후 적용하려면 **서버 재시작** 이 필요합니다 (config 는 시작 시 1회만 로딩)
+- 접속한 플레이어 화면에는 `/videopreload` 와 동일한 `[videopreload] 다운로드 시작 / 완료` 채팅 메시지가 보입니다
+- 이미 캐시된 URL 은 다시 다운로드하지 않습니다 (SHA-256 캐시 키)
+- 싱글플레이는 자체적으로 통합 서버를 띄우므로, 통합 서버의 config 폴더(`<게임폴더>/config/video_player.json`)에도 같은 효과로 동작합니다
 
 ---
 
 ## 알려진 이슈
 
-- JavaCV가 안 잡혀있으면 영상 자리만 잡힐 뿐 검게 보입니다. 로그 파일(`.minecraft/logs/latest.log`)에서 `JavaCV not on classpath` WARN 또는 `JavaCV decode error: ...UnsatisfiedLinkError... jnijavacpp` 메시지로 확인 가능합니다. 후자는 `javacpp-<os>.jar` 네이티브 jar 가 빠진 케이스입니다 (STEP 5-B 1번의 5개 jar 모두 등록되어야 함).
+- 영상 자리만 잡히고 검게 보이는 경우: 자신의 OS·CPU 와 다른 플랫폼의 jar 를 받았거나, 이전 버전(0.4.7 이하)의 `-Xbootclasspath/a:...javacv...` JVM 인수가 그대로 남아 있는 경우가 가장 흔합니다. 로그 파일(`.minecraft/logs/latest.log`)에서 `JavaCV not on classpath` WARN 또는 `UnsatisfiedLinkError... jnijavacpp` 메시지로 확인 가능합니다.
 - 0.3.x 이하 버전에서 만든 영상은 새 버전(0.4.x) 에서 보이지 않으니 다시 배치해야 합니다.
 
 ---
 
 ## 개발자용 빌드
 
+바닐라(JavaCV 미포함, 별도 설치 가정) 빌드:
 ```sh
 JAVA_HOME=/usr/lib/jvm/java-25-openjdk-amd64 ./gradlew build
 ```
+산출물: `build/libs/video_player-0.4.12.jar` (~85KB)
 
-산출물: `build/libs/video_player-0.4.3.jar`
+플랫폼별 fat jar (JavaCV 1.5.13 + ffmpeg 8.0.1 네이티브 nested):
+```sh
+JAVA_HOME=/usr/lib/jvm/java-25-openjdk-amd64 ./gradlew clean build -Pplatform=windows-x86_64
+JAVA_HOME=/usr/lib/jvm/java-25-openjdk-amd64 ./gradlew clean build -Pplatform=linux-x86_64
+JAVA_HOME=/usr/lib/jvm/java-25-openjdk-amd64 ./gradlew clean build -Pplatform=macosx-x86_64
+JAVA_HOME=/usr/lib/jvm/java-25-openjdk-amd64 ./gradlew clean build -Pplatform=macosx-arm64
+```
+산출물: `build/libs/video_player-<platform>-0.4.12.jar` (~21-32MB, jar 내부에 nested 로 javacv/javacpp/ffmpeg jar 5개 포함, Fabric loader 가 런타임에 classpath 로 풀어서 로딩)
 
 JavaCV를 직접 의존성으로 가져오는 경우의 Maven 좌표:
 ```

build.gradle

@@ -7,8 +7,25 @@ plugins {
 version = project.mod_version
 group = project.maven_group
 
+// Optional platform bundle target: `-Pplatform=windows-x86_64` etc. produces a fat jar
+// with that platform's JavaCV + FFmpeg natives nested inside via Fabric's `include`
+// directive. Without `-Pplatform`, the build matches pre-0.4.8 behavior (small jar,
+// user supplies JavaCV separately).
+def javacvPlatform = (project.findProperty('platform') ?: '').toString()
+def bundleJavaCv = !javacvPlatform.isEmpty()
+
+def javacvVersion = '1.5.13'
+def ffmpegVersion = '8.0.1-1.5.13'
+def supportedPlatforms = ['windows-x86_64', 'linux-x86_64', 'macosx-x86_64', 'macosx-arm64']
+if (bundleJavaCv && !supportedPlatforms.contains(javacvPlatform)) {
+    throw new GradleException(
+        "Unknown -Pplatform=${javacvPlatform}. Allowed: ${supportedPlatforms.join(', ')}")
+}
+
 base {
-    archivesName = project.archives_base_name
+    archivesName = bundleJavaCv
+        ? "${project.archives_base_name}-${javacvPlatform}"
+        : project.archives_base_name
 }
 
 repositories {
@@ -26,6 +43,19 @@ dependencies {
 
     implementation "net.fabricmc:fabric-loader:${project.loader_version}"
     implementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"
+
+    if (bundleJavaCv) {
+        // Nest the same 5 jars that the README's manual install step used to require, so
+        // users no longer need -Xbootclasspath/a. `include` adds them as jar-in-jar entries;
+        // Fabric loader unpacks and classloads them at runtime.
+        // `transitive = false` keeps us from dragging in opencv/openblas/etc — we only use
+        // FFmpegFrameGrabber / Frame / Java2DFrameConverter.
+        include(implementation("org.bytedeco:javacv:${javacvVersion}") { transitive = false })
+        include(implementation("org.bytedeco:javacpp:${javacvVersion}") { transitive = false })
+        include(implementation("org.bytedeco:ffmpeg:${ffmpegVersion}") { transitive = false })
+        include(implementation("org.bytedeco:javacpp:${javacvVersion}:${javacvPlatform}") { transitive = false })
+        include(implementation("org.bytedeco:ffmpeg:${ffmpegVersion}:${javacvPlatform}") { transitive = false })
+    }
 }
 
 processResources {

gradle.properties

@@ -5,7 +5,7 @@ org.gradle.configuration-cache=false
 
 # Mod
 mod_id=video_player
-mod_version=0.4.3
+mod_version=0.4.30
 maven_group=com.ejclaw.videoplayer
 archives_base_name=video_player
 

src/main/java/com/ejclaw/videoplayer/VideoPlayerClient.java

@@ -1,7 +1,9 @@
 package com.ejclaw.videoplayer;
 
 import com.ejclaw.videoplayer.block.VideoAnchorBlockEntity;
+import com.ejclaw.videoplayer.client.MusicQuizClient;
 import com.ejclaw.videoplayer.client.net.ClientNetworking;
+import com.ejclaw.videoplayer.client.playback.VideoCache;
 import com.ejclaw.videoplayer.client.playback.VideoPlayback;
 import com.ejclaw.videoplayer.client.render.VideoAnchorRenderer;
 import com.ejclaw.videoplayer.item.VideoStickItem;
@@ -10,13 +12,17 @@ import com.ejclaw.videoplayer.registry.VideoPlayerBlockEntities;
 import net.fabricmc.api.ClientModInitializer;
 import net.fabricmc.api.EnvType;
 import net.fabricmc.api.Environment;
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientBlockEntityEvents;
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientLifecycleEvents;
 import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
 import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
 import net.fabricmc.fabric.api.client.rendering.v1.BlockEntityRendererRegistry;
+import net.fabricmc.fabric.api.client.rendering.v1.level.LevelRenderEvents;
 import net.fabricmc.fabric.api.event.player.AttackBlockCallback;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.player.LocalPlayer;
 import net.minecraft.core.BlockPos;
+import net.minecraft.sounds.SoundSource;
 import net.minecraft.world.InteractionResult;
 import net.minecraft.world.phys.Vec3;
 
@@ -26,6 +32,7 @@ public class VideoPlayerClient implements ClientModInitializer {
     @Override
     public void onInitializeClient() {
         ClientNetworking.register();
+        MusicQuizClient.register();
 
         BlockEntityRendererRegistry.register(
             VideoPlayerBlockEntities.VIDEO_ANCHOR,
@@ -53,31 +60,63 @@ public class VideoPlayerClient implements ClientModInitializer {
             return InteractionResult.PASS;
         });
 
-        ClientTickEvents.END_CLIENT_TICK.register(client -> {
-            VideoPlayback.tick();
-            updateDistanceGains(client);
-        });
+        // Pump frame uploads on every render frame (60+Hz) rather than every client tick
+        // (20Hz). At 24fps source, a 20Hz pump can skip a frame whenever a tick window happens
+        // to miss the decode boundary, producing visible micro-stutter even when frames are
+        // ready. Polling at render rate lets the texture latch as soon as a frame is decoded.
+        LevelRenderEvents.START_MAIN.register(ctx -> VideoPlayback.tick());
+
+        // Distance-gain math is cheap and only audible state — 20Hz is plenty and avoids
+        // recomputing it on every render frame.
+        ClientTickEvents.END_CLIENT_TICK.register(VideoPlayerClient::updateDistanceGains);
 
         ClientTickEvents.END_LEVEL_TICK.register(world -> {
             // no-op for now
         });
 
+        // When an anchor block is deleted (shift+left-click, /videodelete) or its chunk
+        // unloads (player walks away), Minecraft removes the block entity client-side. Hook
+        // that to stop the decode worker and audio line — otherwise VideoPlayback.ENTRIES
+        // keeps holding the backend and the sound keeps playing.
+        ClientBlockEntityEvents.BLOCK_ENTITY_UNLOAD.register((blockEntity, level) -> {
+            if (blockEntity instanceof VideoAnchorBlockEntity) {
+                VideoPlayback.stop(blockEntity.getBlockPos());
+            }
+        });
+
+        // Wipe video_player_cache/ on game exit so preloaded clips don't pile up across
+        // sessions. Cache entries are re-broadcast by the server on every JOIN, so a freshly
+        // started game will repopulate the cache automatically.
+        ClientLifecycleEvents.CLIENT_STOPPING.register(client -> VideoCache.wipeOnShutdown());
+
         VideoPlayerMod.LOG.info("[{}] client initialized", VideoPlayerMod.MOD_ID);
     }
 
-    /** SPEC §6 — recompute per-anchor audio gain from player distance every tick. */
+    /**
+     * SPEC §6 — recompute per-anchor audio gain from player distance every tick.
+     * Distance is measured from the player's eye to the <em>panel center</em>, not the anchor
+     * block corner — for a 4×4 panel the corner is ~2 blocks off from where the screen visually
+     * sits, which made the audio feel like it was off to the side.
+     *
+     * <p>Gain is also gated by the Minecraft sound options so the in-game sliders work as
+     * expected: vanilla {@code SoundEngine.calculateVolume} multiplies by master × category, so
+     * we do the same with {@link SoundSource#PLAYERS} as the category. Result: dragging the
+     * "Players" slider in Options → Music & Sounds attenuates video audio just like other
+     * player sounds, and "Master" still gates everything.
+     */
     private static void updateDistanceGains(Minecraft client) {
         LocalPlayer p = client.player;
         if (p == null || client.level == null) return;
         Vec3 eye = p.getEyePosition();
+        float masterVol = client.options.getSoundSourceVolume(SoundSource.MASTER);
+        float playersVol = client.options.getSoundSourceVolume(SoundSource.PLAYERS);
+        float categoryScale = masterVol * playersVol;
         for (BlockPos pos : VideoPlayback.activePositions()) {
             if (!(client.level.getBlockEntity(pos) instanceof VideoAnchorBlockEntity be)) continue;
-            double dx = (pos.getX() + 0.5) - eye.x;
-            double dy = (pos.getY() + 0.5) - eye.y;
-            double dz = (pos.getZ() + 0.5) - eye.z;
-            double d  = Math.sqrt(dx * dx + dy * dy + dz * dz);
+            Vec3 center = be.panelCenter();
+            double d = center.distanceTo(eye);
             float attenuation = (float) Math.max(0.0, Math.min(1.0, 1.0 - d / 16.0));
-            float gain = be.isMuted() ? 0F : be.getVolume() * attenuation;
+            float gain = be.isMuted() ? 0F : be.getVolume() * attenuation * categoryScale;
             VideoPlayback.setGain(pos, gain);
         }
     }

src/main/java/com/ejclaw/videoplayer/VideoPlayerConfig.java

@@ -0,0 +1,327 @@
+package com.ejclaw.videoplayer;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import net.fabricmc.loader.api.FabricLoader;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Server-side mod config, stored at {@code <gameDir>/config/video_player.json}.
+ *
+ * <p>Schema (auto-generated on first start):
+ * <pre>{@code
+ * {
+ *   "max_preload_mb": 1024,
+ *   "preload_urls": [
+ *     "https://example.com/intro.mp4"
+ *   ],
+ *   "cache_entries": [
+ *     { "name": "intro", "url": "https://example.com/intro.mp4" }
+ *   ]
+ * }
+ * }</pre>
+ *
+ * <p>{@code max_preload_mb} is the hard ceiling each client enforces on a single video download
+ * (default 1024 MB ≈ 1 GB; enough headroom for ~50 short FHD clips). Pushed to every client on
+ * join via {@link com.ejclaw.videoplayer.net.CachePolicyPayload}.
+ *
+ * <p>{@code cache_entries} is the named cache index managed by {@code /videocache add|list|remove}.
+ * Each entry's URL is pushed to clients on join (and immediately on {@code add}). Names are unique.
+ *
+ * <p>{@code preload_urls} is the legacy un-named auto-preload list — same behavior as
+ * {@code cache_entries} but without a removable handle. Kept for backward-compat.
+ */
+public final class VideoPlayerConfig {
+    private VideoPlayerConfig() {}
+
+    private static final String FILE_NAME = "video_player.json";
+
+    /**
+     * Default per-video download cap in MB. Sized to allow a single 4K short clip
+     * (≈25 Mbps × 60 s ≈ 190 MB, with headroom for higher-bitrate sources). Per-video
+     * cap is intentionally separate from the total-cache cap below.
+     */
+    private static final int DEFAULT_MAX_PRELOAD_MB = 2048;
+    /**
+     * Default total-cache cap in MB. Sized to comfortably fit ~50 short FHD clips:
+     * FHD H.264 at ~5 Mbps × 20 s ≈ 12.5 MB, so 50 × 15 MB ≈ 750 MB with headroom.
+     */
+    private static final int DEFAULT_MAX_CACHE_MB = 750;
+    /** Default render-distance cap for video anchors, in blocks. 128 = the legacy hard-coded value. */
+    private static final int DEFAULT_RENDER_DISTANCE = 128;
+
+    private static volatile int    maxPreloadMb = DEFAULT_MAX_PRELOAD_MB;
+    private static volatile int    maxCacheMb   = DEFAULT_MAX_CACHE_MB;
+    private static volatile int    renderDistanceBlocks = DEFAULT_RENDER_DISTANCE;
+    private static volatile List<String> preloadUrls = Collections.emptyList();
+    /** Insertion-ordered name → url. Mutated only under the class monitor. */
+    private static final Map<String, String> CACHE_ENTRIES = new LinkedHashMap<>();
+
+    /** Load (or create) the config file. Called once during mod initialization. */
+    public static synchronized void load() {
+        Path path = configPath();
+        try {
+            if (!Files.exists(path)) {
+                writeDefault(path);
+                VideoPlayerMod.LOG.info("[{}] created default config at {}",
+                    VideoPlayerMod.MOD_ID, path);
+                maxPreloadMb = DEFAULT_MAX_PRELOAD_MB;
+                maxCacheMb = DEFAULT_MAX_CACHE_MB;
+                preloadUrls = Collections.emptyList();
+                CACHE_ENTRIES.clear();
+                return;
+            }
+            String raw = Files.readString(path, StandardCharsets.UTF_8);
+            JsonObject json = JsonParser.parseString(raw).getAsJsonObject();
+
+            // Track whether any expected key was missing; if so, we rewrite the file at the
+            // end so users don't have to delete their config to pick up new options.
+            boolean augmented = false;
+
+            // max_preload_mb (per-video cap, sanity-clamped to [16, 16384])
+            int cap = DEFAULT_MAX_PRELOAD_MB;
+            if (json.has("max_preload_mb") && json.get("max_preload_mb").isJsonPrimitive()
+                    && json.get("max_preload_mb").getAsJsonPrimitive().isNumber()) {
+                cap = json.get("max_preload_mb").getAsInt();
+            } else {
+                augmented = true;
+            }
+            if (cap < 16) cap = 16;
+            if (cap > 16384) cap = 16384;
+            maxPreloadMb = cap;
+
+            // max_cache_mb (total-cache cap, sanity-clamped to [16, 65536])
+            int total = DEFAULT_MAX_CACHE_MB;
+            if (json.has("max_cache_mb") && json.get("max_cache_mb").isJsonPrimitive()
+                    && json.get("max_cache_mb").getAsJsonPrimitive().isNumber()) {
+                total = json.get("max_cache_mb").getAsInt();
+            } else {
+                augmented = true;
+            }
+            if (total < 16) total = 16;
+            if (total > 65536) total = 65536;
+            maxCacheMb = total;
+
+            // render_distance_blocks (sanity-clamped to [16, 2048])
+            int rd = DEFAULT_RENDER_DISTANCE;
+            if (json.has("render_distance_blocks") && json.get("render_distance_blocks").isJsonPrimitive()
+                    && json.get("render_distance_blocks").getAsJsonPrimitive().isNumber()) {
+                rd = json.get("render_distance_blocks").getAsInt();
+            } else {
+                augmented = true;
+            }
+            if (rd < 16)   rd = 16;
+            if (rd > 2048) rd = 2048;
+            renderDistanceBlocks = rd;
+
+            // preload_urls (legacy)
+            List<String> urls = new ArrayList<>();
+            if (json.has("preload_urls") && json.get("preload_urls").isJsonArray()) {
+                json.getAsJsonArray("preload_urls").forEach(el -> {
+                    if (el.isJsonPrimitive() && el.getAsJsonPrimitive().isString()) {
+                        String u = sanitizeUrl(el.getAsString());
+                        if (u != null) urls.add(u);
+                    }
+                });
+            }
+            preloadUrls = Collections.unmodifiableList(urls);
+
+            // cache_entries (named)
+            CACHE_ENTRIES.clear();
+            if (json.has("cache_entries") && json.get("cache_entries").isJsonArray()) {
+                for (JsonElement el : json.getAsJsonArray("cache_entries")) {
+                    if (!el.isJsonObject()) continue;
+                    JsonObject o = el.getAsJsonObject();
+                    String name = o.has("name") && o.get("name").isJsonPrimitive()
+                        ? o.get("name").getAsString().trim() : null;
+                    String url  = o.has("url")  && o.get("url").isJsonPrimitive()
+                        ? sanitizeUrl(o.get("url").getAsString()) : null;
+                    if (name == null || name.isEmpty() || url == null) continue;
+                    if (CACHE_ENTRIES.containsKey(name)) {
+                        VideoPlayerMod.LOG.warn(
+                            "[{}] config: duplicate cache entry name '{}' — keeping first",
+                            VideoPlayerMod.MOD_ID, name);
+                        continue;
+                    }
+                    CACHE_ENTRIES.put(name, url);
+                }
+            }
+
+            VideoPlayerMod.LOG.info(
+                "[{}] config loaded: per-video={} MB, total-cache={} MB, render={} blocks, "
+                    + "preload_urls={}, cache_entries={}",
+                VideoPlayerMod.MOD_ID, maxPreloadMb, maxCacheMb, renderDistanceBlocks,
+                urls.size(), CACHE_ENTRIES.size());
+
+            // Auto-augment: rewrite the file once so missing keys appear after a mod update.
+            if (augmented) {
+                VideoPlayerMod.LOG.info(
+                    "[{}] config missing one or more keys — rewriting with defaults filled in",
+                    VideoPlayerMod.MOD_ID);
+                save();
+            }
+        } catch (Throwable t) {
+            VideoPlayerMod.LOG.warn("[{}] failed to read config {}: {} — using defaults",
+                VideoPlayerMod.MOD_ID, path, t.toString());
+            maxPreloadMb = DEFAULT_MAX_PRELOAD_MB;
+            maxCacheMb = DEFAULT_MAX_CACHE_MB;
+            renderDistanceBlocks = DEFAULT_RENDER_DISTANCE;
+            preloadUrls = Collections.emptyList();
+            CACHE_ENTRIES.clear();
+        }
+    }
+
+    // -- accessors ---------------------------------------------------------------------------
+
+    /** Hard cap on a single client-side video download, in MB. */
+    public static int maxPreloadMb() { return maxPreloadMb; }
+
+    /** Same value in bytes. */
+    public static long maxPreloadBytes() { return (long) maxPreloadMb * 1024L * 1024L; }
+
+    /** Hard cap on the client-side total cache directory, in MB. */
+    public static int maxCacheMb() { return maxCacheMb; }
+
+    /** Same value in bytes. */
+    public static long maxCacheBytes() { return (long) maxCacheMb * 1024L * 1024L; }
+
+    /** Anchor BE view-distance cap, in blocks. */
+    public static int renderDistanceBlocks() { return renderDistanceBlocks; }
+
+    /** Legacy un-named preload list (still pushed at join). Never null. */
+    public static List<String> preloadUrls() { return preloadUrls; }
+
+    /** Snapshot of name → url, insertion-ordered. Never null. */
+    public static synchronized Map<String, String> cacheEntries() {
+        return new LinkedHashMap<>(CACHE_ENTRIES);
+    }
+
+    /** Lookup a single entry's URL by name. */
+    public static synchronized String cacheUrl(String name) {
+        return CACHE_ENTRIES.get(name);
+    }
+
+    /**
+     * Accept either a raw HTTP(S) URL or a previously-registered cache entry name and return
+     * the canonical URL to store on the anchor. Returns the trimmed input when it's already a
+     * URL, the looked-up URL when the input matches a cache entry name, or {@code null} if the
+     * input is neither (caller decides whether to fail or fall through).
+     */
+    public static synchronized String resolveUrlOrName(String input) {
+        if (input == null) return null;
+        String t = input.trim();
+        if (t.isEmpty()) return "";
+        if (t.startsWith("http://") || t.startsWith("https://")) return t;
+        return CACHE_ENTRIES.get(t);
+    }
+
+    // -- mutations (driven by /videocache add|remove) -----------------------------------------
+
+    /** Returns true if added; false if the name already exists. Persists on success. */
+    public static synchronized boolean addCacheEntry(String name, String url) {
+        if (name == null || name.isEmpty() || url == null) return false;
+        if (CACHE_ENTRIES.containsKey(name)) return false;
+        CACHE_ENTRIES.put(name, url);
+        save();
+        return true;
+    }
+
+    /** Returns the removed URL, or null if no entry by that name. Persists on success. */
+    public static synchronized String removeCacheEntry(String name) {
+        if (name == null) return null;
+        String removed = CACHE_ENTRIES.remove(name);
+        if (removed != null) save();
+        return removed;
+    }
+
+    /**
+     * Drop every named cache entry and return the URLs that were registered so the caller
+     * can broadcast {@code DeleteCachePayload} for each. Persists on any non-empty removal.
+     */
+    public static synchronized java.util.List<String> clearCacheEntries() {
+        if (CACHE_ENTRIES.isEmpty()) return java.util.Collections.emptyList();
+        java.util.List<String> urls = new java.util.ArrayList<>(CACHE_ENTRIES.values());
+        CACHE_ENTRIES.clear();
+        save();
+        return urls;
+    }
+
+    // -- io ----------------------------------------------------------------------------------
+
+    private static Path configPath() {
+        return FabricLoader.getInstance().getConfigDir().resolve(FILE_NAME);
+    }
+
+    private static String sanitizeUrl(String s) {
+        if (s == null) return null;
+        String t = s.trim();
+        if (t.isEmpty() || t.length() > 256) return null;
+        if (!(t.startsWith("http://") || t.startsWith("https://"))) return null;
+        return t;
+    }
+
+    private static void writeDefault(Path path) throws IOException {
+        Files.createDirectories(path.getParent());
+        JsonObject root = new JsonObject();
+        root.addProperty("_comment",
+            "max_preload_mb: per-video download cap (each client). "
+                + "max_cache_mb: total cache directory cap (each client). "
+                + "render_distance_blocks: max distance at which a video anchor still renders. "
+                + "preload_urls: HTTP(S) videos auto-pushed to every player on join (no name). "
+                + "cache_entries: named entries managed by /videoCache add|list|remove.");
+        root.addProperty("max_preload_mb", DEFAULT_MAX_PRELOAD_MB);
+        root.addProperty("max_cache_mb", DEFAULT_MAX_CACHE_MB);
+        root.addProperty("render_distance_blocks", DEFAULT_RENDER_DISTANCE);
+        root.add("preload_urls", new JsonArray());
+        root.add("cache_entries", new JsonArray());
+        Gson gson = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();
+        Files.writeString(path, gson.toJson(root), StandardCharsets.UTF_8);
+    }
+
+    /** Persist current in-memory state. Best-effort; logs on failure. */
+    private static void save() {
+        Path path = configPath();
+        try {
+            Files.createDirectories(path.getParent());
+            JsonObject root = new JsonObject();
+            root.addProperty("_comment",
+                "max_preload_mb: per-video download cap (each client). "
+                    + "max_cache_mb: total cache directory cap (each client). "
+                    + "render_distance_blocks: max distance at which a video anchor still renders. "
+                    + "preload_urls: legacy un-named auto-preload list. "
+                    + "cache_entries: managed by /videoCache add|list|remove.");
+            root.addProperty("max_preload_mb", maxPreloadMb);
+            root.addProperty("max_cache_mb", maxCacheMb);
+            root.addProperty("render_distance_blocks", renderDistanceBlocks);
+            JsonArray legacyArr = new JsonArray();
+            for (String u : preloadUrls) legacyArr.add(u);
+            root.add("preload_urls", legacyArr);
+            JsonArray entriesArr = new JsonArray();
+            for (Map.Entry<String, String> e : CACHE_ENTRIES.entrySet()) {
+                JsonObject o = new JsonObject();
+                o.addProperty("name", e.getKey());
+                o.addProperty("url",  e.getValue());
+                entriesArr.add(o);
+            }
+            root.add("cache_entries", entriesArr);
+            Gson gson = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();
+            Files.writeString(path, gson.toJson(root), StandardCharsets.UTF_8);
+        } catch (Throwable t) {
+            VideoPlayerMod.LOG.warn("[{}] failed to save config: {}",
+                VideoPlayerMod.MOD_ID, t.toString());
+        }
+    }
+}

src/main/java/com/ejclaw/videoplayer/VideoPlayerMod.java

@@ -1,15 +1,21 @@
 package com.ejclaw.videoplayer;
 
+import com.ejclaw.videoplayer.command.VideoCacheCommand;
 import com.ejclaw.videoplayer.command.VideoDeleteCommand;
 import com.ejclaw.videoplayer.command.VideoMuteCommand;
 import com.ejclaw.videoplayer.command.VideoPlaceCommand;
 import com.ejclaw.videoplayer.command.VideoStickCommand;
+import com.ejclaw.videoplayer.net.CachePolicyPayload;
+import com.ejclaw.videoplayer.net.PreloadPayload;
 import com.ejclaw.videoplayer.net.VideoPlayerNetwork;
+import com.ejclaw.videoplayer.server.MusicQuizPresence;
 import com.ejclaw.videoplayer.registry.VideoPlayerBlockEntities;
 import com.ejclaw.videoplayer.registry.VideoPlayerBlocks;
 import com.ejclaw.videoplayer.registry.VideoPlayerItems;
 import net.fabricmc.api.ModInitializer;
 import net.fabricmc.fabric.api.command.v2.CommandRegistrationCallback;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -25,12 +31,43 @@ public class VideoPlayerMod implements ModInitializer {
 
         VideoPlayerNetwork.registerPayloadTypes();
         VideoPlayerNetwork.registerServerReceivers();
+        MusicQuizPresence.register();
+
+        VideoPlayerConfig.load();
 
         CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, env) -> {
             VideoStickCommand.register(dispatcher);
             VideoPlaceCommand.register(dispatcher);
             VideoDeleteCommand.register(dispatcher);
             VideoMuteCommand.register(dispatcher);
+            VideoCacheCommand.register(dispatcher);
+        });
+
+        // On join: (1) push the per-video download cap so the client knows whether to abort
+        // an over-cap stream, (2) replay every legacy preload_urls entry, (3) replay every
+        // named /videocache entry. Policy must go first so caps are honored before downloads
+        // start. Each PreloadPayload is fire-and-forget; clients post their own "[videopreload]"
+        // status lines when downloads finish.
+        ServerPlayConnectionEvents.JOIN.register((handler, sender, server) -> {
+            var player = handler.getPlayer();
+            ServerPlayNetworking.send(player, new CachePolicyPayload(
+                VideoPlayerConfig.maxPreloadBytes(),
+                VideoPlayerConfig.maxCacheBytes(),
+                VideoPlayerConfig.renderDistanceBlocks()));
+
+            int sent = 0;
+            for (String url : VideoPlayerConfig.preloadUrls()) {
+                ServerPlayNetworking.send(player, new PreloadPayload(url));
+                sent++;
+            }
+            for (var e : VideoPlayerConfig.cacheEntries().entrySet()) {
+                ServerPlayNetworking.send(player, new PreloadPayload(e.getValue()));
+                sent++;
+            }
+            if (sent > 0) {
+                LOG.info("[{}] sent policy + {} preload(s) to {}",
+                    MOD_ID, sent, player.getName().getString());
+            }
         });
 
         LOG.info("[{}] initialized", MOD_ID);

src/main/java/com/ejclaw/videoplayer/block/VideoAnchorBlockEntity.java

@@ -3,11 +3,16 @@ package com.ejclaw.videoplayer.block;
 import com.ejclaw.videoplayer.registry.VideoPlayerBlockEntities;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
+import net.minecraft.core.HolderLookup;
 import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.protocol.Packet;
+import net.minecraft.network.protocol.game.ClientGamePacketListener;
+import net.minecraft.network.protocol.game.ClientboundBlockEntityDataPacket;
 import net.minecraft.world.level.block.entity.BlockEntity;
 import net.minecraft.world.level.block.state.BlockState;
 import net.minecraft.world.level.storage.ValueInput;
 import net.minecraft.world.level.storage.ValueOutput;
+import net.minecraft.world.phys.Vec3;
 
 /**
  * Anchor BE — holds per-block config that drives playback.
@@ -52,6 +57,37 @@ public class VideoAnchorBlockEntity extends BlockEntity {
         setChanged();
     }
 
+    /**
+     * World-space center of the rendered panel. Used for distance-based audio attenuation so
+     * the sound source feels like it's coming from the middle of the screen, not the corner
+     * (anchor block). Geometry mirrors {@code VideoAnchorRenderer#submit}:
+     * the panel's bottom-left corner sits on the wall surface at
+     * {@code anchorCenter + (-0.5)*facing + (-0.5)*right + (-0.5)*up}, and the panel extends
+     * {@code width × height} blocks along {@code right} and {@code up}. So the center is
+     * {@code anchorCenter + (w/2 - 0.5)*right + (h/2 - 0.5)*up + (-0.5)*facing}.
+     */
+    public Vec3 panelCenter() {
+        Vec3 right, up;
+        switch (facing) {
+            case NORTH -> { right = new Vec3(-1, 0,  0); up = new Vec3(0,  1, 0); }
+            case SOUTH -> { right = new Vec3( 1, 0,  0); up = new Vec3(0,  1, 0); }
+            case EAST  -> { right = new Vec3( 0, 0, -1); up = new Vec3(0,  1, 0); }
+            case WEST  -> { right = new Vec3( 0, 0,  1); up = new Vec3(0,  1, 0); }
+            case UP    -> { right = new Vec3( 1, 0,  0); up = new Vec3(0,  0, -1); }
+            case DOWN  -> { right = new Vec3( 1, 0,  0); up = new Vec3(0,  0,  1); }
+            default    -> { right = new Vec3( 1, 0,  0); up = new Vec3(0,  1,  0); }
+        }
+        Vec3 facingVec = new Vec3(facing.getStepX(), facing.getStepY(), facing.getStepZ());
+        BlockPos p = getBlockPos();
+        Vec3 anchorCenter = new Vec3(p.getX() + 0.5, p.getY() + 0.5, p.getZ() + 0.5);
+        double offR = width  / 2.0 - 0.5;
+        double offU = height / 2.0 - 0.5;
+        return anchorCenter
+            .add(right.scale(offR))
+            .add(up.scale(offU))
+            .add(facingVec.scale(-0.5));
+    }
+
     /** Wire-format NBT used by SaveConfig/SyncAnchor payloads. */
     public CompoundTag toNbt() {
         CompoundTag nbt = new CompoundTag();
@@ -91,6 +127,35 @@ public class VideoAnchorBlockEntity extends BlockEntity {
         out.putBoolean("autoplay", autoplay);
     }
 
+    /**
+     * Vanilla chunk-load BE sync. The base implementation returns an empty tag, which means
+     * when a client first sees this BE (chunk loads or player walks into range) it gets default
+     * values — url="" in particular makes the renderer no-op and the panel appears invisible.
+     *
+     * <p>Returning {@link #toNbt()} here carries the custom fields in the vanilla packet, so
+     * we don't depend on the {@code SyncAnchorPayload} arriving before the chunk's block-update
+     * packet (there's a race: {@code level.setBlock} queues a deferred chunk broadcast while
+     * {@code ServerPlayNetworking.send} writes immediately; if the payload wins, the client
+     * drops it because the BE doesn't exist yet, then the chunk packet creates the BE with
+     * defaults). It also fixes "player walks far away and comes back" — that path has no
+     * SyncAnchorPayload at all, just vanilla chunk re-sync.
+     */
+    @Override
+    public CompoundTag getUpdateTag(HolderLookup.Provider provider) {
+        return toNbt();
+    }
+
+    /**
+     * Triggers a {@link ClientboundBlockEntityDataPacket} whenever the chunk tracker decides
+     * this BE needs to push an update. Default implementation returns {@code null} (no packet
+     * sent on BE change). Combined with {@link #getUpdateTag} above, every BE-state change a
+     * client sees carries the full config.
+     */
+    @Override
+    public Packet<ClientGamePacketListener> getUpdatePacket() {
+        return ClientboundBlockEntityDataPacket.create(this);
+    }
+
     @Override
     protected void loadAdditional(ValueInput in) {
         super.loadAdditional(in);

src/main/java/com/ejclaw/videoplayer/client/ClientPolicy.java

@@ -0,0 +1,30 @@
+package com.ejclaw.videoplayer.client;
+
+import com.ejclaw.videoplayer.VideoPlayerMod;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+
+/**
+ * Client-side mirror of the server's policy bundle (pushed via {@code CachePolicyPayload}
+ * on join). Currently just the anchor render-distance cap; the per-video download cap lives
+ * directly on {@link com.ejclaw.videoplayer.client.playback.VideoCache}.
+ *
+ * <p>Default 128 matches the legacy hard-coded value, so unpaired clients (e.g. dev tests
+ * with no JOIN packet, or older servers without the payload) render identically to before.
+ */
+@Environment(EnvType.CLIENT)
+public final class ClientPolicy {
+    private ClientPolicy() {}
+
+    private static volatile int renderDistanceBlocks = 128;
+
+    public static int renderDistanceBlocks() { return renderDistanceBlocks; }
+
+    public static void setRenderDistanceBlocks(int blocks) {
+        if (blocks < 16)   blocks = 16;
+        if (blocks > 2048) blocks = 2048;
+        renderDistanceBlocks = blocks;
+        VideoPlayerMod.LOG.info("[{}] anchor render distance set to {} blocks",
+            VideoPlayerMod.MOD_ID, blocks);
+    }
+}

src/main/java/com/ejclaw/videoplayer/client/MusicQuizClient.java

@@ -0,0 +1,56 @@
+package com.ejclaw.videoplayer.client;
+
+import com.ejclaw.videoplayer.net.MqHelloPayload;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
+import net.fabricmc.fabric.api.client.networking.v1.ClientPlayConnectionEvents;
+import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
+
+/**
+ * Client side of the {@code music_quiz} datapack handshake
+ * ({@code docs/mc_video_player_mod_integration.md}). Sends one {@link MqHelloPayload}
+ * on JOIN, then repeats every 100 client ticks (~5 s at 20 tps).
+ *
+ * <p>The periodic resend is <em>mandatory</em>: the datapack's
+ * {@code mq:players/login} resets the per-player score to 0 the moment the player
+ * passes the spawn dialog. The single JOIN-time send can land before that reset,
+ * leaving the score at 0 and breaking the {@code mq:commands/start} guard. With a
+ * 5-second resend, the score is restored to 1 within at most one cycle.
+ */
+@Environment(EnvType.CLIENT)
+public final class MusicQuizClient {
+    private MusicQuizClient() {}
+
+    /** ~5 s at 20 tps. Spec recommends ≤5 s; tighter is fine but unnecessary. */
+    private static final int RESEND_INTERVAL_TICKS = 100;
+
+    private static int tickCounter = 0;
+
+    public static void register() {
+        ClientPlayConnectionEvents.JOIN.register((handler, sender, client) ->
+            send());
+
+        ClientTickEvents.END_CLIENT_TICK.register(client -> {
+            // Gate on world presence — when the player isn't in-game, level is null and the
+            // counter resets so the next session starts fresh instead of firing immediately.
+            if (client.level == null) {
+                tickCounter = 0;
+                return;
+            }
+            tickCounter++;
+            if (tickCounter >= RESEND_INTERVAL_TICKS) {
+                tickCounter = 0;
+                send();
+            }
+        });
+    }
+
+    private static void send() {
+        // ClientPlayNetworking.send no-ops when the server hasn't registered the payload
+        // type (e.g. vanilla server or server without this mod) — safe to call blindly.
+        if (ClientPlayNetworking.canSend(MqHelloPayload.TYPE)) {
+            ClientPlayNetworking.send(new MqHelloPayload(MqHelloPayload.CURRENT_VERSION));
+        }
+    }
+}

src/main/java/com/ejclaw/videoplayer/client/net/ClientNetworking.java

@@ -1,9 +1,15 @@
 package com.ejclaw.videoplayer.client.net;
 
 import com.ejclaw.videoplayer.block.VideoAnchorBlockEntity;
+import com.ejclaw.videoplayer.client.ClientPolicy;
 import com.ejclaw.videoplayer.client.gui.VideoConfigScreen;
+import com.ejclaw.videoplayer.client.playback.VideoCache;
 import com.ejclaw.videoplayer.client.playback.VideoPlayback;
+import com.ejclaw.videoplayer.net.CachePolicyPayload;
+import com.ejclaw.videoplayer.net.ClearCachePayload;
+import com.ejclaw.videoplayer.net.DeleteCachePayload;
 import com.ejclaw.videoplayer.net.OpenScreenPayload;
+import com.ejclaw.videoplayer.net.PreloadPayload;
 import com.ejclaw.videoplayer.net.SyncAnchorPayload;
 import net.fabricmc.api.EnvType;
 import net.fabricmc.api.Environment;
@@ -31,5 +37,31 @@ public final class ClientNetworking {
                 }
             });
         });
+
+        // Server broadcasts a preload request to all clients; each client downloads to its
+        // own video_player_cache/ folder. Runs entirely off-thread, so we don't bounce through
+        // mc.execute() — VideoCache.preload() is itself non-blocking.
+        ClientPlayNetworking.registerGlobalReceiver(PreloadPayload.TYPE, (payload, context) -> {
+            VideoCache.preload(payload.url());
+        });
+
+        // Server tells us the per-video and total-cache download caps (bytes). Must arrive
+        // before PreloadPayload (server sends policy first on JOIN) so we don't use stale
+        // defaults.
+        ClientPlayNetworking.registerGlobalReceiver(CachePolicyPayload.TYPE, (payload, context) -> {
+            VideoCache.setMaxBytes(payload.maxPerVideoBytes());
+            VideoCache.setMaxCacheBytes(payload.maxCacheBytes());
+            ClientPolicy.setRenderDistanceBlocks(payload.renderDistanceBlocks());
+        });
+
+        // /videocache remove — drop the URL from this client's disk cache.
+        ClientPlayNetworking.registerGlobalReceiver(DeleteCachePayload.TYPE, (payload, context) -> {
+            VideoCache.purge(payload.url());
+        });
+
+        // /videoCache clear — wipe the entire client cache directory.
+        ClientPlayNetworking.registerGlobalReceiver(ClearCachePayload.TYPE, (payload, context) -> {
+            VideoCache.clearAll();
+        });
     }
 }

src/main/java/com/ejclaw/videoplayer/client/playback/JavaCvBackend.java

@@ -4,6 +4,8 @@ import com.ejclaw.videoplayer.VideoPlayerMod;
 import net.fabricmc.api.EnvType;
 import net.fabricmc.api.Environment;
 
+import org.lwjgl.system.MemoryUtil;
+
 import javax.sound.sampled.AudioFormat;
 import javax.sound.sampled.AudioSystem;
 import javax.sound.sampled.SourceDataLine;
@@ -13,7 +15,7 @@ import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.nio.ShortBuffer;
 import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.atomic.AtomicLong;
 
 /**
  * SPEC §5.3 — fallback mp4/http(s) backend driven by JavaCV's FFmpegFrameGrabber.
@@ -29,21 +31,65 @@ import java.util.concurrent.atomic.AtomicReference;
 public class JavaCvBackend implements VideoBackend {
     private static final String GRABBER_CLASS = "org.bytedeco.javacv.FFmpegFrameGrabber";
     private static final String FRAME_CLASS   = "org.bytedeco.javacv.Frame";
-    private static final String CONVERTER_CLASS = "org.bytedeco.javacv.Java2DFrameConverter";
     /** {@code AV_SAMPLE_FMT_S16} from {@code org.bytedeco.ffmpeg.global.avutil}. */
     private static final int AV_SAMPLE_FMT_S16 = 1;
+    /** {@code AV_PIX_FMT_RGBA} from {@code org.bytedeco.ffmpeg.global.avutil}. */
+    private static final int AV_PIX_FMT_RGBA = 26;
 
     private final Object lock = new Object();
     private Thread worker;
     private final AtomicBoolean running = new AtomicBoolean(false);
     private final AtomicBoolean paused  = new AtomicBoolean(false);
-    private final AtomicReference<ByteBuffer> latest = new AtomicReference<>();
+    /**
+     * Ring buffer of preallocated RGBA staging slots. Decoder thread writes to {@code ringTail}
+     * under {@link #frameLock}; render thread drains the oldest slot via
+     * {@link #consumeFrame(long, long)} under the same lock.
+     *
+     * <p>0.4.10 used a single staging slot and relied on {@link SourceDataLine#write}
+     * backpressure to pace the decoder. That paced only at audio-buffer granularity (~0.5 s):
+     * the decoder burst-produced ~12 video frames into the slot while the audio line drained,
+     * the consumer (60+ Hz polling) saw only the last frame of each burst, then the decoder
+     * stalled until audio drained again — net effect ~2 fps of visible video despite the
+     * decoder producing at the source's 24 fps. The ring absorbs the burst; combined with the
+     * smaller audio buffer (~0.1 s) below the burst collapses to 2–3 frames which fits in
+     * {@link #FRAME_RING_SLOTS}.
+     *
+     * <p>If the ring still fills, the decoder overwrites the oldest slot and increments
+     * {@link #droppedFrames}. Memory cost: {@code 4 × w × h × 4} bytes (32 MB at 1080p,
+     * ~130 MB at 4K).
+     */
+    private static final int FRAME_RING_SLOTS = 4;
+    private final Object frameLock = new Object();
+    private final ByteBuffer[] ringBufs = new ByteBuffer[FRAME_RING_SLOTS];
+    private final int[] ringBytes = new int[FRAME_RING_SLOTS];
+    private int ringHead = 0;  // next slot to consume
+    private int ringTail = 0;  // next slot to produce into
+    private int ringCount = 0;
+
+    /** Decoder telemetry (cumulative). Logged ~every 10 s from the decode thread. */
+    private final AtomicLong producedFrames = new AtomicLong();
+    private final AtomicLong consumedFrames = new AtomicLong();
+    private final AtomicLong droppedFrames  = new AtomicLong();
     private volatile int width = 0;
     private volatile int height = 0;
     private volatile float gain = 1.0F;
     private volatile boolean loop = true;
     private volatile boolean ready = false;
     private volatile boolean closed = false;
+    /**
+     * Held in a field (not just a local) so {@link #close()} can call
+     * {@link SourceDataLine#stop()} / {@link SourceDataLine#flush()} from outside the worker
+     * thread to unblock any in-flight {@link SourceDataLine#write(byte[], int, int)} call.
+     * Without this, deleting an anchor while audio is buffered would leave the worker stuck
+     * in {@code write()} until the in-driver PCM buffer drained naturally, so the deleted
+     * video would keep audible for ~0.5 s after the anchor disappeared.
+     */
+    private volatile SourceDataLine audioLine;
+    /**
+     * Worker-side handle to the grabber. Held so {@link #close()} can yank it from another
+     * thread when {@code grab()} is blocked on a slow HTTP read.
+     */
+    private volatile Object grabberHandle;
 
     @Override
     public void play(String url, boolean loop) {
@@ -73,31 +119,97 @@ public class JavaCvBackend implements VideoBackend {
     public int videoHeight() { return height; }
 
     @Override
-    public ByteBuffer pollFrame() {
-        return latest.getAndSet(null);
+    public boolean consumeFrame(long dstAddr, long maxBytes) {
+        synchronized (frameLock) {
+            if (ringCount <= 0) return false;
+            int idx = ringHead;
+            int n = ringBytes[idx];
+            ByteBuffer buf = ringBufs[idx];
+            // Always advance head regardless of memcpy outcome — otherwise a single oversize
+            // frame (e.g. mid-resize) would jam the ring forever.
+            ringHead = (idx + 1) % FRAME_RING_SLOTS;
+            ringCount--;
+            if (buf == null || n <= 0 || n > maxBytes) {
+                // Texture not yet sized for this frame, or empty slot — skip. ensureTexture()
+                // runs in Entry.tryUpload() before consumeFrame, so n > maxBytes only happens
+                // on the exact tick of a resolution change.
+                return false;
+            }
+            MemoryUtil.memCopy(MemoryUtil.memAddress(buf), dstAddr, n);
+            consumedFrames.incrementAndGet();
+            return true;
+        }
     }
 
     @Override
     public void close() {
         closed = true;
         stopWorker();
+        synchronized (frameLock) {
+            for (int i = 0; i < FRAME_RING_SLOTS; i++) {
+                ringBufs[i] = null;
+                ringBytes[i] = 0;
+            }
+            ringHead = ringTail = ringCount = 0;
+        }
     }
 
     private void stopWorker() {
         running.set(false);
+        // Unblock the audio sink so the worker's line.write() returns immediately instead of
+        // waiting for the in-driver PCM buffer to drain. Without this the audible tail of a
+        // deleted / unloaded anchor outlives the anchor by ~0.5 s.
+        SourceDataLine line = audioLine;
+        if (line != null) {
+            try { line.stop();  } catch (Throwable ignored) {}
+            try { line.flush(); } catch (Throwable ignored) {}
+        }
+        // CRITICAL: we do NOT call grabber.close() from this (caller) thread. The decoder's
+        // per-frame path is:
+        //
+        //     frame = grab(grabber);                  // grabber-owned native memory
+        //     src = frame.image[0];                   // DirectByteBuffer over that memory
+        //     need = src.remaining();                 // (lock-free)
+        //     srcAddr = MemoryUtil.memAddress(src);   // (lock-free)
+        //     synchronized (frameLock) {
+        //         MemoryUtil.memCopy(srcAddr, ...);   // reads from grabber-owned memory
+        //     }
+        //
+        // Even if we held frameLock while closing the grabber, there's a window between
+        // grab() returning and entering the synchronized block where the decoder is holding a
+        // stale srcAddr — closing the grabber there frees the av_frame plane and the next
+        // memcpy crashes inside StubRoutines::jbyte_disjoint_arraycopy (exactly the 4K-delete
+        // crash dump we saw). So the safe rule is: only the decoder thread touches the
+        // grabber. External stop signals `running=false`, stops the audio line, interrupts
+        // the worker, and returns immediately; the worker's own `finally` calls
+        // grabber.close() whenever grab()/start() eventually returns.
+        //
+        // We deliberately do NOT join the worker. close() runs on the client tick thread (via
+        // VideoPlayback.tick → Entry.close), and the worker can spend several seconds inside
+        // the native FFmpeg probe at the top of runLoop — probesize=8 MB and
+        // analyzeduration=2 s do not honor the `running` flag and Thread.interrupt() doesn't
+        // unblock native I/O. A bounded join() there (the old 2 s) is exactly the "place then
+        // immediately delete freezes the game for a moment" symptom: the worker hasn't
+        // entered the grab() loop yet, so flipping running=false has no effect on it until
+        // start() returns. The worker is a daemon, the audio line is already silenced above,
+        // and Entry has been removed from the active map by the caller — nothing observable
+        // depends on the grabber having been closed before this method returns.
         Thread t = worker;
         worker = null;
-        if (t != null) t.interrupt();
+        if (t != null) {
+            t.interrupt();
+        }
         ready = false;
     }
 
     /** Pure-reflection decode loop. Silent fallback if JavaCV isn't present. */
     private void runLoop(String url) {
         Object grabber = null;
-        SourceDataLine audioLine = null;
+        SourceDataLine localAudioLine = null;
         try {
             Class<?> grabberCls = Class.forName(GRABBER_CLASS);
             grabber = grabberCls.getConstructor(String.class).newInstance(url);
+            this.grabberHandle = grabber;
             Method start  = grabberCls.getMethod("start");
             Method stop   = grabberCls.getMethod("stop");
             Method grab   = grabberCls.getMethod("grab");
@@ -107,17 +219,37 @@ public class JavaCvBackend implements VideoBackend {
             Method getAudioChannels = grabberCls.getMethod("getAudioChannels");
             Method setOpt = grabberCls.getMethod("setOption", String.class, String.class);
             Method setSampleFormat  = grabberCls.getMethod("setSampleFormat", int.class);
+            Method setPixelFormat   = grabberCls.getMethod("setPixelFormat", int.class);
 
-            // HTTP(S) tuning for streaming URLs (e.g. webm via Range / chunked transfer).
-            try { setOpt.invoke(grabber, "rw_timeout",         "10000000"); } catch (Throwable ignored) {}
-            try { setOpt.invoke(grabber, "timeout",            "10000000"); } catch (Throwable ignored) {}
-            try { setOpt.invoke(grabber, "reconnect",          "1");        } catch (Throwable ignored) {}
-            try { setOpt.invoke(grabber, "reconnect_streamed", "1");        } catch (Throwable ignored) {}
-            try { setOpt.invoke(grabber, "reconnect_at_eof",   "1");        } catch (Throwable ignored) {}
+            // HTTP(S) tuning for streaming URLs (webm via Range / chunked transfer).
+            // Lower timeouts → close() snaps shut fast when an anchor is deleted mid-stream;
+            // larger buffer/probe options → smoother playback when the upstream throttles.
+            try { setOpt.invoke(grabber, "rw_timeout",          "3000000");   } catch (Throwable ignored) {}
+            try { setOpt.invoke(grabber, "timeout",             "3000000");   } catch (Throwable ignored) {}
+            try { setOpt.invoke(grabber, "reconnect",           "1");         } catch (Throwable ignored) {}
+            try { setOpt.invoke(grabber, "reconnect_streamed",  "1");         } catch (Throwable ignored) {}
+            try { setOpt.invoke(grabber, "reconnect_at_eof",    "1");         } catch (Throwable ignored) {}
+            try { setOpt.invoke(grabber, "reconnect_delay_max", "2");         } catch (Throwable ignored) {}
+            // Bigger network read window so a transient stall doesn't starve the decoder.
+            try { setOpt.invoke(grabber, "buffer_size",         "1048576");   } catch (Throwable ignored) {}
+            try { setOpt.invoke(grabber, "probesize",           "8388608");   } catch (Throwable ignored) {}
+            try { setOpt.invoke(grabber, "analyzeduration",     "2000000");   } catch (Throwable ignored) {}
+            try { setOpt.invoke(grabber, "max_delay",           "500000");    } catch (Throwable ignored) {}
+            try { setOpt.invoke(grabber, "fflags",              "+genpts");   } catch (Throwable ignored) {}
             try { setOpt.invoke(grabber, "user_agent",
                 "video_player/" + com.ejclaw.videoplayer.VideoPlayerMod.MOD_ID); } catch (Throwable ignored) {}
             // Force interleaved signed 16-bit PCM so the audio sink path is single-shape.
             try { setSampleFormat.invoke(grabber, AV_SAMPLE_FMT_S16); } catch (Throwable ignored) {}
+            // Force RGBA output so frame.image[0] is a ByteBuffer we can memcpy straight into
+            // the GPU texture. Without this, frame.image[0] is BGR24 and we'd have to round-trip
+            // through Java2DFrameConverter → BufferedImage.getRGB() → per-pixel ARGB→RGBA loop,
+            // which spends 20-50ms of Java work per 1080p frame and was the dominant stutter
+            // source in 0.4.7/0.4.8: when the decoder fell behind real time, the audio buffer
+            // drained, backpressure vanished, and the decoder burst-fired catch-up frames into
+            // the single-slot AtomicReference (dropping all but the last) before the buffer
+            // refilled and blocked it again. swscale's native SIMD does the same conversion in
+            // <1ms per frame, so the decoder consistently keeps real-time pace.
+            try { setPixelFormat.invoke(grabber, AV_PIX_FMT_RGBA); } catch (Throwable ignored) {}
 
             start.invoke(grabber);
             this.width  = (int) getW.invoke(grabber);
@@ -126,20 +258,48 @@ public class JavaCvBackend implements VideoBackend {
 
             int sampleRate    = safeInt(getSampleRate, grabber);
             int audioChannels = safeInt(getAudioChannels, grabber);
-            audioLine = openLine(sampleRate, audioChannels);
+            localAudioLine = openLine(sampleRate, audioChannels);
+            this.audioLine = localAudioLine;
+
+            // Decoder spec — printed once per playback so the user log shows what the decoder
+            // actually sees (resolution / frame rate / sample rate). Used to verify our pacing
+            // assumptions (e.g. ring depth, audio buffer length) match the source.
+            double srcFrameRate = 0;
+            try { srcFrameRate = ((Number) grabberCls.getMethod("getFrameRate").invoke(grabber)).doubleValue(); }
+            catch (Throwable ignored) {}
+            VideoPlayerMod.LOG.info(
+                "[{}] decoder started: {}x{} @ {} fps, audio {} Hz x{}, ring={} slots",
+                VideoPlayerMod.MOD_ID, width, height,
+                String.format("%.2f", srcFrameRate),
+                sampleRate, audioChannels, FRAME_RING_SLOTS);
 
             Class<?> frameCls    = Class.forName(FRAME_CLASS);
             Field imageField     = frameCls.getField("image");
             Field samplesField   = frameCls.getField("samples");
-            Class<?> convCls     = Class.forName(CONVERTER_CLASS);
-            Object converter     = convCls.getDeclaredConstructor().newInstance();
-            Method toImage       = convCls.getMethod("getBufferedImage", frameCls);
+            // Java2DFrameConverter is no longer used now that we read RGBA bytes directly,
+            // but we still resolve its class so a future code path could fall back to it if a
+            // grabber refuses setPixelFormat. Keep the lookup defensive.
+
+            // Stats sampling: every 10 s of wall-clock we log produced/consumed/dropped deltas
+            // and the implied fps. Lets us tell from the log whether the decoder is keeping
+            // real-time pace (produced≈source fps) and whether the ring is overflowing
+            // (dropped>0). All counters are cumulative; we keep the previous sample to compute
+            // deltas.
+            long statsLastNs = System.nanoTime();
+            long lastProd = 0, lastCons = 0, lastDrop = 0;
 
             while (running.get() && !closed) {
                 if (paused.get()) { Thread.sleep(20); continue; }
-                Object frame = grab.invoke(grabber);
+                Object frame;
+                try {
+                    frame = grab.invoke(grabber);
+                } catch (Throwable t) {
+                    // grabber.close() from another thread races our grab(); treat as a clean exit.
+                    if (!running.get() || closed) break;
+                    throw t;
+                }
                 if (frame == null) {
-                    if (loop) {
+                    if (loop && running.get() && !closed) {
                         try { stop.invoke(grabber); } catch (Throwable ignored) {}
                         try { start.invoke(grabber); } catch (Throwable ignored) {}
                         continue;
@@ -148,23 +308,94 @@ public class JavaCvBackend implements VideoBackend {
                 }
 
                 Object[] samples = (Object[]) samplesField.get(frame);
-                if (samples != null && samples.length > 0 && audioLine != null) {
-                    writeAudio(audioLine, samples, this.gain);
+                if (samples != null && samples.length > 0 && localAudioLine != null) {
+                    writeAudio(localAudioLine, samples, this.gain);
                 }
 
                 Object[] images = (Object[]) imageField.get(frame);
-                if (images != null && images.length > 0) {
-                    java.awt.image.BufferedImage img =
-                        (java.awt.image.BufferedImage) toImage.invoke(converter, frame);
-                    if (img != null) {
-                        ByteBuffer buf = toRgba(img);
-                        if (buf != null) latest.set(buf);
+                if (images != null && images.length > 0 && images[0] instanceof ByteBuffer src) {
+                    // frame.image[0] is the swscale-converted RGBA plane, reused by the grabber
+                    // across grab() calls. Copy into the next ring slot under frameLock so the
+                    // render thread's consumeFrame() sees coherent frames in FIFO order.
+                    //
+                    // Allocation is one-time per slot, lazily on first use (or on a resolution
+                    // upgrade) — never per frame. 0.4.9's per-frame allocateDirect was the
+                    // primary memory-churn problem; 0.4.10 fixed that; 0.4.11 adds the ring on
+                    // top to absorb the burst-then-stall caused by SourceDataLine backpressure
+                    // pacing only at audio-buffer granularity.
+                    int need = src.remaining();
+                    // Reviewer-mandated sanity bounds: memCopy is a raw native copy with no
+                    // fence against overrun. Validate against (a) the source buffer's own
+                    // capacity (so a corrupt plane can't read past it) and (b) the expected
+                    // RGBA frame size (width*height*4) (so an unexpectedly oversized plane
+                    // can't smash the dst slot we'll allocate). If either fails, skip this
+                    // frame and continue — the next grab() will give us a fresh one.
+                    int expected = width * height * 4;
+                    if (need > src.capacity()) {
+                        VideoPlayerMod.LOG.warn("[{}] frame overruns source capacity (need={}, cap={}); skipping",
+                            VideoPlayerMod.MOD_ID, need, src.capacity());
+                        need = 0;
+                    } else if (need > expected) {
+                        VideoPlayerMod.LOG.warn("[{}] frame larger than expected RGBA size (need={}, expected={}); skipping",
+                            VideoPlayerMod.MOD_ID, need, expected);
+                        need = 0;
                     }
+                    if (need > 0) {
+                        int srcPos = src.position();
+                        long srcAddr = MemoryUtil.memAddress(src) + srcPos;
+                        synchronized (frameLock) {
+                            // Recheck shutdown inside the lock: stopWorker() flipped running=false
+                            // before signaling, so worker is the only writer here and grabber.close()
+                            // only runs from this thread's finally — but the explicit check keeps
+                            // the contract obvious to future readers.
+                            if (!running.get() || closed) break;
+                            int idx = ringTail;
+                            if (ringBufs[idx] == null || ringBufs[idx].capacity() < need) {
+                                ringBufs[idx] = ByteBuffer.allocateDirect(need).order(ByteOrder.nativeOrder());
+                            }
+                            long dstAddr = MemoryUtil.memAddress(ringBufs[idx]);
+                            MemoryUtil.memCopy(srcAddr, dstAddr, need);
+                            ringBytes[idx] = need;
+                            ringTail = (idx + 1) % FRAME_RING_SLOTS;
+                            if (ringCount < FRAME_RING_SLOTS) {
+                                ringCount++;
+                            } else {
+                                // Ring was full — we overwrote the oldest frame. Advance head
+                                // to point at the next-oldest so consume order stays FIFO.
+                                ringHead = (ringHead + 1) % FRAME_RING_SLOTS;
+                                droppedFrames.incrementAndGet();
+                            }
+                            producedFrames.incrementAndGet();
+                        }
+                        src.position(srcPos); // restore — JavaCV reads it on subsequent grabs
+                    }
+                }
+
+                // Periodic stats — once per ~10 s of wall-clock. Includes ring depth so we can
+                // see whether the consumer is keeping up.
+                long now = System.nanoTime();
+                if (now - statsLastNs > 10_000_000_000L) {
+                    long prod = producedFrames.get();
+                    long cons = consumedFrames.get();
+                    long drop = droppedFrames.get();
+                    double elapsedS = (now - statsLastNs) / 1e9;
+                    int depth;
+                    synchronized (frameLock) { depth = ringCount; }
+                    VideoPlayerMod.LOG.info(
+                        "[{}] decoder stats: produced={} ({} fps), consumed={} ({} fps), dropped={} (+{}) over {}s, ring={}/{}",
+                        VideoPlayerMod.MOD_ID,
+                        prod, String.format("%.1f", (prod - lastProd) / elapsedS),
+                        cons, String.format("%.1f", (cons - lastCons) / elapsedS),
+                        drop, (drop - lastDrop),
+                        String.format("%.1f", elapsedS),
+                        depth, FRAME_RING_SLOTS);
+                    statsLastNs = now;
+                    lastProd = prod; lastCons = cons; lastDrop = drop;
                 }
 
                 // If we have an open audio line, SourceDataLine.write() blocks for backpressure
                 // and provides natural A/V pacing; otherwise tick ~60fps so we don't busy-loop.
-                if (audioLine == null) Thread.sleep(15);
+                if (localAudioLine == null) Thread.sleep(15);
             }
         } catch (ClassNotFoundException cnf) {
             VideoPlayerMod.LOG.warn(
@@ -177,11 +408,13 @@ public class JavaCvBackend implements VideoBackend {
             VideoPlayerMod.LOG.warn("[{}] JavaCV decode error: {}", VideoPlayerMod.MOD_ID, t.toString());
         } finally {
             ready = false;
-            if (audioLine != null) {
-                try { audioLine.drain(); } catch (Throwable ignored) {}
-                try { audioLine.stop();  } catch (Throwable ignored) {}
-                try { audioLine.close(); } catch (Throwable ignored) {}
+            this.audioLine = null;
+            if (localAudioLine != null) {
+                try { localAudioLine.stop();  } catch (Throwable ignored) {}
+                try { localAudioLine.flush(); } catch (Throwable ignored) {}
+                try { localAudioLine.close(); } catch (Throwable ignored) {}
             }
+            this.grabberHandle = null;
             if (grabber != null) {
                 try { grabber.getClass().getMethod("close").invoke(grabber); } catch (Throwable ignored) {}
             }
@@ -194,7 +427,18 @@ public class JavaCvBackend implements VideoBackend {
         try {
             AudioFormat fmt = new AudioFormat(sampleRate, 16, channels, true, false); // signed 16-bit LE
             SourceDataLine line = AudioSystem.getSourceDataLine(fmt);
-            line.open(fmt);
+            // ~0.1 s of audio buffered in the driver. 0.4.10 used 0.5 s, which let the decoder
+            // burst ~12 video frames between backpressure stalls — way past the video ring's
+            // capacity and the visible cause of the "2-5 fps" stutter the user saw. With 0.1 s
+            // the audio line refills more often, so the decoder is paced more tightly and
+            // bursts collapse to 2-3 frames (well inside FRAME_RING_SLOTS).
+            //
+            // Floor at frameSizeBytes * 256 keeps the buffer above the typical OS / driver
+            // minimum so we don't get UnsupportedOperationException at line.open() on
+            // exotic sample rates.
+            int frameSizeBytes = 2 * channels;
+            int bufferBytes    = Math.max(sampleRate * frameSizeBytes / 10, frameSizeBytes * 256);
+            line.open(fmt, bufferBytes);
             line.start();
             return line;
         } catch (Throwable t) {
@@ -229,24 +473,15 @@ public class JavaCvBackend implements VideoBackend {
                 pcm[idx++] = (byte) ((scaled >> 8) & 0xFF);
             }
         }
-        line.write(pcm, 0, pcm.length);
+        try {
+            line.write(pcm, 0, pcm.length);
+        } catch (Throwable ignored) {
+            // line may have been stop()'d from another thread mid-write — treat as a clean exit.
+        }
     }
 
     private static int safeInt(Method m, Object target) {
         try { return (int) m.invoke(target); } catch (Throwable t) { return 0; }
     }
 
-    private static ByteBuffer toRgba(java.awt.image.BufferedImage img) {
-        int w = img.getWidth(), h = img.getHeight();
-        int[] argb = img.getRGB(0, 0, w, h, null, 0, w);
-        ByteBuffer buf = ByteBuffer.allocateDirect(w * h * 4).order(ByteOrder.nativeOrder());
-        for (int p : argb) {
-            buf.put((byte) ((p >> 16) & 0xFF)); // R
-            buf.put((byte) ((p >>  8) & 0xFF)); // G
-            buf.put((byte) ( p        & 0xFF)); // B
-            buf.put((byte) ((p >> 24) & 0xFF)); // A
-        }
-        buf.flip();
-        return buf;
-    }
 }

src/main/java/com/ejclaw/videoplayer/client/playback/VideoBackend.java

@@ -3,8 +3,6 @@ package com.ejclaw.videoplayer.client.playback;
 import net.fabricmc.api.EnvType;
 import net.fabricmc.api.Environment;
 
-import java.nio.ByteBuffer;
-
 /**
  * SPEC §5.3 — minimal playback backend abstraction. Implementations: WatermediaBackend (preferred,
  * when v2 supports the target MC version) and JavaCvBackend (fallback).
@@ -21,10 +19,19 @@ public interface VideoBackend {
     int videoHeight();
 
     /**
-     * Poll a new decoded RGBA frame if one is ready.
-     * @return the frame buffer (capacity = w*h*4) or {@code null} if no new frame is ready.
+     * If a new RGBA frame is ready, memcpy it directly into the GPU texture buffer at
+     * {@code dstAddr} (must have room for at least {@code w*h*4} bytes) and clear the dirty
+     * flag. Returns {@code true} when a frame was written.
+     *
+     * <p>Replaces the prior {@code pollFrame()} which returned a {@link java.nio.ByteBuffer}.
+     * The old contract forced the decoder to either allocate a fresh direct buffer per frame
+     * (huge memory churn at 1080p — see 0.4.10 changelog) or expose a reused buffer whose
+     * memory the decoder could clobber while the renderer was still reading. Pushing the copy
+     * inside the backend lets the decoder hold a single preallocated buffer under its own
+     * lock and copy out to the GPU pointer in one synchronized block — zero allocation, no
+     * race window.
      */
-    ByteBuffer pollFrame();
+    boolean consumeFrame(long dstAddr, long maxBytes);
 
     void close();
 }

src/main/java/com/ejclaw/videoplayer/client/playback/VideoCache.java

@@ -0,0 +1,533 @@
+package com.ejclaw.videoplayer.client.playback;
+
+import com.ejclaw.videoplayer.VideoPlayerMod;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.minecraft.ChatFormatting;
+import net.minecraft.client.Minecraft;
+import net.minecraft.network.chat.Component;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.HttpURLConnection;
+import java.net.URI;
+import java.net.URLConnection;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.security.MessageDigest;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicLong;
+
+/**
+ * Client-side disk cache for preloaded HTTP video URLs. Driven by the {@code /videopreload}
+ * command (routed to clients via {@code PreloadPayload}). Once a URL is fully downloaded into
+ * {@code <gameDir>/video_player_cache/<sha256>.<ext>}, {@link #lookup(String)} returns its local
+ * path so {@link VideoPlayback} can hand FFmpeg a {@code file://} input that doesn't stall on
+ * network hiccups.
+ *
+ * <p>Concurrency model: {@link #preload(String)} returns immediately and downloads on a daemon
+ * background thread. {@link #lookup(String)} only returns once the download has finished
+ * (atomic rename from {@code .part}), so callers never see a half-written file.
+ */
+@Environment(EnvType.CLIENT)
+public final class VideoCache {
+    private VideoCache() {}
+
+    /** url → local absolute path of the fully-downloaded cache file. */
+    private static final Map<String, Path> READY = new ConcurrentHashMap<>();
+    /** urls whose download is currently queued or in flight. */
+    private static final Set<String> IN_FLIGHT = ConcurrentHashMap.newKeySet();
+    /**
+     * Monotonic cache-generation counter. {@link #clearAll()} bumps this; every download
+     * captures the value at submit time and bails (deletes its {@code .part} without
+     * publishing) if the epoch has moved since. This is the cancellation channel for the
+     * in-flight download — without it, {@code clearAll} only wipes already-finalized files
+     * while the running download keeps writing and re-publishes one entry post-clear.
+     */
+    private static final AtomicLong CACHE_EPOCH = new AtomicLong(0);
+
+    /**
+     * Single-thread executor that serializes all downloads. Cap enforcement (the total
+     * cache size check) needs an authoritative view of the cache directory at the moment a
+     * download starts, so we run one download at a time — that way the directory scan in
+     * {@link #cacheDirSize} reflects every finished download up to this point. Parallel
+     * downloads were racing the cap by each reading the directory before any of them had
+     * renamed their .part to final.
+     */
+    private static final ExecutorService DOWNLOAD_POOL = Executors.newSingleThreadExecutor(r -> {
+        Thread t = new Thread(r, "video_player-preload");
+        t.setDaemon(true);
+        return t;
+    });
+
+    /**
+     * Hard ceiling on a single preload, in bytes. Default 2 GB sized to allow a single 4K
+     * short clip; overridden per-session by {@link com.ejclaw.videoplayer.net.CachePolicyPayload}
+     * on join, which carries the server's {@code max_preload_mb} config value.
+     */
+    private static volatile long MAX_BYTES = 2048L * 1024 * 1024;
+
+    /**
+     * Hard ceiling on the total cache directory size, in bytes. Default 750 MB sized to fit
+     * ~50 short FHD clips; overridden per-session by {@link com.ejclaw.videoplayer.net.CachePolicyPayload}
+     * on join, which carries the server's {@code max_cache_mb} config value. Enforced
+     * cooperatively at the start of each download — running cache + new download must stay
+     * within this cap.
+     */
+    private static volatile long MAX_CACHE_BYTES = 750L * 1024 * 1024;
+
+    /** Server-driven override of the per-video cap. */
+    public static void setMaxBytes(long bytes) {
+        if (bytes < 16L * 1024 * 1024)   bytes = 16L * 1024 * 1024;
+        if (bytes > 16L * 1024 * 1024 * 1024) bytes = 16L * 1024 * 1024 * 1024;
+        MAX_BYTES = bytes;
+        VideoPlayerMod.LOG.info("[{}] per-video preload cap set to {} MB",
+            VideoPlayerMod.MOD_ID, bytes / (1024 * 1024));
+    }
+
+    /** Server-driven override of the total-cache cap. */
+    public static void setMaxCacheBytes(long bytes) {
+        if (bytes < 16L * 1024 * 1024)   bytes = 16L * 1024 * 1024;
+        if (bytes > 64L * 1024 * 1024 * 1024) bytes = 64L * 1024 * 1024 * 1024;
+        MAX_CACHE_BYTES = bytes;
+        VideoPlayerMod.LOG.info("[{}] total-cache cap set to {} MB",
+            VideoPlayerMod.MOD_ID, bytes / (1024 * 1024));
+    }
+
+    /** Server-driven delete of a cached URL. Removes from READY and from disk. */
+    public static void purge(String url) {
+        if (url == null || url.isEmpty()) return;
+        Path p = READY.remove(url);
+        if (p == null) {
+            // Not in this session's index, but the file may still be on disk from a prior run.
+            // Reconstruct the path by hash + extension and try to delete it.
+            try {
+                Path dir = cacheDir();
+                if (dir != null) {
+                    Path guess = dir.resolve(sha256(url) + extensionFromUrl(url));
+                    if (Files.exists(guess)) p = guess;
+                }
+            } catch (Throwable ignored) {}
+        }
+        if (p != null) {
+            try {
+                boolean gone = Files.deleteIfExists(p);
+                VideoPlayerMod.LOG.info("[{}] purge: {} -> deleted={} ({})",
+                    VideoPlayerMod.MOD_ID, url, gone, p.getFileName());
+                if (gone) notifyChat("[videocache] 캐시 삭제: " + url, ChatFormatting.YELLOW);
+            } catch (Throwable t) {
+                VideoPlayerMod.LOG.warn("[{}] purge failed for {}: {}",
+                    VideoPlayerMod.MOD_ID, url, t.toString());
+            }
+        }
+    }
+
+    /**
+     * Wipe the entire cache directory and drop both indexes. Sent in response to
+     * {@code /videoCache clear}.
+     *
+     * <p>Three phases that need to stay in this order:
+     * <ol>
+     *   <li>Bump the epoch first — that flips the cancellation flag for any in-flight
+     *       download. The download thread checks the epoch in the read loop and at the
+     *       move step, so after this point it will refuse to publish a new entry and
+     *       will delete its own {@code .part}.</li>
+     *   <li>Clear the in-memory indexes. (READY clears whatever was already finalized
+     *       pre-clear; IN_FLIGHT is wiped so a subsequent same-URL preload re-enters
+     *       the queue instead of getting deduped by stale state.)</li>
+     *   <li>Best-effort delete every regular file in the cache directory. We do this
+     *       last so that if the in-flight download was momentarily holding a {@code .part}
+     *       open, the listing here also catches its post-close residue (though normally
+     *       phase 1 → the download deletes its own part).</li>
+     * </ol>
+     *
+     * <p>Best-effort per-file deletion; logs failures but doesn't abort on the first one.
+     * On Windows the open {@code .part} may not be deletable here — phase 1's cancellation
+     * + the download's own cleanup-on-bail handles that case.
+     */
+    public static void clearAll() {
+        // Phase 1: signal cancellation to any in-flight download BEFORE wiping disk.
+        CACHE_EPOCH.incrementAndGet();
+
+        // Phase 2: drop indexes.
+        READY.clear();
+        IN_FLIGHT.clear();
+
+        // Phase 3: delete files on disk.
+        int deleted = 0;
+        int failed  = 0;
+        try {
+            Path dir = cacheDir();
+            if (dir != null && Files.isDirectory(dir)) {
+                try (var stream = Files.newDirectoryStream(dir)) {
+                    for (Path p : stream) {
+                        try {
+                            if (Files.isRegularFile(p) && Files.deleteIfExists(p)) deleted++;
+                        } catch (Throwable t) {
+                            failed++;
+                            VideoPlayerMod.LOG.warn("[{}] clearAll: could not delete {}: {}",
+                                VideoPlayerMod.MOD_ID, p.getFileName(), t.toString());
+                        }
+                    }
+                }
+            }
+        } catch (Throwable t) {
+            VideoPlayerMod.LOG.warn("[{}] clearAll failed: {}",
+                VideoPlayerMod.MOD_ID, t.toString());
+        }
+        VideoPlayerMod.LOG.info("[{}] clearAll: deleted={} failed={}",
+            VideoPlayerMod.MOD_ID, deleted, failed);
+        notifyChat("[videocache] 전체 캐시 삭제: " + deleted + "개 파일", ChatFormatting.YELLOW);
+    }
+
+    /** Kick off a background download. No-op if already cached or in flight. */
+    public static void preload(String url) {
+        if (url == null || url.isEmpty()) return;
+        if (!(url.startsWith("http://") || url.startsWith("https://"))) return;
+        // Use lookup() (which also verifies the file exists on disk) instead of
+        // READY.containsKey — defends against READY containing a stale entry whose
+        // backing file was removed by clearAll() / a user-side file delete. Without this,
+        // a stale key would silently block a re-preload.
+        if (lookup(url) != null) {
+            VideoPlayerMod.LOG.info("[{}] preload: already cached {}", VideoPlayerMod.MOD_ID, url);
+            notifyChat("[videopreload] 이미 캐시됨: " + url, ChatFormatting.GRAY);
+            return;
+        }
+        if (!IN_FLIGHT.add(url)) {
+            VideoPlayerMod.LOG.info("[{}] preload: already downloading {}", VideoPlayerMod.MOD_ID, url);
+            notifyChat("[videopreload] 이미 다운로드 중: " + url, ChatFormatting.GRAY);
+            return;
+        }
+        notifyChat("[videopreload] 다운로드 대기열 추가: " + url, ChatFormatting.YELLOW);
+        // Capture the current epoch at submit time. The download thread checks against
+        // CACHE_EPOCH later — any mismatch means clearAll() ran in between and this
+        // download must abort without publishing.
+        long epoch = CACHE_EPOCH.get();
+        DOWNLOAD_POOL.submit(() -> download(url, epoch));
+    }
+
+    /** Return the local cached file path for this URL, or {@code null} if not yet ready. */
+    public static Path lookup(String url) {
+        if (url == null) return null;
+        Path p = READY.get(url);
+        if (p != null && Files.exists(p)) return p;
+        return null;
+    }
+
+    /** Drop the in-memory index (does not delete files). Called on disconnect. */
+    public static void clearIndex() {
+        READY.clear();
+        IN_FLIGHT.clear();
+    }
+
+    /**
+     * Wipe the cache directory at game shutdown so the user doesn't accumulate disk usage
+     * across sessions. Distinct from {@link #clearAll()}: at shutdown there are no concurrent
+     * downloads to race and no player to chat-notify, so we skip the chat ping but still bump
+     * the epoch (defensive — any straggler write inside the in-flight {@code .part} stream
+     * will detect the bump and self-clean) and drop indexes.
+     */
+    public static void wipeOnShutdown() {
+        CACHE_EPOCH.incrementAndGet();
+        READY.clear();
+        IN_FLIGHT.clear();
+        int deleted = 0;
+        int failed  = 0;
+        try {
+            Path dir = cacheDir();
+            if (dir != null && Files.isDirectory(dir)) {
+                try (var stream = Files.newDirectoryStream(dir)) {
+                    for (Path p : stream) {
+                        try {
+                            if (Files.isRegularFile(p) && Files.deleteIfExists(p)) deleted++;
+                        } catch (Throwable t) {
+                            failed++;
+                        }
+                    }
+                }
+            }
+        } catch (Throwable t) {
+            VideoPlayerMod.LOG.warn("[{}] wipeOnShutdown failed: {}",
+                VideoPlayerMod.MOD_ID, t.toString());
+        }
+        VideoPlayerMod.LOG.info("[{}] wipeOnShutdown: deleted={} failed={}",
+            VideoPlayerMod.MOD_ID, deleted, failed);
+    }
+
+    /** Caller-supplied: current set of URLs that are fully cached, for diagnostics. */
+    public static Set<String> readyUrls() {
+        return new HashSet<>(READY.keySet());
+    }
+
+    // -- internals -----------------------------------------------------------------------
+
+    /**
+     * Publish {@code path} into {@link #READY} for {@code url}, but only if the cache
+     * epoch hasn't moved since {@code startEpoch} was captured. Wraps the
+     * pre-check / put / post-check / rollback dance so every publish site uses the
+     * same race-free pattern instead of re-implementing it.
+     *
+     * <p>Race coverage: if {@link #clearAll()} runs at any point between the
+     * pre-check and the post-check, the post-check sees the epoch bump and we
+     * roll back — {@link Map#remove(Object, Object)} is a compareAndRemove so we
+     * don't clobber a legitimate concurrent put under the same key, and we delete
+     * the on-disk file because clearAll's directory scan may have missed it (the
+     * file may not have existed yet when clearAll ran).
+     *
+     * @return {@code true} if the entry is now published; {@code false} if the
+     *         caller's work was cancelled and {@code path} has been cleaned up.
+     */
+    private static boolean publishIfNotCancelled(String url, Path path, long startEpoch) {
+        // If the wipe ran between download's pre-move epoch check and Files.move, its
+        // directory scan won't have seen this just-promoted file. We must delete it here,
+        // not just bail — otherwise the freshly-moved final file leaks across shutdown.
+        if (CACHE_EPOCH.get() != startEpoch) {
+            try { Files.deleteIfExists(path); } catch (Throwable ignored) {}
+            return false;
+        }
+        READY.put(url, path);
+        if (CACHE_EPOCH.get() != startEpoch) {
+            READY.remove(url, path);
+            try { Files.deleteIfExists(path); } catch (Throwable ignored) {}
+            return false;
+        }
+        return true;
+    }
+
+    private static void download(String url, long startEpoch) {
+        Path cacheDir = cacheDir();
+        Path partPath = null;
+        try {
+            if (cacheDir == null) {
+                VideoPlayerMod.LOG.warn("[{}] preload: no game dir, skipping {}",
+                    VideoPlayerMod.MOD_ID, url);
+                return;
+            }
+            // Pre-flight cancellation check — if clearAll already ran between submit and now,
+            // skip the whole thing. Avoids creating directories / .part files post-clear.
+            if (CACHE_EPOCH.get() != startEpoch) {
+                VideoPlayerMod.LOG.info("[{}] preload: cancelled before start (clearAll ran) — {}",
+                    VideoPlayerMod.MOD_ID, url);
+                return;
+            }
+            Files.createDirectories(cacheDir);
+
+            String hash = sha256(url);
+            String ext  = extensionFromUrl(url);
+            Path finalPath = cacheDir.resolve(hash + ext);
+            partPath  = cacheDir.resolve(hash + ext + ".part");
+
+            // Resume-friendly: if the file's already on disk from an earlier session, just
+            // index it without re-downloading.
+            if (Files.exists(finalPath) && Files.size(finalPath) > 0) {
+                if (!publishIfNotCancelled(url, finalPath, startEpoch)) {
+                    VideoPlayerMod.LOG.info("[{}] preload: reindex cancelled (clearAll ran) — {}",
+                        VideoPlayerMod.MOD_ID, url);
+                    return;
+                }
+                VideoPlayerMod.LOG.info("[{}] preload: indexed existing cache {} -> {}",
+                    VideoPlayerMod.MOD_ID, url, finalPath.getFileName());
+                notifyChat("[videopreload] 기존 캐시 사용: " + url, ChatFormatting.GREEN);
+                return;
+            }
+
+            // Total-cache check: refuse to start if the cache directory is already at the cap.
+            // We re-check during the read loop too, since other downloads may be in flight in
+            // parallel. {@code existingCacheBytes} excludes our own .part (which we just wrote 0
+            // bytes to / haven't created yet).
+            long existingCacheBytes = cacheDirSize(cacheDir, partPath);
+            if (existingCacheBytes >= MAX_CACHE_BYTES) {
+                long capMb = MAX_CACHE_BYTES / (1024 * 1024);
+                long usedMb = existingCacheBytes / (1024 * 1024);
+                VideoPlayerMod.LOG.warn(
+                    "[{}] preload: total-cache cap reached ({}/{} MB); aborting {}",
+                    VideoPlayerMod.MOD_ID, usedMb, capMb, url);
+                notifyChat("[videopreload] 실패 (전체 캐시 " + capMb + "MB 초과 / 현재 "
+                    + usedMb + "MB): " + url, ChatFormatting.RED);
+                return;
+            }
+
+            URLConnection raw = URI.create(url).toURL().openConnection();
+            raw.setConnectTimeout(10_000);
+            raw.setReadTimeout(30_000);
+            raw.setRequestProperty("User-Agent", "video_player/" + VideoPlayerMod.MOD_ID);
+            if (raw instanceof HttpURLConnection http) {
+                http.setInstanceFollowRedirects(true);
+                int code = http.getResponseCode();
+                if (code >= 400) {
+                    VideoPlayerMod.LOG.warn("[{}] preload: HTTP {} for {}",
+                        VideoPlayerMod.MOD_ID, code, url);
+                    notifyChat("[videopreload] 실패 (HTTP " + code + "): " + url, ChatFormatting.RED);
+                    return;
+                }
+            }
+
+            long total = 0;
+            boolean cancelled = false;
+            try (InputStream in = raw.getInputStream();
+                 OutputStream out = Files.newOutputStream(partPath)) {
+                byte[] buf = new byte[64 * 1024];
+                int n;
+                while ((n = in.read(buf)) >= 0) {
+                    // Cancellation check inside the loop. Break (not return) so the try-with
+                    // closes the output stream first — on Windows, deleting an open .part can
+                    // fail with AccessDeniedException, so we always close before deleting.
+                    if (CACHE_EPOCH.get() != startEpoch) {
+                        cancelled = true;
+                        break;
+                    }
+                    total += n;
+                    if (total > MAX_BYTES) {
+                        long capMb = MAX_BYTES / (1024 * 1024);
+                        VideoPlayerMod.LOG.warn(
+                            "[{}] preload: {} exceeded per-video {} MB cap; aborting",
+                            VideoPlayerMod.MOD_ID, url, capMb);
+                        // Same close-before-delete dance for Windows.
+                        cancelled = true;
+                        notifyChat("[videopreload] 실패 (단일 영상 " + capMb + "MB 초과): " + url,
+                            ChatFormatting.RED);
+                        break;
+                    }
+                    if (existingCacheBytes + total > MAX_CACHE_BYTES) {
+                        long capMb = MAX_CACHE_BYTES / (1024 * 1024);
+                        long usedMb = (existingCacheBytes + total) / (1024 * 1024);
+                        VideoPlayerMod.LOG.warn(
+                            "[{}] preload: total-cache cap exceeded ({}>{} MB); aborting {}",
+                            VideoPlayerMod.MOD_ID, usedMb, capMb, url);
+                        cancelled = true;
+                        notifyChat("[videopreload] 실패 (전체 캐시 " + capMb + "MB 초과): " + url,
+                            ChatFormatting.RED);
+                        break;
+                    }
+                    out.write(buf, 0, n);
+                }
+            }
+            // Now the .part file is closed — safe to delete on Windows.
+            if (cancelled) {
+                try { Files.deleteIfExists(partPath); } catch (Throwable ignored) {}
+                return;
+            }
+
+            // Pre-move cancellation check. If clearAll ran during the read loop, abort
+            // before promoting .part to final — saves a wasted move + delete.
+            if (CACHE_EPOCH.get() != startEpoch) {
+                VideoPlayerMod.LOG.info("[{}] preload: cancelled before move (clearAll ran) — {}",
+                    VideoPlayerMod.MOD_ID, url);
+                try { Files.deleteIfExists(partPath); } catch (Throwable ignored) {}
+                return;
+            }
+
+            Files.move(partPath, finalPath, StandardCopyOption.REPLACE_EXISTING,
+                StandardCopyOption.ATOMIC_MOVE);
+
+            // Race-safe publish: this covers the window between Files.move and READY.put
+            // (clearAll deletes the freshly-moved file then we resurrect it in READY) AND
+            // the window between READY.put and the "완료" notification (clearAll wipes
+            // READY then we re-publish + emit stale completion chat). publishIfNotCancelled
+            // rolls back both READY and the on-disk file if the epoch moved at any time.
+            if (!publishIfNotCancelled(url, finalPath, startEpoch)) {
+                VideoPlayerMod.LOG.info("[{}] preload: cancelled at publish (clearAll ran) — {}",
+                    VideoPlayerMod.MOD_ID, url);
+                return;
+            }
+            VideoPlayerMod.LOG.info("[{}] preload: cached {} ({} bytes) -> {}",
+                VideoPlayerMod.MOD_ID, url, total, finalPath.getFileName());
+            long mb = Math.max(1, total / (1024 * 1024));
+            notifyChat("[videopreload] 완료 (" + mb + " MB): " + url, ChatFormatting.GREEN);
+        } catch (Throwable t) {
+            VideoPlayerMod.LOG.warn("[{}] preload failed for {}: {}",
+                VideoPlayerMod.MOD_ID, url, t.toString());
+            notifyChat("[videopreload] 실패 (" + t.getClass().getSimpleName() + "): " + url,
+                ChatFormatting.RED);
+            // Best-effort cleanup of any leftover .part on the error path.
+            if (partPath != null) {
+                try { Files.deleteIfExists(partPath); } catch (Throwable ignored) {}
+            }
+        } finally {
+            IN_FLIGHT.remove(url);
+        }
+    }
+
+    /** Post a status line to the local player's chat. No-op if there's no client/player yet. */
+    private static void notifyChat(String text, ChatFormatting color) {
+        Minecraft mc = Minecraft.getInstance();
+        if (mc == null) return;
+        mc.execute(() -> {
+            if (mc.player == null) return;
+            mc.player.sendSystemMessage(Component.literal(text).withStyle(color));
+        });
+    }
+
+    /**
+     * Sum of regular-file sizes under {@code dir}, skipping {@code excludePart} (the .part file
+     * for the in-flight download — we account for that via the running {@code total} counter).
+     * Best-effort: errors collapse to 0 so a transient FS hiccup doesn't strand a download.
+     */
+    private static long cacheDirSize(Path dir, Path excludePart) {
+        if (dir == null) return 0L;
+        try {
+            if (!Files.isDirectory(dir)) return 0L;
+            final long[] sum = { 0L };
+            try (var stream = Files.newDirectoryStream(dir)) {
+                for (Path p : stream) {
+                    if (excludePart != null && p.equals(excludePart)) continue;
+                    try {
+                        if (Files.isRegularFile(p)) sum[0] += Files.size(p);
+                    } catch (Throwable ignored) {}
+                }
+            }
+            return sum[0];
+        } catch (Throwable t) {
+            VideoPlayerMod.LOG.warn("[{}] cacheDirSize failed: {}",
+                VideoPlayerMod.MOD_ID, t.toString());
+            return 0L;
+        }
+    }
+
+    private static Path cacheDir() {
+        Minecraft mc = Minecraft.getInstance();
+        if (mc == null || mc.gameDirectory == null) return null;
+        return mc.gameDirectory.toPath().resolve("video_player_cache");
+    }
+
+    /** SHA-256 of the URL, hex. */
+    private static String sha256(String s) {
+        try {
+            MessageDigest md = MessageDigest.getInstance("SHA-256");
+            byte[] dig = md.digest(s.getBytes(java.nio.charset.StandardCharsets.UTF_8));
+            StringBuilder sb = new StringBuilder(64);
+            for (byte b : dig) sb.append(String.format("%02x", b));
+            return sb.toString();
+        } catch (Throwable t) {
+            // Fallback: tag with identity hash. Still unique within a session.
+            return "h" + Integer.toHexString(s.hashCode());
+        }
+    }
+
+    /**
+     * Best-effort filename extension from the URL path so FFmpeg's container probe gets a hint
+     * (e.g. {@code .webm} for a webm stream). Falls back to {@code .bin}.
+     */
+    private static String extensionFromUrl(String url) {
+        try {
+            String path = URI.create(url).getPath();
+            if (path == null) return ".bin";
+            int slash = path.lastIndexOf('/');
+            String tail = slash < 0 ? path : path.substring(slash + 1);
+            int dot = tail.lastIndexOf('.');
+            if (dot <= 0 || dot == tail.length() - 1) return ".bin";
+            String ext = tail.substring(dot).toLowerCase();
+            // Sanity-clamp: only allow short, safe extensions.
+            if (ext.length() > 8 || !ext.matches("\\.[a-z0-9]+")) return ".bin";
+            return ext;
+        } catch (Throwable t) {
+            return ".bin";
+        }
+    }
+}

src/main/java/com/ejclaw/videoplayer/client/playback/VideoPlayback.java

@@ -10,7 +10,7 @@ import net.minecraft.client.renderer.texture.DynamicTexture;
 import net.minecraft.core.BlockPos;
 import net.minecraft.resources.Identifier;
 
-import java.nio.ByteBuffer;
+import java.nio.file.Path;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
@@ -58,7 +58,12 @@ public final class VideoPlayback {
         }
 
         VideoBackend backend = WatermediaProbe.isAvailable() ? new WatermediaBackend() : new JavaCvBackend();
-        backend.play(be.getUrl(), be.isLoop());
+        // If /videopreload already cached the URL to disk, hand the local file path to FFmpeg
+        // instead of the HTTP URL — eliminates the network read entirely. Falls back to the
+        // live URL when the cache miss or the download hasn't finished yet.
+        Path cached = VideoCache.lookup(be.getUrl());
+        String source = cached != null ? cached.toAbsolutePath().toString() : be.getUrl();
+        backend.play(source, be.isLoop());
         backend.setVolume(be.isMuted() ? 0F : be.getVolume());
 
         Entry created = new Entry(be.getUrl(), backend);
@@ -89,16 +94,25 @@ public final class VideoPlayback {
 
     /** Called every client tick to upload new frames into the GPU texture. */
     public static void tick() {
-        if (Minecraft.getInstance() == null) return;
+        Minecraft mc = Minecraft.getInstance();
+        if (mc == null) return;
         Iterator<Map.Entry<BlockPos, Entry>> it = ENTRIES.entrySet().iterator();
         while (it.hasNext()) {
             Map.Entry<BlockPos, Entry> me = it.next();
+            BlockPos pos = me.getKey();
             Entry e = me.getValue();
+            // Belt-and-suspenders for the audio-on-delete bug: if BLOCK_ENTITY_UNLOAD didn't
+            // fire for some edge case (dimension change, chunk torn down before event runs,
+            // etc.), the BE will be gone from the level but our Entry still holds an open
+            // audio line. Catch it here and stop next tick.
+            if (mc.level == null || !(mc.level.getBlockEntity(pos) instanceof VideoAnchorBlockEntity)) {
+                e.close();
+                it.remove();
+                continue;
+            }
             if (!e.backend.isReady()) continue;
-            ByteBuffer buf = e.backend.pollFrame();
-            if (buf == null) continue;
             try {
-                e.upload(buf);
+                e.tryUpload();
             } catch (Throwable t) {
                 VideoPlayerMod.LOG.warn("[{}] texture upload failed: {}", VideoPlayerMod.MOD_ID, t.toString());
                 e.close();
@@ -170,34 +184,45 @@ public final class VideoPlayback {
             }
         }
 
-        /** Copy an incoming RGBA byte buffer into the texture, resizing if dimensions changed. */
-        void upload(ByteBuffer rgba) {
+        /**
+         * If the backend has a new RGBA frame, copy it straight into the texture's native
+         * pixel buffer and re-upload to GPU. The backend does the memcpy under its own lock
+         * so we never read a half-written frame. RGBA bytes already match NativeImage's
+         * ABGR-int layout in little-endian byte order (byte 0 = R = low byte of the int).
+         */
+        void tryUpload() {
             int w = backend.videoWidth();
             int h = backend.videoHeight();
             if (w <= 0 || h <= 0) return;
             ensureTexture(w, h, false);
             NativeImage img = texture.getPixels();
             if (img == null) return;
-
-            int pixels = w * h;
-            for (int i = 0; i < pixels; i++) {
-                int r = rgba.get() & 0xFF;
-                int g = rgba.get() & 0xFF;
-                int b = rgba.get() & 0xFF;
-                int a = rgba.get() & 0xFF;
-                int abgr = (a << 24) | (b << 16) | (g << 8) | r;
-                img.setPixelABGR(i % w, i / w, abgr);
+            long maxBytes = (long) w * h * 4L;
+            if (backend.consumeFrame(img.getPointer(), maxBytes)) {
+                texture.upload();
             }
-            texture.upload();
         }
 
         void close() {
             try { backend.close(); } catch (Throwable ignored) {}
+            // Unregister from TextureManager BEFORE closing the texture itself, so any
+            // straggler binding by Identifier looks up "no such texture" instead of a closed
+            // GL handle (which crashes the renderer on the next frame). Renderer pipelines
+            // can cache RenderType objects keyed by Identifier across frames, and on delete
+            // the old anchor's frame can still be in flight in the submit buffer when its
+            // texture closes — without this release(), the bind would dereference a freed
+            // GL handle.
+            if (registered) {
+                Minecraft mc = Minecraft.getInstance();
+                if (mc != null) {
+                    try { mc.getTextureManager().release(id); } catch (Throwable ignored) {}
+                }
+                registered = false;
+            }
             if (texture != null) {
                 try { texture.close(); } catch (Throwable ignored) {}
                 texture = null;
             }
-            // texture manager keeps the registration; the texture itself is closed.
         }
     }
 }

src/main/java/com/ejclaw/videoplayer/client/playback/WatermediaBackend.java

@@ -4,8 +4,6 @@ import com.ejclaw.videoplayer.VideoPlayerMod;
 import net.fabricmc.api.EnvType;
 import net.fabricmc.api.Environment;
 
-import java.nio.ByteBuffer;
-
 /**
  * SPEC §5.3 / §5.4 — WaterMedia v2 backend. Reflection-only so the mod jar stays clean of
  * compile-time WaterMedia dependencies. Until a v2 build supports 1.21.6+ this returns
@@ -38,8 +36,8 @@ public class WatermediaBackend implements VideoBackend {
     @Override public int videoHeight() { return height; }
 
     @Override
-    public ByteBuffer pollFrame() {
-        return null; // no frames until v2 is wired up
+    public boolean consumeFrame(long dstAddr, long maxBytes) {
+        return false; // no frames until v2 is wired up
     }
 
     @Override

src/main/java/com/ejclaw/videoplayer/client/render/VideoAnchorRenderer.java

@@ -1,6 +1,7 @@
 package com.ejclaw.videoplayer.client.render;
 
 import com.ejclaw.videoplayer.block.VideoAnchorBlockEntity;
+import com.ejclaw.videoplayer.client.ClientPolicy;
 import com.ejclaw.videoplayer.client.playback.VideoPlayback;
 import com.mojang.blaze3d.vertex.PoseStack;
 import com.mojang.math.Axis;
@@ -30,8 +31,19 @@ import org.joml.Matrix4f;
 @Environment(EnvType.CLIENT)
 public class VideoAnchorRenderer implements BlockEntityRenderer<VideoAnchorBlockEntity, VideoAnchorRenderer.State> {
 
-    /** Tiny outward offset so the quad doesn't z-fight with the wall. */
-    private static final float SURFACE_EPSILON = 0.001F;
+    /**
+     * Outward offset so the quad doesn't z-fight with the wall it sits on.
+     *
+     * <p>Depth-buffer precision drops with the square of view distance: with near=0.05 and
+     * 24-bit depth, the smallest resolvable step at 30 blocks is ~1mm, and ~12mm at 100
+     * blocks. The old 0.001 (1mm) offset was right at the precision boundary at ~30 blocks
+     * — which is exactly the distance users started seeing the wall texture flicker through
+     * the video panel once {@code render_distance_blocks} was raised past the default.
+     *
+     * <p>2cm gives ~20× margin at 30 blocks and is still visually unnoticeable up close
+     * (~3% of a block thickness).
+     */
+    private static final float SURFACE_EPSILON = 0.02F;
 
     public VideoAnchorRenderer(BlockEntityRendererProvider.Context ctx) {
         // no-op
@@ -74,18 +86,21 @@ public class VideoAnchorRenderer implements BlockEntityRenderer<VideoAnchorBlock
         pose.translate(-0.5F, -0.5F, -0.5F + SURFACE_EPSILON);
 
         final Matrix4f mat = new Matrix4f(pose.last().pose());
-        RenderType rt = RenderTypes.entityCutout(tex);
+        // entitySolid (not entityCutout): video frames come from swscale → AV_PIX_FMT_RGBA with
+        // alpha hard-set to 255, so there is no alpha-tested cutout. Cutout's alpha-discard step
+        // adds nothing here and makes distant sampling unstable — without mipmaps on a dynamic
+        // texture, neighbouring texels can shimmer above/below the discard threshold at sub-pixel
+        // sampling rates, contributing to the flicker users see once render distance is raised.
+        RenderType rt = RenderTypes.entitySolid(tex);
         collector.submitCustomGeometry(pose, rt, (poseUnused, vc) -> {
-            // Front face (visible from outside, looking back at the wall)
+            // Single-sided: the back of the anchor is by design pressed against the wall the
+            // player clicked, so a back face is pure GPU waste. Halves the fragment shader work
+            // per anchor and removes the mirrored-texture artifact a player would see if they
+            // somehow clipped behind the wall.
             emit(vc, mat, 0F, 0F, 0F, 0F, 1F, light);
             emit(vc, mat, w,  0F, 0F, 1F, 1F, light);
             emit(vc, mat, w,  h,  0F, 1F, 0F, light);
             emit(vc, mat, 0F, h,  0F, 0F, 0F, light);
-            // Back face (in case the player ends up on the other side, e.g. clipping into the wall)
-            emit(vc, mat, 0F, h,  0F, 0F, 0F, light);
-            emit(vc, mat, w,  h,  0F, 1F, 0F, light);
-            emit(vc, mat, w,  0F, 0F, 1F, 1F, light);
-            emit(vc, mat, 0F, 0F, 0F, 0F, 1F, light);
         });
 
         pose.popPose();
@@ -126,7 +141,9 @@ public class VideoAnchorRenderer implements BlockEntityRenderer<VideoAnchorBlock
 
     @Override
     public int getViewDistance() {
-        return 128;
+        // Driven by server config (video_player.json:render_distance_blocks), pushed to clients
+        // on join. Default 128 = legacy behavior, so an unpaired client behaves identically.
+        return ClientPolicy.renderDistanceBlocks();
     }
 
     /** Per-frame render data extracted from the BE. */

src/main/java/com/ejclaw/videoplayer/command/VideoCacheCommand.java

@@ -0,0 +1,174 @@
+package com.ejclaw.videoplayer.command;
+
+import com.ejclaw.videoplayer.VideoPlayerConfig;
+import com.ejclaw.videoplayer.net.ClearCachePayload;
+import com.ejclaw.videoplayer.net.DeleteCachePayload;
+import com.ejclaw.videoplayer.net.PreloadPayload;
+import com.mojang.brigadier.CommandDispatcher;
+import com.mojang.brigadier.arguments.StringArgumentType;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.context.CommandContext;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import net.fabricmc.fabric.api.networking.v1.PlayerLookup;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
+import net.minecraft.ChatFormatting;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.commands.Commands;
+import net.minecraft.network.chat.ClickEvent;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.MutableComponent;
+import net.minecraft.network.chat.Style;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.permissions.Permissions;
+
+import java.net.URI;
+import java.util.Map;
+
+/**
+ * {@code /videocache add <name> <url>} — name a URL, store it in server config, and broadcast a
+ * preload request to every client.
+ * <br>{@code /videocache list} — print the named index with clickable URLs.
+ * <br>{@code /videocache remove <name>} — drop the entry from server config and tell every client
+ * to delete the matching cache file.
+ *
+ * <p>Replaces the old {@code /videopreload}. Same permission gate
+ * ({@link Permissions#COMMANDS_GAMEMASTER}) so command blocks can drive it.
+ */
+public final class VideoCacheCommand {
+    private VideoCacheCommand() {}
+
+    public static void register(CommandDispatcher<CommandSourceStack> dispatcher) {
+        dispatcher.register(build("videoCache"));
+    }
+
+    private static LiteralArgumentBuilder<CommandSourceStack> build(String root) {
+        return Commands.literal(root)
+            .requires(s -> s.permissions().hasPermission(Permissions.COMMANDS_GAMEMASTER))
+            .then(Commands.literal("add")
+                .then(Commands.argument("name", StringArgumentType.word())
+                    .then(Commands.argument("url", StringArgumentType.greedyString())
+                        .executes(VideoCacheCommand::runAdd))))
+            .then(Commands.literal("list")
+                .executes(VideoCacheCommand::runList))
+            .then(Commands.literal("remove")
+                .then(Commands.argument("name", StringArgumentType.word())
+                    .executes(VideoCacheCommand::runRemove)))
+            .then(Commands.literal("clear")
+                .executes(VideoCacheCommand::runClear));
+    }
+
+    private static int runAdd(CommandContext<CommandSourceStack> ctx) throws CommandSyntaxException {
+        CommandSourceStack src = ctx.getSource();
+        String name = StringArgumentType.getString(ctx, "name").trim();
+        String url  = StringArgumentType.getString(ctx, "url").trim();
+
+        if (name.isEmpty() || name.length() > 64) {
+            src.sendFailure(Component.literal("이름은 1~64자여야 합니다"));
+            return 0;
+        }
+        if (url.isEmpty() || !(url.startsWith("http://") || url.startsWith("https://"))) {
+            src.sendFailure(Component.literal("url 은 http:// 또는 https:// 로 시작해야 합니다"));
+            return 0;
+        }
+        if (url.length() > 256) {
+            src.sendFailure(Component.literal("url 이 너무 깁니다 (최대 256자)"));
+            return 0;
+        }
+        if (VideoPlayerConfig.cacheUrl(name) != null) {
+            src.sendFailure(Component.literal("이미 사용 중인 이름입니다: " + name));
+            return 0;
+        }
+        if (!VideoPlayerConfig.addCacheEntry(name, url)) {
+            src.sendFailure(Component.literal("저장 실패: 이름 중복 또는 IO 오류"));
+            return 0;
+        }
+
+        MinecraftServer server = src.getServer();
+        PreloadPayload payload = new PreloadPayload(url);
+        int sent = 0;
+        for (ServerPlayer p : PlayerLookup.all(server)) {
+            ServerPlayNetworking.send(p, payload);
+            sent++;
+        }
+        final int sentFinal = sent;
+        src.sendSuccess(() -> Component.literal(
+            "[videocache] 추가됨: " + name + " → " + url
+                + "  (" + sentFinal + " 클라이언트에 preload 전송)"), false);
+        return 1;
+    }
+
+    private static int runList(CommandContext<CommandSourceStack> ctx) {
+        CommandSourceStack src = ctx.getSource();
+        Map<String, String> entries = VideoPlayerConfig.cacheEntries();
+        if (entries.isEmpty()) {
+            src.sendSuccess(() -> Component.literal("[videocache] 저장된 항목이 없습니다")
+                .withStyle(ChatFormatting.GRAY), false);
+            return 0;
+        }
+        src.sendSuccess(() -> Component.literal("[videocache] 저장된 항목 " + entries.size() + "개:")
+            .withStyle(ChatFormatting.YELLOW), false);
+        for (Map.Entry<String, String> e : entries.entrySet()) {
+            String url = e.getValue();
+            ClickEvent click;
+            try {
+                click = new ClickEvent.OpenUrl(URI.create(url));
+            } catch (Throwable t) {
+                click = null; // bad URI — show without click action rather than failing the whole list
+            }
+            Style urlStyle = Style.EMPTY.withColor(ChatFormatting.AQUA).withUnderlined(true);
+            if (click != null) urlStyle = urlStyle.withClickEvent(click);
+            MutableComponent line = Component.literal(" • " + e.getKey() + " : ")
+                .withStyle(ChatFormatting.WHITE)
+                .append(Component.literal(url).withStyle(urlStyle));
+            src.sendSuccess(() -> line, false);
+        }
+        return entries.size();
+    }
+
+    private static int runClear(CommandContext<CommandSourceStack> ctx) {
+        CommandSourceStack src = ctx.getSource();
+        // Drop server-side named entries (preload_urls is left alone — it's an admin-edited
+        // list, not something /videoCache manages).
+        java.util.List<String> urls = VideoPlayerConfig.clearCacheEntries();
+
+        // Always broadcast a full-cache wipe to every client, even if the named index was
+        // empty — leftover files from prior sessions, legacy preload_urls downloads, and
+        // any in-flight stragglers all get scrubbed in one shot.
+        MinecraftServer server = src.getServer();
+        ClearCachePayload payload = new ClearCachePayload();
+        int clients = 0;
+        for (ServerPlayer p : PlayerLookup.all(server)) {
+            ServerPlayNetworking.send(p, payload);
+            clients++;
+        }
+        final int sentFinal = clients;
+        final int countFinal = urls.size();
+        src.sendSuccess(() -> Component.literal(
+            "[videocache] 전체 삭제: 등록 항목 " + countFinal + "개 제거"
+                + " + " + sentFinal + " 클라이언트 디스크 캐시 전체 wipe"), false);
+        return Math.max(countFinal, 1);
+    }
+
+    private static int runRemove(CommandContext<CommandSourceStack> ctx) throws CommandSyntaxException {
+        CommandSourceStack src = ctx.getSource();
+        String name = StringArgumentType.getString(ctx, "name").trim();
+        String url = VideoPlayerConfig.removeCacheEntry(name);
+        if (url == null) {
+            src.sendFailure(Component.literal("해당 이름의 항목이 없습니다: " + name));
+            return 0;
+        }
+        MinecraftServer server = src.getServer();
+        DeleteCachePayload payload = new DeleteCachePayload(url);
+        int sent = 0;
+        for (ServerPlayer p : PlayerLookup.all(server)) {
+            ServerPlayNetworking.send(p, payload);
+            sent++;
+        }
+        final int sentFinal = sent;
+        src.sendSuccess(() -> Component.literal(
+            "[videocache] 삭제됨: " + name + " → " + url
+                + "  (" + sentFinal + " 클라이언트에 cache_delete 전송)"), false);
+        return 1;
+    }
+}

src/main/java/com/ejclaw/videoplayer/command/VideoDeleteCommand.java

@@ -19,7 +19,6 @@ public final class VideoDeleteCommand {
 
     public static void register(CommandDispatcher<CommandSourceStack> dispatcher) {
         dispatcher.register(build("videoDelete"));
-        dispatcher.register(build("videodelete"));
     }
 
     private static com.mojang.brigadier.builder.LiteralArgumentBuilder<CommandSourceStack>

src/main/java/com/ejclaw/videoplayer/command/VideoMuteCommand.java

@@ -22,7 +22,6 @@ public final class VideoMuteCommand {
 
     public static void register(CommandDispatcher<CommandSourceStack> dispatcher) {
         dispatcher.register(build("videoMute"));
-        dispatcher.register(build("videomute"));
     }
 
     private static com.mojang.brigadier.builder.LiteralArgumentBuilder<CommandSourceStack>

src/main/java/com/ejclaw/videoplayer/command/VideoPlaceCommand.java

@@ -1,5 +1,6 @@
 package com.ejclaw.videoplayer.command;
 
+import com.ejclaw.videoplayer.VideoPlayerConfig;
 import com.ejclaw.videoplayer.block.VideoAnchorBlockEntity;
 import com.ejclaw.videoplayer.net.SyncAnchorPayload;
 import com.ejclaw.videoplayer.registry.VideoPlayerBlocks;
@@ -21,13 +22,32 @@ import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.server.permissions.Permissions;
 import net.minecraft.world.level.block.Block;
 
-/** SPEC §4.5.1 — {@code /videoPlace <pos> <facing> <width> <height> <url>} */
+/**
+ * SPEC §4.5.1 — {@code /videoPlace} has two accepted forms:
+ *
+ * <ul>
+ *   <li><b>Legacy 5-arg</b>: {@code /videoPlace <pos> <facing> <width> <height> <url>}
+ *       — preserved for existing command blocks. Volume defaults to 50% and muted=false.
+ *       The {@code url} here is a single-token string so it doesn't swallow the {@code volume}
+ *       slot of the new form.</li>
+ *   <li><b>New 6-arg</b>: {@code /videoPlace <pos> <facing> <width> <height> <volume> <url>}
+ *       — {@code volume} is 0..100 (percent) or {@code -1} to start muted. The percent form
+ *       mirrors the GUI slider; {@code -1} is a CLI shortcut so admins don't need a follow-up
+ *       {@code /videoMute} step. {@code url} is greedy here, so URLs containing spaces (rare
+ *       but possible after URL-decoding) still work.</li>
+ * </ul>
+ *
+ * <p>Brigadier disambiguates the two by the type of the 5th argument: integer → new form,
+ * non-integer token → legacy form.
+ */
 public final class VideoPlaceCommand {
     private VideoPlaceCommand() {}
 
+    /** Default volume (percent) applied to the legacy 5-arg form. */
+    private static final int DEFAULT_VOLUME_PCT = 50;
+
     public static void register(CommandDispatcher<CommandSourceStack> dispatcher) {
         dispatcher.register(build("videoPlace"));
-        dispatcher.register(build("videoplace"));
     }
 
     private static com.mojang.brigadier.builder.LiteralArgumentBuilder<CommandSourceStack>
@@ -38,12 +58,33 @@ public final class VideoPlaceCommand {
                 .then(Commands.argument("facing", StringArgumentType.word())
                     .then(Commands.argument("width", IntegerArgumentType.integer(1, 32))
                         .then(Commands.argument("height", IntegerArgumentType.integer(1, 32))
-                            .then(Commands.argument("url", StringArgumentType.greedyString())
-                                .executes(VideoPlaceCommand::run))))));
+                            // New form: volume (int) + greedy url
+                            .then(Commands.argument("volume", IntegerArgumentType.integer(-1, 100))
+                                .then(Commands.argument("url", StringArgumentType.greedyString())
+                                    .executes(ctx -> runNew(ctx))))
+                            // Legacy form: single-token url, no volume slot. Single-token string
+                            // is intentional so "<int> https://..." cannot be parsed as a legacy
+                            // url that happens to start with a number — Brigadier first tries the
+                            // new branch and only falls through here if "volume" isn't an int.
+                            .then(Commands.argument("url", StringArgumentType.string())
+                                .executes(ctx -> runLegacy(ctx)))))));
     }
 
-    private static int run(com.mojang.brigadier.context.CommandContext<CommandSourceStack> ctx)
+    private static int runNew(com.mojang.brigadier.context.CommandContext<CommandSourceStack> ctx)
             throws CommandSyntaxException {
+        int volumeArg = IntegerArgumentType.getInteger(ctx, "volume");
+        String url = StringArgumentType.getString(ctx, "url");
+        return runWithValues(ctx, volumeArg, url);
+    }
+
+    private static int runLegacy(com.mojang.brigadier.context.CommandContext<CommandSourceStack> ctx)
+            throws CommandSyntaxException {
+        String url = StringArgumentType.getString(ctx, "url");
+        return runWithValues(ctx, DEFAULT_VOLUME_PCT, url);
+    }
+
+    private static int runWithValues(com.mojang.brigadier.context.CommandContext<CommandSourceStack> ctx,
+                                     int volumeArg, String rawUrl) throws CommandSyntaxException {
         CommandSourceStack src = ctx.getSource();
         ServerLevel level = src.getLevel();
         BlockPos pos = BlockPosArgument.getLoadedBlockPos(ctx, "pos");
@@ -54,9 +95,19 @@ public final class VideoPlaceCommand {
         }
         int width  = IntegerArgumentType.getInteger(ctx, "width");
         int height = IntegerArgumentType.getInteger(ctx, "height");
-        String url = StringArgumentType.getString(ctx, "url").trim();
-        if (!url.isEmpty() && !(url.startsWith("http://") || url.startsWith("https://"))) {
-            src.sendFailure(Component.literal("url must be http:// or https:// (or empty)"));
+        // -1 is the CLI mute shortcut; the BE keeps the underlying volume so an admin can
+        // /videoMute false later without re-typing a level. Anything 0..100 sets %-volume and
+        // clears mute.
+        boolean placeMuted = volumeArg < 0;
+        float placeVolume = placeMuted ? 0.5F : (volumeArg / 100.0F);
+        String raw = rawUrl == null ? "" : rawUrl.trim();
+        // Accept either an http(s) URL or a /videoCache add <name> entry: resolveUrlOrName()
+        // returns the canonical URL in both cases, or null when a non-URL string didn't match
+        // any named entry.
+        String url = VideoPlayerConfig.resolveUrlOrName(raw);
+        if (url == null) {
+            src.sendFailure(Component.literal(
+                "url 은 http(s):// 로 시작하거나 /videoCache add 로 등록된 이름이어야 합니다: " + raw));
             return 0;
         }
         if (url.length() > 256) url = url.substring(0, 256);
@@ -70,6 +121,8 @@ public final class VideoPlaceCommand {
         be.setWidth(width);
         be.setHeight(height);
         be.setUrl(url);
+        be.setVolume(placeVolume);
+        be.setMuted(placeMuted);
 
         CompoundTag nbt = be.toNbt();
         for (ServerPlayer p : PlayerLookup.tracking(level, pos)) {

src/main/java/com/ejclaw/videoplayer/command/VideoStickCommand.java

@@ -6,16 +6,18 @@ import net.minecraft.commands.CommandSourceStack;
 import net.minecraft.commands.Commands;
 import net.minecraft.network.chat.Component;
 import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.permissions.Permissions;
 import net.minecraft.world.item.ItemStack;
 
 public final class VideoStickCommand {
     private VideoStickCommand() {}
 
     public static void register(CommandDispatcher<CommandSourceStack> dispatcher) {
+        // OP/console/command-block 만 사용 가능. Permissions.COMMANDS_GAMEMASTER = level 2,
+        // 즉 /op 받은 플레이어(level 4) 와 콘솔(level 4), command block(default level 2) 통과.
+        // 일반 플레이어(level 0) 는 탭 자동완성에도 안 떠야 정상.
         dispatcher.register(Commands.literal("videoStick")
-            .executes(ctx -> run(ctx.getSource())));
-        // Lowercase alias — Brigadier is case-sensitive.
-        dispatcher.register(Commands.literal("videostick")
+            .requires(s -> s.permissions().hasPermission(Permissions.COMMANDS_GAMEMASTER))
             .executes(ctx -> run(ctx.getSource())));
     }
 

src/main/java/com/ejclaw/videoplayer/net/CachePolicyPayload.java

@@ -0,0 +1,32 @@
+package com.ejclaw.videoplayer.net;
+
+import com.ejclaw.videoplayer.VideoPlayerMod;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.Identifier;
+
+/**
+ * S2C — broadcasts the server-configured client-side policy bundle on join, before any
+ * {@link PreloadPayload}. Carries: {@code maxPerVideoBytes} (per-video download cap),
+ * {@code maxCacheBytes} (total-cache directory cap), and {@code renderDistanceBlocks}
+ * (anchor BE view-distance cap).
+ */
+public record CachePolicyPayload(long maxPerVideoBytes, long maxCacheBytes, int renderDistanceBlocks)
+        implements CustomPacketPayload {
+    public static final CustomPacketPayload.Type<CachePolicyPayload> TYPE =
+        new CustomPacketPayload.Type<>(Identifier.fromNamespaceAndPath(VideoPlayerMod.MOD_ID, "cache_policy"));
+
+    public static final StreamCodec<RegistryFriendlyByteBuf, CachePolicyPayload> CODEC = StreamCodec.composite(
+        ByteBufCodecs.VAR_LONG, CachePolicyPayload::maxPerVideoBytes,
+        ByteBufCodecs.VAR_LONG, CachePolicyPayload::maxCacheBytes,
+        ByteBufCodecs.VAR_INT,  CachePolicyPayload::renderDistanceBlocks,
+        CachePolicyPayload::new
+    );
+
+    @Override
+    public Type<? extends CustomPacketPayload> type() {
+        return TYPE;
+    }
+}

src/main/java/com/ejclaw/videoplayer/net/ClearCachePayload.java

@@ -0,0 +1,26 @@
+package com.ejclaw.videoplayer.net;
+
+import com.ejclaw.videoplayer.VideoPlayerMod;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.Identifier;
+
+/**
+ * S2C — tell every client to wipe its entire {@code video_player_cache} directory and reset
+ * the in-memory READY/IN_FLIGHT index. Sent by {@code /videoCache clear}. Carries no payload —
+ * the receiving client just nukes everything under the cache dir regardless of how the file
+ * got there (named entry, legacy preload_url, or leftover from a prior session).
+ */
+public record ClearCachePayload() implements CustomPacketPayload {
+    public static final CustomPacketPayload.Type<ClearCachePayload> TYPE =
+        new CustomPacketPayload.Type<>(Identifier.fromNamespaceAndPath(VideoPlayerMod.MOD_ID, "cache_clear"));
+
+    public static final StreamCodec<RegistryFriendlyByteBuf, ClearCachePayload> CODEC =
+        StreamCodec.unit(new ClearCachePayload());
+
+    @Override
+    public Type<? extends CustomPacketPayload> type() {
+        return TYPE;
+    }
+}

src/main/java/com/ejclaw/videoplayer/net/DeleteCachePayload.java

@@ -0,0 +1,28 @@
+package com.ejclaw.videoplayer.net;
+
+import com.ejclaw.videoplayer.VideoPlayerMod;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.Identifier;
+
+/**
+ * S2C — tell connected clients to drop a previously preloaded URL from their on-disk cache.
+ * Sent by {@code /videocache remove <name>}. Each client deletes the matching cache file and
+ * drops it from {@code VideoCache.READY}.
+ */
+public record DeleteCachePayload(String url) implements CustomPacketPayload {
+    public static final CustomPacketPayload.Type<DeleteCachePayload> TYPE =
+        new CustomPacketPayload.Type<>(Identifier.fromNamespaceAndPath(VideoPlayerMod.MOD_ID, "cache_delete"));
+
+    public static final StreamCodec<RegistryFriendlyByteBuf, DeleteCachePayload> CODEC = StreamCodec.composite(
+        ByteBufCodecs.STRING_UTF8, DeleteCachePayload::url,
+        DeleteCachePayload::new
+    );
+
+    @Override
+    public Type<? extends CustomPacketPayload> type() {
+        return TYPE;
+    }
+}

src/main/java/com/ejclaw/videoplayer/net/MqHelloPayload.java

@@ -0,0 +1,35 @@
+package com.ejclaw.videoplayer.net;
+
+import com.ejclaw.videoplayer.VideoPlayerMod;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.Identifier;
+
+/**
+ * C2S — client-presence handshake for the {@code music_quiz} datapack
+ * ({@code docs/mc_video_player_mod_integration.md}). Each modded client sends one on JOIN
+ * and one every ~5 s thereafter. The server side flips the player's {@code mq_video_mod}
+ * scoreboard score to {@code 1}, which the datapack reads in its {@code mq:commands/start}
+ * guard.
+ *
+ * <p>Payload body is a single int (protocol version) so future schema bumps don't require
+ * a new packet id. v1 is the only version that exists today.
+ */
+public record MqHelloPayload(int version) implements CustomPacketPayload {
+    public static final int CURRENT_VERSION = 1;
+
+    public static final CustomPacketPayload.Type<MqHelloPayload> TYPE =
+        new CustomPacketPayload.Type<>(Identifier.fromNamespaceAndPath(VideoPlayerMod.MOD_ID, "mq_hello"));
+
+    public static final StreamCodec<RegistryFriendlyByteBuf, MqHelloPayload> CODEC = StreamCodec.composite(
+        ByteBufCodecs.VAR_INT, MqHelloPayload::version,
+        MqHelloPayload::new
+    );
+
+    @Override
+    public Type<? extends CustomPacketPayload> type() {
+        return TYPE;
+    }
+}

src/main/java/com/ejclaw/videoplayer/net/PreloadPayload.java

@@ -0,0 +1,27 @@
+package com.ejclaw.videoplayer.net;
+
+import com.ejclaw.videoplayer.VideoPlayerMod;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.Identifier;
+
+/**
+ * S2C — instruct connected clients to prefetch {@code url} into their local
+ * {@code video_player_cache/} directory. Triggered by {@code /videopreload}.
+ */
+public record PreloadPayload(String url) implements CustomPacketPayload {
+    public static final CustomPacketPayload.Type<PreloadPayload> TYPE =
+        new CustomPacketPayload.Type<>(Identifier.fromNamespaceAndPath(VideoPlayerMod.MOD_ID, "preload"));
+
+    public static final StreamCodec<RegistryFriendlyByteBuf, PreloadPayload> CODEC = StreamCodec.composite(
+        ByteBufCodecs.STRING_UTF8, PreloadPayload::url,
+        PreloadPayload::new
+    );
+
+    @Override
+    public Type<? extends CustomPacketPayload> type() {
+        return TYPE;
+    }
+}

src/main/java/com/ejclaw/videoplayer/net/VideoPlayerNetwork.java

@@ -1,5 +1,6 @@
 package com.ejclaw.videoplayer.net;
 
+import com.ejclaw.videoplayer.VideoPlayerConfig;
 import com.ejclaw.videoplayer.VideoPlayerMod;
 import com.ejclaw.videoplayer.block.VideoAnchorBlockEntity;
 import net.fabricmc.fabric.api.networking.v1.PayloadTypeRegistry;
@@ -24,9 +25,14 @@ public final class VideoPlayerNetwork {
         // S2C
         PayloadTypeRegistry.clientboundPlay().register(OpenScreenPayload.TYPE, OpenScreenPayload.CODEC);
         PayloadTypeRegistry.clientboundPlay().register(SyncAnchorPayload.TYPE, SyncAnchorPayload.CODEC);
+        PayloadTypeRegistry.clientboundPlay().register(PreloadPayload.TYPE, PreloadPayload.CODEC);
+        PayloadTypeRegistry.clientboundPlay().register(CachePolicyPayload.TYPE, CachePolicyPayload.CODEC);
+        PayloadTypeRegistry.clientboundPlay().register(DeleteCachePayload.TYPE, DeleteCachePayload.CODEC);
+        PayloadTypeRegistry.clientboundPlay().register(ClearCachePayload.TYPE, ClearCachePayload.CODEC);
         // C2S
         PayloadTypeRegistry.serverboundPlay().register(SaveConfigPayload.TYPE, SaveConfigPayload.CODEC);
         PayloadTypeRegistry.serverboundPlay().register(DeleteAnchorPayload.TYPE, DeleteAnchorPayload.CODEC);
+        PayloadTypeRegistry.serverboundPlay().register(MqHelloPayload.TYPE, MqHelloPayload.CODEC);
     }
 
     public static void registerServerReceivers() {
@@ -94,13 +100,13 @@ public final class VideoPlayerNetwork {
 
     private static String trimUrl(String s) {
         if (s == null) return "";
-        String t = s.trim();
-        if (t.length() > 256) t = t.substring(0, 256);
-        // SPEC §4.4: only https?:// or empty
-        if (!t.isEmpty() && !(t.startsWith("http://") || t.startsWith("https://"))) {
-            return "";
-        }
-        return t;
+        // GUI / C2S accepts either an http(s) URL or a /videoCache add <name>. Names resolve
+        // to their stored URL; URLs pass through verbatim. Anything else collapses to empty
+        // (SPEC §4.4: anchors with non-URL urls are no-ops).
+        String resolved = VideoPlayerConfig.resolveUrlOrName(s);
+        if (resolved == null) return "";
+        if (resolved.length() > 256) resolved = resolved.substring(0, 256);
+        return resolved;
     }
 
     private static int clamp(int v, int lo, int hi) {

src/main/java/com/ejclaw/videoplayer/server/MusicQuizPresence.java

@@ -0,0 +1,74 @@
+package com.ejclaw.videoplayer.server;
+
+import com.ejclaw.videoplayer.VideoPlayerMod;
+import com.ejclaw.videoplayer.net.MqHelloPayload;
+import net.fabricmc.fabric.api.event.lifecycle.v1.ServerTickEvents;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.scores.Objective;
+import net.minecraft.world.scores.ScoreHolder;
+import net.minecraft.world.scores.Scoreboard;
+
+/**
+ * Implements the server side of the {@code music_quiz} datapack handshake described in
+ * {@code docs/mc_video_player_mod_integration.md}.
+ *
+ * <p>Two scoreboard writes against objective {@code mq_video_mod} (dummy):
+ * <ul>
+ *   <li>Every server tick — {@code #server mq_video_mod = 1}. Proves the mod jar is on the
+ *       server side. The datapack's {@code mq:commands/start} guard checks this first.</li>
+ *   <li>Every received {@link MqHelloPayload} — {@code <player> mq_video_mod = 1}. Proves
+ *       the sending player's client has the mod installed. Per-player flag is needed
+ *       because rendering is client-side; the server can't tell from join state alone.</li>
+ * </ul>
+ *
+ * <p>The objective itself ({@code scoreboard objectives add mq_video_mod dummy}) is
+ * created by the datapack's {@code mq:load} function. If it isn't present yet (datapack
+ * not applied, or load hasn't run), the writes are silently skipped — when the datapack
+ * appears later, the next tick / next payload arrival populates it.
+ */
+public final class MusicQuizPresence {
+    private MusicQuizPresence() {}
+
+    /** Scoreboard objective name expected by the {@code music_quiz} datapack. */
+    private static final String OBJECTIVE = "mq_video_mod";
+    /** Fake holder used to mark "the server has the mod" (datapack reads {@code #server}). */
+    private static final String SERVER_HOLDER = "#server";
+
+    /** Call from {@code VideoPlayerMod.onInitialize} after payload types are registered. */
+    public static void register() {
+        // (a) per-tick server presence
+        ServerTickEvents.END_SERVER_TICK.register(MusicQuizPresence::onServerTick);
+
+        // (b) per-player client presence — flipped on every received Hello
+        ServerPlayNetworking.registerGlobalReceiver(MqHelloPayload.TYPE, (payload, context) -> {
+            ServerPlayer player = context.player();
+            MinecraftServer server = context.server();
+            // hop back onto the server thread before touching the scoreboard
+            server.execute(() -> markPlayerPresent(server, player));
+        });
+    }
+
+    private static void onServerTick(MinecraftServer server) {
+        Scoreboard sb = server.getScoreboard();
+        Objective obj = sb.getObjective(OBJECTIVE);
+        // Datapack not loaded yet — silently skip. The score holder doesn't exist until
+        // the objective does, and trying to write blind would just blow up.
+        if (obj == null) return;
+        sb.getOrCreatePlayerScore(ScoreHolder.forNameOnly(SERVER_HOLDER), obj).set(1);
+    }
+
+    private static void markPlayerPresent(MinecraftServer server, ServerPlayer player) {
+        Scoreboard sb = server.getScoreboard();
+        Objective obj = sb.getObjective(OBJECTIVE);
+        if (obj == null) {
+            VideoPlayerMod.LOG.debug("[{}] mq hello from {} but objective '{}' not present",
+                VideoPlayerMod.MOD_ID, player.getName().getString(), OBJECTIVE);
+            return;
+        }
+        // ServerPlayer itself implements ScoreHolder, so this matches selector @s on the
+        // datapack side without name-formatting quirks (uuid vs profile name).
+        sb.getOrCreatePlayerScore(player, obj).set(1);
+    }
+}