veodl 1.12.1 → 2.0.0

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to veo. This project follows [Semantic Versioning](https://semver.org/).
 
+## 2.0.0
+
+### Changed
+
+- **Native Rust binary**: veo is rewritten in Rust and ships as a single native executable per platform. Node.js is no longer required to run veo; `npm install -g veodl` keeps working and installs the matching prebuilt binary from the single veodl package. Commands, flags, JSON output, config files, profiles, run records, history, statistics and retry jobs stay compatible, including resumable staging directories of 1.x.
+- Startup is about ten times faster, and SHA-256 checks of yt-dlp, FFmpeg and FFprobe run in parallel with hardware acceleration, so every run still verifies the managed tools before use.
+- A single-URL download reuses the metadata read while checking the page, so the backend starts once instead of twice per URL. Dry runs, quality and subtitle listings benefit the same way.
+- First-use FFmpeg/FFprobe setup downloads both tools in parallel and publishes them by rename instead of copying them again.
+- yt-dlp receives an installed Node.js, Deno or Bun as JavaScript runtime for YouTube challenges; `VEO_JS_RUNTIME=name:path` selects one explicitly. `veo doctor` reports the runtime instead of the Node.js version.
+- Cancelling a download stops yt-dlp together with the FFmpeg processes it started.
+
+### Removed
+
+- Unused compatibility code for configuration comments of the former German template.
+
 ## 1.12.1
 
 ### Fixed

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 veo contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 veo contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -8,9 +8,12 @@ Automating with an agent? Start with the [agent guide](docs/AGENT_GUIDE.md) for
 
 ## Install and run
 
-Requires **Node.js 22+** and npm. Internet access is needed for installation and first-use backend setup.
+veo is a single native executable (written in Rust) for Windows, macOS, Linux and
+Android/Termux. Internet access is needed for installation and first-use backend setup.
 
-The npm package is `veodl`; the installed commands are `veo` and `veodl`.
+The npm package is `veodl`; the installed commands are `veo` and `veodl`. npm installs the
+prebuilt binary for your platform from a matching `veodl-<platform>-<arch>` package; no
+install scripts run. Node.js is only needed for npm itself, not to run downloads.
 
 ```bash
 npx veodl "https://example.com/video.mp4"
@@ -30,16 +33,22 @@ JavaScript support with `pkg install -y`. On desktop systems, missing media tool
 are downloaded into veo's own cache. Run `veo doctor fix` to prepare everything
 before downloading. Plain `veo doctor`, help and version do not install tools.
 
-From this checkout, without publishing:
+Without npm, download the binary for your platform from the GitHub releases page, or
+build it with Rust 1.85+:
 
 ```bash
-npm install
-node bin/veo.js --help
-npm link
-veo "https://example.com/video.mp4"
+cargo install --git https://github.com/Mailo037/veodl
+```
+
+From this checkout:
+
+```bash
+cargo build --release     # target/release/veo
+cargo test                # unit and offline end-to-end tests
+cargo test --test smoke -- --ignored   # real downloads with yt-dlp and FFmpeg
 ```
 
-`package.json` maps `"veo": "./bin/veo.js"`; npm creates the executable/shim automatically. No custom command prefix is needed. Use only trusted URLs, and quote URLs to protect query strings from your shell.
+Use only trusted URLs, and quote URLs to protect query strings from your shell.
 
 If something does not work, run `veo doctor` first: it inspects the whole local setup and prints one line per check.
 
@@ -54,50 +63,109 @@ regular command arguments; veo never starts a prompt in a script.
 ## Usage
 
 ```text
-veo <url> [<url>...] [options]
-
-Options:
-  -q, --quality <quality>   best, 2160p, 1440p, 1080p, 720p, 480p, 360p
-  -o, --output <path>       Output directory (default: current working directory)
-  -r, --rename <name>       Filename without extension; * inserts the original title
-  --closest-quality         Nearest available resolution instead of an upper bound
-  --open                    Open the saved file with your default app
-  --audio                   Audio only (MP3 by default)
-  --format <format>         Video: mp4, mkv, webm, mov
-                            Audio: mp3, m4a, aac, opus, flac, wav
-  --recode                  Explicit video conversion (requires --format)
-  --playlist-concurrency <n> Parallel playlist entries, 1-4 (default: 2)
-  --playlist                Download every entry of a playlist or channel URL
-  -N, --concurrent-fragments <n>   Parallel fragments, 1-64 (default: 8; 17-64 experimental)
-  --experimental-fragments  Explicitly accept experimental values above 16
-  --subs                    Download subtitles (default languages: en)
-  --auto-subs               Include automatically generated subtitles
-  --sub-langs <langs>       Subtitle languages, e.g. "de,en" (manual unless --auto-subs)
-  --sub-format <format>     Prefer subtitle formats, e.g. srt/vtt/best
-  --list-subs               Show manual and automatic subtitle availability
-  --embed-subs              Embed subtitles into the video file
-  --embed-metadata          Embed title, date and other metadata
-  --embed-thumbnail         Embed the thumbnail
-  --sponsorblock-remove <categories>   e.g. "sponsor,selfpromo"
-  --section <range>         Only a time range, e.g. "*10:00-12:00"
-  --cookies <file>          Netscape cookie file, for content you may access
+Usage:
+  veo <url> [<url>...] [options]
+
+Download:
+  -q, --quality <quality>     Video quality (best, 2160p, 1440p, 1080p, 720p, 480p, 360p)
+                              Numeric qualities are an upper bound: -q 720p never
+                              downloads 2160p.
+  --closest-quality           Pick the nearest available resolution, above or below
+  -o, --output <path>         Output directory (default: current directory)
+  -r, --rename <name>         Filename without extension; * inserts the original title
+  --audio                     Download audio only (default: mp3)
+  --format <format>           Video: mp4, mkv, webm, mov; audio: mp3, m4a, aac, opus, flac, wav
+                              Video uses lossless remux; incompatible codecs fail.
+  --compatible                Ensure MP4 H.264/AAC; converts only when needed (may lose quality)
+  --recode                    Allow video conversion (requires --format; may lose quality)
+  --open                      Open the saved file with your default app
+  --resume                    Keep partial data and continue an interrupted download
+  --skip-existing             Skip matching downloads still present on disk
+  --section <range>           Download only a time range, e.g. "*10:00-12:00"
+  --sponsorblock-remove <categories>
+                              Remove sponsor segments, e.g. "sponsor,selfpromo"
+
+Subtitles and metadata:
+  --subs                      Download subtitles (default languages: en)
+  --auto-subs                 Include automatically generated subtitles
+  --sub-langs <langs>         Subtitle languages, e.g. "de,en" (manual unless --auto-subs)
+  --sub-format <format>       Preferred subtitle format, e.g. srt/vtt/best
+  --list-subs                 Show manual and automatic subtitle languages, then exit
+  --embed-subs                Embed subtitles into the video file
+  --embed-metadata            Embed title, date and other metadata
+  --embed-thumbnail           Embed the thumbnail
+
+Playlists and batches:
+  --playlist                  Download every entry of a playlist or channel URL
+  --playlist-items <list>     Select playlist entries, e.g. 1,3-5 (implies --playlist)
+  --playlist-concurrency <n>  Simultaneous playlist downloads (1-4; default: 2)
+  --concurrent-downloads <n>  Parallel URLs/batch entries (1-4; default: 2)
+  --batch-file <file>         Read URLs from a file (one per line; # comments)
+  --retry-failed <id|file>    Retry failed/unfinished items by run ID or job file
+
+Naming and privacy:
+  --filename-template <s>     Filename without extension, e.g. {index} - {title}
+  --folder-template <s>       Relative folders, e.g. {channel}/{year}
+  --neutral-filename          Use a random video name; omit title and naming templates
+  --incognito                 Save media without run IDs, history, stats or retry data
+
+Inspect before downloading:
+  --list-qualities            Show available video resolutions and exit
+  --list-qualitys             Alias for --list-qualities
+  --list-formats              Show the available formats and exit
+  --list-sources              Find video sources loaded by a web page and exit
+  --auto-list-sources         Search after no video is found (default: on)
+  --source <n>                Select source number from that page (also for scripts)
+  --deep-scan                 Check every media candidate found during source search
+  --timeout <duration>        Source search deadline, e.g. 30, 30s or 2m (5s-10m)
+  --dry-run                   Show what would be downloaded and exit
+
+Network and performance:
+  -N, --concurrent-fragments <n>
+                              Parallel fragments (1-64; default: 8); 17-64 are experimental
+  --experimental-fragments    Explicitly accept experimental values above 16
+                              Otherwise requires terminal confirmation before download
+  --adaptive-concurrency      Reduce connections and retry temporary failures (default: on)
+  --check-space               Estimate cache/output space before downloading (default: on)
+  --cookies <file>            Netscape cookie file, for content you may access
   --cookies-from-browser <browser[:profile]>
-  --resume                  Keep partial data and continue an interrupted download
-  --incognito               Save media without run ID, history, stats or retry data
-  --neutral-filename        Optional random filename instead of title and templates
-  --list-qualities          Show available video resolutions and exit
-  --list-formats            Show available formats and exit
-  --dry-run                 Show what would be downloaded and exit
-  --verify                  Probe saved media files with FFprobe (default: off)
-  --json                    One JSON object per URL instead of prose
-  --profile <name>          Use a named profile from the config file
-  --batch-file <file>       Read one URL per line (blank lines and # comments ignored)
-  --retry-failed <id|file>  Retry failed/unfinished downloads by run ID or job file
-  --playlist-items <list>   Select entries, e.g. 1,3-5 (implies --playlist)
-  --skip-existing          Skip matching downloads that are still on disk
-  --no-<boolean-option>    Disable a default, e.g. --no-open or --no-audio
-  -v, --version             Show installed version (also: veo version)
-  -h, --help                Show help
+                              Read cookies from an installed browser
+
+Output and scripting:
+  --json                      Print one JSON object per URL instead of prose
+  --verify                    Probe saved media files with FFprobe (default: off)
+  --timings                   Show phase timings (default: on; --no-timings disables)
+  --no-color                  Disable terminal colors (also respects NO_COLOR)
+  --profile <name>            Apply a named config profile
+  --no-<boolean-option>       Disable a stored boolean default, e.g. --no-open
+  -v, --version               Show installed version (also: veo version)
+  -h, --help                  Show help; veo help all lists every option and command
+
+Commands:
+  veo doctor                  Diagnose the local setup
+  veo update|up [--check]     Update veo itself with npm (up is a short alias)
+  veo history                 Show the last 5 downloads (--json for scripting)
+  veo history --failed --limit 20
+                              Filter and extend download history
+  veo retry --last            Retry the newest failed or unfinished job
+  veo runs [id]               List active runs; add --json for metadata and progress
+  veo stop [id]               Stop one run, or every active run
+  veo stats                   Show persistent download statistics
+  veo changes [<version>]     List release notes; --since <version> for newer changes
+  veo subs <url>              List available manual and automatic subtitles
+  veo inspect <file>          Read media metadata; --check-audio measures audio signal
+  veo inspect run <id>        Inspect saved files from a finished run by its id
+  veo backend update          Install a newer yt-dlp release (see veo backend --help)
+  veo flush                   Stop veo runs and clear temporary downloads and jobs
+  veo config edit|path|profiles|guide|check|show|reset
+                              Manage defaults and named profiles
+  veo config edit [--external|--terminal]
+                              Choose the configuration editor
+  veo profile [list|reset|name]
+                              Show, list or change the default profile
+  veo alias list|add|remove   Manage extra command names (wrappers calling veo)
+  veo uninstall [-p <name>]   Remove one alias, or everything with --yes
+  veo version                 Show the installed version
 ```
 
 ```bash
@@ -224,7 +292,7 @@ example through `veo config edit`. Enable it with `veo URL --profile kompatibel`
   `"profiles": { "default": { "color": true }, "plain": { "color": false } }`.
   Use `veo stats --profile plain` or `veo URL --profile plain`; `--color` or
   `--no-color` overrides the profile for one invocation (except `NO_COLOR`).
-  External npm/editor output and Node runtime warnings keep their own formatting.
+  External npm and editor output keeps its own formatting.
 
 ### Filename templates and folders
 
@@ -750,7 +818,8 @@ because a single stray file in the cache must never stop later runs.
 
 ### `veo doctor`
 
-Prints one line per check: `ok`, `warn` or `fail`. It inspects Node.js, the platform, the
+Prints one line per check: `ok`, `warn` or `fail`. It inspects the JavaScript runtime used by
+yt-dlp, the platform, the
 output directory, the backend cache, yt-dlp (including the SHA-256 of the cached binary and
 the version it reports), FFmpeg/FFprobe, a system FFmpeg fallback, the config file, leftover
 partial downloads, stale duplicate-detection records, the npm registry and the yt-dlp release host. It downloads no backend and
@@ -759,8 +828,8 @@ at least one check fails.
 
 Run `veo doctor fix` to restore missing or damaged managed tools and check again.
 It stages bundled FFmpeg/FFprobe and downloads verified yt-dlp when needed. Missing
-desktop media tools are installed in veo's cache using npm and the pinned media
-packages. On Termux it installs missing native tools with the package manager.
+desktop media tools are downloaded into veo's cache from the pinned media releases and
+verified before use. On Termux it installs missing native tools with the package manager.
 With `--offline`, it only uses local binaries; missing tools are reported for an online retry.
 Use `-o PATH` to create and check an output directory. Config errors and invalid overrides
 are reported for manual correction; PATH and config values are never rewritten.
@@ -770,13 +839,13 @@ A missing system FFmpeg is not a warning when the selected media tools work.
 
 YouTube, X/Twitter, TikTok, Vimeo, Reddit, Instagram, and [many other yt-dlp sites](https://github.com/yt-dlp/yt-dlp/blob/master/supportedsites.md) are supported **when publicly accessible and technically available**. Support changes with websites, regions, rate limits, and backend versions; it is not a guarantee that every URL will work.
 
-Official standalone yt-dlp is acquired on first download and cached outside the package directory; help, version and plain doctor never download the backend. The release is pinned and SHA-256 verified against hashes shipped with this package. The npm package has no runtime dependencies and runs no installation scripts.
+Official standalone yt-dlp is acquired on first download and cached outside the package directory; help, version and plain doctor never download the backend. The release is pinned and SHA-256 verified against hashes shipped with this package. The npm package runs no installation scripts; its only dependencies are the optional per-platform packages that carry the veo binary.
 
 When no trusted local FFmpeg/FFprobe pair is available, veo downloads both tools directly from the upstream [ffmpeg-static binary releases](https://github.com/eugeneware/ffmpeg-static/releases/tag/b6.1.1). Release URLs, compressed and executable SHA-256 hashes, and byte counts are pinned in the package. The complete pair and its license and README must pass verification before either executable is started. Later uses verify the cached pair again; legacy or damaged cached binaries are not accepted merely because they are executable. Most targets use FFmpeg 6.1.1; Windows ia32 uses the last available pair, FFmpeg 6.0. Old `FFMPEG_BINARIES_URL`, `FFMPEG_BINARY_RELEASE` and `FFMPEG_BIN` variables do not change these downloads. Use `VEO_FFMPEG_PATH` to choose a trusted installed pair explicitly.
 
-The downloaded binaries retain their separate upstream licenses. `FFmpeg.LICENSE` and `FFmpeg.README` are saved next to the cached tools, including upstream source and build information. The JavaScript CLI remains MIT licensed. No Python installation is needed on supported standalone platforms.
+The downloaded binaries retain their separate upstream licenses. `FFmpeg.LICENSE` and `FFmpeg.README` are saved next to the cached tools, including upstream source and build information. veo itself is MIT licensed. No Python installation is needed on supported standalone platforms.
 
-The existing Node executable is explicitly enabled as yt-dlp's JavaScript runtime for YouTube. Local yt-dlp configuration and plugins are disabled for predictable execution. Arguments are passed without a shell.
+An installed Node.js, Deno or Bun (found on PATH, in that order) is passed to yt-dlp as its JavaScript runtime for YouTube; `VEO_JS_RUNTIME=deno:/path/to/deno` selects one explicitly. Without one, yt-dlp uses its own default. Local yt-dlp configuration and plugins are disabled for predictable execution. Arguments are passed without a shell.
 
 Windows ARM64 uses an FFmpeg/FFprobe pair found on `PATH`, including the usual
 WinGet, Chocolatey and `C:\ffmpeg\bin` locations, or automatically downloads x64
@@ -784,7 +853,8 @@ media tools for Windows 11's x64 emulation.
 
 ### Android / Termux
 
-With Node.js 22+ and npm already installed in Termux:
+With npm installed in Termux (`pkg install nodejs`), npm fetches the native
+Android binary:
 
 ```sh
 npm install -g veodl
@@ -831,11 +901,15 @@ if you need them on subsequent launches of 1.6.1.
 - `VEO_FFMPEG_PATH`: directory containing both `ffmpeg` and `ffprobe` executables (with
   `.exe` on Windows).
 - `VEO_CONFIG`: path to the config file.
+- `VEO_JS_RUNTIME`: `name:path` of the JavaScript runtime passed to yt-dlp, for example
+  `deno:/usr/local/bin/deno` (`node`, `deno`, `bun` or `quickjs`).
+- `VEO_BINARY`: path to a veo executable the npm launcher should start instead of the
+  installed platform package (for testing a local build).
 
 Automatic setup covers Windows x64/ia32/ARM64, macOS x64/ARM64, Linux x64/ARM64,
 and Android through Termux. Windows ARM64 media tools require x64 emulation.
 `--open` uses `termux-open` in Termux; another Android app must be available to view the file.
-Other systems should supply trusted native binaries. Node.js 22+, npm, internet
+Other systems should supply trusted native binaries. Internet
 access, executable private storage and working OS libraries are prerequisites;
 network blocks or unavailable repositories can still prevent setup. Android's
 shared-storage permission must be granted by the user. Maintainers should update
@@ -861,46 +935,53 @@ silently falls back to the pinned release.
 
 ## Develop and publish
 
+veo is a Rust crate (Rust 1.85+). The npm package `veodl` contains only a small launcher
+(`bin/veo.js`); the binaries ship in `veodl-<platform>-<arch>` packages generated from
+`Cargo.toml` by `scripts/npm-packages.mjs`.
+
 ```bash
-npm install
-npm test                 # unit tests, no network
-npm run test:smoke       # real downloads: local HTTP server, real yt-dlp, real FFmpeg
-npm run test:open        # real download plus a controlled desktop-opener replacement
-npm pack
-npm run check:package    # inspect the packed tarball
-npm link
-veo --version
-# Then, authenticated as the account that owns the name:
-npm publish
+cargo build --release                  # target/release/veo
+cargo test                             # unit tests and offline CLI tests, no network
+cargo test --test smoke -- --ignored   # real downloads: local HTTP server, real yt-dlp, real FFmpeg
+cargo clippy --all-targets -- -D warnings
+node scripts/npm-packages.mjs          # sync npm package versions after a version bump
+npm pack && node scripts/check-package.js
 ```
 
-The smoke test generates a two-second synthetic video with FFmpeg, serves it on loopback,
-and runs real yt-dlp downloads. It checks default output, the quality cap, duplicate names,
-audio extraction, conversion, dry-run, format listing, JSON output, metadata embedding,
-resume, batch behaviour, playlist selection and nonzero failures, and verifies that a
-finished download whose destination was unavailable is retried from the local cache
-without contacting the source again. It also confirms that real runs leave `veo history`
-entries, that finished runs clean up their record, and that `veo runs`/`veo stop` report
-nothing left behind. It needs network access once for yt-dlp acquisition; it downloads no
-third-party video. Prepare media tools with `veo doctor fix` before `npm test` on a fresh checkout; the tests themselves use local fixtures and require no network. CI explicitly prepares and verifies the native binary pair before testing.
-
-The published tarball only includes `bin/`, `src/`, package metadata, README and LICENSE.
-The lockfile is kept for reproducible development. There is no build step. npm makes the
-shebang-bearing bin executable on installation (on Unix, `chmod +x bin/veo.js` also enables
-direct checkout execution).
-
-Continuous integration runs the unit tests on Windows, macOS and Linux for Node 22 and 24,
-runs the end-to-end smoke test on Node 22, and verifies the packed tarball.
-
-Modules separate argument parsing (`src/cli.js`), configuration (`src/config.js`,
-`src/config-errors.js`, `src/config-template.js`), backend setup (`src/backend.js`),
-backend updates (`src/backend-update.js`), download orchestration (`src/downloader.js`,
-`src/download-cache.js`), retry jobs (`src/jobs.js`), playlists (`src/playlist.js`),
-statistics, download history, the run registry and cleanup (`src/stats.js`,
-`src/history.js`, `src/runs.js`, `src/flush.js`), diagnostics (`src/doctor.js`),
-progress (`src/progress.js`), and helpers (`src/utils.js`, `src/paths.js`,
-`src/state.js`, `src/version.js`) so new options and providers can be added without
-replacing the CLI.
+The offline tests (`tests/cli.rs`) run the real binary against `tests/fake-backend`, a
+small stand-in for yt-dlp, ffmpeg and ffprobe, in isolated cache and config directories.
+They cover downloads, duplicate names, skip-existing, playlists and entry selection,
+audio, subtitles, naming templates, dry runs and listings, incognito mode, retries by run
+ID, transient-failure back-off, profiles and release notes.
+
+The smoke test prepares the pinned tools with `veo doctor fix`, generates a two-second
+synthetic video with FFmpeg, serves it on loopback and runs real yt-dlp downloads. It checks
+default output, the quality cap, duplicate names, audio extraction, conversion, remuxing,
+dry-run, format listing, JSON output, audio inspection, batch failures, profiles with URL
+lists, retry by run ID from another directory, playlist selection, and that a finished
+download whose destination was unavailable is transferred later without contacting the
+source again. It downloads no third-party video.
+
+Continuous integration runs formatting, Clippy, the unit and offline tests, and the smoke
+test on Windows, macOS and Linux, and verifies the npm package. Pushing a tag `vX.Y.Z`
+(matching `Cargo.toml`) builds the binaries for Windows x64/ARM64, macOS x64/ARM64,
+static Linux x64/ARM64 (musl) and Android ARM64 and uploads the eight npm tarballs
+as an Actions artifact. The `rust-port` branch also triggers this build.
+
+GitHub builds all seven native targets and bundles them into the single veodl npm
+package. No platform packages or npm credentials are needed on GitHub. Download
+its npm-2.0.0 artifact and publish locally with npm run release. Users only need
+npm install -g veodl; the launcher automatically selects the bundled binary.
+
+Modules mirror the commands and stay small (larger ones are directories of focused
+submodules): argument parsing and dispatch (`src/cli/`), configuration (`src/config*.rs`,
+`src/config_editor/`), backend setup and updates (`src/backend/`, `src/tool_setup.rs`,
+`src/backend_update.rs`), downloads (`src/downloader/`, `src/download_cache.rs`,
+`src/jobs/`, `src/playlist.rs`), records (`src/runs/`, `src/history.rs`, `src/stats.rs`,
+`src/run_archive.rs`, `src/flush.rs`), diagnostics (`src/doctor.rs`,
+`src/inspect_media.rs`), source discovery over the Chrome DevTools Protocol
+(`src/source_discovery/`), terminal output (`src/output.rs`, `src/progress/`,
+`src/terminal.rs`) and helpers.
 
 ## License
 

package/bin/veo.js

@@ -1,4 +1,49 @@
 #!/usr/bin/env node
-import { main } from '../src/cli.js';
+// Starts the native veo binary that npm installed from the matching platform
+// package (veodl-<platform>-<arch>). Exit codes and signals pass through.
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
 
-process.exitCode = await main();
+const root = fileURLToPath(new URL('../', import.meta.url));
+const target = `${process.platform}-${process.arch}`;
+const executable = process.platform === 'win32' ? 'veo.exe' : 'veo';
+
+function binaryPath() {
+  if (process.env.VEO_BINARY) return process.env.VEO_BINARY;
+  // Windows on ARM can run the x64 build through emulation.
+  const candidates = [target, ...(target === 'win32-arm64' ? ['win32-x64'] : [])];
+  for (const candidate of candidates) {
+    const file = path.join(root, 'native', candidate, executable);
+    if (existsSync(file)) return file;
+  }
+  return null;
+}
+
+const binary = binaryPath();
+if (!binary) {
+  process.stderr.write(`veo: no prebuilt binary for ${target} is installed.\n`
+    + 'Reinstall with npm install -g veodl\n'
+    + 'Or build from source: cargo install --git https://github.com/Mailo037/veodl\n');
+  process.exit(1);
+}
+
+const child = spawn(binary, process.argv.slice(2), { stdio: 'inherit', windowsHide: false });
+// The terminal already delivers Ctrl+C to veo itself; keep this launcher alive
+// until veo has cleaned up, and forward termination requests sent only to it.
+for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
+  process.on(signal, () => { if (signal !== 'SIGINT') child.kill(signal); });
+}
+child.on('error', error => {
+  process.stderr.write(`veo: could not start ${binary}: ${error.message}\n`);
+  process.exit(1);
+});
+child.on('close', (code, signal) => {
+  if (signal) {
+    process.removeAllListeners(signal);
+    process.kill(process.pid, signal);
+    return;
+  }
+  process.exit(code ?? 1);
+});

package/docs/AGENT_GUIDE.md

@@ -116,7 +116,7 @@ The run record is stored in veo's per-user cache on the device that ran the down
 - Example profile: `"experimental": { "concurrentFragments": 32, "experimentalFragments": true }`. Run with `veo <URL> --profile experimental`; use `--no-experimental-fragments` to revoke a stored opt-in.
 
 - Run `veo doctor --offline` to check the local setup without network repair. `veo doctor fix` may install missing tools.
-- Desktop media downloads use fixed release URLs and shipped SHA-256 hashes; both FFmpeg and FFprobe are verified before execution and on cache reuse. A rejected legacy cache requires `veo doctor fix`. Trusted PATH tools and `VEO_FFMPEG_PATH` remain explicit alternatives. The npm package has no runtime dependencies or install scripts.
+- Desktop media downloads use fixed release URLs and shipped SHA-256 hashes; both FFmpeg and FFprobe are verified before execution and on cache reuse. A rejected legacy cache requires `veo doctor fix`. Trusted PATH tools and `VEO_FFMPEG_PATH` remain explicit alternatives. The npm package runs no install scripts; it includes the native veo binaries and selects your platform automatically.
 - Use `--resume` for interrupted downloads and `--skip-existing` when repeated saves should be avoided.
 - `veo flush` removes temporary downloads and retry jobs; do not run it as routine maintenance in an agent workflow.
 - Do not call bare `veo` in an interactive terminal from automation: it opens a wizard. Use explicit URLs and flags.