@poe-platform/safe-bash 0.1.844 → 0.1.846

package/dist/safe-bash-command-ffmpeg/index.js

@@ -23,7 +23,7 @@ import {
   sliceMp4,
   srtAst,
   webvttAst
-} from "../safe-bash/command-chunks/chunk-LORSYIAF.js";
+} from "../safe-bash/command-chunks/chunk-CSJHADNR.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 
 // packages/safe-bash-command-ffmpeg/src/index.ts
@@ -78,6 +78,73 @@ async function resampleAudio(channels, outputLength, rateRatio, budget, signal)
 
 // packages/safe-bash-command-ffmpeg/src/audio-tempo.ts
 import { yieldTurn as yieldTurn2 } from "../safe-bash-contracts/yield.js";
+async function filterUnityTempo(channels, sampleRate, pcm16, budget, signal) {
+  const length = channels[0]?.length ?? 0;
+  const window = 2 ** Math.ceil(Math.log2(Math.max(2, Math.floor(sampleRate / 24))));
+  const hop = window / 2;
+  if (length < hop) return channels.map(() => new Float32Array(0));
+  const hann = Float32Array.from({ length: window }, (_, i) => (1 - Math.cos(2 * Math.PI * i / (window - 1))) / 2);
+  const mono = new Float32Array(length);
+  for (let i = 0; i < length; i++) {
+    if (i % 16384 === 0) {
+      await yieldTurn2(signal);
+      signal?.throwIfAborted();
+      budget.checkCpu();
+    }
+    for (const channel of channels) {
+      if (Math.abs(channel[i]) > Math.abs(mono[i])) mono[i] = channel[i];
+    }
+  }
+  const output = channels.map(() => []);
+  let previous = -hop;
+  let position = -hop;
+  let work = 0;
+  while (true) {
+    let current = previous + hop;
+    position += hop;
+    const drift = position - hop - previous;
+    const start = Math.min(window, Math.max(0, -drift));
+    const end = Math.max(0, Math.min(window - drift, window - window / 16));
+    let correction = -drift;
+    let best = -Infinity;
+    for (let lag = start; lag < end; lag++) {
+      let correlation = 0;
+      for (let j = Math.max(0, -current); j < Math.min(window - lag, length - current, length - previous - lag); j++) {
+        correlation += (mono[previous + j + lag] ?? 0) * mono[current + j];
+        if (++work % 16384 === 0) {
+          await yieldTurn2(signal);
+          signal?.throwIfAborted();
+          budget.checkCpu();
+        }
+      }
+      const metric = correlation * (drift + lag) * (lag - start) * (end - lag);
+      if (metric > best) {
+        best = metric;
+        correction = lag - hop;
+      }
+    }
+    current -= correction;
+    const count = Math.max(0, Math.min(window, length - current));
+    const overlap = Math.min(hop, count, length - previous - hop);
+    for (let c = 0; c < channels.length; c++) {
+      const channel = channels[c];
+      const dst = output[c];
+      for (let i = 0; i < overlap; i++) {
+        const a = channel[previous + hop + i] ?? 0;
+        const b = channel[current + i] ?? 0;
+        const sample = current + i < 0 ? a : Math.fround(a * hann[hop + i] + Math.fround(b * hann[i]));
+        dst.push(pcm16 ? Math.trunc(sample * 32768) / 32768 : sample);
+      }
+      if (current + count >= length) {
+        for (let i = overlap; i < count; i++) dst.push(channel[current + i] ?? 0);
+      }
+    }
+    budget.checkDuration((output[0]?.length ?? 0) / sampleRate);
+    if (current + count >= length) break;
+    previous = current;
+  }
+  return output.map((channel) => Float32Array.from(channel));
+}
 async function stretchAudio(channels, sampleRate, tempo, budget, signal) {
   const length = channels[0]?.length ?? 0;
   if (tempo === 1 || length === 0) return channels;
@@ -275,6 +342,26 @@ import {
   resizeImage,
   rotateImage
 } from "../image-ast/portable.js";
+function parseFrameRate(value) {
+  switch (value) {
+    case "ntsc":
+    case "qntsc":
+    case "sntsc":
+      return 3e4 / 1001;
+    case "pal":
+    case "qpal":
+    case "spal":
+      return 25;
+    case "film":
+      return 24;
+    case "ntsc-film":
+      return 24e3 / 1001;
+  }
+  const [numerator, denominator = "1", extra] = value.split("/");
+  if (extra !== void 0 || !numerator?.trim() || !denominator.trim()) return void 0;
+  const rate = Number(numerator) / Number(denominator);
+  return Number.isFinite(rate) && rate > 0 ? rate : void 0;
+}
 function loopToOutputEnd(doc, endSeconds, budget) {
   if (endSeconds === void 0 || !Number.isFinite(endSeconds)) {
     throw new Error("-stream_loop -1 requires a finite output -t or -to");
@@ -532,6 +619,7 @@ function* lavfiSteps(spec, budget, durationOverride) {
   };
 }
 async function ensureDecodedFrames(track, movieTimescale, budget, signal, maxFrames) {
+  if (maxFrames === 0) return [];
   const width = track.width ?? track.codecDescriptions[0]?.width ?? 64;
   const height = track.height ?? track.codecDescriptions[0]?.height ?? 64;
   const ts = track.timescale || 9e4;
@@ -601,6 +689,9 @@ function parseFilterExpression(expression, filter, variables) {
         }
         if (name === "not" && args.length === 1) value = Number(args[0] === 0);
         else if (name === "eq" && args.length === 2) value = Number(args[0] === args[1]);
+        else if (name === "gte" && args.length === 2) value = Number(args[0] >= args[1]);
+        else if (name === "lt" && args.length === 2) value = Number(args[0] < args[1]);
+        else if (name === "if" && args.length === 3) value = args[0] !== 0 ? args[1] : args[2];
         else if (name === "gt" && args.length === 2) value = Number(args[0] > args[1]);
         else if (name === "mod" && args.length === 2) value = args[0] - Math.floor(args[0] / args[1]) * args[1];
         else if (name === "between" && args.length === 3) value = Number(args[0] >= args[1] && args[0] <= args[2]);
@@ -787,10 +878,7 @@ async function renderBitmapTextToRgba(rgba, width, height, text, opts = {}, sign
   }
   return out;
 }
-async function applyVideoFilterChain(frames, filterChainStr, budget, subtitleCues, signal) {
-  let work = 0;
-  let current = frames;
-  if (current.length === 0) return current;
+function parseFilterChain(filterChainStr) {
   const filters = [];
   let filter = "";
   let quoted = false;
@@ -808,7 +896,13 @@ async function applyVideoFilterChain(frames, filterChainStr, budget, subtitleCue
     }
   }
   if (filter.trim()) filters.push(filter.trim());
-  for (const filterSpec of filters) {
+  return filters;
+}
+async function applyVideoFilterChain(frames, filterChainStr, budget, subtitleCues, signal) {
+  let work = 0;
+  let current = frames;
+  if (current.length === 0) return current;
+  for (const filterSpec of parseFilterChain(filterChainStr)) {
     if (++work % 1024 === 0) {
       await yieldTurn5(signal);
       signal?.throwIfAborted();
@@ -1397,7 +1491,7 @@ function evalSyncFfmpeg(inBytesOrArgs, maybeArgs, readFileSync, writeFileSync) {
       if (arg === "-y" || arg === "-n") {
         if (noOverwrite !== void 0 && noOverwrite !== (arg === "-n")) return void 0;
         noOverwrite = arg === "-n";
-      } else if (arg === "-v" || arg === "-loglevel" || arg === "-safe" || arg === "-threads" || arg === "-pix_fmt" || arg === "-preset" || arg === "-crf" || arg === "-b:v" || arg === "-b:a" || arg === "-bsf:v" || arg === "-bsf:a" || arg === "-tag:v" || arg === "-tag:a" || arg === "-vsync" || arg === "-fps_mode") i++;
+      } else if (arg === "-v" || arg === "-loglevel" || arg === "-safe" || arg === "-threads" || arg === "-pix_fmt" || arg === "-preset" || arg === "-crf" || arg === "-bf" || arg === "-b:v" || arg === "-b:a" || arg === "-bsf:v" || arg === "-bsf:a" || arg === "-tag:v" || arg === "-tag:a" || arg === "-vsync" || arg === "-fps_mode") i++;
       else if (arg === "-map_chapters") {
         const value = args[++i];
         chapterSource = value?.trim() ? Number(value) : NaN;
@@ -1411,8 +1505,10 @@ function evalSyncFfmpeg(inBytesOrArgs, maybeArgs, readFileSync, writeFileSync) {
         if (!Number.isSafeInteger(val) || val < 0) return void 0;
         if (args.slice(i + 1).includes("-i")) pendingStartNumber = val;
         else outputStartNumber = val;
-      } else if (arg === "-ar") audioRate = parseInt(args[++i] ?? "0", 10) || void 0;
-      else if (arg === "-ac") audioChannels = parseInt(args[++i] ?? "0", 10) || void 0;
+      } else if (arg === "-ar") {
+        audioRate = parseInt(args[++i] ?? "0", 10) || void 0;
+        if (audioRate !== void 0 && audioRate < 0) return void 0;
+      } else if (arg === "-ac") audioChannels = parseInt(args[++i] ?? "0", 10) || void 0;
       else if (arg === "-hide_banner" || arg === "-nostdin" || arg === "-stats") continue;
       else if (arg === "-f") {
         const val = args[++i];
@@ -1433,7 +1529,8 @@ function evalSyncFfmpeg(inBytesOrArgs, maybeArgs, readFileSync, writeFileSync) {
         else outputDuration = val;
       } else if (arg === "-stream_loop") pendingLoop = parseInt(args[++i] ?? "0", 10) || 0;
       else if (arg === "-r" || arg === "-framerate") {
-        const val = parseFloat(args[++i] ?? "25") || 25;
+        const val = parseFrameRate(args[++i] ?? "");
+        if (val === void 0) return void 0;
         if (args.slice(i + 1).includes("-i")) pendingFps = val;
         else outputFps = val;
       } else if (arg === "-s") outputSize = args[++i];
@@ -1471,7 +1568,7 @@ function evalSyncFfmpeg(inBytesOrArgs, maybeArgs, readFileSync, writeFileSync) {
       else if (arg === "-vn") stripVideo = true;
       else if (arg === "-sn") stripSubtitles = true;
       else if (arg === "-shortest") shortest = true;
-      else if (arg === "-frames:v" || arg === "-vframes") maxVideoFrames = parseInt(args[++i] ?? "1", 10) || 1;
+      else if (arg === "-frames:v" || arg === "-vframes") maxVideoFrames = parseInt(args[++i] ?? "1", 10);
       else if (arg === "-frames:a" || arg === "-aframes") {
         const value = args[++i];
         maxAudioFrames = value?.trim() ? Number(value) : NaN;
@@ -1483,7 +1580,7 @@ function evalSyncFfmpeg(inBytesOrArgs, maybeArgs, readFileSync, writeFileSync) {
       } else if (arg === "-vf" || arg === "-filter:v") {
         const f = args[++i];
         if (f) vfFilters.push(f);
-      } else if (arg === "-af" || arg === "-filter:a") {
+      } else if (arg === "-af" || arg === "-filter:a" || arg.startsWith("-af:") || arg.startsWith("-filter:a:")) {
         return void 0;
       } else if (arg === "-disposition" || arg.startsWith("-disposition:")) {
         streamDispositions.push([arg.slice("-disposition:".length), args[++i] ?? ""]);
@@ -1588,16 +1685,16 @@ function evalSyncFfmpeg(inBytesOrArgs, maybeArgs, readFileSync, writeFileSync) {
     if (isNullMux) return "";
     if (inputs.some((inp) => isStdin(inp.path)) && !inBytes) return void 0;
     if (!writeFileSync || !outputTarget || outputTarget.endsWith("/") || outputTarget.endsWith("/.") || outputTarget.includes("/./") || /(?:^|\/)\.\.(?:\/|$)/u.test(outputTarget)) return void 0;
-    if (/%0?\d*d/.test(outputTarget)) {
+    if (formatImageSequence(outputTarget, outputStartNumber ?? 1) !== void 0) {
       const outExt2 = outputTarget.split(".").pop()?.toLowerCase() ?? "png";
       const vTrack = workingDoc.tracks.find((t) => t.type === "video");
       if (vTrack && !vTrack.decodedVideoFrames) return void 0;
       const frames = vTrack?.decodedVideoFrames ?? [];
-      const limit = maxVideoFrames ? Math.min(frames.length, maxVideoFrames) : frames.length;
+      const limit = Math.min(frames.length, maxVideoFrames ?? Infinity);
       const imgFmt = outExt2 === "jpg" || outExt2 === "jpeg" ? "jpeg" : outExt2 === "webp" ? "webp" : outExt2 === "gif" ? "gif" : outExt2 === "bmp" ? "bmp" : outExt2 === "ppm" ? "ppm" : "png";
       for (let idx = 0; idx < limit; idx++) {
         const f = frames[idx];
-        const fileName = outputTarget.replace(/%0?(\d*)d/, (_, widthDigits) => String(idx + (outputStartNumber ?? 1)).padStart(parseInt(widthDigits || "0", 10) || 0, "0"));
+        const fileName = formatImageSequence(outputTarget, idx + (outputStartNumber ?? 1));
         const encoded = encodeImage(makeRgbaImg(f.width, f.height, f.data), { format: imgFmt }).data;
         if (!writeFileSync(fileName, encoded)) return void 0;
       }
@@ -1605,6 +1702,7 @@ function evalSyncFfmpeg(inBytesOrArgs, maybeArgs, readFileSync, writeFileSync) {
     }
     const outPlugin = outputFormat ? registry.findByFormatName(outputFormat) : registry.findByFilename(outputTarget);
     if (!outPlugin || !outPlugin.canMux || outPlugin.id === "dash" || outPlugin.id === "hls") return void 0;
+    if (outPlugin.id === "image2" && maxVideoFrames === 0) return "";
     const outExt = outputTarget.split(".").pop()?.toLowerCase();
     const serializedBytes = outPlugin.serialize(workingDoc, { audioCodec, format: outputFormat ?? outExt, faststart, fragmented, metadata: metaTags, budget });
     if (isStdout(outputTarget)) return void 0;
@@ -1614,6 +1712,81 @@ function evalSyncFfmpeg(inBytesOrArgs, maybeArgs, readFileSync, writeFileSync) {
     return void 0;
   }
 }
+function formatImageSequence(pattern, number) {
+  let filename = "";
+  let numbered = false;
+  for (let i = 0; i < pattern.length; i++) {
+    if (pattern[i] !== "%") {
+      filename += pattern[i];
+      continue;
+    }
+    i++;
+    if (pattern[i] === "%") {
+      filename += "%";
+      continue;
+    }
+    let width = 0;
+    while (i < pattern.length && pattern[i] >= "0" && pattern[i] <= "9") {
+      width = width * 10 + Number(pattern[i]);
+      i++;
+    }
+    if (pattern[i] !== "d") return void 0;
+    filename += String(number).padStart(width, "0");
+    numbered = true;
+  }
+  return numbered ? filename : void 0;
+}
+function matchesImageGlob(pattern, name, budget) {
+  const characters = Array.from(name);
+  let positions = /* @__PURE__ */ new Set([0]);
+  for (let i = 0; i < pattern.length; i++) {
+    budget.checkCpu();
+    const token = pattern[i];
+    const next = /* @__PURE__ */ new Set();
+    if (token === "*") {
+      let start = characters.length;
+      for (const p of positions) start = Math.min(start, p);
+      for (let p = start; p <= characters.length; p++) next.add(p);
+    } else {
+      let literal = token;
+      let contents;
+      if (token === "\\") literal = pattern[++i] ?? "\\";
+      if (token === "[") {
+        let end = i + 1;
+        if (pattern[end] === "!" || pattern[end] === "^") end++;
+        if (pattern[end] === "]") end++;
+        while (end < pattern.length && pattern[end] !== "]") end++;
+        if (end < pattern.length) {
+          contents = pattern.slice(i + 1, end);
+          i = end;
+        }
+      }
+      for (const p of positions) {
+        budget.checkCpu();
+        const character = characters[p];
+        if (character === void 0) continue;
+        let matches = token === "?" || character === literal;
+        if (contents !== void 0) {
+          const negated = contents[0] === "!" || contents[0] === "^";
+          let included = false;
+          for (let c = negated ? 1 : 0; c < contents.length; c++) {
+            let start = contents[c];
+            if (start === "\\" && c + 1 < contents.length) start = contents[++c];
+            if (contents[c + 1] === "-" && c + 2 < contents.length) {
+              included ||= character >= start && character <= contents[c + 2];
+              c += 2;
+            } else included ||= character === start;
+          }
+          matches = negated ? !included : included;
+        }
+        if (matches) next.add(p + 1);
+      }
+    }
+    positions = next;
+    if (positions.size === 0) return false;
+  }
+  return positions.has(characters.length);
+}
 function createFfmpegCommand(options = {}) {
   const astPlugins = options.asts ?? allMediaAsts();
   const registry = createMediaAstRegistry(astPlugins);
@@ -1647,14 +1820,20 @@ function createFfmpegCommand(options = {}) {
       }
       const inputs = [];
       let pendingFormat;
+      let pendingSafe;
       let pendingAudioDecoder;
       let pendingSs;
       let pendingTo;
       let pendingDuration;
       let pendingLoop;
+      let pendingImageLoop;
       let pendingFps;
       let pendingStartNumber;
+      let pendingStartNumberRange;
+      let pendingPatternType;
       let overwrite;
+      let exitOnError = false;
+      let inputReadFailed = false;
       let filterComplex;
       const outputs = [];
       const inputBytes = /* @__PURE__ */ new Map();
@@ -1670,6 +1849,8 @@ function createFfmpegCommand(options = {}) {
       let i = 0;
       while (i < args.length) {
         let outputStartNumber;
+        let updateImage = false;
+        let framePts = false;
         let outputFormat;
         let outputSs;
         let outputTo;
@@ -1715,8 +1896,19 @@ function createFfmpegCommand(options = {}) {
               return { exitCode: 234 };
             }
             overwrite = arg === "-y";
-          } else if (arg === "-v" || arg === "-loglevel" || arg === "-safe" || arg === "-threads" || arg === "-pix_fmt" || arg === "-preset" || arg === "-crf" || arg === "-b:v" || arg === "-b:a" || arg === "-bsf:v" || arg === "-bsf:a" || arg === "-tag:v" || arg === "-tag:a" || arg === "-update" || arg === "-loop") {
+          } else if (arg === "-xerror") {
+            exitOnError = true;
+          } else if (arg === "-safe") {
+            const value = args[++i];
+            if (value !== "0" && value !== "1") {
+              await writeBytes(context.stderr, encodeUtf8("ffmpeg: -safe must be 0 or 1\n"), context.signal);
+              return { exitCode: 1 };
+            }
+            pendingSafe = value === "1";
+          } else if (arg === "-v" || arg === "-loglevel" || arg === "-threads" || arg === "-pix_fmt" || arg === "-preset" || arg === "-crf" || arg === "-bf" || arg === "-b:v" || arg === "-b:a" || arg === "-bsf:v" || arg === "-bsf:a" || arg === "-tag:v" || arg === "-tag:a") {
             i++;
+          } else if (arg === "-update") {
+            updateImage = args[++i] === "1";
           } else if (arg === "-vsync" || arg === "-fps_mode") {
             videoSync = args[++i] ?? "";
           } else if (arg === "-hls_time" || arg === "-seg_duration") {
@@ -1768,6 +1960,20 @@ function createFfmpegCommand(options = {}) {
               await writeBytes(context.stderr, encodeUtf8("ffmpeg: invalid metadata input index\n"), context.signal);
               return { exitCode: 1 };
             }
+          } else if (arg === "-frame_pts") {
+            const value = args[++i];
+            if (value !== "0" && value !== "1") {
+              await writeBytes(context.stderr, encodeUtf8("ffmpeg: invalid frame_pts\n"), context.signal);
+              return { exitCode: 1 };
+            }
+            framePts = value === "1";
+          } else if (arg === "-start_number_range") {
+            const value = Number(args[++i]);
+            if (!Number.isInteger(value) || value < 1 || value > 2147483647) {
+              await writeBytes(context.stderr, encodeUtf8("ffmpeg: invalid start_number_range\n"), context.signal);
+              return { exitCode: 1 };
+            }
+            pendingStartNumberRange = value;
           } else if (arg === "-start_number") {
             const val = Number(args[++i]);
             if (!Number.isSafeInteger(val) || val < 0) {
@@ -1778,6 +1984,10 @@ function createFfmpegCommand(options = {}) {
             else outputStartNumber = val;
           } else if (arg === "-ar") {
             audioRate = parseInt(args[++i] ?? "0", 10) || void 0;
+            if (audioRate !== void 0 && audioRate < 0) {
+              await writeBytes(context.stderr, encodeUtf8("ffmpeg: sample rate must be nonnegative\n"), context.signal);
+              return { exitCode: 1 };
+            }
           } else if (arg === "-ac") {
             audioChannels = parseInt(args[++i] ?? "0", 10) || void 0;
           } else if (arg === "-hide_banner" || arg === "-nostdin" || arg === "-stats") {
@@ -1813,10 +2023,29 @@ function createFfmpegCommand(options = {}) {
             } else {
               outputDuration = val;
             }
+          } else if (arg === "-pattern_type") {
+            const value = args[++i];
+            if (value !== "glob" && value !== "none" && value !== "sequence") {
+              await writeBytes(context.stderr, encodeUtf8(`ffmpeg: Invalid image2 pattern type: ${value ?? ""}
+`), context.signal);
+              return { exitCode: 1 };
+            }
+            pendingPatternType = value;
+          } else if (arg === "-loop") {
+            const value = args[++i];
+            if (value !== "0" && value !== "1") {
+              await writeBytes(context.stderr, encodeUtf8("ffmpeg: -loop must be 0 or 1\n"), context.signal);
+              return { exitCode: 1 };
+            }
+            pendingImageLoop = value === "1";
           } else if (arg === "-stream_loop") {
             pendingLoop = parseInt(args[++i] ?? "0", 10) || 0;
           } else if (arg === "-r" || arg === "-framerate") {
-            const val = parseFloat(args[++i] ?? "25") || 25;
+            const val = parseFrameRate(args[++i] ?? "");
+            if (val === void 0) {
+              await writeBytes(context.stderr, encodeUtf8("ffmpeg: Invalid framerate\n"), context.signal);
+              return { exitCode: 1 };
+            }
             if (args.slice(i + 1).includes("-i")) {
               pendingFps = val;
             } else {
@@ -1835,20 +2064,28 @@ function createFfmpegCommand(options = {}) {
             inputs.push({
               path,
               format: pendingFormat,
+              safe: pendingSafe,
               startSeconds: pendingSs,
               endSeconds: pendingTo,
               durationSeconds: pendingDuration,
               streamLoop: pendingLoop,
+              imageLoop: pendingImageLoop,
               fps: pendingFps,
-              startNumber: pendingStartNumber
+              startNumber: pendingStartNumber,
+              patternType: pendingPatternType,
+              startNumberRange: pendingStartNumberRange
             });
             pendingFormat = void 0;
+            pendingSafe = void 0;
             pendingSs = void 0;
             pendingTo = void 0;
             pendingDuration = void 0;
             pendingLoop = void 0;
+            pendingImageLoop = void 0;
             pendingFps = void 0;
             pendingStartNumber = void 0;
+            pendingStartNumberRange = void 0;
+            pendingPatternType = void 0;
           } else if (arg === "-c" || arg === "-codec") {
             const val = args[++i];
             videoCodec = val;
@@ -1870,7 +2107,7 @@ function createFfmpegCommand(options = {}) {
           } else if (arg === "-shortest") {
             shortest = true;
           } else if (arg === "-frames:v" || arg === "-vframes") {
-            maxVideoFrames = parseInt(args[++i] ?? "1", 10) || 1;
+            maxVideoFrames = parseInt(args[++i] ?? "1", 10);
           } else if (arg === "-frames:a" || arg === "-aframes") {
             const value = args[++i];
             maxAudioFrames = value?.trim() ? Number(value) : NaN;
@@ -1890,9 +2127,14 @@ function createFfmpegCommand(options = {}) {
           } else if (arg === "-vf" || arg === "-filter:v") {
             const f = args[++i];
             if (f) vfFilters.push(f);
-          } else if (arg === "-af" || arg === "-filter:a") {
+          } else if (arg === "-af" || arg === "-filter:a" || arg.startsWith("-af:") || arg.startsWith("-filter:a:")) {
             const f = args[++i];
-            if (f) afFilters.push(f);
+            const selector = arg.startsWith("-af:") ? arg.slice(4) : arg.startsWith("-filter:a:") ? arg.slice(10) : void 0;
+            const ordinal = selector === void 0 ? void 0 : Number(selector);
+            if (selector !== void 0 && (!selector || !Array.from(selector).every((char) => char >= "0" && char <= "9") || !Number.isSafeInteger(ordinal))) {
+              throw new Error(`Unsupported audio stream specifier: ${selector}`);
+            }
+            if (f) afFilters.push({ ordinal, expression: f });
           } else if (arg === "-filter_complex" || arg === "-lavfi") {
             filterComplex = args[++i];
           } else if (arg === "-disposition" || arg.startsWith("-disposition:")) {
@@ -1985,16 +2227,41 @@ function createFfmpegCommand(options = {}) {
                 }
                 return concatMp4(docs, { limits: options.limits, budget });
               }
-              if (/%0?\d*d/.test(filePath)) {
+              let globPaths;
+              if (input?.patternType === "glob") {
+                globPaths = ["/"];
+                for (const component of resolvePath(context.cwd, filePath).split("/").filter(Boolean)) {
+                  const matches = [];
+                  for (const directory of globPaths) {
+                    budget.checkCpu();
+                    context.signal.throwIfAborted();
+                    let entries;
+                    try {
+                      entries = await context.fs.readdir(directory, { signal: context.signal });
+                    } catch (error) {
+                      rethrowRuntimeError(context, error);
+                      if (["ENOENT", "ENOTDIR"].includes(error.code ?? "")) continue;
+                      throw error;
+                    }
+                    for (const entry of entries) {
+                      budget.checkCpu();
+                      if (entry.name.startsWith(".") && !component.startsWith(".") && !component.startsWith("\\.")) continue;
+                      if (matchesImageGlob(component, entry.name, budget)) matches.push(resolvePath(directory, entry.name));
+                    }
+                  }
+                  globPaths = matches;
+                }
+                globPaths.sort();
+              }
+              if (globPaths || input?.patternType !== "none" && formatImageSequence(filePath, input?.startNumber ?? 0) !== void 0) {
                 const frames = [];
                 const fps = fpsHint ?? 25;
-                for (let idx = input?.startNumber ?? 0; ; idx++) {
+                const startNumber = input?.startNumber ?? 0;
+                const startNumberRange = input?.startNumberRange ?? 5;
+                for (let idx = globPaths ? 0 : startNumber; !globPaths || idx < globPaths.length; idx++) {
                   budget.checkCpu();
                   context.signal.throwIfAborted();
-                  const formatted = filePath.replace(/%0?(\d*)d/, (_, widthDigits) => {
-                    const padLen = parseInt(widthDigits || "0", 10) || 0;
-                    return String(idx).padStart(padLen, "0");
-                  });
+                  const formatted = globPaths ? globPaths[idx] : formatImageSequence(filePath, idx);
                   const resolved = resolvePath(context.cwd, formatted);
                   let imgBytes;
                   try {
@@ -2002,7 +2269,8 @@ function createFfmpegCommand(options = {}) {
                   } catch (error) {
                     rethrowRuntimeError(context, error);
                     if (error.code !== "ENOENT") throw error;
-                    if (idx === 0 && input?.startNumber === void 0) continue;
+                    if (globPaths) throw error;
+                    if (frames.length === 0 && idx - startNumber < startNumberRange - 1) continue;
                     break;
                   }
                   {
@@ -2041,27 +2309,76 @@ function createFfmpegCommand(options = {}) {
                 detachBytesBuffer(synthBytes);
                 return {
                   ...base,
+                  duration: Math.round(frames.length / fps * base.timescale),
+                  durationSeconds: frames.length / fps,
                   tracks: base.tracks.map(
-                    (t) => t.type === "video" ? { ...t, width: first.width, height: first.height, samples: [], decodedVideoFrames: frames } : t
+                    (t) => t.type === "video" ? { ...t, width: first.width, height: first.height, duration: Math.round(frames.length / fps * t.timescale), samples: [], decodedVideoFrames: frames } : t
                   )
                 };
               }
               const rawBytes = await readInput(filePath);
-              if (explicitFormat === "concat") {
+              const concatSignature = "ffconcat version 1.0";
+              if (explicitFormat === "concat" || explicitFormat === void 0 && new TextDecoder("utf-8", { ignoreBOM: true }).decode(rawBytes.subarray(0, concatSignature.length)) === concatSignature) {
                 const listText = new TextDecoder().decode(rawBytes);
                 const listDir = filePath === "-" ? context.cwd : dirnameOf(resolvePath(context.cwd, filePath));
                 const concatDocs = [];
+                const startTimesSeconds = [];
+                let nextStartSeconds = 0;
+                const segments = [];
                 let currentInpoint;
                 let currentOutpoint;
                 let currentDuration;
                 const lines = listText.split(/\r?\n/);
                 for (let l = 0; l < lines.length; l++) {
-                  const line = lines[l].trim();
-                  if (!line || line.startsWith("#") || line.startsWith("ffconcat")) continue;
-                  if (line.startsWith("file ")) {
-                    let target2 = line.slice(5).trim();
-                    if (target2.startsWith("'") && target2.endsWith("'") || target2.startsWith('"') && target2.endsWith('"')) {
-                      target2 = target2.slice(1, -1);
+                  const line = lines[l].trimStart();
+                  if (!line || line.startsWith("#")) continue;
+                  const keyword = line.split(/[ \t]/, 1)[0];
+                  if (keyword === "option" && input?.safe !== false) {
+                    throw new Error(`Line ${l + 1}: option not allowed if safe`);
+                  }
+                  if (keyword === "ffconcat") {
+                    const [, declaration, version] = line.split("	").join(" ").split(" ").filter(Boolean);
+                    if (declaration !== "version" || version !== "1.0") {
+                      throw new Error(`Line ${l + 1}: invalid version`);
+                    }
+                    continue;
+                  }
+                  if (segments.length === 0) {
+                    const directive = ["duration", "inpoint", "outpoint"].find(
+                      (name) => line === name || line.startsWith(`${name} `) || line.startsWith(`${name}	`)
+                    );
+                    if (directive) throw new Error(`Line ${l + 1}: ${directive} without file`);
+                  }
+                  if (keyword === "file") {
+                    let target2 = "";
+                    let protectedEnd = 0;
+                    let cursor = keyword.length;
+                    const whitespace = " 	\r\n";
+                    while (cursor < line.length && whitespace.includes(line[cursor])) cursor++;
+                    while (cursor < line.length && !whitespace.includes(line[cursor])) {
+                      const char = line[cursor++];
+                      if (char === "\\" && cursor < line.length) {
+                        target2 += line[cursor++];
+                        protectedEnd = target2.length;
+                      } else if (char === "'") {
+                        while (cursor < line.length && line[cursor] !== "'") target2 += line[cursor++];
+                        if (cursor < line.length) {
+                          cursor++;
+                          protectedEnd = target2.length;
+                        }
+                      } else {
+                        target2 += char;
+                      }
+                    }
+                    while (target2.length > protectedEnd && whitespace.includes(target2[target2.length - 1])) {
+                      target2 = target2.slice(0, -1);
+                    }
+                    if (input?.safe !== false && target2.split("/").some(
+                      (component) => !component || component.startsWith(".") || Array.from(component).some(
+                        (char) => !(char >= "a" && char <= "z") && !(char >= "A" && char <= "Z") && !(char >= "0" && char <= "9") && char !== "_" && char !== "-" && char !== "."
+                      )
+                    )) {
+                      throw new Error(`Unsafe file name '${target2}'`);
                     }
                     const resolvedItem = resolvePath(listDir, target2);
                     currentInpoint = void 0;
@@ -2069,32 +2386,66 @@ function createFfmpegCommand(options = {}) {
                     currentDuration = void 0;
                     while (l + 1 < lines.length) {
                       const nextLine = lines[l + 1].trim();
-                      if (nextLine.startsWith("inpoint ")) {
-                        currentInpoint = parseFfmpegTimestamp(nextLine.slice(8));
+                      if (!nextLine || nextLine.startsWith("#")) {
                         l++;
-                      } else if (nextLine.startsWith("outpoint ")) {
-                        currentOutpoint = parseFfmpegTimestamp(nextLine.slice(9));
-                        l++;
-                      } else if (nextLine.startsWith("duration ")) {
-                        currentDuration = parseFfmpegTimestamp(nextLine.slice(9));
+                      } else if (["inpoint", "outpoint", "duration"].includes(nextLine.split(/[ \t]/, 1)[0])) {
+                        const directive = nextLine.split(/[ \t]/, 1)[0];
+                        const value = nextLine.slice(directive.length).trim();
+                        if (!/^-?(?:(?:\d+(?:\.\d*)?|\.\d+)(?:s|ms|us)?|(?:\d+:)?[0-5]?\d:[0-5]?\d(?:\.\d*)?)$/.test(value)) {
+                          throw new Error(`Line ${l + 2}: invalid ${directive} '${value}'`);
+                        }
+                        const seconds = value.startsWith("-") ? -parseFfmpegTimestamp(value.slice(1)) : parseFfmpegTimestamp(value);
+                        if (!Number.isFinite(seconds) || Math.abs(seconds) >= 2 ** 63 / 1e6) {
+                          throw new Error(`Line ${l + 2}: invalid ${directive} '${value}'`);
+                        }
+                        if (directive === "inpoint") currentInpoint = seconds;
+                        else if (directive === "outpoint") currentOutpoint = seconds;
+                        else currentDuration = seconds;
                         l++;
                       } else {
                         break;
                       }
                     }
-                    let itemDoc = await loadSingleDocument(resolvedItem);
-                    if (currentInpoint !== void 0 || currentOutpoint !== void 0 || currentDuration !== void 0) {
-                      itemDoc = sliceMp4(itemDoc, {
-                        startSeconds: currentInpoint,
-                        endSeconds: currentOutpoint,
-                        durationSeconds: currentDuration
-                      });
+                    if (currentInpoint !== void 0 && currentOutpoint !== void 0 && currentOutpoint < currentInpoint) {
+                      throw new Error(`${resolvedItem}: outpoint must not precede inpoint`);
                     }
-                    concatDocs.push(itemDoc);
+                    segments.push({ path: resolvedItem, inpoint: currentInpoint, outpoint: currentOutpoint, duration: currentDuration });
+                  } else {
+                    throw new Error(`Line ${l + 1}: unknown keyword '${keyword}'`);
                   }
                 }
-                budget.checkConcatInputs(concatDocs.length);
-                return concatMp4(concatDocs, { limits: options.limits, budget });
+                budget.checkConcatInputs(segments.length);
+                for (const segment of segments) {
+                  let itemDoc;
+                  try {
+                    itemDoc = await loadSingleDocument(segment.path);
+                  } catch (error) {
+                    rethrowRuntimeError(context, error);
+                    if (error.code !== "ENOENT" || !concatDocs.some((doc) => doc.tracks.some((track) => track.samples.length > 0))) throw error;
+                    await writeBytes(context.stderr, encodeUtf8(`ffmpeg: Impossible to open '${segment.path}': No such file or directory
+`), context.signal);
+                    inputReadFailed = true;
+                    break;
+                  }
+                  let sliceEnd = segment.outpoint;
+                  const wavTrack = itemDoc.containerFormat === "wav" ? itemDoc.tracks[0] : void 0;
+                  const packetFrames = wavTrack?.samples[0]?.duration;
+                  if (sliceEnd !== void 0 && wavTrack && packetFrames) {
+                    const start = Math.max(0, segment.inpoint ?? 0);
+                    const packets = Math.ceil(Math.max(0, sliceEnd - start) * wavTrack.timescale / packetFrames);
+                    sliceEnd = start + packets * packetFrames / wavTrack.timescale;
+                  }
+                  if (segment.inpoint !== void 0 || segment.outpoint !== void 0) {
+                    itemDoc = sliceMp4(itemDoc, {
+                      startSeconds: segment.inpoint,
+                      endSeconds: sliceEnd
+                    });
+                  }
+                  startTimesSeconds.push(nextStartSeconds);
+                  nextStartSeconds += segment.duration ?? itemDoc.durationSeconds;
+                  concatDocs.push(itemDoc);
+                }
+                return concatMp4(concatDocs, { startTimesSeconds, limits: options.limits, budget });
               }
               const plugin = explicitFormat !== void 0 ? registry.findByFormatName(explicitFormat) : registry.detect(rawBytes, filePath);
               if (!plugin || !plugin.canDemux) {
@@ -2115,6 +2466,38 @@ function createFfmpegCommand(options = {}) {
               await yieldTurn5(context.signal);
               context.signal.throwIfAborted();
               let doc = await loadSingleDocument(inp.path, inp.format, inp.fps, inp);
+              if (inp.imageLoop) {
+                const fps = inp.fps ?? 25;
+                const endSeconds = Math.min(
+                  inp.durationSeconds !== void 0 ? (inp.startSeconds ?? 0) + inp.durationSeconds : inp.endSeconds ?? Infinity,
+                  (inp.startSeconds ?? 0) + (outputDuration !== void 0 ? (outputSs ?? 0) + outputDuration : outputTo ?? Infinity),
+                  maxVideoFrames !== void 0 ? (inp.startSeconds ?? 0) + (outputSs ?? 0) + maxVideoFrames / (outputFps ?? fps) : Infinity
+                );
+                if (!Number.isFinite(endSeconds)) {
+                  throw new Error("-loop 1 requires a finite frame count or duration");
+                }
+                budget.checkDuration(endSeconds);
+                const frameCount = Math.max(0, Math.ceil(endSeconds * fps));
+                doc = {
+                  ...doc,
+                  duration: Math.round(frameCount / fps * doc.timescale),
+                  durationSeconds: frameCount / fps,
+                  tracks: await mapWork(doc.tracks, async (track) => {
+                    if (track.type !== "video") return track;
+                    const source = track.decodedVideoFrames;
+                    if (!source?.length) throw new Error("-loop requires decoded image input");
+                    const frames = [];
+                    for (let index = 0; index < frameCount; index++) {
+                      if (index % 64 === 0) await yieldTurn5(context.signal);
+                      context.signal.throwIfAborted();
+                      const frame = source[index % source.length];
+                      budget.recordFrame(frame.width, frame.height);
+                      frames.push({ ...frame, ptsSeconds: index / fps, durationSeconds: 1 / fps });
+                    }
+                    return { ...track, duration: Math.round(frameCount / fps * track.timescale), samples: [], decodedVideoFrames: frames };
+                  }, context.signal)
+                };
+              }
               if (inp.startSeconds !== void 0 || inp.endSeconds !== void 0 || inp.durationSeconds !== void 0) {
                 doc = sliceMp4(doc, {
                   startSeconds: inp.startSeconds,
@@ -2430,7 +2813,8 @@ To ignore this, add a trailing '?' to the map.
               }, context.signal);
             }
             validateAudioEncoder(audioCodec, workingDoc, astPlugins);
-            if (audioCodec === "copy" && afFilters.length > 0 && workingDoc.tracks.some((track) => track.type === "audio")) {
+            const audioTrackCount = workingDoc.tracks.filter((track) => track.type === "audio").length;
+            if (audioCodec === "copy" && audioTrackCount > 0 && afFilters.some((filter) => filter.ordinal === void 0 || filter.ordinal < audioTrackCount)) {
               await writeBytes(context.stderr, encodeUtf8("ffmpeg: Filtering and streamcopy cannot be used together for audio.\n"), context.signal);
               return { exitCode: 218 };
             }
@@ -2538,60 +2922,117 @@ To ignore this, add a trailing '?' to the map.
               workingDoc = limitAudioCopyPackets(workingDoc, maxAudioFrames);
             }
             if ((audioRate !== void 0 || audioChannels !== void 0 || afFilters.length > 0) && audioCodec !== "copy") {
+              let audioOrdinal = 0;
               workingDoc = {
                 ...workingDoc,
                 tracks: await mapWork(workingDoc.tracks, async (t) => {
                   let work = 0;
                   if (t.type !== "audio") return t;
+                  const ordinal = audioOrdinal++;
+                  const filter = afFilters.filter((filter2) => filter2.ordinal === void 0 || filter2.ordinal === ordinal).at(-1);
+                  if (audioRate === void 0 && audioChannels === void 0 && !filter) return t;
                   const audio = t.decodedAudio ?? (t.codecDescriptions[0]?.codecName === "aac" ? decodeAacTrack(workingDoc, t) : void 0);
                   if (!audio) throw new Error("Audio filtering requires decoded PCM audio");
                   const origRate = audio.sampleRate;
                   const origCh = audio.channels;
                   const targetRate = audioRate ?? origRate;
-                  const targetCh = audioChannels ?? origCh;
+                  const targetCh = audioChannels === -1 ? origCh : audioChannels ?? origCh;
                   const channelMask = audio.channelMask;
                   const surroundMono = origCh === 6 && targetCh === 1;
                   const monoStereo = origCh === 1 && (targetCh === 2 || targetCh === 3);
+                  const pcm16MonoStereo = monoStereo && !filter && targetRate === origRate && t.codecDescriptions[0]?.codecName === "pcm_s16le" && (audioCodec === "pcm_s16le" || audioCodec === void 0 && (outputFormat ?? outputTarget2.split(".").pop()?.toLowerCase()) === "wav");
+                  const monoSurround = origCh === 1 && targetCh >= 4 && targetCh <= 8;
                   if (targetCh !== origCh && origCh > 2 && (!surroundMono || channelMask && channelMask !== 63 && channelMask !== 1551)) {
                     throw new Error(`Unsupported audio channel layout conversion: ${origCh} channels (mask ${channelMask ?? 0}) to ${targetCh}`);
                   }
-                  const durSec = (audio.channelData[0]?.length ?? 0) / origRate;
-                  let volFactor = t.volume ?? 1;
-                  let tempoFactor = 1;
-                  let reverseAudio = false;
-                  for (const af of afFilters) {
-                    if (++work % 1024 === 0) {
-                      await yieldTurn5(context.signal);
-                      context.signal?.throwIfAborted();
-                    }
-                    for (const item of af.split(",")) {
+                  const volFactor = t.volume ?? 1;
+                  let stretched = audio.channelData;
+                  if (filter) {
+                    for (const item of parseFilterChain(filter.expression)) {
                       if (++work % 1024 === 0) {
                         await yieldTurn5(context.signal);
                         context.signal?.throwIfAborted();
                       }
-                      const trimmed = item.trim();
-                      if (trimmed.startsWith("volume=")) {
-                        const volSpec = trimmed.slice("volume=".length).trim();
+                      let trimmed = item.trim();
+                      const equals = trimmed.indexOf("=");
+                      const instance = trimmed.indexOf("@");
+                      if (instance >= 0 && (equals < 0 || instance < equals)) {
+                        trimmed = trimmed.slice(0, instance) + (equals < 0 ? "" : trimmed.slice(equals));
+                      }
+                      if (trimmed === "anull") continue;
+                      if (trimmed === "volume" || trimmed.startsWith("volume=")) {
+                        const argument = trimmed === "volume" ? "1" : trimmed.slice("volume=".length).trim();
+                        let volSpec = "1";
+                        let precision = "float";
+                        let evaluation = "once";
+                        let enable;
+                        for (const [index, option] of argument.split(":").entries()) {
+                          const separator = option.indexOf("=");
+                          const key = separator < 0 ? ["volume", "precision", "eval"][index] ?? "" : option.slice(0, separator).trim();
+                          const value = separator < 0 ? option.trim() : option.slice(separator + 1).trim();
+                          if (key === "volume") volSpec = value;
+                          else if (key === "precision") precision = value;
+                          else if (key === "eval") evaluation = value;
+                          else if (key === "enable") enable = value;
+                          else throw new Error(`volume: unsupported option ${key}`);
+                        }
+                        if (!["fixed", "float", "double"].includes(precision)) throw new Error("volume: invalid precision");
+                        if (evaluation !== "once" && evaluation !== "frame") throw new Error("volume: invalid eval");
                         const decibels = volSpec.endsWith("dB");
-                        const gain = parseFilterExpression(decibels ? volSpec.slice(0, -2) : volSpec, "volume", {});
-                        const factor = decibels ? Math.pow(10, gain / 20) : gain;
-                        if (!Number.isFinite(factor)) throw new Error("volume: invalid gain");
-                        volFactor *= factor;
-                      } else if (trimmed.startsWith("atempo=")) {
-                        const tempo = Number(trimmed.slice(7));
-                        if (!Number.isFinite(tempo) || tempo < 0.5 || tempo > 100) {
+                        const output = stretched.map((channel) => new Float32Array(channel.length));
+                        const length = stretched[0]?.length ?? 0;
+                        const sampleScale = t.codecDescriptions[0]?.codecName === "pcm_s16le" ? 32768 : 2147483648;
+                        for (let start = 0, n = 0; start < length; n++) {
+                          const packet = t.samples[n];
+                          const count = packet ? Math.max(1, Math.round(packet.duration * origRate / t.timescale)) : 1024;
+                          const end = evaluation === "once" && enable === void 0 ? length : Math.min(length, start + count);
+                          const variables = { sample_rate: origRate, nb_channels: origCh, tb: 1 / origRate };
+                          if (evaluation === "frame") Object.assign(variables, {
+                            n,
+                            t: packet ? packet.pts / t.timescale : start / origRate,
+                            pts: packet ? packet.pts * origRate / t.timescale : start,
+                            nb_samples: end - start,
+                            nb_consumed_samples: start
+                          });
+                          const gain = parseFilterExpression(decibels ? volSpec.slice(0, -2) : volSpec, "volume", variables);
+                          const factor = decibels ? Math.pow(10, gain / 20) : gain;
+                          if (!Number.isFinite(factor)) throw new Error("volume: invalid gain");
+                          const fixedGain = Math.floor(factor * 256 + 0.5);
+                          const enabled = enable === void 0 || parseFilterExpression(enable, "volume enable", {
+                            n,
+                            t: packet ? packet.pts / t.timescale : start / origRate
+                          }) !== 0;
+                          for (let c = 0; c < stretched.length; c++) {
+                            const channel = stretched[c];
+                            for (let i2 = start; i2 < end; i2++) {
+                              if (++work % 1024 === 0) {
+                                await yieldTurn5(context.signal);
+                                context.signal?.throwIfAborted();
+                              }
+                              output[c][i2] = !enabled ? channel[i2] : precision === "fixed" ? Math.max(-sampleScale, Math.min(
+                                sampleScale - 1,
+                                Math.floor((channel[i2] * sampleScale * fixedGain + 128) / 256)
+                              )) / sampleScale : channel[i2] * (precision === "float" ? Math.fround(factor) : factor);
+                            }
+                          }
+                          start = end;
+                        }
+                        stretched = output;
+                      } else if (trimmed === "atempo" || trimmed.startsWith("atempo=")) {
+                        const argument = trimmed === "atempo" ? "1" : trimmed.slice("atempo=".length).trim();
+                        const tempo = parseFilterExpression(argument.startsWith("tempo=") ? argument.slice("tempo=".length) : argument, "atempo", {});
+                        if (tempo < 0.5 || tempo > 100) {
                           throw new Error("atempo must be in the range [0.5, 100]");
                         }
-                        tempoFactor *= tempo;
+                        stretched = tempo === 1 ? await filterUnityTempo(stretched, origRate, t.codecDescriptions[0]?.codecName === "pcm_s16le", budget, context.signal) : await stretchAudio(stretched, origRate, tempo, budget, context.signal);
                       } else if (trimmed === "areverse") {
-                        reverseAudio = !reverseAudio;
+                        stretched = await mapWork(stretched, async (channel) => channel.slice().reverse(), context.signal);
                       } else {
                         throw new Error(`Unsupported audio filter: ${trimmed}`);
                       }
                     }
                   }
-                  const targetSamples = Math.max(0, Math.round(durSec / tempoFactor * targetRate));
-                  let stretched = await stretchAudio(audio.channelData, origRate, tempoFactor, budget, context.signal);
+                  const targetSamples = Math.max(0, Math.round((stretched[0]?.length ?? 0) * targetRate / origRate));
                   if (targetRate !== origRate) stretched = await resampleAudio(stretched, targetSamples, origRate / targetRate, budget, context.signal);
                   const newChannelData = [];
                   for (let c = 0; c < targetCh; c++) {
@@ -2600,7 +3041,7 @@ To ignore this, add a trailing '?' to the map.
                       context.signal?.throwIfAborted();
                     }
                     const dst = new Float32Array(targetSamples);
-                    const srcCh = monoStereo && c >= 2 ? void 0 : stretched[origCh === 1 ? 0 : c];
+                    const srcCh = monoStereo && c >= 2 || monoSurround && c !== 2 ? void 0 : stretched[origCh === 1 ? 0 : c];
                     const rightCh = origCh === 2 && targetCh === 1 ? stretched[1] : void 0;
                     if (srcCh && srcCh.length > 0) {
                       for (let i2 = 0; i2 < targetSamples; i2++) {
@@ -2610,10 +3051,10 @@ To ignore this, add a trailing '?' to the map.
                         }
                         const srcIdx = Math.min(srcCh.length - 1, i2);
                         const sample = surroundMono ? ((stretched[0][srcIdx] + stretched[1][srcIdx]) * Math.SQRT1_2 + stretched[2][srcIdx] + (stretched[4][srcIdx] + stretched[5][srcIdx]) / 2) / (2 + Math.SQRT2) : rightCh ? (srcCh[srcIdx] + rightCh[srcIdx]) / 2 : srcCh[srcIdx];
-                        dst[i2] = Math.max(-1, Math.min(1, sample * volFactor * (monoStereo ? Math.SQRT1_2 : 1)));
+                        const mixed = pcm16MonoStereo ? Math.floor((sample * 32768 * 23170 + 16384) / 32768) / 32768 : sample * (monoStereo ? Math.SQRT1_2 : 1);
+                        dst[i2] = Math.max(-1, Math.min(1, mixed * volFactor));
                       }
                     }
-                    if (reverseAudio) dst.reverse();
                     newChannelData.push(dst);
                   }
                   const nextDescs = t.codecDescriptions.map((d) => ({
@@ -2788,10 +3229,15 @@ To ignore this, add a trailing '?' to the map.
               options.onMetrics?.(budget.getStats());
               return { exitCode: 0 };
             }
+            if (imageOutput && maxVideoFrames === 0) {
+              options.onMetrics?.(budget.getStats());
+              return { exitCode: 0 };
+            }
             if (imageOutput && !workingDoc.tracks.some((track) => track.type === "video" && track.decodedVideoFrames?.length)) {
               throw new Error("No video frame in the requested presentation interval");
             }
-            if (/%0?\d*d/.test(outputTarget2)) {
+            const numberedImageOutput = formatImageSequence(outputTarget2, outputStartNumber ?? 1) !== void 0;
+            if (imageOutput && !isStdout(outputTarget2) || numberedImageOutput) {
               const outExt2 = outputTarget2.split(".").pop()?.toLowerCase() ?? "png";
               const imgPlugin = registry.findByFilename(`x.${outExt2}`);
               if (!imgPlugin || !imgPlugin.canMux) {
@@ -2813,15 +3259,16 @@ To ignore this, add a trailing '?' to the map.
                 const previousCopies = constantRate && delta0 > 1.1 ? Math.max(0, Math.round(delta0 - 0.6)) : 0;
                 if (!Number.isSafeInteger(copies)) throw new Error("Invalid output frame timestamp");
                 for (let copy = 0; copy < copies && idx < limit; copy++, idx++, nextPts++) {
+                  if (idx > 0 && !numberedImageOutput && !updateImage) {
+                    throw new Error("Cannot write more than one file with the same name. Use a numbered pattern or -update 1.");
+                  }
                   budget.checkCpu();
                   budget.checkSamples(idx + 1);
                   budget.checkDuration((idx + 1) * duration);
                   const f = copy < previousCopies && sourceIndex > 0 ? frames[sourceIndex - 1] : source;
                   if (copy > 0) budget.recordFrame(f.width, f.height);
-                  const fileName = outputTarget2.replace(/%0?(\d*)d/, (_, widthDigits) => {
-                    const padLen = parseInt(widthDigits || "0", 10) || 0;
-                    return String(idx + (outputStartNumber ?? 1)).padStart(padLen, "0");
-                  });
+                  const number = framePts ? Math.round(constantRate ? nextPts : source.ptsSeconds / duration) : idx + (outputStartNumber ?? 1);
+                  const fileName = updateImage ? outputTarget2 : formatImageSequence(outputTarget2, number) ?? outputTarget2;
                   const fullOutPath = resolvePath(context.cwd, fileName);
                   const encoded = (await yieldTurn5(context.signal), context.signal?.throwIfAborted(), encodeImage(makeRgbaImg(f.width, f.height, f.data), {
                     format: imgFmt
@@ -2897,7 +3344,7 @@ To ignore this, add a trailing '?' to the map.
         const result = await output();
         if (result.exitCode !== 0) return result;
       }
-      return { exitCode: 0 };
+      return { exitCode: exitOnError && inputReadFailed ? 1 : 0 };
     }
   };
 }