halfsize 0.1.3 → 0.1.5

package/CHANGELOG.md

@@ -0,0 +1,40 @@
+# Changelog
+
+## 0.1.5
+
+- `--for discord` now targets 20 MB (Discord raised its free upload cap from 10 MB in August 2026)
+- `--for wechat` now targets 20 MB (WeChat's chat-video cap, per its help center)
+- The web app's presets and copy match the current caps
+- `npx` installs behind a restrictive network can use the npmmirror FFmpeg mirror (see Install notes)
+
+## 0.1.4
+
+- Batch mode: `halfsize a.mp4 b.mp4 --to 10mb` compresses several files in a row
+- `--for discord|whatsapp|wechat|email|twitter` picks the platform's upload cap for you
+- `--no-audio` drops the audio track and spends the bits on video instead
+- Streams are mapped explicitly, so cover art and extra tracks cannot be picked by mistake
+- Mono audio stays mono instead of being silently upmixed to stereo
+
+## 0.1.3
+
+- Two-pass progress now spans both passes and shows `pass 1/2`
+- `--web --port <n>` to pick a port
+- Pass logs are cleaned up even when an encode fails
+
+## 0.1.2
+
+- npm release is live
+- CI badge in the README
+
+## 0.1.1
+
+- `--version` no longer falls through to the help screen
+- Force CFR so two-pass encodes of Matroska/VFR sources stay on target
+- Always emit MP4 from the CLI, even for MKV/AVI sources
+
+## 0.1.0
+
+- First release: exact target size, resolution ladder, two-pass H.264/H.265
+- SSIM sampling and VMAF measurement with a plain-language verdict
+- Local web app with drag and drop, platform presets, and a share card
+- `--json`, `--dry-run`, `--doctor`, and `--no-verify`

package/README.md

@@ -19,6 +19,7 @@
 
 <p align="center">
   <a href="README.zh-CN.md">中文说明</a> ·
+  <a href="https://YKLovePython.github.io/halfsize/">Website &amp; guides</a> ·
   <a href="#quick-start">Quick start</a> ·
   <a href="#how-it-works">How it works</a> ·
   <a href="#faq">FAQ</a>
@@ -26,7 +27,7 @@
 
 ---
 
-WeChat refuses anything over **25 MB**. Discord gives you **10 MB**. Email chokes around **20 MB**.
+WeChat and Discord both stop at **20 MB**. Email chokes around the same.
 So you open a video editor, guess a bitrate, export, check the size, export again, and still
 can't tell whether the picture got worse.
 
@@ -40,7 +41,7 @@ It computes the bitrate, picks the resolution that actually fits, encodes twice,
 the result with **SSIM** and **VMAF** so you know whether it still looks the same.
 
 ```
-  halfsize 0.1.0
+  halfsize 0.1.5
 
   source.mp4
   23.2 MB  8s  1920x1080  30.00 fps  h264
@@ -51,9 +52,9 @@ the result with **SSIM** and **VMAF** so you know whether it still looks the sam
   estimate   1.94 MB  (12x smaller)
   output     source.2mb.mp4
 
-  measuring quality                                        done in 2s
+  measuring quality                                        done in 1s
 
-  23.2 MB  ->  1.99 MB   12x smaller   0.3% under target
+  23.2 MB  ->  1.99 MB   12x smaller   0.4% under target
   VMAF 84.4   SSIM 0.968   slight softening
 
   -> C:\Videos\source.2mb.mp4
@@ -61,7 +62,7 @@ the result with **SSIM** and **VMAF** so you know whether it still looks the sam
 
 ## Why this exists
 
-"Make it smaller" is a solved problem. **"Make it fit in exactly 25 MB, and tell me if it
+"Make it smaller" is a solved problem. **"Make it fit in exactly 20 MB, and tell me if it
 still looks right"** is the part every tool makes you guess at.
 
 - HandBrake is excellent, but it asks you to think in codecs, RF values, and presets.
@@ -87,6 +88,12 @@ be downloaded, `halfsize` uses your system install instead.
 # compress to a size
 npx halfsize video.mp4 --to 25mb
 
+# or just name the app you are uploading to
+npx halfsize video.mp4 --for discord
+
+# several files in one go
+npx halfsize clip1.mp4 clip2.mp4 clip3.mp4 --to 10mb
+
 # smaller file, same quality budget
 npx halfsize video.mp4 --to 10mb --codec h265
 
@@ -112,7 +119,7 @@ npm install -g halfsize
 npx halfsize --web
 ```
 
-Opens `http://127.0.0.1:4174` — drag a video in, pick 25 MB / 10 MB / 20 MB / 5 MB or type
+Opens `http://127.0.0.1:4174` — drag a video in, pick 20 MB / 16 MB / 5 MB or type
 your own limit, and watch the encode. The file goes to a temporary folder **on your own
 machine**; nothing is sent anywhere.
 
@@ -123,6 +130,19 @@ machine**; nothing is sent anywhere.
 After each run you can download a **share card** (the image at the top of this README) with the
 real numbers on it.
 
+Step-by-step guides with measured quality numbers:
+[Discord 20 MB](https://YKLovePython.github.io/halfsize/discord/) ·
+[WhatsApp 16 MB](https://YKLovePython.github.io/halfsize/whatsapp/) ·
+[WeChat 20 MB](https://YKLovePython.github.io/halfsize/wechat/) ·
+[any 20 MB limit](https://YKLovePython.github.io/halfsize/20mb/).
+
+### Use it from an agent
+
+The repo ships a skill in [`skills/halfsize/SKILL.md`](skills/halfsize/SKILL.md). Drop that
+folder into your agent's skills directory (for Claude Code: `.claude/skills/halfsize/`) and the
+agent can turn "make this fit in 25 MB" into a compression plus a measured quality report,
+instead of guessing a bitrate.
+
 ## How it works
 
 1. **Probe.** Read duration, resolution, frame rate, audio bitrate, rotation, and HDR metadata.
@@ -149,16 +169,37 @@ below 70   clearly degraded
 VMAF is Netflix's perceptual metric; it correlates with human judgement far better than PSNR
 or bitrate. It is not magic, but it is a much better answer than "trust me".
 
+## What each size costs
+
+Same 60-second 1080p clip, default settings, measured on a normal laptop:
+
+| Target | Output | Resolution | Video bitrate | VMAF | Verdict |
+|---|---|---|---|---|---|
+| 20 MB | 19.45 MB | 1280×720 | 2.46 Mbps | 88.3 | slight softening |
+| 16 MB | 15.59 MB | 960×540 | 1.94 Mbps | 84.8 | slight softening |
+| 10 MB | 9.77 MB | 960×540 | 1.17 Mbps | 82.9 | slight softening |
+| 5 MB | 4.93 MB | 640×360 | 0.55 Mbps | 72.0 | visible loss |
+
+Source: 60 s, 1920×1080, 30 fps, 18 Mbps H.264 (136 MB). VMAF is measured against the
+source at the midpoint, SSIM at three points. Real numbers move with content: a talking head
+does much better than confetti.
+
+At 20 MB the tool picked 720p on purpose. Sixty seconds of 1080p at 2.4 Mbps looks worse than
+720p at the same bits. `--no-downscale` overrides that, and `--codec h265` buys roughly 30%
+more quality at the same size if your player supports it.
+
 ## CLI reference
 
 ```
 halfsize <file> [options]
 
   --to <size>       Target size: 25mb, 700k, 1.5gb
+  --for <app>       Target cap for discord, whatsapp, wechat, email, twitter
   --crf <n>         Quality mode instead of size mode (18 best, 23 balanced, 28 small)
   --codec <name>    h264 (default, maximum compatibility) or h265 (about 30% smaller)
   --preset <name>   ultrafast .. veryslow (default: medium)
   --out <file>      Output path
+  --no-audio        Drop the audio track
   --no-verify       Skip SSIM/VMAF
   --no-downscale    Never reduce resolution (the target may then be missed)
   --json            Machine-readable result
@@ -172,16 +213,24 @@ halfsize <file> [options]
 
 Sizes accept `b`, `k`/`kb`, `m`/`mb`, `g`/`gb`, with or without a space. No unit means MB.
 
+`--for` uses the current free-tier caps (checked November 2026): `discord` 20 MB,
+`whatsapp` 16 MB, `wechat` 20 MB, `email` 20 MB, `twitter` 512 MB. Caps change, so `--to`
+always overrides.
+
 Exit codes: `0` success, `1` error. `--json` returns the plan, the measured quality, and the
 target accuracy, which makes it easy to wrap in a script.
 
 ## Install notes
 
-`ffmpeg-static` and `ffprobe-static` download prebuilt binaries during `npm install`. If you are
-behind a proxy or a TLS-inspecting network, that download can fail. `halfsize` then falls back
-to any `ffmpeg` on your `PATH`, or to a build you point at explicitly:
+`ffmpeg-static` downloads a prebuilt FFmpeg during `npm install`; FFprobe ships inside
+`ffprobe-static`, so it needs no download. If you are behind a proxy or a TLS-inspecting
+network, that download can fail. Point it at a mirror, or use a build you already have:
 
 ```bash
+# use the npmmirror binary mirror (fast in mainland China)
+FFMPEG_BINARIES_URL=https://registry.npmmirror.com/-/binary/ffmpeg-static npx halfsize video.mp4 --to 25mb
+
+# or an FFmpeg already on disk
 HALFSIZE_FFMPEG=/path/to/ffmpeg HALFSIZE_FFPROBE=/path/to/ffprobe npx halfsize video.mp4 --to 25mb
 ```
 
@@ -194,14 +243,23 @@ Debian/Ubuntu, `sudo apt install ffmpeg`. Run `npx halfsize --doctor` to see wha
 No. The CLI never touches the network. The web app talks only to `127.0.0.1`, and uploaded
 files go to a temp directory that is deleted when the process exits.
 
+**How do I get a video under Discord's 20 MB limit?**
+`npx halfsize clip.mp4 --for discord` targets the free-tier cap (20 MB as of late 2026) and
+writes a normal MP4 that plays in Discord's preview. Long 1080p clips usually come out at 720p;
+that resolution drop is what buys the size.
+
+**WeChat says the video is too large. What now?**
+`npx halfsize clip.mp4 --for wechat` targets the 20 MB chat-video cap. If you need it smaller
+still, pass `--to 10mb` (or any size) instead.
+
 **Why did it lower my resolution?**
-Because 25 MB of 4K is not enough bits to look good. Lowering resolution and keeping the
+Because 20 MB of 4K is not enough bits to look good. Lowering resolution and keeping the
 bitrate per pixel sane almost always looks better than keeping 4K and starving it. Use
 `--no-downscale` if you want to override that.
 
 **Why is the output slightly under the target, not exactly on it?**
 Container overhead and two-pass ABR both vary a little. `halfsize` aims ~3% under so it never
-overshoots a hard platform cap. In the example above it landed 0.3% under.
+overshoots a hard platform cap. In the example above it landed 0.4% under.
 
 **H.264 or H.265?**
 H.264 plays everywhere, including old Android phones and browsers. H.265 is roughly 30% smaller
@@ -211,12 +269,15 @@ at the same quality but can be awkward in some editors and older hardware. Defau
 Yes. It is plain Node.js and FFmpeg.
 
 **Can I batch a folder?**
-Not built in yet. A shell loop works today:
+Yes. List the files, or let your shell expand them:
 
 ```bash
-for f in *.mp4; do npx halfsize "$f" --to 25mb; done
+npx halfsize *.mp4 --to 25mb
 ```
 
+Each file gets its own plan and verdict, a failure does not stop the rest, and `--json` returns
+`{ "files": [ ... ] }`. `--out` is allowed only when there is a single input.
+
 **Why "halfsize"?**
 Because the honest answer to "how much smaller will it get?" is usually "about half, or a lot
 more than half". The tool reports the real number either way.
@@ -224,12 +285,11 @@ more than half". The tool reports the real number either way.
 ## Roadmap
 
 - Hardware encoding (NVENC / QSV / VideoToolbox) as an opt-in fast path
-- Batch mode and a folder watcher
+- A folder watcher that compresses new files as they appear
 - Subtitle and multiple audio track passthrough
 - HDR-to-SDR tonemapping, so iPhone HDR clips keep their colors
 - AV1 (`libsvtav1`) when the source is already AV1-friendly
 - A single-file binary, so Node.js is not required
-- Presets for specific platform caps (WeChat, Discord, email, X, Bluesky)
 
 If you want one of these, open an issue and say which. Pull requests are welcome; see
 [CONTRIBUTING.md](CONTRIBUTING.md).
@@ -251,6 +311,8 @@ it to a target, probes the output, and asserts the size and SSIM. No fixtures in
 
 MIT. Use it, fork it, ship it.
 
+See [CHANGELOG.md](CHANGELOG.md) for what changed.
+
 ---
 
 If `halfsize` saved you from guessing a bitrate, a star helps the next person find it.

package/README.zh-CN.md

@@ -19,6 +19,7 @@
 
 <p align="center">
   <a href="README.md">English</a> ·
+  <a href="https://YKLovePython.github.io/halfsize/zh/">官网与教程</a> ·
   <a href="#快速开始">快速开始</a> ·
   <a href="#它怎么工作">它怎么工作</a> ·
   <a href="#常见问题">常见问题</a>
@@ -26,7 +27,7 @@
 
 ---
 
-微信不让发超过 **25 MB**，Discord 只给 **10 MB**，邮件大多卡在 **20 MB**。
+微信和 Discord 都只让发 **20 MB**，邮件也大多卡在 **20 MB**。
 于是你打开剪辑软件，猜一个码率，导出，看一眼大小，再导一次——最后还是不知道画质到底掉了多少。
 
 `halfsize` 把这件事变成一行命令：
@@ -39,7 +40,7 @@ npx halfsize 婚礼.mp4 --to 25mb
 画质到底还在不在。
 
 ```
-  halfsize 0.1.0
+  halfsize 0.1.5
 
   source.mp4
   23.2 MB  8s  1920x1080  30.00 fps  h264
@@ -50,9 +51,9 @@ npx halfsize 婚礼.mp4 --to 25mb
   estimate   1.94 MB  (12x smaller)
   output     source.2mb.mp4
 
-  measuring quality                                        done in 2s
+  measuring quality                                        done in 1s
 
-  23.2 MB  ->  1.99 MB   12x smaller   0.3% under target
+  23.2 MB  ->  1.99 MB   12x smaller   0.4% under target
   VMAF 84.4   SSIM 0.968   slight softening
 
   -> C:\Videos\source.2mb.mp4
@@ -60,7 +61,7 @@ npx halfsize 婚礼.mp4 --to 25mb
 
 ## 为什么做这个
 
-「把视频变小」早就有人解决了。真正没人做好的是：**「刚好塞进 25 MB，然后告诉我画质还行不行」**。
+「把视频变小」早就有人解决了。真正没人做好的是：**「刚好塞进 20 MB，然后告诉我画质还行不行」**。
 
 - HandBrake 很好用，但它要你想清楚编码器、RF 值、preset 这些词。
 - 在线压缩网站也能用，直到你想起自己刚把私人视频传给了陌生人。
@@ -84,6 +85,12 @@ npx halfsize 婚礼.mp4 --to 25mb
 # 压到指定大小
 npx halfsize video.mp4 --to 25mb
 
+# 或者直接说你要传到哪里
+npx halfsize video.mp4 --for discord
+
+# 一次压好几个
+npx halfsize clip1.mp4 clip2.mp4 clip3.mp4 --to 10mb
+
 # 更小的文件，H.265
 npx halfsize video.mp4 --to 10mb --codec h265
 
@@ -109,7 +116,7 @@ npm install -g halfsize
 npx halfsize --web
 ```
 
-打开 `http://127.0.0.1:4174`，把视频拖进去，选 25 MB / 10 MB / 20 MB / 5 MB，或者自己输入一个数，
+打开 `http://127.0.0.1:4174`，把视频拖进去，选 20 MB / 16 MB / 5 MB，或者自己输入一个数，
 然后看着它压。文件只会写进**你自己电脑**的临时目录，不会发到任何地方。
 
 <p align="center">
@@ -118,6 +125,18 @@ npx halfsize --web
 
 每次压完可以生成一张**分享图**（就是本文最上面那张），上面是这次真实的数字。
 
+附实测画质的分平台教程：
+[微信 20 MB](https://YKLovePython.github.io/halfsize/zh/wechat/) ·
+[任意 20 MB 限制](https://YKLovePython.github.io/halfsize/zh/20mb/) ·
+[Discord 20 MB](https://YKLovePython.github.io/halfsize/discord/) ·
+[WhatsApp 16 MB](https://YKLovePython.github.io/halfsize/whatsapp/)。
+
+### 给 agent 用
+
+仓库里带了 [`skills/halfsize/SKILL.md`](skills/halfsize/SKILL.md)。把整个文件夹放进你的
+agent 技能目录（Claude Code 是 `.claude/skills/halfsize/`），agent 就能把「把这个视频压到
+25 MB」变成一次压缩加一份画质报告，而不是瞎猜码率。
+
 ## 它怎么工作
 
 1. **探测。** 读取时长、分辨率、帧率、音频码率、旋转信息、HDR 标记。
@@ -140,16 +159,35 @@ VMAF ≥ 70  能看出损失
 VMAF 是 Netflix 提出的感知质量指标，比 PSNR 或「码率多少」更接近人眼判断。
 它不是魔法，但比「相信我」靠谱得多。
 
+## 各档大小到底损失多少画质
+
+同一个 60 秒 1080p 视频，默认设置，在普通笔记本上实测：
+
+| 目标 | 输出 | 分辨率 | 视频码率 | VMAF | 结论 |
+|---|---|---|---|---|---|
+| 20 MB | 19.45 MB | 1280×720 | 2.46 Mbps | 88.3 | 轻微变软 |
+| 16 MB | 15.59 MB | 960×540 | 1.94 Mbps | 84.8 | 轻微变软 |
+| 10 MB | 9.77 MB | 960×540 | 1.17 Mbps | 82.9 | 轻微变软 |
+| 5 MB | 4.93 MB | 640×360 | 0.55 Mbps | 72.0 | 能看出损失 |
+
+源片：60 秒、1920×1080、30fps、18 Mbps H.264（136 MB）。VMAF 在中间点对着源片测量，
+SSIM 取三个采样点。实际数字会随内容变化：新闻口播会好很多，满屏彩纸会差很多。
+
+20 MB 这一档是故意降到 720p 的：60 秒 1080p 给 2.4 Mbps，还不如把同样的比特给 720p。
+想强制保分辨率就加 `--no-downscale`；播放器支持的话，`--codec h265` 能在同尺寸下多换约 30% 画质。
+
 ## 命令行参数
 
 ```
 halfsize <file> [options]
 
   --to <size>       目标大小：25mb、700k、1.5gb
+  --for <app>       按平台上限：discord、whatsapp、wechat、email、twitter
   --crf <n>         质量模式，不按大小（18 最好，23 均衡，28 更小）
   --codec <name>    h264（默认，兼容性最好）或 h265（大约再小 30%）
   --preset <name>   ultrafast .. veryslow（默认 medium）
   --out <file>      输出路径
+  --no-audio        去掉音轨
   --no-verify       跳过 SSIM/VMAF 检测
   --no-downscale    绝不降分辨率（可能会压不到目标）
   --json            机器可读结果
@@ -163,6 +201,9 @@ halfsize <file> [options]
 
 大小支持 `b`、`k`/`kb`、`m`/`mb`、`g`/`gb`，中间可以有空格。不写单位按 MB 算。
 
+`--for` 用的是当前免费档上限（2026 年 11 月核对）：`discord` 20 MB、`whatsapp` 16 MB、
+`wechat` 20 MB、`email` 20 MB、`twitter` 512 MB。平台上限会变，写死不如随时用 `--to` 覆盖。
+
 退出码：`0` 成功，`1` 出错。`--json` 会返回方案、画质测量和目标误差，方便包进脚本。
 
 ## 安装说明
@@ -177,18 +218,39 @@ HALFSIZE_FFMPEG=/path/to/ffmpeg HALFSIZE_FFPROBE=/path/to/ffprobe npx halfsize v
 Windows 上 `winget install Gyan.FFmpeg` 就够了；macOS 用 `brew install ffmpeg`；
 Debian/Ubuntu 用 `sudo apt install ffmpeg`。跑一下 `npx halfsize --doctor` 能看到实际用的是哪个。
 
+如果 GitHub 下载慢或被阻断（大陆网络很常见），可以让 `ffmpeg-static` 改从 npmmirror 取二进制：
+
+```bash
+# macOS / Linux
+FFMPEG_BINARIES_URL=https://registry.npmmirror.com/-/binary/ffmpeg-static npx halfsize 视频.mp4 --to 25mb
+
+# Windows PowerShell
+$env:FFMPEG_BINARIES_URL="https://registry.npmmirror.com/-/binary/ffmpeg-static"; npx halfsize 视频.mp4 --to 25mb
+```
+
+`ffprobe` 是随包附带的，不需要单独下载。已经装过系统 FFmpeg 的话，`halfsize` 会优先用它，
+连这一步都可以跳过。
+
 ## 常见问题
 
 **视频会被上传吗？**
 不会。命令行完全不联网。网页版只和 `127.0.0.1` 通信，上传的文件放在临时目录，进程退出就删掉。
 
+**Discord 发不出去，怎么压到 20 MB？**
+`npx halfsize 视频.mp4 --for discord` 会按免费档上限（2026 年底是 20 MB）压，输出就是普通 MP4，
+Discord 预览能直接播。长一点的 1080p 视频通常会降到 720p，尺寸就是靠这一步省出来的。
+
+**微信提示视频太大怎么办？**
+`npx halfsize 视频.mp4 --for wechat` 会按微信聊天视频的 20 MB 上限压。还想更小就换成
+`--to 10mb`（或者任意大小）。
+
 **为什么给我降分辨率了？**
-因为 25 MB 的 4K 根本不够比特，硬撑 4K 只会满屏马赛克。降分辨率、把每像素比特数保住，
+因为 20 MB 的 4K 根本不够比特，硬撑 4K 只会满屏马赛克。降分辨率、把每像素比特数保住，
 通常比「分辨率不变但饿死编码器」好看得多。不想降就加 `--no-downscale`。
 
 **为什么输出比目标小一点，而不是刚好等于？**
 容器开销和两遍 ABR 都会有波动。`halfsize` 会刻意瞄准低 3%，保证不会超过平台的硬上限。
-上面那个例子里，最终比目标低 0.3%。
+上面那个例子里，最终比目标低 0.4%。
 
 **H.264 还是 H.265？**
 H.264 到处都能播，包括老安卓机和浏览器。H.265 同画质大约小 30%，但部分剪辑软件和老硬件
@@ -198,24 +260,26 @@ H.264 到处都能播，包括老安卓机和浏览器。H.265 同画质大约
 能。就是 Node.js + FFmpeg，没有平台特定的东西。
 
 **能批量压一个文件夹吗？**
-还没内置。现在可以用一行 shell：
+能。直接把文件列出来，或者让 shell 展开：
 
 ```bash
-for f in *.mp4; do npx halfsize "$f" --to 25mb; done
+npx halfsize *.mp4 --to 25mb
 ```
 
+每个文件单独出方案和结论，某个失败不影响后面的，`--json` 返回 `{ "files": [ ... ] }`。
+多个输入时不能用 `--out`。
+
 **为什么叫 halfsize？**
 因为「能小多少」的诚实答案通常是「差不多一半，或者远不止一半」。它每次都会把真实数字告诉你。
 
 ## 路线图
 
 - 硬件编码（NVENC / QSV / VideoToolbox）作为可选的快速路径
-- 批量模式与文件夹监听
+- 文件夹监听，新文件一出现就自动压
 - 字幕和多音轨原样保留
 - HDR 转 SDR（让 iPhone 拍的 HDR 视频保住颜色）
 - 源已经是 AV1 时改用 AV1（`libsvtav1`）
 - 单文件二进制，不依赖 Node.js
-- 面向具体平台上限的预设（微信、Discord、邮件、X、Bluesky）
 
 想要哪个就开 issue 说一声。欢迎 PR，见 [CONTRIBUTING.md](CONTRIBUTING.md)。
 
@@ -236,6 +300,8 @@ node bin/halfsize.mjs --web
 
 MIT。随便用，随便改，随便发布。
 
+版本变化见 [CHANGELOG.md](CHANGELOG.md)。
+
 ---
 
 如果 `halfsize` 帮你少猜了一次码率，点个 star 能让下一个人也找到它。

package/package.json

@@ -1,47 +1,59 @@
-{
-  "name": "halfsize",
-  "version": "0.1.3",
-  "description": "Compress any video to an exact target size, locally, and prove the quality did not drop.",
-  "type": "module",
-  "bin": {
-    "halfsize": "bin/halfsize.mjs"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/YKLovePython/halfsize.git"
-  },
-  "homepage": "https://github.com/YKLovePython/halfsize#readme",
-  "bugs": {
-    "url": "https://github.com/YKLovePython/halfsize/issues"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "files": [
-    "bin",
-    "src",
-    "web",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "start": "node bin/halfsize.mjs",
-    "web": "node bin/halfsize.mjs --web",
-    "test": "node --test test/human.test.mjs test/plan.test.mjs test/quality.test.mjs test/cli.test.mjs test/e2e.test.mjs"
-  },
-  "keywords": [
-    "video",
-    "compress",
-    "video-compression",
-    "ffmpeg",
-    "target-size",
-    "vmaf",
-    "cli",
-    "windows"
-  ],
-  "license": "MIT",
-  "dependencies": {
-    "ffmpeg-static": "^5.3.0",
-    "ffprobe-static": "^3.1.0"
-  }
-}
+{
+  "name": "halfsize",
+  "version": "0.1.5",
+  "description": "Compress any video to an exact size (Discord or WeChat 20 MB, WhatsApp 16 MB) locally with FFmpeg and verify the quality with VMAF/SSIM.",
+  "type": "module",
+  "bin": {
+    "halfsize": "bin/halfsize.mjs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/YKLovePython/halfsize.git"
+  },
+  "homepage": "https://YKLovePython.github.io/halfsize/",
+  "bugs": {
+    "url": "https://github.com/YKLovePython/halfsize/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin",
+    "src",
+    "web",
+    "README.md",
+    "README.zh-CN.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node bin/halfsize.mjs",
+    "web": "node bin/halfsize.mjs --web",
+    "test": "node --test test/human.test.mjs test/plan.test.mjs test/quality.test.mjs test/cli.test.mjs test/e2e.test.mjs"
+  },
+  "keywords": [
+    "video",
+    "compress",
+    "compress-video",
+    "video-compression",
+    "video-compressor",
+    "reduce-video-size",
+    "ffmpeg",
+    "target-size",
+    "vmaf",
+    "ssim",
+    "discord",
+    "wechat",
+    "whatsapp",
+    "cli",
+    "privacy",
+    "windows",
+    "macos",
+    "linux"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "ffmpeg-static": "^5.3.0",
+    "ffprobe-static": "^3.1.0"
+  }
+}

package/src/cli.mjs

@@ -7,13 +7,15 @@ import { encode } from "./encode.mjs";
 import { measureQuality, verdict } from "./quality.mjs";
 import { bytes, duration, bitrate, ratio, parseSize, clock } from "./human.mjs";
 
-const VERSION = "0.1.3";
+const VERSION = "0.1.5";
 
 const HELP = `
   halfsize ${VERSION} - compress a video to an exact size, and prove it still looks the same.
 
   Usage
     halfsize <file> --to 25mb          Compress to a target size
+    halfsize <file> --for discord      Use a platform's upload limit
+    halfsize a.mp4 b.mp4 --to 10mb     Compress several files in a row
     halfsize <file> --to 25mb --codec h265
     halfsize <file> --crf 23           Quality-first mode
     halfsize --web                     Open the local app
@@ -22,10 +24,12 @@ const HELP = `
 
   Options
     --to <size>       Target size: 25mb, 700k, 1.5gb
+    --for <app>       Target cap for discord, whatsapp, wechat, email, twitter
     --crf <n>         Quality mode (18 best / 23 balanced / 28 small)
     --codec <name>    h264 (default, compatible) or h265 (smaller)
     --preset <name>   ultrafast..veryslow (default: medium)
     --out <file>      Output path
+    --no-audio        Drop the audio track
     --no-verify       Skip the SSIM/VMAF check
     --no-downscale    Never reduce resolution
     --json            Machine-readable result
@@ -40,7 +44,27 @@ const HELP = `
     resolution, encodes twice, then measures the result with SSIM and VMAF.
 `;
 
-const DEFAULTS = { codec: "h264", preset: "medium", verify: true, downscale: true };
+const DEFAULTS = { codec: "h264", preset: "medium", verify: true, downscale: true, audio: true };
+
+// Current upload caps as people hit them (checked November 2026). Discord raised
+// its free cap to 20 MB in August 2026 and WeChat's chat-video cap is 20 MB.
+// Caps change, so --to always wins if a preset is wrong for your account tier.
+export const PLATFORMS = {
+  discord: { bytes: 20 * 1_000_000, label: "Discord free (20 MB)" },
+  whatsapp: { bytes: 16 * 1_000_000, label: "WhatsApp media (16 MB)" },
+  wechat: { bytes: 20 * 1_000_000, label: "WeChat video (20 MB)" },
+  email: { bytes: 20 * 1_000_000, label: "Email attachment (20 MB)" },
+  twitter: { bytes: 512 * 1_000_000, label: "X / Twitter (512 MB)" },
+};
+
+function platformFor(name) {
+  const key = String(name || "").toLowerCase();
+  const found = PLATFORMS[key];
+  if (!found) {
+    throw new Error(`Unknown platform "${name}". Use one of: ${Object.keys(PLATFORMS).join(", ")}.`);
+  }
+  return { key, ...found };
+}
 
 function parseArgs(argv) {
   const args = { _: [], flags: { ...DEFAULTS } };
@@ -52,10 +76,12 @@ function parseArgs(argv) {
     else if (a === "--dry-run") args.flags.dryRun = true;
     else if (a === "--no-verify") args.flags.verify = false;
     else if (a === "--no-downscale") args.flags.downscale = false;
+    else if (a === "--no-audio") args.flags.audio = false;
     else if (a === "--web") args.flags.web = true;
     else if (a === "--doctor") args.flags.doctor = true;
     else if (a === "--port") args.flags.port = Number(argv[++i]);
     else if (a === "--to") args.flags.to = argv[++i];
+    else if (a === "--for") args.flags.for = argv[++i];
     else if (a === "--crf") args.flags.crf = Number(argv[++i]);
     else if (a === "--codec") args.flags.codec = argv[++i];
     else if (a === "--preset") args.flags.preset = argv[++i];
@@ -81,18 +107,53 @@ export async function main(argv) {
   if (flags.doctor) return doctor();
   if (flags.web) return startWeb(flags.port);
 
-  const input = path.resolve(args._[0]);
-  if (!fs.existsSync(input)) throw new Error(`File not found: ${input}`);
-  if (!flags.to && flags.crf === undefined) {
-    throw new Error("Pick a target: --to 25mb, or use --crf 23 for quality mode.");
+  if (flags.to && flags.for) throw new Error("Use --to or --for, not both.");
+  const platform = flags.for ? platformFor(flags.for) : null;
+  if (!flags.to && !platform && flags.crf === undefined) {
+    throw new Error("Pick a target: --to 25mb, --for discord, or --crf 23 for quality mode.");
+  }
+  if (flags.out && args._.length > 1) {
+    throw new Error("--out only works with one input file. It would overwrite itself in a batch.");
+  }
+
+  const inputs = args._.map((file) => path.resolve(file));
+  const targetBytes = platform ? platform.bytes : flags.to ? parseSize(flags.to) : null;
+  const batch = inputs.length > 1;
+
+  const results = [];
+  let failed = 0;
+  for (const input of inputs) {
+    try {
+      results.push(await processFile(input, flags, targetBytes, platform, batch));
+    } catch (err) {
+      failed++;
+      results.push({ input: { file: input }, error: err?.message || String(err) });
+      if (!flags.json) console.error(`\n  x ${path.basename(input)}: ${err?.message || err}`);
+      if (process.env.HALFSIZE_DEBUG) console.error(err?.stack);
+    }
   }
 
-  const targetBytes = flags.to ? parseSize(flags.to) : null;
+  if (flags.json) {
+    console.log(JSON.stringify(batch ? { files: results } : results[0], null, 2));
+  } else if (batch && !flags.dryRun) {
+    printBatch(results);
+  }
+
+  if (failed) process.exitCode = 1;
+}
+
+async function processFile(input, flags, targetBytes, platform, batch) {
+  if (!fs.existsSync(input)) throw new Error(`File not found: ${input}`);
+
   const info = await probe(input);
 
   if (targetBytes && targetBytes >= info.sizeBytes) {
-    console.log(`\n  This file is already ${bytes(info.sizeBytes)}, smaller than the ${bytes(targetBytes)} target.\n`);
-    return;
+    if (batch) {
+      console.log(`\n  ${path.basename(input)} already fits (${bytes(info.sizeBytes)}), skipped.`);
+    } else {
+      console.log(`\n  This file is already ${bytes(info.sizeBytes)}, smaller than the ${bytes(targetBytes)} target.\n`);
+    }
+    return { input: { file: input, bytes: info.sizeBytes }, targetBytes, skipped: "already-smaller" };
   }
 
   const plan = planEncode(info, {
@@ -101,17 +162,20 @@ export async function main(argv) {
     codec: flags.codec,
     preset: flags.preset,
     downscale: flags.downscale,
+    audio: flags.audio,
   });
 
-  const outPath = flags.out
-    ? path.resolve(flags.out)
-    : defaultOutput(input, flags, plan);
+  const outPath = flags.out ? path.resolve(flags.out) : defaultOutput(input, flags, plan);
 
-  if (!flags.json) printPlan(info, plan, flags, outPath);
+  if (!flags.json) printPlan(info, plan, flags, outPath, platform, !batch);
 
   if (flags.dryRun) {
-    if (flags.json) console.log(JSON.stringify({ info, plan, out: outPath }, null, 2));
-    return;
+    return {
+      info,
+      plan,
+      out: outPath,
+      dryRun: true,
+    };
   }
 
   const progress = new Progress(Boolean(process.stdout.isTTY) && !flags.json, info.duration);
@@ -123,7 +187,7 @@ export async function main(argv) {
   }
 
   let quality = { ssim: null, vmaf: null };
-  if (flags.verify && !flags.noVerify) {
+  if (flags.verify) {
     if (!flags.json) process.stdout.write(`  measuring quality `);
     quality = await measureQuality(input, outPath, info.duration);
     if (!flags.json) process.stdout.write(`\r${" ".repeat(40)}\r`);
@@ -142,19 +206,34 @@ export async function main(argv) {
     elapsedMs: result.elapsedMs,
   };
 
-  if (flags.json) {
-    console.log(JSON.stringify(summary, null, 2));
-    return;
-  }
+  if (!flags.json) printResult(summary, outPath);
+  return summary;
+}
 
-  printResult(summary, outPath);
+function printBatch(results) {
+  const done = results.filter((r) => r.output);
+  const skipped = results.filter((r) => r.skipped);
+  const errors = results.filter((r) => r.error);
+  console.log("");
+  if (done.length) {
+    const before = done.reduce((sum, r) => sum + r.input.bytes, 0);
+    const after = done.reduce((sum, r) => sum + r.output.bytes, 0);
+    console.log(`  ${done.length} compressed   ${bytes(before)} -> ${bytes(after)}   ${ratio(before, after)} smaller`);
+  }
+  if (skipped.length) console.log(`  ${skipped.length} skipped (already under target)`);
+  if (errors.length) console.log(`  ${errors.length} failed`);
+  console.log("");
 }
 
 function defaultOutput(input, flags, plan) {
   const dir = path.dirname(input);
   const ext = path.extname(input);
   const base = path.basename(input, ext);
-  const tag = flags.to ? String(flags.to).replace(/\s+/g, "").toLowerCase() : `crf${flags.crf}`;
+  const tag = flags.for
+    ? String(flags.for).toLowerCase()
+    : flags.to
+      ? String(flags.to).replace(/\s+/g, "").toLowerCase()
+      : `crf${flags.crf}`;
   return path.join(dir, `${base}.${tag}.mp4`);
 }
 
@@ -162,16 +241,18 @@ function line(label, value) {
   console.log(`  ${label.padEnd(10)} ${value}`);
 }
 
-function printPlan(info, plan, flags, outPath) {
-  console.log("");
-  console.log(`  halfsize ${VERSION}`);
+function printPlan(info, plan, flags, outPath, platform, showHeader = true) {
   console.log("");
+  if (showHeader) {
+    console.log(`  halfsize ${VERSION}`);
+    console.log("");
+  }
   console.log(`  ${path.basename(info.file)}`);
   console.log(
     `  ${bytes(info.sizeBytes)}  ${duration(info.duration)}  ${info.video.width}x${info.video.height}  ${info.video.fps.toFixed(2)} fps  ${info.video.codec}`,
   );
   console.log("");
-  if (plan.mode === "size") line("target", bytes(plan.targetBytes));
+  if (plan.mode === "size") line("target", platform ? `${bytes(plan.targetBytes)}  (${platform.label})` : bytes(plan.targetBytes));
   else line("mode", `CRF ${plan.crf}`);
   line(
     "plan",

package/src/encode.mjs

@@ -15,6 +15,10 @@ function buildFilters(plan) {
 
 function baseArgs(input, plan, passlog) {
   const args = ["-hide_banner", "-y", "-i", input];
+  // Map exactly the streams we mean to encode. Without this, ffmpeg can pick a
+  // cover art / thumbnail stream on files that carry one.
+  args.push("-map", "0:v:0");
+  if (plan.audioKbps) args.push("-map", "0:a:0?");
   const filters = buildFilters(plan);
   if (filters) args.push("-vf", filters);
   args.push("-fps_mode", "cfr");
@@ -28,7 +32,7 @@ function baseArgs(input, plan, passlog) {
 
 function audioArgs(plan) {
   if (!plan.audioKbps) return ["-an"];
-  return ["-c:a", "aac", "-b:a", `${plan.audioKbps}k`, "-ac", "2"];
+  return ["-c:a", "aac", "-b:a", `${plan.audioKbps}k`, "-ac", String(plan.audioChannels === 1 ? 1 : 2)];
 }
 
 export async function encode(input, output, plan, info, onProgress = () => {}) {

package/src/plan.mjs

@@ -62,6 +62,8 @@ export function planEncode(info, options = {}) {
 
   if (!info.duration) throw new Error("Could not read the duration of this file.");
 
+  const audioChannels = info.audio?.channels === 1 ? 1 : 2;
+
   if (options.crf !== undefined) {
     return {
       mode: "quality",
@@ -74,7 +76,8 @@ export function planEncode(info, options = {}) {
       height: info.video.height,
       fps: capFps(info.video.fps),
       videoKbps: null,
-      audioKbps: audioBitrate(info, 2000),
+      audioKbps: options.audio === false ? 0 : audioBitrate(info, 2000),
+      audioChannels,
       targetBytes: null,
       twoPass: false,
       downscaled: false,
@@ -87,7 +90,7 @@ export function planEncode(info, options = {}) {
   if (!options.targetBytes) throw new Error("A target size is required.");
 
   const totalKbps = ((options.targetBytes * 8) / info.duration / 1000) * 0.97;
-  const audioKbps = audioBitrate(info, totalKbps);
+  const audioKbps = options.audio === false ? 0 : audioBitrate(info, totalKbps);
   const videoKbps = Math.max(40, Math.round(totalKbps - audioKbps));
   const fps = capFps(info.video.fps);
 
@@ -131,6 +134,7 @@ export function planEncode(info, options = {}) {
     fps,
     videoKbps,
     audioKbps,
+    audioChannels,
     targetBytes: options.targetBytes,
     twoPass: Boolean(codec.twoPass),
     downscaled,

package/web/index.html

@@ -138,6 +138,8 @@
   .error.on { display: block; }
 
   footer { margin-top: 46px; color: var(--dim); font-size: 12px; display: flex; justify-content: space-between; gap: 12px; flex-wrap: wrap; }
+  footer a { color: var(--muted); }
+  footer a:hover { color: var(--accent); }
   .kbd { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 12px; color: var(--muted); background: var(--panel-2); border: 1px solid var(--line); padding: 3px 7px; border-radius: 6px; }
   .hidden { display: none !important; }
 </style>
@@ -150,7 +152,7 @@
   </header>
 
   <h1 data-i18n-html="title">把任何视频，塞进任何限制。<br><em>并且证明画质没变。</em></h1>
-  <p class="sub" data-i18n-html="sub">微信只让发 25 MB，Discord 只让发 10 MB。选一个数字，剩下的交给它：算码率、降分辨率、两遍编码，最后用 <b>VMAF</b> 告诉你画质掉没掉。</p>
+  <p class="sub" data-i18n-html="sub">微信和 Discord 都只让发 20 MB，邮件也差不多。选一个数字，剩下的交给它：算码率、降分辨率、两遍编码，最后用 <b>VMAF</b> 告诉你画质掉没掉。</p>
 
   <div class="card" id="card">
     <div id="drop" class="drop" role="button" tabindex="0">
@@ -172,9 +174,8 @@
         <div>
           <div class="label" data-i18n="target">目标大小</div>
           <div class="chips" id="presets">
-            <button class="chip on" data-size="25mb">25 MB<small data-i18n="wechat">微信</small></button>
-            <button class="chip" data-size="10mb">10 MB<small>Discord</small></button>
-            <button class="chip" data-size="20mb">20 MB<small data-i18n="email">邮件</small></button>
+            <button class="chip on" data-size="20mb">20 MB<small data-i18n="wechat">微信 / Discord</small></button>
+            <button class="chip" data-size="16mb">16 MB<small>WhatsApp</small></button>
             <button class="chip" data-size="5mb">5 MB<small data-i18n="web">网页</small></button>
           </div>
           <div class="row">
@@ -217,7 +218,7 @@
 
   <footer>
     <div><span class="kbd">npx halfsize video.mp4 --to 25mb</span></div>
-    <div data-i18n="footer">本地 ffmpeg · 零上传 · MIT</div>
+    <div><span data-i18n="footer">本地 ffmpeg · 零上传 · MIT</span> · <a href="https://github.com/YKLovePython/halfsize" target="_blank" rel="noopener">GitHub ★</a> · <a href="https://YKLovePython.github.io/halfsize/" target="_blank" rel="noopener">Guides</a></div>
   </footer>
 </div>
 
@@ -226,7 +227,7 @@ const I18N = {
   zh: {
     pill: "本地运行 · 不上传 · 无账号",
     title: "把任何视频，塞进任何限制。<br><em>并且证明画质没变。</em>",
-    sub: "微信只让发 25 MB，Discord 只让发 10 MB。选一个数字，剩下的交给它：算码率、降分辨率、两遍编码，最后用 <b>VMAF</b> 告诉你画质掉没掉。",
+    sub: "微信和 Discord 都只让发 20 MB，邮件也差不多。选一个数字，剩下的交给它：算码率、降分辨率、两遍编码，最后用 <b>VMAF</b> 告诉你画质掉没掉。",
     dropBig: "把视频拖进来，或点击选择",
     dropSmall: "MP4 · MOV · MKV · AVI · WebM · 不超过 8 GB",
     target: "目标大小",
@@ -242,8 +243,7 @@ const I18N = {
     verifying: "正在测画质…",
     done: "完成",
     uploading: "上传中",
-    wechat: "微信",
-    email: "邮件",
+    wechat: "微信 / Discord",
     web: "网页",
     smallerLabel: "更小",
     accuracyUnder: (p) => `比目标小 ${p}%`,
@@ -266,7 +266,7 @@ const I18N = {
   en: {
     pill: "runs locally · no upload · no account",
     title: "Fit any video into any limit.<br><em>And prove nothing changed.</em>",
-    sub: "WeChat caps at 25 MB. Discord caps at 10 MB. Pick the number. It does the rest: bitrate math, resolution, two-pass encoding, then measures the result with <b>VMAF</b>.",
+    sub: "WeChat and Discord both cap videos at 20 MB. Email is about the same. Pick the number. It does the rest: bitrate math, resolution, two-pass encoding, then measures the result with <b>VMAF</b>.",
     dropBig: "Drop a video, or click to choose",
     dropSmall: "MP4 · MOV · MKV · AVI · WebM · up to 8 GB",
     target: "Target size",
@@ -282,8 +282,7 @@ const I18N = {
     verifying: "measuring quality…",
     done: "done",
     uploading: "uploading",
-    wechat: "WeChat",
-    email: "email",
+    wechat: "WeChat / Discord",
     web: "web",
     smallerLabel: "smaller",
     accuracyUnder: (p) => `${p}% under target`,
@@ -320,7 +319,7 @@ const drop = $("drop"), fileInput = $("file"), editor = $("editor"), preview = $
 const meta = $("meta"), fname = $("fname"), go = $("go"), progress = $("progress");
 const fill = $("fill"), pct = $("pct"), speed = $("speed"), result = $("result"), error = $("error");
 
-let state = { id: null, target: "25mb", codec: "h264", data: null };
+let state = { id: null, target: "20mb", codec: "h264", data: null };
 
 function fmtBytes(n) {
   if (!n && n !== 0) return "—";