@hyperframes/engine 0.8.226 → 0.8.227

package/dist/services/chunkEncoder.d.ts

@@ -105,7 +105,7 @@ export declare function appendRateCapArgs(args: string[], options: {
     maxBitrate?: string;
     bufferSize?: string;
 }): void;
-export declare function buildEncoderArgs(options: EncoderOptions, inputArgs: string[], outputPath: string, gpuEncoder?: GpuEncoder): string[];
+export declare function buildEncoderArgs(options: EncoderOptions, inputArgs: string[], outputPath: string, gpuEncoder?: GpuEncoder, nvencPresets?: ReadonlySet<string>): string[];
 export declare function encodeFramesFromDir(framesDir: string, framePattern: string, outputPath: string, options: EncoderOptions, signal?: AbortSignal, config?: Partial<Pick<EngineConfig, "ffmpegEncodeTimeout">>, onFramesEncoded?: (frames: number) => void): Promise<EncodeResult>;
 export declare function buildConcatArgs(concatListPath: string, outputPath: string): string[];
 /**

package/dist/services/chunkEncoder.js

@@ -9,7 +9,7 @@ import { frameSequencePath } from "./extractedFrameIndex.js";
 import { closeSync, copyFileSync, existsSync, ftruncateSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, statSync, writeFileSync, writeSync, } from "fs";
 import { join, dirname, extname, resolve } from "path";
 import { DEFAULT_CONFIG } from "../config.js";
-import { getCachedGpuEncoder, getGpuEncoderName, buildVideoToolboxRateControlArgs, mapPresetForGpuEncoder, } from "../utils/gpuEncoder.js";
+import { getCachedGpuEncoder, getCachedNvencPresets, getGpuEncoderName, buildVideoToolboxRateControlArgs, mapPresetForGpuEncoder, } from "../utils/gpuEncoder.js";
 import { getHdrEncoderColorParams, hdrFrameTagsFilter } from "../utils/hdr.js";
 import { withEvenDimensionPad } from "../utils/evenDimensions.js";
 import { SDR_CAPTURE_TO_BT709_FILTER, SDR_RGB_TO_TAGGED_BT709_FILTER, } from "../utils/sdrCaptureColor.js";
@@ -169,7 +169,7 @@ export function appendRateCapArgs(args, options) {
     }
     args.push("-maxrate", String(Math.round(cap)), "-bufsize", String(Math.round(buffer)));
 }
-export function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = null) {
+export function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = null, nvencPresets) {
     const { fps, codec = "h264", preset = "medium", quality = 23, bitrate, pixelFormat = "yuv420p", vp9CpuUsed, useGpu = false, } = options;
     // libx264 cannot encode HDR. If a caller passes hdr with codec=h264 we'd
     // produce a "half-HDR" file (BT.2020 container tags but a BT.709 VUI block
@@ -190,7 +190,7 @@ export function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = nu
             args.push("-c:v", encoderName);
             switch (gpuEncoder) {
                 case "nvenc":
-                    args.push("-preset", mapPresetForGpuEncoder("nvenc", preset));
+                    args.push("-preset", mapPresetForGpuEncoder("nvenc", preset, nvencPresets));
                     if (bitrate)
                         args.push("-b:v", bitrate);
                     else
@@ -437,7 +437,8 @@ export async function encodeFramesFromDir(framesDir, framePattern, outputPath, o
     }
     const inputPath = frameSequencePath(framesDir, framePattern);
     const inputArgs = ["-framerate", fpsToFfmpegArg(options.fps), "-i", inputPath];
-    const args = buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder);
+    const nvencPresets = gpuEncoder === "nvenc" ? await getCachedNvencPresets() : undefined;
+    const args = buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder, nvencPresets);
     const encodeTimeout = config?.ffmpegEncodeTimeout ?? DEFAULT_CONFIG.ffmpegEncodeTimeout;
     let framesRead = 0;
     const result = await runFfmpeg(args, {
@@ -587,7 +588,8 @@ export async function encodeFramesChunkedConcat(framesDir, framePattern, outputP
         let gpuEncoder = null;
         if (options.useGpu)
             gpuEncoder = await getCachedGpuEncoder();
-        const args = buildEncoderArgs(options, inputArgs, chunkPath, gpuEncoder);
+        const nvencPresets = gpuEncoder === "nvenc" ? await getCachedNvencPresets() : undefined;
+        const args = buildEncoderArgs(options, inputArgs, chunkPath, gpuEncoder, nvencPresets);
         const encodeTimeout = config?.ffmpegEncodeTimeout ?? DEFAULT_CONFIG.ffmpegEncodeTimeout;
         let framesRead = 0;
         const processResult = await runFfmpeg(args, {

package/dist/services/frameCapture.js

@@ -1538,7 +1538,7 @@ export async function pollVideosReady(page, skipIds, timeoutMs, intervalMs = 100
                         return true;
                     if (ve.networkState === HTMLMediaElement.NETWORK_NO_SOURCE)
                         return true;
-                    return false;
+                    return !ve.getAttribute("src") && !ve.querySelector("source");
                 }));
         }, skipIds));
     };
@@ -1635,6 +1635,8 @@ export async function collectMediaReadinessWarnings(page, skipIds, timeoutMs) {
             const mediaElement = media;
             if (skipped.has(mediaElement.id))
                 continue;
+            if (!mediaElement.getAttribute("src") && !mediaElement.querySelector("source"))
+                continue;
             const src = mediaElement.currentSrc || mediaElement.getAttribute("src") || "(no src)";
             const failed = Boolean(mediaElement.error) ||
                 mediaElement.networkState === HTMLMediaElement.NETWORK_NO_SOURCE;

package/dist/services/streamingEncoder.d.ts

@@ -104,7 +104,7 @@ export interface StreamingEncoder {
  * Exported so unit tests can assert on the constructed CLI without spawning
  * FFmpeg — see streamingEncoder.test.ts.
  */
-export declare function buildStreamingArgs(options: StreamingEncoderOptions, outputPath: string, gpuEncoder?: GpuEncoder): string[];
+export declare function buildStreamingArgs(options: StreamingEncoderOptions, outputPath: string, gpuEncoder?: GpuEncoder, nvencPresets?: ReadonlySet<string>): string[];
 /**
  * Spawn a streaming FFmpeg encoder that accepts frame buffers on stdin.
  */

package/dist/services/streamingEncoder.js

@@ -19,7 +19,7 @@ import { trackChildProcess } from "../utils/processTracker.js";
 import { ManagedChildProcess, } from "../utils/managedChildProcess.js";
 import { existsSync, mkdirSync, statSync } from "fs";
 import { dirname } from "path";
-import { getCachedGpuEncoder, getGpuEncoderName, buildVideoToolboxRateControlArgs, mapPresetForGpuEncoder, } from "../utils/gpuEncoder.js";
+import { getCachedGpuEncoder, getCachedNvencPresets, getGpuEncoderName, buildVideoToolboxRateControlArgs, mapPresetForGpuEncoder, } from "../utils/gpuEncoder.js";
 import { ffmpegStatsReader, formatFfmpegError, isExternalFfmpegInterruption, } from "../utils/runFfmpeg.js";
 import { getFfmpegBinary } from "../utils/ffmpegBinaries.js";
 import { getHdrEncoderColorParams, hdrFrameTagsFilter } from "../utils/hdr.js";
@@ -98,7 +98,7 @@ export function createFrameReorderBuffer(startFrame, endFrame) {
  * Exported so unit tests can assert on the constructed CLI without spawning
  * FFmpeg — see streamingEncoder.test.ts.
  */
-export function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
+export function buildStreamingArgs(options, outputPath, gpuEncoder = null, nvencPresets) {
     const { fps, codec = "h264", preset = "medium", quality = 23, bitrate, pixelFormat = "yuv420p", vp9CpuUsed, useGpu = false, imageFormat = "jpeg", } = options;
     // Input args: pipe from stdin
     const args = [];
@@ -137,7 +137,7 @@ export function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
             args.push("-c:v", encoderName);
             switch (gpuEncoder) {
                 case "nvenc":
-                    args.push("-preset", mapPresetForGpuEncoder("nvenc", preset));
+                    args.push("-preset", mapPresetForGpuEncoder("nvenc", preset, nvencPresets));
                     if (bitrate)
                         args.push("-b:v", bitrate);
                     else
@@ -278,7 +278,7 @@ export function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
         else if (options.videoLayer) {
             const video = `[1:v]${options.videoLayer.filters.join(",")},format=gbrp[v]`;
             const tail = withEvenDimensionPad(SDR_RGB_TO_TAGGED_BT709_FILTER, pixelFormat, options.width, options.height);
-            args.push("-filter_complex", `${video};[0:v]format=rgba[o];[v][o]overlay=format=gbrp,${tail}[vout]`, "-map", "[vout]");
+            args.push("-filter_complex", `${video};[0:v]format=rgba[o];[v][o]overlay=eof_action=endall:format=gbrp,${tail}[vout]`, "-map", "[vout]");
         }
         else {
             // Pad odd dimensions up to even so 4:2:0 encoders (software and
@@ -309,7 +309,8 @@ export async function spawnStreamingEncoder(outputPath, options, signal, config)
     if (options.useGpu) {
         gpuEncoder = await getCachedGpuEncoder();
     }
-    const args = buildStreamingArgs(options, outputPath, gpuEncoder);
+    const nvencPresets = gpuEncoder === "nvenc" ? await getCachedNvencPresets() : undefined;
+    const args = buildStreamingArgs(options, outputPath, gpuEncoder, nvencPresets);
     const ffmpeg = spawn(getFfmpegBinary(), args, {
         stdio: ["pipe", "pipe", "pipe"],
         // See runFfmpeg.ts: keeps a console window off the user's desktop on Windows.

package/dist/services/videoFrameExtractor.js

@@ -709,10 +709,12 @@ function videoFilterChain(input) {
     }
     return (seek) => [...head, ...sampling(seek), ...tail];
 }
+const VIDEO_LAYER_TAIL_SLACK_SECONDS = 0.5;
 /** ffmpeg input and filters showing the same frames and colour as extraction; undefined if unsupported. */
 export async function buildVideoLayerInput(videoPath, startTime, duration, fps, canvas, fit = "fill") {
     const metadata = await extractMediaMetadata(videoPath);
-    if (startTime + duration > resolvePlayableVideoDuration(metadata) + 1e-3 ||
+    if (startTime + duration >
+        resolvePlayableVideoDuration(metadata) + VIDEO_LAYER_TAIL_SLACK_SECONDS ||
         isHdrColorSpaceUtil(metadata.colorSpace) ||
         metadata.isVFR ||
         metadata.hasAlpha ||
@@ -733,6 +735,7 @@ export async function buildVideoLayerInput(videoPath, startTime, duration, fps,
             ? `scale=${canvas.width}:${canvas.height}:force_original_aspect_ratio=increase:flags=bicubic,crop=${canvas.width}:${canvas.height}`
             : `scale=${canvas.width}:${canvas.height}:flags=bicubic`);
     }
+    filters.push(`tpad=stop_mode=clone:stop_duration=${VIDEO_LAYER_TAIL_SLACK_SECONDS * 2}`);
     return {
         inputArgs: [
             "-noaccurate_seek",
@@ -741,8 +744,6 @@ export async function buildVideoLayerInput(videoPath, startTime, duration, fps,
             ...urlInputArgs(videoPath),
             "-i",
             videoPath,
-            "-t",
-            formatFfmpegSeconds(duration),
         ],
         filters,
     };

package/dist/utils/gpuEncoder.d.ts

@@ -31,4 +31,8 @@ export declare function getProbeArgs(encoder: ConcreteGpuEncoder): string[];
  * - `videotoolbox`, `vaapi`, `amf`, `null`: no remap (they either ignore
  *   `-preset` entirely or accept the libx264 vocabulary).
  */
-export declare function mapPresetForGpuEncoder(encoder: GpuEncoder, preset: string): string;
+export declare function mapPresetForGpuEncoder(encoder: GpuEncoder, preset: string, nvencPresets?: ReadonlySet<string>): string;
+/** The names an encoder lists under its `-preset` option in `ffmpeg -h encoder=<name>`. */
+export declare function parseEncoderPresetNames(helpText: string): ReadonlySet<string>;
+/** The presets this ffmpeg's h264_nvenc takes; empty when it cannot be read, which keeps the pN names. */
+export declare function getCachedNvencPresets(): Promise<ReadonlySet<string>>;

package/dist/utils/gpuEncoder.js

@@ -44,9 +44,10 @@ export async function selectUsableGpuEncoder(candidates, isUsable) {
     }
     return null;
 }
-export async function detectGpuEncoder() {
-    const ffmpeg = spawn(getFfmpegBinary(), ["-encoders"], {
-        stdio: ["pipe", "pipe", "pipe"],
+/** ffmpeg's stdout, or null when it did not exit cleanly within the deadline. */
+async function ffmpegStdout(args, deadlineMs, terminationGraceMs) {
+    const ffmpeg = spawn(getFfmpegBinary(), args, {
+        stdio: ["ignore", "pipe", "pipe"],
         // See runFfmpeg.ts: keeps a console window off the user's desktop on Windows.
         windowsHide: true,
     });
@@ -56,9 +57,14 @@ export async function detectGpuEncoder() {
         stdout += data.toString();
     });
     const outcome = await new ManagedChildProcess(ffmpeg, {
-        deadlineAtMs: Date.now() + 30_000,
+        deadlineAtMs: Date.now() + deadlineMs,
+        terminationGraceMs,
     }).wait();
-    if (outcome.reason !== "exit" || outcome.exitCode !== 0)
+    return outcome.reason === "exit" && outcome.exitCode === 0 ? stdout : null;
+}
+export async function detectGpuEncoder() {
+    const stdout = await ffmpegStdout(["-encoders"], 30_000);
+    if (stdout === null)
         return null;
     const candidates = getCompiledGpuEncoders(stdout);
     return selectUsableGpuEncoder(candidates, canUseGpuEncoder).catch(() => null);
@@ -213,9 +219,11 @@ const QSV_PRESET_MAP = {
  * - `videotoolbox`, `vaapi`, `amf`, `null`: no remap (they either ignore
  *   `-preset` entirely or accept the libx264 vocabulary).
  */
-export function mapPresetForGpuEncoder(encoder, preset) {
+export function mapPresetForGpuEncoder(encoder, preset, nvencPresets) {
     switch (encoder) {
         case "nvenc":
+            if (nvencPresets && nvencPresets.size > 0 && !nvencPresets.has("p4"))
+                return legacyNvencPreset(preset, nvencPresets);
             if (/^p[1-7]$/.test(preset))
                 return preset;
             return NVENC_PRESET_MAP[preset] ?? "p4";
@@ -225,3 +233,47 @@ export function mapPresetForGpuEncoder(encoder, preset) {
             return preset;
     }
 }
+// Builds on an older NVENC SDK list `default slow medium fast hp hq ...` and reject p1..p7.
+const LEGACY_NVENC_PRESET_MAP = {
+    ultrafast: "hp",
+    superfast: "hp",
+    veryfast: "hp",
+    faster: "fast",
+    fast: "fast",
+    medium: "medium",
+    slow: "slow",
+    slower: "slow",
+    veryslow: "slow",
+    placebo: "slow",
+};
+function legacyNvencPreset(preset, accepted) {
+    if (accepted.has(preset) && !/^p[1-7]$/.test(preset))
+        return preset;
+    const mapped = LEGACY_NVENC_PRESET_MAP[preset] ?? "medium";
+    return accepted.has(mapped) ? mapped : "default";
+}
+/** The names an encoder lists under its `-preset` option in `ffmpeg -h encoder=<name>`. */
+export function parseEncoderPresetNames(helpText) {
+    const names = new Set();
+    let inPreset = false;
+    for (const line of helpText.split(/\r?\n/)) {
+        if (/^\s{1,3}-\S/.test(line)) {
+            inPreset = /^\s{1,3}-preset\s/.test(line);
+            continue;
+        }
+        const entry = inPreset ? /^\s{4,}([a-z][a-z0-9_]*)\s+-?\d+\s+[E.]\S{3}/.exec(line) : null;
+        if (entry)
+            names.add(entry[1]);
+    }
+    return names;
+}
+let cachedNvencPresets = undefined;
+/** The presets this ffmpeg's h264_nvenc takes; empty when it cannot be read, which keeps the pN names. */
+export function getCachedNvencPresets() {
+    cachedNvencPresets ??= readNvencPresets();
+    return cachedNvencPresets;
+}
+async function readNvencPresets() {
+    const help = await ffmpegStdout(["-hide_banner", "-h", "encoder=h264_nvenc"], GPU_PROBE_TIMEOUT_MS, GPU_PROBE_KILL_GRACE_MS).catch(() => null);
+    return help === null ? new Set() : parseEncoderPresetNames(help);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperframes/engine",
-  "version": "0.8.226",
+  "version": "0.8.227",
   "description": "Seekable web page to video rendering engine (Puppeteer + FFmpeg)",
   "repository": {
     "type": "git",
@@ -59,8 +59,8 @@
     "puppeteer": "~25.11.0",
     "puppeteer-core": "^25.11.0",
     "undici": "7.25.0",
-    "@hyperframes/parsers": "^0.8.226",
-    "@hyperframes/core": "^0.8.226"
+    "@hyperframes/parsers": "^0.8.227",
+    "@hyperframes/core": "^0.8.227"
   },
   "devDependencies": {
     "@types/node": "^25.0.10",