clip-join 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BrenoHA
+
+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

@@ -0,0 +1,173 @@
+# ClipJoin 🎬
+
+**Merge your videos into one file: fast, lossless, and right from your terminal.**
+
+> _Back from a trip with a memory card full of GoPro clips? Select them, stitch them into
+> one file, and upload the whole adventure to YouTube in one shot, public or unlisted,
+> your call._
+
+Run ClipJoin, pick the files you want, reorder them, and hit join. Simple as that.
+
+![Usage demo](docs/gifs/usage-demo.gif)
+
+Matching clips merge **losslessly in seconds**, with no re-encoding and no quality loss
+(40×1GB in seconds, not hours). Different formats? ClipJoin re-encodes them for you. No
+flags, no config, just a clean keyboard-driven flow from folder to finished file.
+
+## How it works
+
+1. A short **clips-merging animation** plays on launch while ClipJoin checks for ffmpeg.
+2. **Browse** the filesystem to a folder of clips (or select individual files).
+3. Each clip's embedded `creation_time` (falling back to file mtime) sets the true
+   capture order, which you can then reorder by hand.
+4. **Toggle** clips in/out and rename the output, watching the live preview (clip
+   count, total duration, size, lossless-vs-re-encode).
+5. On join, ClipJoin first tries a **lossless concat** (`ffmpeg -c copy`), which keeps full
+   quality and works when clips share a codec/resolution. If that fails (e.g. mixed formats
+   or codecs) it **re-encodes** automatically (H.264/AAC, slower but always works).
+
+Optionally, add a **crossfade transition** between clips (press `t` on the arrange screen).
+It's off by default; enabling it re-encodes the output (transitions can't be done losslessly).
+
+Every joined file is written to the **`output/`** folder with a timestamped default
+name (`joined_output_YYYY-MM-DD_HHMMSS.mp4`), so repeated joins never overwrite one another.
+
+## Install
+
+The fastest way — one line, and you get a global `clipjoin` command
+(`clip-join` works too, they're the same thing):
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/BrenoHA/clip-join/main/install.sh | bash
+```
+
+The installer checks for Node and ffmpeg (guiding you if either is missing), then
+installs ClipJoin globally. Prefer to do it yourself? Any of these also work:
+
+```bash
+npm install -g clip-join   # global `clipjoin` (or `clip-join`) command
+npx clip-join              # run once without installing
+```
+
+**ffmpeg is still required** (it bundles `ffprobe`) — install it with your package
+manager if you don't have it:
+
+```bash
+brew install ffmpeg        # macOS
+sudo apt install ffmpeg    # Debian/Ubuntu
+```
+
+## Requirements
+
+- **Node.js 18+**
+- **ffmpeg** (bundles `ffprobe`) on your `PATH`
+
+## Building from source
+
+```bash
+git clone https://github.com/BrenoHA/clip-join.git
+cd clip-join
+npm install
+npm run build
+```
+
+## Usage
+
+```bash
+clipjoin                 # after installing globally
+clipjoin ~/clips         # jump straight into a folder
+
+npm run dev              # dev mode from source, no build step (via tsx)
+npm start                # from source, after `npm run build`
+npm start ~/clips        # jump straight into a folder
+
+Everything is keyboard-driven.
+
+**Browsing**
+
+| Key                          | Action                                               |
+| ---------------------------- | ---------------------------------------------------- |
+| `↑ ↓`                        | Move the cursor                                      |
+| `space` / `Enter`            | Open a directory, or select/deselect a video file    |
+| `←` / `Backspace` / `Delete` | Up a directory (cursor lands on the folder you left) |
+| `~`                          | Jump to your home directory                          |
+| `s`                          | Use every video in the current folder                |
+| `c`                          | Continue with the files you've selected              |
+| `q`                          | Quit                                                 |
+
+**Arranging & joining**
+
+Once you've picked your clips, arrange them and watch the live preview (clip count,
+total duration, size, and whether the join will be lossless):
+
+| Key               | Action                                        |
+| ----------------- | --------------------------------------------- |
+| `↑ ↓`             | Move the cursor                               |
+| `space` / `Enter` | Toggle a clip in/out of the join              |
+| `Shift+↑ ↓`       | Reorder the selected clip                     |
+| `o`               | Rename the output file (saved into `output/`) |
+| `t`               | Toggle the transition (None / Crossfade)      |
+| `j`               | **▶ Start the join**                          |
+| `esc`             | Back to the browser                           |
+| `r`               | Join again (summary screen)                   |
+| `q`               | Quit                                          |
+
+## Project structure
+
+The interface is built with [Ink](https://github.com/vadimdemedes/ink) (React for the
+terminal), the same UI framework behind Claude Code, with the video engine kept cleanly
+separate from it:
+
+```
+src/
+  index.tsx            # CLI entry (bin: clipjoin / clip-join)
+  config.ts            # extensions, output dir, default name, encode settings
+  core/                # domain logic, no UI, unit-testable
+    videos · probe · join · output · format · types
+  ui/                  # Ink presentation layer
+    App.tsx            # phase router (splash → browse → edit → join → summary)
+    theme.ts
+    screens/           # SplashScreen, BrowseScreen, EditScreen, JoinScreen, SummaryScreen
+    components/        # Banner, Header, PreviewPanel, ProgressBar, KeyHints
+    hooks/             # useFullscreen
+```
+
+`core/` never imports Ink, so the engine can be exercised without a terminal.
+
+## Testing
+
+Unit tests cover core functionality and can be run without ffmpeg installed:
+
+```bash
+npm test                # run all unit tests
+npm test -- --watch     # run tests in watch mode during development
+npm run test:ui         # open test UI in browser
+```
+
+Tests use [Vitest](https://vitest.dev/) and cover formatting utilities, video sorting,
+codec detection, and join logic. See `src/core/*.test.ts` for examples.
+
+## Roadmap
+
+- Per-clip trimming (in/out points).
+- Audio normalization.
+
+Mixed file types / codecs already work today via the automatic re-encode fallback.
+
+## Contributing
+
+Contributions are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md) for setup, coding
+conventions, and the PR process.
+
+## Notes
+
+- A successful lossless stream copy doesn't guarantee every player handles a file with
+  slightly different per-clip encoding perfectly. If playback looks off, the clips likely
+  need re-encoding (ClipJoin falls back automatically when stream copy fails).
+- **Original files are never modified or deleted.**
+- Output names are always confined to `output/` (a path typed into the rename field is
+  reduced to its basename).
+
+## License
+
+[MIT](LICENSE) © BrenoHA

package/dist/config.js

@@ -0,0 +1,27 @@
+import path from "node:path";
+export const DEFAULT_EXTS = ["mp4", "mov", "m4v", "avi", "mkv"];
+/**
+ * Overlap length for a transition, in seconds. ffmpeg's own xfade default is
+ * 1.0s; we go shorter for a subtler blend. Auto-clamped down when a clip is
+ * shorter than this (see core/join.ts).
+ */
+export const TRANSITION_DURATION_SEC = 0.5;
+/** The transitions offered in the UI, in cycle order, with their xfade names. */
+export const TRANSITIONS = [
+    { id: "none", label: "None" },
+    { id: "crossfade", label: "Crossfade", xfade: "fade" },
+];
+/** Every joined video is written here, relative to where ClipJoin is launched. */
+export const OUTPUT_DIR = path.resolve(process.cwd(), "output");
+export const REENCODE_CRF = 18;
+export const REENCODE_PRESET = "veryfast";
+/**
+ * Timestamped default filename, so repeated joins never silently overwrite each
+ * other when the user leaves the name unchanged.
+ */
+export function defaultOutputName() {
+    const d = new Date();
+    const p = (n) => String(n).padStart(2, "0");
+    const stamp = `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}_${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+    return `joined_output_${stamp}.mp4`;
+}

package/dist/core/format.js

@@ -0,0 +1,41 @@
+export function humanSize(bytes) {
+    let n = bytes;
+    for (const unit of ["B", "KB", "MB", "GB", "TB"]) {
+        if (n < 1024)
+            return `${n.toFixed(1)}${unit}`;
+        n /= 1024;
+    }
+    return `${n.toFixed(1)}PB`;
+}
+export function humanTime(secs) {
+    const total = Math.max(0, Math.floor(secs));
+    const h = Math.floor(total / 3600);
+    const m = Math.floor((total % 3600) / 60);
+    const s = total % 60;
+    const pad = (x) => String(x).padStart(2, "0");
+    return `${pad(h)}:${pad(m)}:${pad(s)}`;
+}
+/** Compact clock: MM:SS, promoting to HH:MM:SS only when there are hours. */
+export function humanClock(secs) {
+    const t = humanTime(secs);
+    return t.startsWith("00:") ? t.slice(3) : t;
+}
+const MONTHS = [
+    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+];
+/**
+ * Finder-style modified date in local time, e.g. "Jul 16, 2026, 7:07 PM".
+ * Used for the browse screen's Date Modified column.
+ */
+export function humanDate(d) {
+    const month = MONTHS[d.getMonth()];
+    const day = d.getDate();
+    const year = d.getFullYear();
+    const min = String(d.getMinutes()).padStart(2, "0");
+    const ampm = d.getHours() >= 12 ? "PM" : "AM";
+    let hour = d.getHours() % 12;
+    if (hour === 0)
+        hour = 12;
+    return `${month} ${day}, ${year}, ${hour}:${min} ${ampm}`;
+}

package/dist/core/join.js

@@ -0,0 +1,173 @@
+import { spawn } from "node:child_process";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { REENCODE_CRF, REENCODE_PRESET, TRANSITION_DURATION_SEC, TRANSITIONS } from "../config.js";
+import { ensureOutputDir } from "./output.js";
+/**
+ * ffmpeg's concat demuxer treats backslash as an escape character, so a raw
+ * Windows path (`C:\Users\me\clip.mp4`) gets mangled. Forward slashes work on
+ * every platform (Windows ffmpeg accepts them too), so normalize on Windows.
+ * Pure and platform-parameterized so it can be unit-tested off-Windows.
+ */
+export function normalizeConcatPath(p, isWindows = process.platform === "win32") {
+    return isWindows ? p.replace(/\\/g, "/") : p;
+}
+async function buildConcatFile(paths) {
+    const tmp = path.join(os.tmpdir(), `clipjoin-${Date.now()}-${process.pid}.txt`);
+    const body = paths
+        .map((p) => `file '${normalizeConcatPath(path.resolve(p)).replace(/'/g, "'\\''")}'`)
+        .join("\n");
+    await fs.writeFile(tmp, body + "\n", "utf8");
+    return tmp;
+}
+function runFfmpeg(args, totalDuration, mode, onProgress) {
+    return new Promise((resolve) => {
+        const proc = spawn("ffmpeg", [...args, "-progress", "pipe:1", "-nostats"], {
+            windowsHide: true, // don't flash a console window / steal focus on Windows
+        });
+        let stderr = "";
+        let stdoutBuf = "";
+        proc.stdout.on("data", (chunk) => {
+            stdoutBuf += chunk.toString();
+            let idx;
+            while ((idx = stdoutBuf.indexOf("\n")) !== -1) {
+                const line = stdoutBuf.slice(0, idx).trim();
+                stdoutBuf = stdoutBuf.slice(idx + 1);
+                // out_time_us (newer) / out_time_ms (older) are both microseconds.
+                const m = line.match(/^out_time_(?:us|ms)=(\d+)/);
+                if (m && totalDuration > 0) {
+                    const fraction = Math.min(1, Math.max(0, Number(m[1]) / 1_000_000 / totalDuration));
+                    onProgress?.({ fraction, mode });
+                }
+            }
+        });
+        proc.stderr.on("data", (chunk) => (stderr += chunk.toString()));
+        proc.on("error", () => resolve({ code: 1, stderr: stderr || "failed to spawn ffmpeg" }));
+        proc.on("close", (code) => resolve({ code: code ?? 1, stderr }));
+    });
+}
+/**
+ * Safe overlap length for a transition: the configured default, but never as
+ * long as the shortest clip (xfade would run off the end of a short clip).
+ */
+export function resolveTransitionDuration(clips) {
+    const shortest = Math.min(...clips.map((c) => c.durationSec));
+    return Math.max(0.1, Math.min(TRANSITION_DURATION_SEC, shortest - 0.05));
+}
+/**
+ * Build the ffmpeg args for a transition join: every clip is its own `-i`
+ * input, blended with an xfade (video) / acrossfade (audio) filtergraph. This
+ * always re-encodes. Pure/synchronous so it can be unit-tested without ffmpeg.
+ *
+ * `d` is the per-boundary overlap in seconds (see resolveTransitionDuration).
+ */
+export function buildTransitionArgs(clips, output, transition, d, enc) {
+    const n = clips.length;
+    const xfade = TRANSITIONS.find((t) => t.id === transition)?.xfade ?? "fade";
+    const withAudio = clips.every((c) => c.hasAudio);
+    // Normalize to the first clip's geometry/framerate so every xfade pair matches.
+    const w = clips[0].width || 1920;
+    const h = clips[0].height || 1080;
+    const fps = clips[0].fps || 30;
+    const parts = [];
+    // Video: normalize each input, then chain xfade across the boundaries.
+    for (let i = 0; i < n; i++) {
+        parts.push(`[${i}:v]fps=${fps},scale=${w}:${h}:force_original_aspect_ratio=decrease,` +
+            `pad=${w}:${h}:(ow-iw)/2:(oh-ih)/2,setsar=1,format=yuv420p,settb=AVTB[v${i}]`);
+    }
+    let vPrev = "v0";
+    let sumBefore = clips[0].durationSec;
+    for (let k = 1; k < n; k++) {
+        const out = k === n - 1 ? "vout" : `vx${k}`;
+        const offset = sumBefore - k * d;
+        parts.push(`[${vPrev}][v${k}]xfade=transition=${xfade}:duration=${d}:offset=${offset.toFixed(3)}[${out}]`);
+        vPrev = out;
+        sumBefore += clips[k].durationSec;
+    }
+    // Audio: crossfade the tail of each clip into the next (skipped if any clip
+    // has no audio track — acrossfade would fail).
+    if (withAudio) {
+        for (let i = 0; i < n; i++) {
+            parts.push(`[${i}:a]aresample=async=1,aformat=sample_fmts=fltp:channel_layouts=stereo[a${i}]`);
+        }
+        let aPrev = "a0";
+        for (let k = 1; k < n; k++) {
+            const out = k === n - 1 ? "aout" : `ax${k}`;
+            parts.push(`[${aPrev}][a${k}]acrossfade=d=${d}[${out}]`);
+            aPrev = out;
+        }
+    }
+    const args = ["-y"];
+    for (const c of clips)
+        args.push("-i", c.path);
+    args.push("-filter_complex", parts.join(";"));
+    args.push("-map", "[vout]");
+    if (withAudio)
+        args.push("-map", "[aout]");
+    // Force 4:2:0 on the encoder: xfade's output format is flexible, so without
+    // this ffmpeg may up-convert to yuv444p, which QuickTime refuses to play.
+    args.push("-c:v", "libx264", "-pix_fmt", "yuv420p", "-crf", String(enc.crf), "-preset", enc.preset);
+    if (withAudio)
+        args.push("-c:a", "aac", "-b:a", "192k");
+    args.push(output);
+    const totalDuration = clips.reduce((sum, c) => sum + c.durationSec, 0) - (n - 1) * d;
+    return { args, totalDuration };
+}
+/** Join the included clips, trying a lossless stream copy before re-encoding. */
+export async function runJoin(opts) {
+    const { output, forceReencode = false, crf = REENCODE_CRF, preset = REENCODE_PRESET, transition = "none", onProgress, } = opts;
+    const included = opts.clips.filter((c) => c.included);
+    if (included.length === 0)
+        throw new Error("No clips selected to join.");
+    await ensureOutputDir();
+    const started = Date.now();
+    // Transition path: filtergraph, always re-encodes. Needs at least two clips
+    // (a single clip has no boundary to blend), so fall through to concat otherwise.
+    if (transition !== "none" && included.length >= 2) {
+        const d = resolveTransitionDuration(included);
+        const { args, totalDuration } = buildTransitionArgs(included, output, transition, d, {
+            crf,
+            preset,
+        });
+        onProgress?.({ fraction: 0, mode: "reencode" });
+        const { code, stderr } = await runFfmpeg(args, totalDuration, "reencode", onProgress);
+        if (code !== 0)
+            throw new Error(`ffmpeg failed:\n${stderr.split("\n").slice(-15).join("\n")}`);
+        return finalize(output, "reencode", totalDuration, started);
+    }
+    const totalDuration = included.reduce((sum, c) => sum + c.durationSec, 0);
+    const concatFile = await buildConcatFile(included.map((c) => c.path));
+    try {
+        if (!forceReencode) {
+            const args = ["-y", "-f", "concat", "-safe", "0", "-i", concatFile, "-c", "copy", output];
+            onProgress?.({ fraction: 0, mode: "lossless" });
+            const { code } = await runFfmpeg(args, totalDuration, "lossless", onProgress);
+            if (code === 0)
+                return finalize(output, "lossless", totalDuration, started);
+        }
+        const args = [
+            "-y", "-f", "concat", "-safe", "0", "-i", concatFile,
+            "-c:v", "libx264", "-crf", String(crf), "-preset", preset,
+            "-c:a", "aac", "-b:a", "192k", output,
+        ];
+        onProgress?.({ fraction: 0, mode: "reencode" });
+        const { code, stderr } = await runFfmpeg(args, totalDuration, "reencode", onProgress);
+        if (code !== 0)
+            throw new Error(`ffmpeg failed:\n${stderr.split("\n").slice(-15).join("\n")}`);
+        return finalize(output, "reencode", totalDuration, started);
+    }
+    finally {
+        await fs.rm(concatFile, { force: true });
+    }
+}
+async function finalize(output, mode, durationSec, started) {
+    const stat = await fs.stat(output).catch(() => null);
+    return {
+        mode,
+        outputPath: path.resolve(output),
+        sizeBytes: stat?.size ?? 0,
+        durationSec,
+        elapsedMs: Date.now() - started,
+    };
+}

package/dist/core/output.js

@@ -0,0 +1,43 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { OUTPUT_DIR, defaultOutputName } from "../config.js";
+import { humanClock } from "./format.js";
+/**
+ * Resolve a user-supplied name to an absolute path inside OUTPUT_DIR. Only the
+ * basename is honored, so "../evil.mp4" or an absolute path can't escape output/.
+ */
+export function resolveOutputPath(name) {
+    let base = path.basename(name.trim());
+    // basename() strips separators; "." / ".." would still resolve to or above
+    // OUTPUT_DIR, so fall back to the default for those (and for an empty name).
+    if (!base || base === "." || base === "..")
+        base = defaultOutputName();
+    return path.join(OUTPUT_DIR, base);
+}
+export async function ensureOutputDir() {
+    await fs.mkdir(OUTPUT_DIR, { recursive: true });
+}
+/** Build the line-per-chapter text content for the given (included) clips. */
+function buildChaptersContent(clips) {
+    let cumulative = 0;
+    const lines = [];
+    for (const clip of clips) {
+        const name = path.parse(clip.name).name;
+        lines.push(`${humanClock(cumulative)} ${name}`);
+        cumulative += clip.durationSec;
+    }
+    return lines.join("\n") + "\n";
+}
+/**
+ * Write a chapters .txt file alongside the video output.
+ * Returns the generated file path, or an empty string when there are no clips.
+ */
+export async function writeChaptersFile(clips, videoOutputPath) {
+    if (clips.length === 0)
+        return "";
+    const parsed = path.parse(videoOutputPath);
+    const chaptersPath = path.join(parsed.dir, `${parsed.name}_chapters.txt`);
+    const content = buildChaptersContent(clips);
+    await fs.writeFile(chaptersPath, content, "utf-8");
+    return chaptersPath;
+}

package/dist/core/probe.js

@@ -0,0 +1,115 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+const execFileAsync = promisify(execFile);
+// windowsHide stops a console window from flashing up (and stealing terminal
+// focus) on every ffprobe spawn — on Windows that makes the UI look frozen.
+const EXEC_OPTS = { windowsHide: true };
+async function toolExists(tool) {
+    try {
+        await execFileAsync(tool, ["-version"], EXEC_OPTS);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function checkDeps() {
+    const [ffmpeg, ffprobe] = await Promise.all([toolExists("ffmpeg"), toolExists("ffprobe")]);
+    return { ffmpeg, ffprobe, ok: ffmpeg && ffprobe };
+}
+async function ffprobeJson(file) {
+    try {
+        const { stdout } = await execFileAsync("ffprobe", [
+            "-v", "error", "-print_format", "json", "-show_format", "-show_streams", file,
+        ], EXEC_OPTS);
+        return JSON.parse(stdout);
+    }
+    catch {
+        return {};
+    }
+}
+function creationTimeFrom(probe, fallback) {
+    const ct = probe?.format?.tags?.creation_time;
+    if (typeof ct === "string") {
+        const parsed = new Date(ct);
+        if (!Number.isNaN(parsed.getTime()))
+            return parsed;
+    }
+    return fallback;
+}
+function getDuration(probe) {
+    const d = parseFloat(probe?.format?.duration);
+    return Number.isFinite(d) ? d : 0;
+}
+function videoStream(probe) {
+    return (probe?.streams ?? []).find((s) => s.codec_type === "video");
+}
+function videoSignature(probe) {
+    const v = videoStream(probe);
+    if (!v)
+        return "unknown";
+    return `${v.codec_name ?? "?"} ${v.width ?? "?"}x${v.height ?? "?"}`;
+}
+/** Parse ffprobe's "num/den" (or plain number) r_frame_rate into fps. */
+function parseFps(raw) {
+    if (typeof raw !== "string")
+        return 0;
+    const [num, den] = raw.split("/");
+    const n = Number(num);
+    const d = den === undefined ? 1 : Number(den);
+    if (!Number.isFinite(n) || !Number.isFinite(d) || d === 0)
+        return 0;
+    return n / d;
+}
+function hasAudioStream(probe) {
+    return (probe?.streams ?? []).some((s) => s.codec_type === "audio");
+}
+/** How many ffprobe processes to run at once — bounded so we don't fork-bomb. */
+const PROBE_CONCURRENCY = 4;
+async function probeOne(file) {
+    const abs = path.resolve(file);
+    // A single locked/inaccessible file must not sink the whole probe (which
+    // would leave the UI stuck on the spinner, never reaching Arrange).
+    const [probe, stat] = await Promise.all([
+        ffprobeJson(abs),
+        fs.stat(abs).catch(() => null),
+    ]);
+    const v = videoStream(probe);
+    const mtime = stat?.mtime ?? new Date(0);
+    return {
+        id: abs,
+        path: abs,
+        name: path.basename(abs),
+        durationSec: getDuration(probe),
+        sizeBytes: stat?.size ?? 0,
+        creationTime: creationTimeFrom(probe, mtime),
+        mtime,
+        videoSignature: videoSignature(probe),
+        width: Number(v?.width) || 0,
+        height: Number(v?.height) || 0,
+        fps: parseFps(v?.r_frame_rate),
+        hasAudio: hasAudioStream(probe),
+        included: true,
+    };
+}
+export async function probeClips(files, onProgress) {
+    // Probe in parallel with a small pool: sequential spawns are painfully slow
+    // on Windows (process creation + AV scans per launch look like a freeze).
+    const clips = new Array(files.length);
+    let next = 0;
+    let done = 0;
+    async function worker() {
+        while (true) {
+            const i = next++;
+            if (i >= files.length)
+                return;
+            clips[i] = await probeOne(files[i]);
+            onProgress?.(++done, files.length);
+        }
+    }
+    const workers = Array.from({ length: Math.min(PROBE_CONCURRENCY, files.length) }, () => worker());
+    await Promise.all(workers);
+    return clips;
+}

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/videos.js

@@ -0,0 +1,42 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { DEFAULT_EXTS } from "../config.js";
+export async function findVideos(folder, exts = DEFAULT_EXTS, recursive = false) {
+    const wanted = new Set(exts.map((e) => e.toLowerCase().replace(/^\./, "")));
+    const matches = [];
+    async function walk(dir, descend) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (descend)
+                    await walk(full, true);
+            }
+            else if (entry.isFile()) {
+                const ext = entry.name.split(".").pop()?.toLowerCase() ?? "";
+                if (wanted.has(ext))
+                    matches.push(full);
+            }
+        }
+    }
+    await walk(folder, recursive);
+    return matches;
+}
+export function sortClips(clips, by) {
+    const copy = [...clips];
+    if (by === "date") {
+        copy.sort((a, b) => a.creationTime.getTime() - b.creationTime.getTime());
+    }
+    else {
+        copy.sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
+    }
+    return copy;
+}
+/** True when every included clip shares one signature, so a stream copy can work. */
+export function canLossless(clips) {
+    const included = clips.filter((c) => c.included);
+    if (included.length === 0)
+        return false;
+    const first = included[0].videoSignature;
+    return included.every((c) => c.videoSignature === first);
+}

package/dist/index.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import { App } from "./ui/App.js";
+const folderArg = process.argv[2];
+const { waitUntilExit } = render(_jsx(App, { initialFolder: folderArg }));
+await waitUntilExit();