@torrent-tv/proxy 2.95.3 → 2.95.4

package/package.json

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

package/routes/encode-input/get.js

@@ -0,0 +1,29 @@
+import { parseRange } from "../../utils/parse-range.js";
+
+/** FFmpeg reads only original byte ranges already owned by its live run. */
+export function handleEncodeInputGet(req, reply, { inputOf }) {
+  const address = req.raw?.socket?.remoteAddress;
+  if (!["127.0.0.1", "::1", "::ffff:127.0.0.1"].includes(address)) return reply.code(403).send();
+  const token = Number(req.params.token), fileIndex = Number(req.params.fileIndex);
+  if (!Number.isSafeInteger(token) || !Number.isSafeInteger(fileIndex) || fileIndex < 0) return reply.code(400).send();
+  const input = inputOf(token);
+  const length = input?.lengthOf(fileIndex);
+  if (!Number.isSafeInteger(length) || length <= 0) return reply.code(404).send();
+  reply.header("Accept-Ranges", "bytes");
+  reply.header("Content-Type", "application/octet-stream");
+  if (req.method === "HEAD") {
+    reply.hijack();
+    reply.raw.writeHead(200, { "Accept-Ranges": "bytes", "Content-Type": "application/octet-stream", "Content-Length": String(length) });
+    reply.raw.end();
+    return;
+  }
+  const range = parseRange(req.headers.range, length);
+  if (!range || range.start >= length) return reply.code(416).header("Content-Range", `bytes */${length}`).send();
+  // Older FFmpeg versions request through EOF. A finite partial response keeps
+  // each read within the admitted lookahead, without version-specific options.
+  range.end = Math.min(range.end, range.start + 1048575);
+  const held = input.read(fileIndex, range.start, range.end, true);
+  if (!held) return reply.code(503).send({ error: "Original input bytes are outside the admitted ranges." });
+  return reply.code(206).header("Content-Length", String(held.bytes.length))
+    .header("Content-Range", `bytes ${range.start}-${held.end}/${length}`).send(held.bytes);
+}

package/server.js

@@ -42,6 +42,7 @@ import { handleApiTranscodeSessionNetReportPost } from "./routes/api/transcode-s
 import { handleApiTranscodeSessionFragmentFarPost } from "./routes/api/transcode-sessions/fragment-far/post.js";
 import { handleApiTranscodeSessionSeekPost } from "./routes/api/transcode-sessions/seek/post.js";
 import { handleStreamGet } from "./routes/stream/get.js";
+import { handleEncodeInputGet } from "./routes/encode-input/get.js";
 import { handleTranscodeSessionFileGet } from "./routes/transcode/session-file/get.js";
 import { handleTranscodeVariantFileGet } from "./routes/transcode/variant-file/get.js";
 import { handleTranscodeAudioFileGet } from "./routes/transcode/audio-file/get.js";
@@ -57,7 +58,7 @@ import { SubtitleOrchestrator } from "./services/media/SubtitleOrchestrator.js";
 import { containerOrchestrator, CONTAINER_HEAD_BYTES, describeWorkTags } from "./services/media/ContainerOrchestrator.js";
 import { readPlaybackDeclarations } from "./services/media/read-playback-declarations.js";
 import { DownloadMaps } from "./services/viewer/DownloadMaps.js";
-import { nativeSourceMap } from "./services/viewer/NativeSourceMap.js";
+import { nativeSourceMap, nativeOriginalSourceMap } from "./services/viewer/NativeSourceMap.js";
 import { MediaReadRequests } from "./services/media/MediaReadRequests.js";
 import { SegmentInputs } from "./services/media/SegmentInputs.js";
 import { ContainerTrack } from "./services/media/tracks/ContainerTrack.js";
@@ -417,7 +418,7 @@ export async function startProxyServer({
       const tracks = await containerOrchestrator.inspect(params, "tracks");
       if (tracks.kind !== "result" || !map.isCurrent()) return [];
       const container = containerOrchestrator.known(map.sourceKey, map.fileIndex);
-      if (typeof container?.readPacketIndex !== "function") return [];
+      if (typeof container?.readSourceRanges !== "function" && typeof container?.readPacketIndex !== "function") return [];
       const media = await containerOrchestrator.inspect(params, "media-info");
       if (media.kind !== "result" || !map.isCurrent()) return [];
       const shift = Number(media.value?.startTimeSeconds) || 0;
@@ -450,7 +451,9 @@ export async function startProxyServer({
       demands.sort((left, right) => left.deadlineAt - right.deadlineAt || right.priority - left.priority || left.index - right.index);
       for (const zone of demands) {
         if (!map.isCurrent()) return [];
-        const selected = zone.tracks.map(choice => ({ choice, track: tracks.value.filter(track => track.type === choice.type)[choice.index] }));
+        const selected = zone.tracks.map(choice => ({ choice, track: choice.type === "video"
+          ? ContainerTrack.firstUsable(tracks.value, "video")
+          : tracks.value.filter(track => track.type === choice.type)[choice.index] }));
         if (selected.some(({ track }) => !track)) continue;
         const wanted = selected.map(({ track }) => track);
         const modes = new Map(selected.map(({ choice, track }) => [track, choice.mode]));
@@ -461,10 +464,15 @@ export async function startProxyServer({
           demand: { ...zone.owner, leadSeconds: zone.leadSeconds } });
         if (!map.isCurrent()) return [];
         if (!intervalParams) continue;
-        const packets = await containerOrchestrator.inspect(intervalParams, "packets");
+        const navigation = await containerOrchestrator.inspect(intervalParams, "source-navigation");
+        if (navigation.kind !== "result") continue;
+        const originalRanges = navigation.value;
+        const packets = originalRanges && !zone.urgent
+          ? { kind: "result", value: await container.readMappedSourceRanges(interval) }
+          : await containerOrchestrator.inspect(intervalParams, originalRanges ? "source-ranges" : "packets");
         if (!map.isCurrent()) return [];
         if (packets.kind !== "result") continue;
-        const input = new SegmentInputs({ index: packets.value, tracks: wanted }).forInterval({ ...interval, mode: track => modes.get(track) });
+        const input = originalRanges ? packets.value : new SegmentInputs({ index: packets.value, tracks: wanted }).forInterval({ ...interval, mode: track => modes.get(track) });
         if (input.kind !== "result") continue;
         const { tracks: _choices, owner: _owner, sourceInterval: _sourceInterval, ...demand } = zone;
         for (const [byteStart, byteEnd] of input.ranges) converted.push({ ...demand,
@@ -610,6 +618,16 @@ export async function startProxyServer({
         params.packetInterval = { ...sourceInterval,
           trackIds: wanted.map(track => track.trackNumber),
           modes: Object.fromEntries(wanted.map(track => [track.trackNumber, modes.get(track)])) };
+        const navigation = await containerOrchestrator.inspect(params, "source-navigation");
+        if (navigation.kind !== "result") return navigation;
+        if (navigation.value && selected.size === 1 && output.segmentFormat.supportsOriginalInput === true) {
+          const ranges = await containerOrchestrator.inspect(params, "source-ranges");
+          if (ranges.kind !== "result") return ranges;
+          sources.push({ sourceKey: params.sourceKey, fileIndex, timeShiftSeconds,
+            input: { ...ranges.value, original: true, selections: wanted.map(track => ({ track,
+              index: track.declaredIndex ?? choices.find(choice => choice.type === track.type)?.index ?? 0 })) } });
+          continue;
+        }
         const packets = await containerOrchestrator.inspect(params, "packets");
         if (packets.kind !== "result") return packets;
         const input = new SegmentInputs({ index: packets.value, tracks: wanted }).forInterval({
@@ -769,13 +787,15 @@ export async function startProxyServer({
   // decides anything, keeps the segments whose closure is proven, and removes
   // the one piece per output that was being written when the process died.
   outputParts.lifecycle.adoptSegmentsLeftBehind();
-  const publishNative = work => {
+  const publishNative = async work => {
     if (!work.nativeInput || !sourcePreparation.accepts(work)) return Promise.resolve();
     const viewers = outputParts.viewers.forSource(work.sourceKey)
       .filter(viewer => viewer.source.selectedFileIndex === work.fileIndex && viewer.outputs.size === 0);
-    const zones = nativeSourceMap({ ...work.nativeInput, viewers,
+    const convert = work.nativeInput.container ? nativeOriginalSourceMap : nativeSourceMap;
+    const zones = await convert({ ...work.nativeInput, viewers,
       allowanceSeconds: outputParts.segmentDurationSec,
       urgentReadyFor: viewer => sourcePreparation.urgentReadyFor(viewer) });
+    if (!sourcePreparation.accepts(work)) return;
     return downloadMaps.native({ sourceKey: work.sourceKey, fileIndex: work.fileIndex, zones });
   };
   sourcePreparation = new SourcePreparation({
@@ -828,7 +848,12 @@ export async function startProxyServer({
       const params = await containerOver(work);
       if (!params) return { kind: "needs-source" };
       params.isCurrent = () => sourcePreparation.accepts(work);
-      if (work.statement === "packets" && work.role === "source-rest" && sourcePreparation.accepts(work)) {
+      const originalContainer = work.statement === "packets" ? await containerOrchestrator.containerFor(params) : null;
+      const navigation = work.statement === "packets" && work.role !== "subtitle-embedded"
+        ? await containerOrchestrator.inspect(params, "source-navigation") : { kind: "result", value: false };
+      if (navigation.kind !== "result") return navigation;
+      const originalRanges = navigation.value;
+      if (!originalRanges && work.statement === "packets" && work.role === "source-rest" && sourcePreparation.accepts(work)) {
         const file = torrentPool.knownTorrent(work.sourceKey)?.files?.[work.fileIndex];
         if (file?.length > 0) {
           const statement = `${work.statement}:${work.requestId}:input`;
@@ -837,7 +862,7 @@ export async function startProxyServer({
             scope: "preparation", ...sourcePreparation.demandFor(work) });
         }
       }
-      if ((work.statement === "packets" && work.role !== "source-rest") || work.role === "subtitle-embedded" && work.statement === "subtitle-cues") {
+      if ((work.statement === "packets" && (work.role !== "source-rest" || originalRanges)) || work.role === "subtitle-embedded" && work.statement === "subtitle-cues") {
         const info = await containerOrchestrator.inspect({ ...params, onReadResult: undefined }, "media-info");
         if (info.kind !== "result") return info;
         const positions = outputParts.viewers.forSource(work.sourceKey)
@@ -858,6 +883,23 @@ export async function startProxyServer({
         if (!sourcePreparation.accepts(work)) return;
         mediaReads.record(params, statement, result, revision.storage, revision.memory);
         const inputStatement = `${work.statement}:${work.requestId}:input`;
+        if (statement === "source-ranges" && result.kind === "result") {
+          if (work.selected) work.inputRanges = result.value.ranges;
+          if (work.role === "source-rest") {
+            const info = await containerOrchestrator.inspect({ ...params, onReadResult: undefined }, "media-info");
+            if (!sourcePreparation.accepts(work)) return;
+            if (info.kind === "result") {
+              work.nativeInput = { container: originalContainer, durationSeconds: info.value.durationSeconds,
+                startTimeSeconds: info.value.startTimeSeconds ?? 0 };
+              await publishNative(work);
+            }
+          } else {
+            await downloadMaps.metadata({ sourceKey: work.sourceKey, fileIndex: work.fileIndex,
+              statement: inputStatement, result: { kind: "needs-ranges", ranges: result.value.ranges, requestId: inputStatement },
+              scope: "preparation", ...sourcePreparation.demandFor(work) });
+            if (work.selected) await sourcePreparation.bytesChanged(work.sourceKey, work.fileIndex);
+          }
+        }
         if (statement === "packets" && work.role === "source-rest" && result.kind === "result") {
           const tracks = await containerOrchestrator.containerFor(params).then(container => container.readTracks());
           const info = await containerOrchestrator.inspect({ ...params, onReadResult: undefined }, "media-info");
@@ -895,7 +937,7 @@ export async function startProxyServer({
       };
       return work.statement === "subtitle-file"
         ? subtitles.inspectFile(params) : work.statement === "subtitle-cues"
-          ? subtitles.inspectPackets(params) : containerOrchestrator.inspect(params, work.statement);
+          ? subtitles.inspectPackets(params) : containerOrchestrator.inspect(params, originalRanges ? "source-ranges" : work.statement);
     },
     withdraw: work => {
       if (work.role === "source-rest" && work.statement === "packets") {
@@ -1055,6 +1097,9 @@ export async function startProxyServer({
       subtitles
     })
   );
+  app.get("/encode-input/:token/:fileIndex", (req, reply) =>
+    handleEncodeInputGet(req, reply, { inputOf: token => outputParts.encodeRuns.originalInputOf(token) })
+  );
   app.get("/stream", async (req, reply) =>
     handleStreamGet(req, reply, {
       sourceRegistry,

package/services/encode/EncodeInputs.js

@@ -1,4 +1,5 @@
 import { admitInput } from "./AdmittedInput.js";
+import { admitOriginalInput } from "./OriginalInput.js";
 
 /** Event-driven preparation; a synchronous run request can take only ready input. */
 export class EncodeInputs {
@@ -31,7 +32,11 @@ export class EncodeInputs {
     let bytes = this.#held;
     for (const [key, wanted] of this.#wanted) {
       const request = this.#requests.get(key);
-      if (request && this.#urgent(request.output, request.from)) bytes += wanted;
+      // The encode plan already chose this finite input. It must fit before
+      // production can advance, even when playback has not reached it yet.
+      // Sharing against speculative whole-file demand can otherwise deny it
+      // forever, so urgency must not decide its minimum allocation again.
+      if (request) bytes += wanted;
     }
     return bytes;
   }
@@ -110,7 +115,8 @@ export class EncodeInputs {
     request.promise = (async () => {
       const resolved = await this.#resolve(request.output, request.from, request.to);
       if (this.#requests.get(request.key) !== request) return;
-      const result = resolved.kind === "result" ? await admitInput({
+      const admit = resolved.sources?.every(source => source.input.original === true) ? admitOriginalInput : admitInput;
+      const result = resolved.kind === "result" ? await admit({
         sources: resolved.sources,
         readRanges: this.#read,
         reserve: async bytes => {

package/services/encode/EncodeRuns.js

@@ -15,6 +15,7 @@ import { ENCODE_EXIT } from "./encode-exit.js";
 import { EncodeRun } from "./EncodeRun.js";
 import { computeOutputDimensions } from "./args.js";
 import { buildAdmittedCommand } from "./admitted-command.js";
+import { buildOriginalCommand } from "./source-command.js";
 import { writeAdmittedInput } from "./AdmittedInput.js";
 import { cutOf, judgeNeighbors, judgePiece } from "./piece-completeness.js";
 import { presentationSegment } from "./segment-formats/presentation-segment.js";
@@ -254,6 +255,10 @@ export class EncodeRuns {
     }
   }
 
+  originalInputOf(runToken) {
+    return this.#runsByInputToken.get(runToken)?.originalInput ?? null;
+  }
+
   /**
    * @param {object} output
    * @returns {number}
@@ -892,8 +897,12 @@ export class EncodeRuns {
     this.#lastInputToken += 1;
     const inputToken = this.#lastInputToken;
     if (admittedInput) admittedInput.runTag = `${startIndex}r${inputToken}`;
-    const { args, safeIndex, startSeconds, cutTimes } = buildAdmittedCommand({
+    const buildCommand = admittedInput.original ? buildOriginalCommand : buildAdmittedCommand;
+    const { args, safeIndex, startSeconds, cutTimes } = buildCommand({
       admittedInput,
+      inputToken,
+      baseUrl: this.#host.localBaseUrl,
+      keyframes: session.file.keyframes,
 
       timeline: session.timeline,
       output: session.output,
@@ -971,7 +980,10 @@ export class EncodeRuns {
 
         const index = session.segmentFormat.segmentIndexFromName(
           session.segmentFormat.servedNameOf?.(name) ?? name);
-        if (Number.isInteger(index) && index < safeIndex) return null;
+        // Encoder flush can create a partial file beyond its assigned interval.
+        // It belongs to no requested output segment and must not condemn the
+        // complete input or overwrite a neighboring run's segment.
+        if (Number.isInteger(index) && (index < safeIndex || index > run.to)) return null;
         let bytes = null;
         if (admittedInput && session.segmentFormat.id === "fmp4" && session.spec.carries !== "audio-only" &&
           session.spec.audio && !this.#host.servesAudioSeparately(session)) {
@@ -997,10 +1009,16 @@ export class EncodeRuns {
       onSpeedMeasured: () => this.#host.noteRunSpeedMeasured?.(session, run),
       onEnded: (ended) => {
         this.#runsByInputToken.delete(inputToken);
+        if (admittedInput.original) admittedInput.release();
         this.noteRunEnded(session, run, ended);
       }
     });
-    if (admittedInput) {
+    if (admittedInput.original) {
+      run.originalInput = admittedInput;
+      run.inputFingerprint = admittedInput.fingerprint;
+      run.admittedInputKeys = new Map([[safeIndex, inputKey]]);
+      run.process.stdin.end();
+    } else if (admittedInput) {
       run.inputFingerprint = admittedInput.fingerprint;
       run.admittedInputKeys = new Map([[safeIndex, inputKey]]);
       let nextIndex = startIndex + 1;

package/services/encode/OriginalInput.js

@@ -0,0 +1,59 @@
+import { createHash } from "node:crypto";
+
+/** Retain complete original byte ranges under the encoder's input allowance.
+ * The available-only reader acquires complete pieces atomically before copying;
+ * owned buffers then outlive torrent eviction without keeping duplicate pins.
+ */
+export async function admitOriginalInput({ sources, reserve, readRanges }) {
+  const bytes = sources.reduce((total, source) => total + source.input.ranges
+    .reduce((sum, [start, end]) => sum + end - start + 1, 0), 0);
+  if (!Number.isSafeInteger(bytes) || bytes <= 0) throw new TypeError("Original input requires complete finite byte ranges.");
+  const releaseBudget = await reserve(bytes);
+  if (typeof releaseBudget !== "function") return releaseBudget?.kind === "terminal" ? releaseBudget : { kind: "needs-memory", bytes };
+  const held = new Map();
+  const hash = createHash("sha256");
+  let retained = false;
+  try {
+    for (const source of sources) {
+      const buffers = await readRanges(source, source.input.ranges, bytes);
+      if (buffers === null) return { kind: "needs-bytes", sourceKey: source.sourceKey, fileIndex: source.fileIndex, ranges: source.input.ranges };
+      if (!Array.isArray(buffers) || buffers.length !== source.input.ranges.length || buffers.some((buffer, index) =>
+        !Buffer.isBuffer(buffer) || buffer.length !== source.input.ranges[index][1] - source.input.ranges[index][0] + 1)) {
+        throw new Error("Original input reader returned incomplete ranges.");
+      }
+      hash.update(JSON.stringify([source.sourceKey, source.fileIndex, source.input.ranges, source.input.selections]));
+      for (const buffer of buffers) hash.update(buffer);
+      held.set(source.fileIndex, { source, buffers });
+    }
+    let released = false;
+    retained = true;
+    return {
+      kind: "result", original: true, sources, bytes, fingerprint: hash.digest("hex"),
+      tracks: sources.flatMap(source => (source.input.selections ?? []).map(selection => ({ track: selection.track,
+        ...(Number.isFinite(source.input.sourceEnds?.[selection.track.trackNumber]) ? {
+          sourceEndSeconds: source.input.sourceEnds[selection.track.trackNumber] - source.timeShiftSeconds
+        } : {}) }))),
+      read(fileIndex, start, end, partial = false) {
+        if (released) return null;
+        const entry = held.get(fileIndex);
+        if (!entry) return null;
+        const { ranges, fileLength } = entry.source.input;
+        if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end < start || start >= fileLength) return null;
+        let stop = Math.min(end, fileLength - 1);
+        const position = ranges.findIndex(([from, to]) => from <= start && (partial ? start : stop) <= to);
+        if (position < 0) return null;
+        stop = Math.min(stop, ranges[position][1]);
+        return { length: fileLength, end: stop, bytes: entry.buffers[position].subarray(start - ranges[position][0], stop - ranges[position][0] + 1) };
+      },
+      lengthOf: fileIndex => held.get(fileIndex)?.source.input.fileLength ?? null,
+      release() {
+        if (released) return;
+        released = true;
+        held.clear();
+        releaseBudget();
+      }
+    };
+  } finally {
+    if (!retained) releaseBudget();
+  }
+}

package/services/encode/admitted-command.js

@@ -13,7 +13,13 @@ export function buildAdmittedCommand({ admittedInput, timeline, output, segmentF
   const origin = admittedInput.originSeconds;
   const relativeStart = Math.max(0, startSeconds - origin);
   const relativeEnd = endSeconds - origin;
-  const cutTimes = grid.slice(safeIndex + 1, endIndex + 1).map(time => time - startSeconds);
+  // segment.c adds the first reference packet's PTS to every relative cut.
+  // Copied audio can start after the published boundary; price cuts from its
+  // actual first packet rather than adding that delay to every segment end.
+  const firstAudio = audioOnly && !transcodeAudio
+    ? admittedInput.tracks.find(input => input.track.type === "audio")?.packets[0]?.pts : null;
+  const cutOrigin = Number.isFinite(firstAudio) ? firstAudio : startSeconds;
+  const cutTimes = grid.slice(safeIndex + 1, endIndex + 1).map(time => time - cutOrigin);
   const args = ["-hide_banner", "-nostats", "-loglevel", "error", "-progress", "pipe:1"];
   if (transcodeVideo && Array.isArray(videoEncoder.inputArgs)) args.push(...videoEncoder.inputArgs);
   args.push("-f", "matroska", "-i", "pipe:0", "-copyts", "-avoid_negative_ts", "disabled", "-output_ts_offset", ffmpegSeconds(origin));
@@ -42,7 +48,7 @@ export function buildAdmittedCommand({ admittedInput, timeline, output, segmentF
   else args.push("-map", "0:v:0", "-map", "0:a:0?", ...video, ...audio);
   args.push("-to", ffmpegSeconds(relativeEnd), "-f", "segment");
   if (cutTimes.length) args.push("-segment_times", cutTimes.join(","));
-  else args.push("-segment_time", ffmpegSeconds(endSeconds - startSeconds));
+  else args.push("-segment_time", ffmpegSeconds(endSeconds - cutOrigin));
   const formatArgs = segmentFormat.explicitTimesMuxerArgs?.();
   if (!Array.isArray(formatArgs)) throw new Error("The segment format cannot publish admitted packet input.");
   const muxOptions = formatArgs.indexOf("-segment_format_options");

package/services/encode/output/Timeline.js

@@ -180,6 +180,7 @@ export class Timeline {
       let priority = 0;
       let withinSeconds = Number.POSITIVE_INFINITY;
       let behind = true;
+      let urgent = false;
       for (let second = from; second < until && second < map.durationSeconds; second += 1) {
         if (map.priority[second] > priority) {
           priority = map.priority[second];
@@ -190,6 +191,7 @@ export class Timeline {
         if (map.behind[second] === 0) {
           behind = false;
         }
+        if (map.urgent?.[second]) urgent = true;
       }
       if (priority === 0) {
         continue;
@@ -200,6 +202,7 @@ export class Timeline {
         && previous.to === index - 1
         && previous.priority === priority
         && previous.behind === behind
+        && previous.urgent === urgent
       ) {
         // The time is not compared, only the rank. A run's time is that of its
         // near edge — a stretch is met at its beginning — and whoever needs the
@@ -212,6 +215,7 @@ export class Timeline {
         to: index,
         priority,
         withinSeconds,
+        urgent,
         // Which side of the viewers this is. Stated by the map and carried
         // through: converting seconds into piece numbers cannot move a stretch
         // from in front of somebody to behind them.

package/services/encode/piece-completeness.js

@@ -141,7 +141,11 @@ function intervalFailure(coverage, { from, to, requiredKinds, sourceEnds = {} })
     const end = BigInt(Math.round(through * Number(track.timescale)));
     const first = track.ranges[0];
     const frame = track.productionFrame ?? first.frame;
-    if (first.start > start + frame || first.start < start - frame) return `segment-start-outside-interval-${kind}`;
+    // The muxer rounds an empty edit to movie ticks independently of sample
+    // cadence. Account for that recorded position uncertainty at the boundary,
+    // without admitting another missing frame or widening internal gaps.
+    const positionError = track.positionErrorTicks ?? 0n;
+    if (first.start > start + frame + positionError || first.start < start - frame - positionError) return `segment-start-outside-interval-${kind}`;
     // The first sample's cadence already bounds the interval start. A shorter
     // final sample must not replace that bound when this range is traversed.
     let reached = first.start;
@@ -150,7 +154,7 @@ function intervalFailure(coverage, { from, to, requiredKinds, sourceEnds = {} })
       if (range.end > reached) reached = range.end;
     }
     const finalFrame = track.productionFrame ?? track.ranges.at(-1).frame;
-    if (reached < end - finalFrame || reached > end + finalFrame) return `segment-end-outside-interval-${kind}`;
+    if (reached < end - finalFrame - positionError || reached > end + finalFrame + positionError) return `segment-end-outside-interval-${kind}`;
   }
   return null;
 

package/services/encode/run-command.js

@@ -23,19 +23,19 @@
  * duration parser rejects that outright: a field session died on
  * `Invalid duration for option ss: 3.3333333249174757e-7`, after which the
  * transcode was in state `failed` and every segment request answered 500 for
- * as long as the viewer kept trying. Anything under a millisecond is also not a
- * real offset — it is the residue of subtracting two nearly equal floats — so
- * it is dropped rather than passed on.
+ * as long as the viewer kept trying. Round to the duration parser's microsecond
+ * precision; a sub-millisecond value can be a real trim, not subtraction noise.
  *
  * @param {number} value
  * @returns {string}
  */
 export function ffmpegSeconds(value) {
-  if (!Number.isFinite(value) || Math.abs(value) < 0.001) {
+  if (!Number.isFinite(value)) {
     return "0";
   }
   // Microsecond resolution, fixed notation, no trailing zero noise.
-  return value.toFixed(6).replace(/\.?0+$/, "");
+  const rounded = value.toFixed(6).replace(/\.?0+$/, "");
+  return rounded === "-0" ? "0" : rounded;
 }
 
 /**

package/services/encode/segment-formats/fmp4.js

@@ -98,6 +98,7 @@ const SEGMENT_PATTERN = /^segment-(\d{5})\.mp4$/;
  */
 export const fmp4Format = {
   id: "fmp4",
+  supportsOriginalInput: true,
   initFileName: INIT_FILE_NAME,
   initContentType: "video/mp4",
   segmentContentType: "video/mp4",

package/services/encode/segment-formats/mp4-boxes.js

@@ -165,16 +165,40 @@ export function readTrackEdits(initSegment) {
 }
 
 /** An init shared across seeks has no segment-specific empty edit. */
-export function neutralizeEmptyEdits(initSegment) {
+export function neutralizeEmptyEdits(initSegment, { audioEncoderDelay = 0 } = {}) {
   const neutral = Buffer.from(initSegment);
+  const audioTracks = new Set();
+  let trackId = null;
+  if (audioEncoderDelay > 0) walkBoxes(neutral, (type, start, end) => {
+    if (type === "tkhd") {
+      const at = start + (neutral[start] === 1 ? 20 : 12);
+      if (at + 4 <= end) trackId = neutral.readUInt32BE(at);
+    } else if (type === "hdlr" && start + 12 <= end && neutral.toString("latin1", start + 8, start + 12) === "soun") {
+      audioTracks.add(trackId);
+    }
+  });
+  trackId = null;
   walkBoxes(neutral, (type, start, end) => {
+    if (type === "tkhd") {
+      const at = start + (neutral[start] === 1 ? 20 : 12);
+      if (at + 4 <= end) trackId = neutral.readUInt32BE(at);
+    }
     if (type !== "elst" || start + 8 > end) return;
     const version = neutral[start];
     const width = version === 1 ? 20 : 12;
     const count = neutral.readUInt32BE(start + 4);
     for (let entry = 0, at = start + 8; entry < count && at + width <= end; entry++, at += width) {
       const mediaTime = version === 1 ? neutral.readBigInt64BE(at + 8) : BigInt(neutral.readInt32BE(at + 4));
-      if (mediaTime !== -1n) continue;
+      if (mediaTime !== -1n) {
+        // Native AAC emits 1024 samples of encoder delay (aacenc.c).
+        // A later run's positive start can hide that delay in an empty edit.
+        // The shared origin must also represent the first run's negative DTS.
+        if (audioTracks.has(trackId) && mediaTime < BigInt(audioEncoderDelay)) {
+          if (version === 1) neutral.writeBigInt64BE(BigInt(audioEncoderDelay), at + 8);
+          else neutral.writeInt32BE(audioEncoderDelay, at + 4);
+        }
+        continue;
+      }
       if (version === 1) neutral.writeBigUInt64BE(0n, at);
       else neutral.writeUInt32BE(0, at);
     }