@torrent-tv/proxy 2.5.11 → 2.6.0

package/CHANGELOG.md

@@ -1,3 +1,28 @@
+## 2.5.15
+
+- **New**: `GET /api/sources/:sourceKey/stats?fileIndex=N` — returns live torrent stats: connected peer count, download/upload speed, per-file download progress and size. Used by the browser to show meaningful feedback while waiting for file metadata.
+- **New**: `TorrentPool.getFileStats()` — reads `torrent.numPeers`, `torrent.downloadSpeed`, `file.progress`, `file.downloaded`, `file.length` from the WebTorrent instance.
+
+## 2.5.14
+
+- **New**: `TorrentPool.prefetchFileEdges()` — opens WebTorrent read streams for the first 256 KB and last 2 MB of a file before ffprobe runs. This prioritises the torrent pieces that contain file headers (FTYP box) and the MOOV atom (typically at end of non-faststart MP4), ensuring codec and duration detection succeeds even for freshly-added torrents. Timeout is 5 minutes; failure is non-blocking.
+- **New**: Seek-to-position HLS transcode — `createOrGetSession` now accepts `startPositionSeconds`. ffmpeg is started with `-ss <pos>` (fast keyframe seek before `-i`) and `-output_ts_offset <pos>` so that output PTS matches the original timeline, keeping `video.currentTime` correct after a seek restart. Session cache key includes the rounded start position (10 s buckets) so nearby seeks share a session.
+- **New**: `POST /api/transcode-sessions` accepts `startPositionSeconds` in the request body.
+- **Chore**: `computeProgressMetrics` updated to compute percentage relative to the remaining duration from the seek point rather than the full file.
+
+## 2.5.13
+
+- **Fix**: HLS playlist type changed from `vod` to `event`. With `vod`, ffmpeg only wrote `#EXT-X-ENDLIST` after transcoding the entire file, blocking playback start for large files indefinitely.
+- **Fix**: `waitForHlsPlaylist` in the browser now unblocks as soon as `#EXTINF:` appears (first segment ready) instead of waiting for `#EXT-X-ENDLIST`. Latency to first frame drops from minutes to seconds.
+- **Fix**: Codec detection in `PlaybackPlanner` — when ffprobe returns an empty audio codec (MOOV atom not yet downloaded), the plan now defaults to `direct` mode instead of forcing HLS transcode. The browser's range-request mechanism fetches the MOOV atom on demand.
+
+## 2.5.12
+
+- **New**: Timestamps (`HH:MM:SS.mmm`) added to all log lines.
+- **New**: Proxy version logged at startup (`Starting @torrent-tv/proxy vX.Y.Z`).
+- **Fix**: WebRTC session torn down immediately after connect — `disconnected` ICE state is transient and no longer triggers `closeSession()`. Only `failed` and `closed` are terminal. This fixed data channels opening and closing within milliseconds.
+- **Fix**: Fastify `bodyLimit` raised from 10 MB to 256 MB — large `.torrent` files encoded as base64 JSON exceeded the previous limit.
+
 ## 2.5.7
 
 - **Fix**: WebRTC connection failure behind symmetric NAT — all ICE candidates (private and public) are now sent to the browser immediately. The browser attempts all paths in parallel; the local LAN path succeeds when browser and proxy are on the same network. Chrome's Private Network Access dialog appears once on first connect.

package/README.md

@@ -122,9 +122,17 @@ The browser uses these metrics together with tunnel RTT to score proxies:
 score = memFree × 0.4 + (1 - clamp(cpuLoad, 0, 1)) × 0.4 − (rttMs / 2000) × 0.2
 ```
 
+### PlaybackPlanner
+
+Determines whether a file should be streamed directly or transcoded to HLS, and caches the result per `(sourceKey, fileIndex)`.
+
+Before running ffprobe it calls `TorrentPool.prefetchFileEdges()` which opens WebTorrent read streams for the first 256 KB and last 2 MB of the file. This forces WebTorrent to prioritise those torrent pieces, ensuring the MOOV atom (usually at the end of non-faststart MP4 files) is available before codec detection runs. The timeout is 5 minutes; if it elapses the plan still proceeds with whatever data is available and defaults to `direct` mode when the codec is unknown.
+
 ### HlsSessionManager & ffmpeg
 
-Creates and manages ffmpeg-based HLS transcode sessions. Sessions are keyed by `sourceKey:fileIndex:mode` and shared across consumers.
+Creates and manages ffmpeg-based HLS transcode sessions. Sessions are keyed by `sourceKey:fileIndex:mode:startPosition` and shared across consumers.
+
+**Seek-to-position:** `createOrGetSession` accepts `startPositionSeconds` which allows restarting a transcode from an arbitrary point. ffmpeg is invoked with `-ss <N>` (fast keyframe seek before `-i`) and `-output_ts_offset <N>` (shifts output PTS) so that `video.currentTime` in the browser reflects the original timeline position rather than resetting to zero. Start positions are rounded to 10-second buckets for session reuse.
 
 ```mermaid
 sequenceDiagram
@@ -211,6 +219,27 @@ GET /stream?sourceKey=<key>&fileIndex=0
 
 Supports HTTP Range requests.
 
+### Source stats
+
+```bash
+GET /api/sources/:sourceKey/stats?fileIndex=0
+```
+
+Returns live torrent statistics for polling during the metadata wait phase:
+
+```json
+{
+  "numPeers": 4,
+  "downloadSpeed": 1258291,
+  "uploadSpeed": 0,
+  "fileProgress": 0.008,
+  "fileDownloaded": 10485760,
+  "fileLength": 1299000000
+}
+```
+
+`fileProgress` is 0–1 and reflects only the pieces that have been downloaded so far (initially the prefetched head + tail). `downloadSpeed` and `uploadSpeed` are in bytes/s.
+
 ### Create HLS transcode session
 
 ```bash
@@ -222,10 +251,13 @@ Content-Type: application/json
   "fileIndex": 0,
   "transcodeVideo": false,
   "consumerId": "uuid",
-  "fileName": "Episode01.mkv"
+  "fileName": "Episode01.mkv",
+  "startPositionSeconds": 300
 }
 ```
 
+`startPositionSeconds` is optional (default `0`). When set, ffmpeg fast-seeks to the specified position and shifts output timestamps accordingly, enabling seek-to-position playback.
+
 Response: `{ "sessionId": "…", "playlistPath": "/transcode/<id>/index.m3u8" }`
 
 ### Poll transcode progress
@@ -234,7 +266,7 @@ Response: `{ "sessionId": "…", "playlistPath": "/transcode/<id>/index.m3u8" }`
 GET /api/transcode-sessions/:sessionId/progress
 ```
 
-Returns: `percent`, `processedSeconds`, `totalSeconds`, `remainingSeconds`, `speed`, `warmupPercent`, `warmupRemainingSeconds`.
+Returns: `percent`, `processedSeconds`, `startPositionSeconds`, `totalSeconds`, `remainingSeconds`, `speed`, `warmupPercent`, `warmupRemainingSeconds`.
 
 ### Release consumer
 
@@ -325,9 +357,11 @@ sequenceDiagram
 ## Notes
 
 - HLS session temp files are in the OS temp directory and cleaned up automatically.
-- Transcode sessions are cached by `sourceKey:fileIndex:mode` and shared across consumers.
+- Transcode sessions are cached by `sourceKey:fileIndex:mode:startPosition` and shared across consumers.
 - The source registry is in-memory and bounded (old entries evicted).
 - The proxy reconnects to the server automatically on tunnel disconnect.
+- `prefetchFileEdges` downloads only the file's head and tail (≈ 2.3 MB total), not the full file, before codec detection runs.
+- When `startPositionSeconds > 0`, ffmpeg uses fast seek (`-ss` before `-i`) — it starts from the nearest keyframe at or before the requested position. The first few frames may be slightly before the exact seek time.
 
 ## License
 

package/bin/cli.js

@@ -11,6 +11,7 @@
 import { Command } from "commander";
 import crypto from "node:crypto";
 import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
 import ffmpegStatic from "ffmpeg-static";
 import { startProxyServer } from "../server.js";
 import { registerClient } from "../services/registry-api.js";
@@ -20,6 +21,9 @@ import { createDataChannelHandler } from "../services/data-channel-handler.js";
 import { collectHealthMetrics } from "../services/health-collector.js";
 import { logger } from "../utils/logger.js";
 
+const require = createRequire(import.meta.url);
+const { version: PROXY_VERSION } = require("../package.json");
+
 const program = new Command();
 
 const HELP_EXAMPLES = `
@@ -205,6 +209,7 @@ try {
   actualPort = started.port;
   const directBaseUrl = explicitBaseUrl || `http://${bindHost}:${actualPort}`;
 
+  logger.info(`Starting @torrent-tv/proxy v${PROXY_VERSION}`);
   logger.info(`Local stream endpoint: http://${bindHost}:${actualPort}/stream`);
   logger.info(`Advertised direct URL: ${directBaseUrl}`);
   if (transcodeAudio) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.5.11",
+  "version": "2.6.0",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "publishConfig": {

package/routes/api/sources/stats/get.js

@@ -0,0 +1,42 @@
+/**
+ * Return download statistics for a registered torrent source.
+ *
+ * Provides peer count, transfer speeds, and per-file download progress so
+ * that the browser client can display meaningful feedback while the proxy is
+ * pre-fetching file metadata (MOOV atom / EBML headers) before codec probing.
+ *
+ * GET /api/sources/:sourceKey/stats?fileIndex=N
+ *
+ * @param {import("fastify").FastifyRequest} req
+ * @param {import("fastify").FastifyReply} reply
+ * @param {{
+ *   sourceRegistry: ReturnType<import("../../../../store/source-registry.js").createSourceRegistry>,
+ *   torrentPool: import("../../../../services/torrent-pool.js").TorrentPool
+ * }} deps
+ * @returns {Promise<void>}
+ */
+export async function handleApiSourceStatsGet(req, reply, { sourceRegistry, torrentPool }) {
+  const sourceKey = typeof req.params.sourceKey === "string" ? req.params.sourceKey.trim() : "";
+  if (!sourceKey) {
+    return reply.code(400).send({ error: "sourceKey is required." });
+  }
+
+  const sourceRecord = sourceRegistry.get(sourceKey);
+  if (!sourceRecord) {
+    return reply.code(404).send({ error: "Source key was not found." });
+  }
+
+  let torrent;
+  try {
+    // getTorrent resolves immediately when the torrent is already loaded.
+    torrent = await torrentPool.getTorrent(sourceRecord.sourceType, sourceRecord.source);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return reply.code(500).send({ error: `Failed to load torrent: ${message}` });
+  }
+
+  const fileIndexRaw = typeof req.query.fileIndex === "string" ? req.query.fileIndex : "";
+  const fileIndex = fileIndexRaw !== "" && /^\d+$/.test(fileIndexRaw) ? Number(fileIndexRaw) : null;
+
+  return reply.send(torrentPool.getFileStats(torrent, fileIndex));
+}

package/routes/api/transcode-sessions/post.js

@@ -33,6 +33,7 @@ export async function handleApiTranscodeSessionsPost(req, reply, { hlsSessionMan
   const fileName = typeof payload.fileName === "string" ? payload.fileName.trim() : "";
   const targetWidth = Number(payload.targetWidth);
   const targetHeight = Number(payload.targetHeight);
+  const startPositionSeconds = Number(payload.startPositionSeconds);
 
   if (!sourceKey || !Number.isInteger(fileIndex) || fileIndex < 0) {
     return reply.code(400).send({ error: "sourceKey and valid fileIndex are required." });
@@ -47,7 +48,11 @@ export async function handleApiTranscodeSessionsPost(req, reply, { hlsSessionMan
       consumerId,
       fileName,
       targetWidth: Number.isInteger(targetWidth) && targetWidth > 0 ? targetWidth : 0,
-      targetHeight: Number.isInteger(targetHeight) && targetHeight > 0 ? targetHeight : 0
+      targetHeight: Number.isInteger(targetHeight) && targetHeight > 0 ? targetHeight : 0,
+      startPositionSeconds:
+        Number.isFinite(startPositionSeconds) && startPositionSeconds > 0
+          ? startPositionSeconds
+          : 0
     });
     return reply.send({
       sessionId: session.id,

package/server.js

@@ -16,6 +16,7 @@ import { fileURLToPath } from "node:url";
 import { handleHealthGet } from "./routes/health/get.js";
 import { handleHealthzGet } from "./routes/healthz/get.js";
 import { handleApiSourcesPost } from "./routes/api/sources/post.js";
+import { handleApiSourceStatsGet } from "./routes/api/sources/stats/get.js";
 import { handleApiPlaybackPlanPost } from "./routes/api/playback-plan/post.js";
 import { handleApiTranscodeSessionsPost } from "./routes/api/transcode-sessions/post.js";
 import { handleApiTranscodeSessionsProgressGet } from "./routes/api/transcode-sessions/progress/get.js";
@@ -62,7 +63,9 @@ function buildPortCandidates(startPort, maxAttempts = 51) {
  */
 export async function startProxyServer({ host, port, transcodeAudio, ffmpegBin }) {
   const app = Fastify({
-    bodyLimit: 10 * 1024 * 1024
+    // No practical body-size limit — the proxy server is localhost-only and
+    // receives torrent source payloads that may be arbitrarily large.
+    bodyLimit: 256 * 1024 * 1024 // 256 MB
   });
 
   await app.register(fastifyHelmet, {
@@ -107,6 +110,9 @@ export async function startProxyServer({ host, port, transcodeAudio, ffmpegBin }
   app.post("/api/sources", async (req, reply) =>
     handleApiSourcesPost(req, reply, { sourceRegistry })
   );
+  app.get("/api/sources/:sourceKey/stats", async (req, reply) =>
+    handleApiSourceStatsGet(req, reply, { sourceRegistry, torrentPool })
+  );
   app.post("/api/playback-plan", async (req, reply) =>
     handleApiPlaybackPlanPost(req, reply, { playbackPlanner })
   );

package/services/hls-session-manager.js

@@ -188,17 +188,28 @@ function formatSeconds(seconds) {
 /**
  * Compute derived progress metrics from raw ffmpeg output values.
  *
- * @param {number} processedSeconds - Seconds of content encoded so far.
+ * When `startPositionSeconds` is provided (seek-restart case), progress is
+ * computed relative to the remaining duration after the seek point so the
+ * percent value reflects transcoding of the requested segment, not the whole
+ * file.
+ *
+ * @param {number} processedSeconds   - Output timestamp of last encoded frame.
  * @param {number | null} totalSeconds - Total duration, or `null` if unknown.
+ * @param {number} [startPositionSeconds=0] - Seek offset used for this session.
  * @returns {{ totalSeconds: number | null, percent: number | null, remainingSeconds: number | null, processedSeconds: number }}
  */
-function computeProgressMetrics(processedSeconds, totalSeconds) {
+function computeProgressMetrics(processedSeconds, totalSeconds, startPositionSeconds = 0) {
   const processed = Number.isFinite(processedSeconds) ? Math.max(0, processedSeconds) : 0;
+  const startOffset = Number.isFinite(startPositionSeconds) && startPositionSeconds > 0
+    ? startPositionSeconds
+    : 0;
   if (!Number.isFinite(totalSeconds) || totalSeconds <= 0) {
     return { totalSeconds: null, percent: null, remainingSeconds: null, processedSeconds: processed };
   }
   const safeTotal = totalSeconds;
-  const percent = Math.max(0, Math.min(100, (processed / safeTotal) * 100));
+  const segmentDuration = Math.max(1, safeTotal - startOffset);
+  const segmentProcessed = Math.max(0, processed - startOffset);
+  const percent = Math.max(0, Math.min(100, (segmentProcessed / segmentDuration) * 100));
   const remainingSeconds = Math.max(0, safeTotal - processed);
   return {
     totalSeconds: safeTotal,
@@ -342,10 +353,11 @@ export class HlsSessionManager {
    * @param {number}  options.fileIndex      - Zero-based file index in the torrent.
    * @param {boolean} [options.transcodeVideo=false]
    * @param {boolean} [options.transcodeAudio=false]
-   * @param {string}  [options.consumerId=""]   - Caller ID for reference counting.
-   * @param {string}  [options.fileName=""]     - Display name for log output.
-   * @param {number}  [options.targetWidth=0]   - Target video width (0 = keep source).
-   * @param {number}  [options.targetHeight=0]  - Target video height (0 = keep source).
+   * @param {string}  [options.consumerId=""]            - Caller ID for reference counting.
+   * @param {string}  [options.fileName=""]              - Display name for log output.
+   * @param {number}  [options.targetWidth=0]            - Target video width (0 = keep source).
+   * @param {number}  [options.targetHeight=0]           - Target video height (0 = keep source).
+   * @param {number}  [options.startPositionSeconds=0]   - Seek start position in seconds.
    * @returns {Promise<HlsSession>}
    */
   async createOrGetSession({
@@ -356,7 +368,8 @@ export class HlsSessionManager {
     consumerId = "",
     fileName = "",
     targetWidth = 0,
-    targetHeight = 0
+    targetHeight = 0,
+    startPositionSeconds = 0
   }) {
     if (!this.enabled) {
       const error = new Error("Audio transcoding is disabled on this proxy.");
@@ -366,13 +379,20 @@ export class HlsSessionManager {
 
     const normalizedTargetWidth = Number.isInteger(targetWidth) && targetWidth > 0 ? targetWidth : 0;
     const normalizedTargetHeight = Number.isInteger(targetHeight) && targetHeight > 0 ? targetHeight : 0;
+    // Round seek position to the nearest 10 s so that two consumers seeking
+    // to similar positions can share the same ffmpeg session.
+    const normalizedStartPosition =
+      Number.isFinite(startPositionSeconds) && startPositionSeconds > 0
+        ? Math.round(startPositionSeconds / 10) * 10
+        : 0;
     const sourceMapKey = [
       sourceKey,
       String(fileIndex),
       transcodeVideo ? "video" : "audio",
       transcodeAudio ? "a1" : "a0",
       String(normalizedTargetWidth),
-      String(normalizedTargetHeight)
+      String(normalizedTargetHeight),
+      String(normalizedStartPosition)
     ].join(":");
     const existingId = this.sessionIdBySource.get(sourceMapKey);
     if (existingId) {
@@ -421,15 +441,23 @@ export class HlsSessionManager {
       ? ["-c:a", "aac", "-ac", "2", "-b:a", "128k"]
       : ["-c:a", "copy"];
 
-    const args = [
-      "-hide_banner",
-      "-nostats",
-      "-loglevel",
-      "error",
-      "-progress",
-      "pipe:1",
-      "-i",
-      inputUrl.toString(),
+    const args = ["-hide_banner", "-nostats", "-loglevel", "error", "-progress", "pipe:1"];
+
+    // Fast keyframe-level seek before -i.  This is efficient because ffmpeg
+    // skips decoding all frames before the target position.
+    if (normalizedStartPosition > 0) {
+      args.push("-ss", String(normalizedStartPosition));
+    }
+
+    args.push("-i", inputUrl.toString());
+
+    // Shift output timestamps to match the original timeline so that
+    // video.currentTime reflects the seeked position, not a reset-to-zero.
+    if (normalizedStartPosition > 0) {
+      args.push("-output_ts_offset", String(normalizedStartPosition));
+    }
+
+    args.push(
       "-map",
       "0:v:0?",
       "-map",
@@ -443,13 +471,13 @@ export class HlsSessionManager {
       "-hls_list_size",
       "0",
       "-hls_playlist_type",
-      "vod",
+      "event",
       "-hls_flags",
       "independent_segments+temp_file",
       "-hls_segment_filename",
       "segment-%05d.ts",
       PLAYLIST_FILE_NAME
-    ];
+    );
 
     const ffmpeg = spawn(this.ffmpegBin, args, {
       cwd: sessionDir,
@@ -469,10 +497,13 @@ export class HlsSessionManager {
       consumers: new Set(consumerId ? [consumerId] : []),
       progress: {
         state: "starting",
-        processedSeconds: 0,
+        // With -output_ts_offset the first out_time will be ≈ normalizedStartPosition,
+        // so initialise processedSeconds to that value for consistent percent math.
+        processedSeconds: normalizedStartPosition,
+        startPositionSeconds: normalizedStartPosition,
         totalSeconds: Number.isFinite(durationSeconds) ? durationSeconds : null,
         percent: null,
-        remainingSeconds: Number.isFinite(durationSeconds) ? durationSeconds : null,
+        remainingSeconds: Number.isFinite(durationSeconds) ? durationSeconds - normalizedStartPosition : null,
         speed: "",
         updatedAt: Date.now(),
         lastLoggedAt: 0
@@ -512,7 +543,8 @@ export class HlsSessionManager {
         }
         const metrics = computeProgressMetrics(
           session.progress.processedSeconds,
-          session.progress.totalSeconds
+          session.progress.totalSeconds,
+          session.progress.startPositionSeconds
         );
         session.progress.percent = metrics.percent;
         session.progress.remainingSeconds = metrics.remainingSeconds;
@@ -708,6 +740,7 @@ export class HlsSessionManager {
       sessionId: session.id,
       state: session.progress.state,
       processedSeconds: session.progress.processedSeconds,
+      startPositionSeconds: session.progress.startPositionSeconds ?? 0,
       totalSeconds: session.progress.totalSeconds,
       percent: session.progress.percent,
       remainingSeconds: session.progress.remainingSeconds,

package/services/playback-planner.js

@@ -180,13 +180,24 @@ export function createPlaybackPlanner({
         return plan;
       }
 
+      // Pre-fetch file edges (head + tail) before probing so that WebTorrent
+      // has the MOOV atom (or MKV EBML headers) ready for ffprobe.
+      // Without this, ffprobe times out on fresh torrents whose MOOV sits at
+      // the end of the file and hasn't been downloaded yet.
+      await torrentPool.prefetchFileEdges(torrent, fileIndex);
+
       const { audioCodec, videoCodec } = await probeStreamCodecs({
         ffmpegBin,
         inputUrl: directUrl,
         userAgent
       });
 
-      const requiresTranscode = !audioCodec || !DIRECT_AUDIO_CODECS.has(audioCodec);
+      // Only transcode when the codec is known AND not natively supported.
+      // When ffprobe cannot detect the codec (e.g. the torrent has just started
+      // downloading and the MOOV atom at the end of the MP4 is not yet available),
+      // fall back to "direct" so the browser can attempt native playback.  The
+      // browser-side loading pipeline already has its own transcode fallback.
+      const requiresTranscode = audioCodec.length > 0 && !DIRECT_AUDIO_CODECS.has(audioCodec);
       const plan = {
         mode: requiresTranscode ? "hls" : "direct",
         directUrl,

package/services/torrent-pool.js

@@ -161,6 +161,113 @@ export class TorrentPool {
     };
   }
 
+  /**
+   * Return download statistics for a torrent and optionally a specific file.
+   *
+   * @param {import("webtorrent").Torrent} torrent
+   * @param {number | null} [fileIndex] - Zero-based file index, or null for torrent-level only.
+   * @returns {{
+   *   numPeers: number,
+   *   downloadSpeed: number,
+   *   uploadSpeed: number,
+   *   fileProgress: number | null,
+   *   fileDownloaded: number | null,
+   *   fileLength: number | null
+   * }}
+   */
+  getFileStats(torrent, fileIndex = null) {
+    const numPeers = typeof torrent?.numPeers === "number" ? torrent.numPeers : 0;
+    const downloadSpeed = typeof torrent?.downloadSpeed === "number" ? torrent.downloadSpeed : 0;
+    const uploadSpeed = typeof torrent?.uploadSpeed === "number" ? torrent.uploadSpeed : 0;
+
+    const base = { numPeers, downloadSpeed, uploadSpeed };
+
+    if (fileIndex === null || !Number.isInteger(fileIndex) || !Array.isArray(torrent?.files)) {
+      return { ...base, fileProgress: null, fileDownloaded: null, fileLength: null };
+    }
+
+    const file = torrent.files[fileIndex];
+    if (!file) {
+      return { ...base, fileProgress: null, fileDownloaded: null, fileLength: null };
+    }
+
+    return {
+      ...base,
+      fileProgress: typeof file.progress === "number" ? file.progress : 0,
+      fileDownloaded: typeof file.downloaded === "number" ? file.downloaded : 0,
+      fileLength: typeof file.length === "number" ? file.length : 0
+    };
+  }
+
+  /**
+   * Pre-fetch the leading and trailing bytes of a torrent file so that
+   * WebTorrent prioritises the pieces that contain file headers and footers.
+   *
+   * For MP4 files the MOOV atom is often placed at the very end of the file
+   * (non-faststart encoding).  Fetching the tail ensures that ffprobe can
+   * identify codecs and duration even for freshly-added torrents without
+   * waiting for the rest of the content to download.
+   *
+   * Resolves once both regions have been fully downloaded, or when the
+   * timeout elapses — whichever comes first.  Never rejects.
+   *
+   * @param {import("webtorrent").Torrent} torrent
+   * @param {number} fileIndex - Zero-based index into `torrent.files`.
+   * @param {object} [options]
+   * @param {number} [options.headBytes=262144]   - Leading bytes to fetch (default 256 KB).
+   * @param {number} [options.tailBytes=2097152]  - Trailing bytes to fetch (default 2 MB).
+   * @param {number} [options.timeoutMs=300000]   - Maximum wait time in milliseconds (default 5 min).
+   * @returns {Promise<void>}
+   */
+  async prefetchFileEdges(
+    torrent,
+    fileIndex,
+    { headBytes = 256 * 1024, tailBytes = 2 * 1024 * 1024, timeoutMs = 300_000 } = {}
+  ) {
+    if (!torrent || !Array.isArray(torrent.files)) {
+      return;
+    }
+    const file = torrent.files[fileIndex];
+    if (!file || typeof file.createReadStream !== "function") {
+      return;
+    }
+    const fileSize = file.length;
+    if (!Number.isFinite(fileSize) || fileSize <= 0) {
+      return;
+    }
+
+    const safeHeadEnd = Math.min(headBytes, fileSize) - 1;
+    const safeTailStart = Math.max(0, fileSize - tailBytes);
+
+    /** Drain a readable stream, resolving on end/error/close. */
+    const drainStream = (stream) =>
+      new Promise((resolve) => {
+        stream.on("data", () => undefined);
+        stream.once("end", resolve);
+        stream.once("error", resolve);
+        stream.once("close", resolve);
+      });
+
+    try {
+      const tasks = [
+        // Head: FTYP/MOOV (faststart MP4), EBML header (MKV), etc.
+        drainStream(file.createReadStream({ start: 0, end: safeHeadEnd }))
+      ];
+
+      // Tail: MOOV atom for non-faststart MP4.  Skip when it overlaps the head.
+      if (safeTailStart > safeHeadEnd + 1) {
+        tasks.push(drainStream(file.createReadStream({ start: safeTailStart, end: fileSize - 1 })));
+      }
+
+      await Promise.race([
+        Promise.all(tasks),
+        new Promise((resolve) => setTimeout(resolve, timeoutMs))
+      ]);
+    } catch (_error) {
+      // Best-effort — a prefetch failure must never prevent playback.
+    }
+  }
+
   /**
    * Update WebTorrent piece selection to match the current usage map.
    * Files with at least one consumer are selected; all others are deselected.

package/services/webrtc-manager.js

@@ -147,7 +147,9 @@ export function createWebRtcManager({ sendSignal, onDataChannel, onLog }) {
 
     pc.onStateChange((state) => {
       log(`[webrtc] Session ${sessionId.slice(0, 8)}: state → ${state}`);
-      if (state === "disconnected" || state === "failed" || state === "closed") {
+      // "disconnected" is a transient state — ICE may recover on its own.
+      // Only tear down on terminal states: "failed" and "closed".
+      if (state === "failed" || state === "closed") {
         closeSession(sessionId);
       }
     });

package/utils/logger.js

@@ -9,6 +9,16 @@ import chalk from "chalk";
 
 const PREFIX = "[proxy-client]";
 
+/**
+ * Return the current time as a compact ISO-8601 string, e.g. `12:34:56.789`.
+ * Uses only the time portion to keep log lines short.
+ *
+ * @returns {string}
+ */
+function ts() {
+  return new Date().toISOString().slice(11, 23); // "HH:MM:SS.mmm"
+}
+
 /**
  * @typedef {Object} ProxyLogger
  * @property {(message: string) => void} info    - Informational message (cyan).
@@ -23,8 +33,8 @@ const PREFIX = "[proxy-client]";
  * @type {ProxyLogger}
  */
 export const logger = {
-  info:    (message) => console.log(chalk.cyan(`${PREFIX} ${message}`)),
-  success: (message) => console.log(chalk.green(`${PREFIX} ${message}`)),
-  warn:    (message) => console.warn(chalk.yellow(`${PREFIX} ${message}`)),
-  error:   (message) => console.error(chalk.red(`${PREFIX} ${message}`)),
+  info:    (message) => console.log(chalk.cyan(`${PREFIX} [${ts()}] ${message}`)),
+  success: (message) => console.log(chalk.green(`${PREFIX} [${ts()}] ${message}`)),
+  warn:    (message) => console.warn(chalk.yellow(`${PREFIX} [${ts()}] ${message}`)),
+  error:   (message) => console.error(chalk.red(`${PREFIX} [${ts()}] ${message}`)),
 };