v0.4.36: suppress command/preload chat broadcast

Command-block and player usage no longer spams chat:
- Command feedback (videoPlace/videoDelete/videoMute) now uses
  sendSuccess(..., false) so only the executor sees it; command blocks
  write to their own output + server log instead of broadcasting to ops.
- Removed client-side [videopreload]/[videocache] notifyChat spam in
  VideoCache; download status remains in the client log via LOG.

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

.gitea/workflows/build.yml

@@ -17,7 +17,10 @@ jobs:
           java-version: 25
       - name: Build (MC 26.1.2)
         run: ./gradlew --no-daemon build
-      - uses: actions/upload-artifact@v4
+      # Gitea Actions runs on a GHES-compatible backend that does NOT support the
+      # @actions/artifact v2 protocol (upload-artifact@v4 → GHESNotSupportedError).
+      # v3 uses the v1 artifact API, which Gitea implements — so the run goes green.
+      - uses: actions/upload-artifact@v3
         with:
           name: video_player-mc26.1.2
           path: build/libs/*.jar

README.md

@@ -3,7 +3,7 @@
 마인크래프트 안에서 임의의 동영상 URL을 벽·바닥·천장에 평면으로 재생하는 Fabric 모드.
 
 - 모드 ID: `video_player`
-- 현재 버전: **0.4.12**
+- 현재 버전: **0.4.35**
 - 마인크래프트 버전: **26.1.2**
 - 필요 Java: **25** (마인크래프트 26.x 가 요구함)
 
@@ -54,20 +54,20 @@ Fabric은 마인크래프트에 모드 기능을 추가해 주는 로더입니
 2. **video_player** (이 모드, 0.4.12 부터 JavaCV 가 jar 안에 포함됨)
    - 다운로드: https://git.tkrmagid.kr/tkrmagid/mc_video_player_mod/releases
    - 자신의 OS·CPU 에 맞는 jar **한 개** 만 받아서 `mods` 폴더에 넣으면 됩니다 (별도 JavaCV 설치 불필요):
-     - Windows 64bit: `video_player-windows-x86_64-0.4.12.jar` (~32MB)
+     - Windows 64bit: `video_player-windows-x86_64-0.4.35.jar` (~33MB)
-     - macOS Intel: `video_player-macosx-x86_64-0.4.12.jar` (~24MB)
+     - macOS Intel: `video_player-macosx-x86_64-0.4.35.jar` (~25MB)
-     - macOS Apple Silicon (M1/M2/M3/M4): `video_player-macosx-arm64-0.4.12.jar` (~21MB)
+     - macOS Apple Silicon (M1/M2/M3/M4): `video_player-macosx-arm64-0.4.35.jar` (~21MB)
-     - Linux 64bit: `video_player-linux-x86_64-0.4.12.jar` (~27MB)
+     - Linux 64bit: `video_player-linux-x86_64-0.4.35.jar` (~28MB)
    - 자기 OS 가 헷갈리면: Windows 는 거의 다 `windows-x86_64`, 인텔맥은 `macosx-x86_64`, 애플 실리콘 맥은 `macosx-arm64`, 리눅스는 `linux-x86_64`.
 
 이전 버전(`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. 잘 설치됐는지 확인
 
-게임 안에서 채팅창에 `/videostick` 을 입력하세요. 정상이라면:
+게임 안에서 채팅창에 `/videoStick` 을 입력하세요 (대소문자 구분). 정상이라면:
 
 - 인벤토리에 **비디오 스틱** 아이템이 들어옵니다 (보라/검정 missing-texture 가 아니라 작대기 모양 아이콘).
-- 보라/검정 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 에서 수정됨.)
+- 보라/검정 missing texture 가 나오면 **STEP 4** 에서 이전 버전 jar(`video_player-0.4.0.jar` / `0.4.1.jar` 등)가 mods 폴더에 같이 남아있는 경우입니다. 다 지우고 `0.4.35` 만 남기고 다시 시작하세요. (0.4.1 이하는 Fabric 26.1.2 model 로더가 unprefixed `item/generated` parent 를 거부해서 스틱 아이콘이 missing-model 큐브로 보입니다 — 0.4.2 에서 수정됨.)
 
 ---
 
@@ -93,75 +93,92 @@ Fabric은 마인크래프트에 모드 기능을 추가해 주는 로더입니
 
 ### 명령어
 
+명령어 이름은 **대소문자를 구분**합니다 (`/videoStick` 처럼 camelCase).
+
 | 명령 | 설명 |
 | --- | --- |
-| `/videostick` | 비디오 스틱 아이템을 인벤토리에 지급 |
+| `/videoStick` | 비디오 스틱 아이템을 인벤토리에 지급 (플레이어만) |
-| `/videoplace <pos> <facing> <w> <h> <url>` | 좌표에 영상 앵커를 즉시 배치 |
+| `/videoPlace <pos> <facing> <w> <h> <url-or-name>` | 좌표에 영상 앵커 배치 (볼륨 50%·음소거 해제). `url-or-name` 은 http(s) URL 또는 `/videoCache add` 로 등록한 이름 |
-| `/videodelete <pos>` | 좌표의 영상 앵커 제거 |
+| `/videoPlace <pos> <facing> <w> <h> <volume> <url-or-name>` | 위와 같지만 볼륨 지정: `0`~`100` (%) 또는 `-1`(음소거로 시작) |
-| `/videomute <pos> <on\|off>` | 영상의 음소거 켜고/끄기 |
+| `/videoDelete <pos>` | 좌표의 영상 앵커 제거 |
-| `/videopreload <url>` | URL 을 미리 받아 디스크 캐시에 저장 (자세한 내용은 아래) |
+| `/videoMute <pos> <on\|off>` | 영상의 음소거 켜고/끄기 |
+| `/videoCache add <name> <url>` | 자주 쓰는 URL 을 이름으로 등록 (서버 config 에 저장, 접속자에게 자동 프리로드) |
+| `/videoCache list` | 등록된 이름·URL 목록 표시 |
+| `/videoCache remove <name>` | 등록된 이름 1개 삭제 |
+| `/videoCache clear` | 등록된 이름 전체 삭제 |
 
-`/videoplace`, `/videodelete`, `/videomute`, `/videopreload` 는 기본적으로 OP(권한 레벨 2) 가 필요하므로 **커맨드 블럭에서도 그대로 호출 가능합니다**. 커맨드 블럭은 기본이 권한 레벨 2 라 별도 설정 없이 동작합니다.
+- `facing` 은 `north/south/east/west/up/down`, `w`·`h` 는 `1`~`32` 블록.
+- 모든 `/video*` 명령은 기본적으로 OP(권한 레벨 2) 가 필요하므로 **커맨드 블럭·콘솔에서도 그대로 호출 가능합니다**. 커맨드 블럭은 기본이 권한 레벨 2 라 별도 설정 없이 동작합니다. (0.4.31 부터 커맨드 블럭·콘솔·함수 등 비(非)플레이어 실행자는 `functionPermissionLevel` 게임룰을 건드리지 않아도 호출됩니다.)
+- `/videoStick` 만 플레이어 전용입니다(인벤토리에 아이템을 줘야 하므로).
 
-### `/videopreload` — 영상 미리 로딩 (스터터 제거)
+### 소리(오디오) 설정 (0.4.32+)
 
-스트리밍 URL 을 라이브로 받으면서 재생하면 네트워크가 잠깐 느려질 때 끊김이 생깁니다. `/videopreload <url>` 을 미리 한번 실행하면 클라이언트가 백그라운드에서 URL 을 통째로 다운로드해서 `.minecraft/video_player_cache/` 폴더에 저장해 두고, 같은 URL 로 영상이 재생될 때 인터넷이 아니라 그 로컬 파일을 사용합니다 (= 끊김 없음).
+영상 소리는 마인크래프트 **음량 슬라이더**의 영향을 받습니다. 0.4.32 부터 기본값은 **"주크박스/음반"(record)** 슬라이더입니다 — 영상은 미디어 재생이라 음악·효과음과 따로 조절하라고 이 채널을 씁니다. (마스터 슬라이더는 항상 위에서 한 번 더 곱해집니다.)
+
+어떤 슬라이더가 영상 소리를 제어할지는 `config/video_player.json` 의 `sound_category` 로 바꿀 수 있습니다 (클라이언트별 설정). 가능한 값: `master, music, record, weather, block, hostile, neutral, player, ambient, voice, ui`. 기본값은 `record` 이고, 잘못된 값을 적으면 경고 로그를 남기고 `record` 로 동작합니다.
+
+소리 크기는 **판때기 중앙**으로부터의 거리로 감쇠되며(16블록에서 0), `/videoMute <pos> <on|off>` 로 개별 영상을 음소거할 수 있습니다.
+
+### `/videoCache` — 영상 미리 로딩 (스터터 제거)
+
+스트리밍 URL 을 라이브로 받으면서 재생하면 네트워크가 잠깐 느려질 때 끊김이 생깁니다. `/videoCache add <name> <url>` 로 URL 을 이름과 함께 등록해 두면, 접속해 있는 모든 클라이언트가 백그라운드에서 그 URL 을 통째로 다운로드해 로컬 캐시에 저장하고, 같은 URL(또는 그 이름)로 영상이 재생될 때 인터넷이 아니라 로컬 파일을 사용합니다 (= 끊김 없음).
 
 ```
-/videopreload https://video.example.com/foo.mp4
+/videoCache add intro https://video.example.com/foo.mp4
+/videoPlace 10 64 10 north 4 3 intro          # 등록한 이름을 URL 자리에 그대로 사용
 ```
 
 특징:
 
-- **커맨드 블럭에서 사용 가능** — 예: 압력판 → 커맨드 블럭 `/videopreload <url>` 으로 트리거하면 플레이어가 영상 영역에 다가가기 전에 미리 다운로드 시작
+- **커맨드 블럭·콘솔에서 사용 가능** — 예: 서버 시작 시 함수로 `/videoCache add ...` 를 등록해 두면 접속자가 영상에 다가가기 전에 미리 다운로드가 시작됩니다
-- 명령은 서버에서 실행되지만, 다운로드는 각 **클라이언트**(접속해 있는 모든 플레이어)가 자기 PC 에 받습니다
+- 명령은 서버에서 실행되지만, 다운로드는 각 **클라이언트**(접속한 모든 플레이어)가 자기 PC 에 받습니다
-- 이미 받아둔 URL 은 재요청해도 다시 다운로드 안 함 (URL 의 SHA-256 으로 캐싱)
+- 등록한 이름은 서버 config(`config/video_player.json` 의 `cache_entries`)에 저장되어 **재시작 후에도 유지**되고, 새로 접속하는 플레이어에게도 자동으로 전달됩니다
-- 한 파일당 상한 512 MB
+- 이미 받아둔 URL 은 재요청해도 다시 다운로드하지 않습니다 (URL 의 SHA-256 으로 캐싱)
-- 캐시 폴더가 너무 커지면 직접 `.minecraft/video_player_cache/` 안의 파일을 삭제해도 됩니다 (그러면 다음 사용 시 다시 받아옴)
+- 한 영상당 / 전체 캐시 용량 상한은 config 의 `max_preload_mb` / `max_cache_mb` 로 정합니다 (아래 참고)
+- `/videoCache remove <name>` 하면 다운로드 중인 항목까지 취소되고 해당 캐시 파일이 삭제됩니다 (0.4.34)
+- 클라이언트 캐시는 **게임 종료 시 자동으로 비워집니다**. 등록 항목은 서버에 남아 있으므로 다음 접속 때 다시 받아옵니다 — 캐시 폴더를 수동으로 지울 필요가 없습니다
 
 > 영상 삭제 시 소리가 안 멎던 문제는 0.4.4 에서 수정되었습니다 (앵커 블록이 사라지면 디코더 / 오디오 라인을 즉시 강제 종료). 0.4.5 에서는 `BLOCK_ENTITY_UNLOAD` 이벤트가 누락되는 엣지케이스를 대비해 매 틱마다 BE 존재를 한 번 더 검증합니다.
 
-> 0.4.5 부터 다운로드 시작 / 완료 / 실패가 채팅창에 표시됩니다. 커맨드블럭으로 `/videopreload` 후 `/videoplace` 를 이어 실행할 때는 `[videopreload] 완료` 메시지를 본 뒤에 재생해야 로컬 파일에서 재생됩니다 (그 전에 재생하면 일반 스트리밍으로 떨어집니다).
+> 다운로드 시작 / 완료 / 실패는 `[videopreload]` 채팅 메시지로 표시됩니다. 커맨드블럭/함수로 `/videoCache add` 후 `/videoPlace` 를 이어 실행할 때는 `[videopreload] 완료` 메시지를 본 뒤에 재생해야 로컬 파일에서 재생됩니다 (그 전에 재생하면 일반 스트리밍으로 떨어집니다).
 
-> 0.4.5 부터 오디오 거리 감쇠가 **판때기 중앙**을 기준으로 계산됩니다. 예전엔 앵커 블록(보통 화면 모서리)을 기준으로 측정해서 큰 화면일수록 소리가 한쪽에서 들리는 느낌이었습니다.
+### 서버 config (`config/video_player.json`)
 
-### 서버 config 로 자동 프리로드 (0.4.6+)
+서버(싱글플레이는 통합 서버)에 모드를 넣고 한 번 실행하면 `config/video_player.json` 이 자동 생성됩니다. 기본 생성 내용:
-
-서버에 모드를 넣고 한 번 실행하면 `<서버폴더>/config/video_player.json` 가 자동 생성됩니다. 이 파일에 자주 쓰는 영상 URL 을 적어두면, 플레이어가 접속할 때마다 서버가 자동으로 그 URL 들의 프리로드 요청을 보냅니다 (= `/videopreload` 를 사람마다 친 것과 같음).
-
-기본 생성된 파일 예시:
 
 ```json
 {
-  "_comment": "preload_urls: HTTP(S) video URLs broadcast to every player on join. ...",
+  "_comment": "max_preload_mb: ... cache_entries: named entries managed by /videoCache add|list|remove.",
-  "preload_urls": []
+  "max_preload_mb": 2048,
+  "max_cache_mb": 750,
+  "render_distance_blocks": 128,
+  "sound_category": "record",
+  "preload_urls": [],
+  "cache_entries": []
 }
 ```
 
-사용 예시 — 인트로 영상과 BGM 영상을 모든 접속자가 미리 받도록:
+키 설명:
 
-```json
+- `max_preload_mb` — 클라이언트가 영상 **한 개**를 받을 때의 상한(MB). 초과하면 그 다운로드를 중단합니다. 기본 2048.
-{
+- `max_cache_mb` — 클라이언트 **전체 캐시 폴더**의 상한(MB). 기본 750.
-  "preload_urls": [
+- `render_distance_blocks` — 영상 앵커가 렌더링되는 최대 거리(블록). 기본 128.
-    "https://video.example.com/intro.mp4",
+- `sound_category` — 영상 오디오를 어느 음량 슬라이더로 제어할지 (위 "소리 설정" 참고). 기본 `record`.
-    "https://video.example.com/bgm-loop.webm"
+- `cache_entries` — `/videoCache add|list|remove` 로 관리되는 **이름 있는** 자동 프리로드 목록. 예: `[{ "name": "intro", "url": "https://video.example.com/intro.mp4" }]`. 직접 편집보다 명령어 사용을 권장합니다(명령어는 즉시 반영·접속자에게 즉시 브로드캐스트).
-  ]
+- `preload_urls` — 이름 없는 레거시 자동 프리로드 목록(하위호환). 접속 시 모든 플레이어가 받습니다. 각 URL 은 `http(s)://` 시작, 256자 이하.
-}
-```
 
 규칙:
 
-- 각 URL 은 `http://` 또는 `https://` 시작, 256자 이하 (그 외는 무시되고 서버 로그에 WARN)
+- `cache_entries` 는 명령어로 바꾸면 즉시 저장·반영됩니다. `preload_urls` 등 파일을 직접 수정한 경우엔 **서버 재시작** 이 필요합니다(파일은 시작 시 1회 로딩).
-- 파일 수정 후 적용하려면 **서버 재시작** 이 필요합니다 (config 는 시작 시 1회만 로딩)
+- 이미 캐시된 URL 은 다시 다운로드하지 않습니다 (SHA-256 캐시 키).
-- 접속한 플레이어 화면에는 `/videopreload` 와 동일한 `[videopreload] 다운로드 시작 / 완료` 채팅 메시지가 보입니다
+- 싱글플레이도 통합 서버의 `config/video_player.json` 에 동일하게 동작합니다.
-- 이미 캐시된 URL 은 다시 다운로드하지 않습니다 (SHA-256 캐시 키)
-- 싱글플레이는 자체적으로 통합 서버를 띄우므로, 통합 서버의 config 폴더(`<게임폴더>/config/video_player.json`)에도 같은 효과로 동작합니다
 
 ---
 
 ## 알려진 이슈
 
 - 영상 자리만 잡히고 검게 보이는 경우: 자신의 OS·CPU 와 다른 플랫폼의 jar 를 받았거나, 이전 버전(0.4.7 이하)의 `-Xbootclasspath/a:...javacv...` JVM 인수가 그대로 남아 있는 경우가 가장 흔합니다. 로그 파일(`.minecraft/logs/latest.log`)에서 `JavaCV not on classpath` WARN 또는 `UnsatisfiedLinkError... jnijavacpp` 메시지로 확인 가능합니다.
+- (0.4.33 에서 수정됨) 소리는 나오는데 화면만 검게 나오던 문제: 가로 픽셀 수가 16의 배수가 아닌 해상도의 영상(예: 1674×1080)에서 디코더 행 패딩(swscale linesize 정렬) 때문에 모든 프레임이 버려지던 버그였습니다. **0.4.33 이상**으로 올리면 해결됩니다.
 - 0.3.x 이하 버전에서 만든 영상은 새 버전(0.4.x) 에서 보이지 않으니 다시 배치해야 합니다.
 
 ---
@@ -172,7 +189,7 @@ Fabric은 마인크래프트에 모드 기능을 추가해 주는 로더입니
 ```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.35.jar` (~106KB)
 
 플랫폼별 fat jar (JavaCV 1.5.13 + ffmpeg 8.0.1 네이티브 nested):
 ```sh
@@ -181,7 +198,7 @@ JAVA_HOME=/usr/lib/jvm/java-25-openjdk-amd64 ./gradlew clean build -Pplatform=li
 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 로 풀어서 로딩)
+산출물: `build/libs/video_player-<platform>-0.4.35.jar` (~21-33MB, jar 내부에 nested 로 javacv/javacpp/ffmpeg jar 5개 포함, Fabric loader 가 런타임에 classpath 로 풀어서 로딩)
 
 JavaCV를 직접 의존성으로 가져오는 경우의 Maven 좌표:
 ```

gradle.properties

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

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

@@ -3,9 +3,7 @@ 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;
@@ -52,6 +50,18 @@ public final class VideoCache {
      */
     private static final AtomicLong CACHE_EPOCH = new AtomicLong(0);
 
+    /**
+     * Per-URL cancellation channel for {@link #purge(String)}. The global {@link #CACHE_EPOCH}
+     * can only cancel <em>all</em> in-flight downloads at once; a targeted purge needs to stop
+     * exactly one. Each submitted download captures a unique generation here at submit time;
+     * {@link #purge(String)} removes the URL's entry, which makes the running download's
+     * {@link #cancelled(String, long, long)} checks (read loop + every publish point) fail and
+     * self-clean its {@code .part}/promoted file instead of re-publishing post-purge.
+     */
+    private static final Map<String, Long> DOWNLOAD_GEN = new ConcurrentHashMap<>();
+    /** Monotonic source for per-download generations stored in {@link #DOWNLOAD_GEN}. */
+    private static final AtomicLong GEN_SEQ = 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
@@ -103,6 +113,12 @@ public final class VideoCache {
     /** 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;
+        // Cancel any in-flight download of this exact URL first. Dropping its generation
+        // makes the download thread's cancelled() checks fail, so it deletes its own .part
+        // (or rolls back a just-promoted file) instead of finishing and re-publishing after
+        // we've purged. Without this, a slow/large download evicted mid-flight would silently
+        // reappear on disk + in READY once it completed.
+        DOWNLOAD_GEN.remove(url);
         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.
@@ -120,7 +136,6 @@ public final class VideoCache {
                 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());
@@ -158,6 +173,7 @@ public final class VideoCache {
         // Phase 2: drop indexes.
         READY.clear();
         IN_FLIGHT.clear();
+        DOWNLOAD_GEN.clear();
 
         // Phase 3: delete files on disk.
         int deleted = 0;
@@ -183,7 +199,6 @@ public final class VideoCache {
         }
         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. */
@@ -196,20 +211,22 @@ public final class VideoCache {
         // 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);
+        VideoPlayerMod.LOG.info("[{}] preload: queued {}", VideoPlayerMod.MOD_ID, url);
         // 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));
+        // Register a unique generation for this download so a targeted purge() can cancel
+        // exactly this URL (see DOWNLOAD_GEN / cancelled()).
+        long gen = GEN_SEQ.incrementAndGet();
+        DOWNLOAD_GEN.put(url, gen);
+        DOWNLOAD_POOL.submit(() -> download(url, epoch, gen));
     }
 
     /** Return the local cached file path for this URL, or {@code null} if not yet ready. */
@@ -224,6 +241,7 @@ public final class VideoCache {
     public static void clearIndex() {
         READY.clear();
         IN_FLIGHT.clear();
+        DOWNLOAD_GEN.clear();
     }
 
     /**
@@ -237,6 +255,7 @@ public final class VideoCache {
         CACHE_EPOCH.incrementAndGet();
         READY.clear();
         IN_FLIGHT.clear();
+        DOWNLOAD_GEN.clear();
         int deleted = 0;
         int failed  = 0;
         try {
@@ -283,16 +302,16 @@ public final class VideoCache {
      * @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) {
+    private static boolean publishIfNotCancelled(String url, Path path, long startEpoch, long startGen) {
-        // If the wipe ran between download's pre-move epoch check and Files.move, its
+        // If a wipe (clearAll) or a targeted purge ran between download's pre-move check and
-        // directory scan won't have seen this just-promoted file. We must delete it here,
+        // Files.move, its directory scan won't have seen this just-promoted file. We must
-        // not just bail — otherwise the freshly-moved final file leaks across shutdown.
+        // delete it here, not just bail — otherwise the freshly-moved final file leaks.
-        if (CACHE_EPOCH.get() != startEpoch) {
+        if (cancelled(url, startEpoch, startGen)) {
             try { Files.deleteIfExists(path); } catch (Throwable ignored) {}
             return false;
         }
         READY.put(url, path);
-        if (CACHE_EPOCH.get() != startEpoch) {
+        if (cancelled(url, startEpoch, startGen)) {
             READY.remove(url, path);
             try { Files.deleteIfExists(path); } catch (Throwable ignored) {}
             return false;
@@ -300,7 +319,19 @@ public final class VideoCache {
         return true;
     }
 
-    private static void download(String url, long startEpoch) {
+    /**
+     * True if the in-flight download for {@code url} should abort and self-clean. Two channels:
+     * a global wipe ({@link #clearAll()}/{@link #wipeOnShutdown()} bumped {@link #CACHE_EPOCH}),
+     * or a targeted {@link #purge(String)} that removed/replaced this URL's generation in
+     * {@link #DOWNLOAD_GEN}.
+     */
+    private static boolean cancelled(String url, long startEpoch, long startGen) {
+        if (CACHE_EPOCH.get() != startEpoch) return true;
+        Long cur = DOWNLOAD_GEN.get(url);
+        return cur == null || cur.longValue() != startGen;
+    }
+
+    private static void download(String url, long startEpoch, long startGen) {
         Path cacheDir = cacheDir();
         Path partPath = null;
         try {
@@ -311,8 +342,8 @@ public final class VideoCache {
             }
             // 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) {
+            if (cancelled(url, startEpoch, startGen)) {
-                VideoPlayerMod.LOG.info("[{}] preload: cancelled before start (clearAll ran) — {}",
+                VideoPlayerMod.LOG.info("[{}] preload: cancelled before start (clearAll/purge ran) — {}",
                     VideoPlayerMod.MOD_ID, url);
                 return;
             }
@@ -326,14 +357,13 @@ public final class VideoCache {
             // 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)) {
+                if (!publishIfNotCancelled(url, finalPath, startEpoch, startGen)) {
-                    VideoPlayerMod.LOG.info("[{}] preload: reindex cancelled (clearAll ran) — {}",
+                    VideoPlayerMod.LOG.info("[{}] preload: reindex cancelled (clearAll/purge 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;
             }
 
@@ -348,8 +378,6 @@ public final class VideoCache {
                 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;
             }
 
@@ -363,7 +391,6 @@ public final class VideoCache {
                 if (code >= 400) {
                     VideoPlayerMod.LOG.warn("[{}] preload: HTTP {} for {}",
                         VideoPlayerMod.MOD_ID, code, url);
-                    notifyChat("[videopreload] 실패 (HTTP " + code + "): " + url, ChatFormatting.RED);
                     return;
                 }
             }
@@ -378,7 +405,7 @@ public final class VideoCache {
                     // 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) {
+                    if (cancelled(url, startEpoch, startGen)) {
                         cancelled = true;
                         break;
                     }
@@ -390,8 +417,6 @@ public final class VideoCache {
                             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) {
@@ -401,8 +426,6 @@ public final class VideoCache {
                             "[{}] 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);
@@ -416,8 +439,8 @@ public final class VideoCache {
 
             // 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) {
+            if (cancelled(url, startEpoch, startGen)) {
-                VideoPlayerMod.LOG.info("[{}] preload: cancelled before move (clearAll ran) — {}",
+                VideoPlayerMod.LOG.info("[{}] preload: cancelled before move (clearAll/purge ran) — {}",
                     VideoPlayerMod.MOD_ID, url);
                 try { Files.deleteIfExists(partPath); } catch (Throwable ignored) {}
                 return;
@@ -431,39 +454,28 @@ public final class VideoCache {
             // 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)) {
+            if (!publishIfNotCancelled(url, finalPath, startEpoch, startGen)) {
-                VideoPlayerMod.LOG.info("[{}] preload: cancelled at publish (clearAll ran) — {}",
+                VideoPlayerMod.LOG.info("[{}] preload: cancelled at publish (clearAll/purge 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);
+            // Only clear our own generation — a re-preload after a purge may have installed a
+            // newer gen for this URL that must survive.
+            DOWNLOAD_GEN.remove(url, startGen);
         }
     }
 
-    /** 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).

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

@@ -38,7 +38,7 @@ public final class VideoDeleteCommand {
             return 0;
         }
         level.setBlock(pos, Blocks.AIR.defaultBlockState(), Block.UPDATE_ALL);
-        src.sendSuccess(() -> Component.literal("anchor deleted at " + pos.toShortString()), true);
+        src.sendSuccess(() -> Component.literal("anchor deleted at " + pos.toShortString()), false);
         return 1;
     }
 }

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

@@ -54,7 +54,7 @@ public final class VideoMuteCommand {
             ServerPlayNetworking.send(p, new SyncAnchorPayload(pos, be.toNbt()));
         }
         final boolean mFinal = muted;
-        src.sendSuccess(() -> Component.literal("anchor " + (mFinal ? "muted" : "unmuted")), true);
+        src.sendSuccess(() -> Component.literal("anchor " + (mFinal ? "muted" : "unmuted")), false);
         return 1;
     }
 }

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

@@ -128,7 +128,7 @@ public final class VideoPlaceCommand {
             ServerPlayNetworking.send(p, new SyncAnchorPayload(pos, nbt));
         }
         final BlockPos fp = pos;
-        src.sendSuccess(() -> Component.literal("anchor placed at " + fp.toShortString()), true);
+        src.sendSuccess(() -> Component.literal("anchor placed at " + fp.toShortString()), false);
         return 1;
     }