@hyperframes/engine 0.8.191 → 0.8.193

package/dist/services/parallelCoordinator.js

@@ -6,7 +6,8 @@
  */
 import { cpus, freemem } from "os";
 import { existsSync, mkdirSync, readdirSync } from "fs";
-import { copyFile, readFile, rename } from "fs/promises";
+import { copyFile, readFile } from "fs/promises";
+import { renameWithRetryAsync } from "../utils/renameWithRetry.js";
 import { join } from "path";
 import { getHeapStatistics } from "v8";
 import { createCaptureSession, initializeSession, closeCaptureSession, captureFrame, captureFrameToBufferPipelined, captureFrameToBuffer, getCapturePerfSummary, DrawElementVerificationError, } from "./frameCapture.js";
@@ -615,6 +616,7 @@ async function executeWorkerTask(task, serverUrl, captureOptions, createBeforeCa
             frameStride: task.frameStride,
             durationMs: Date.now() - startTime,
             perf,
+            pageErrorLines: pageErrorLinesOf(activeSession),
         };
     }
     catch (error) {
@@ -629,6 +631,7 @@ async function executeWorkerTask(task, serverUrl, captureOptions, createBeforeCa
         const failure = classifyCaptureFailure(error, {
             signal,
             workerDiagnostics: [workerDiagnostic],
+            pageErrorLines: session ? pageErrorLinesOf(session) : undefined,
         });
         onFailure?.(failure);
         return {
@@ -641,6 +644,7 @@ async function executeWorkerTask(task, serverUrl, captureOptions, createBeforeCa
             perf,
             error: failure.message,
             diagnostics: diagnostics.length > 0 ? diagnostics : undefined,
+            pageErrorLines: session ? pageErrorLinesOf(session) : undefined,
             failure,
         };
     }
@@ -681,6 +685,9 @@ export function isPoolFatalWorkerFailure(failure, streaming) {
         return failure.kind !== "cancelled";
     return isFatalCaptureFailure(failure);
 }
+function pageErrorLinesOf(session) {
+    return session.browserConsoleBuffer.filter((line) => line.includes("PAGEERROR"));
+}
 /**
  * The pool's single failure gate. Both halves of the contract the streaming
  * stage relies on live here so they can be pinned without a browser: the
@@ -778,6 +785,7 @@ export async function executeParallelCapture(serverUrl, workDir, tasks, captureO
             message: `[Parallel] Capture failed: ${errorMessages}`,
             cause: representative,
             workerDiagnostics,
+            pageErrorLines: [...new Set(results.flatMap((result) => result.pageErrorLines ?? []))],
         });
     }
     return results;
@@ -798,7 +806,7 @@ export async function mergeWorkerFrames(workDir, tasks, outputDir) {
             const sourcePath = join(task.outputDir, file);
             const targetPath = join(outputDir, file);
             try {
-                await rename(sourcePath, targetPath);
+                await renameWithRetryAsync(sourcePath, targetPath);
             }
             catch {
                 await copyFile(sourcePath, targetPath);

package/dist/services/softwareEncoderThreads.d.ts

@@ -1,2 +1,3 @@
+export declare const X265_MAX_THREADS = 16;
 /** x264/x265 bitstreams depend on the thread count, so it comes from the CPU quota, never ffmpeg's host-core guess. */
-export declare function appendSoftwareEncoderThreadsArg(args: string[], parallelism?: number): void;
+export declare function appendSoftwareEncoderThreadsArg(args: string[], encoder: "libx264" | "libx265", parallelism?: number): void;

package/dist/services/softwareEncoderThreads.js

@@ -1,5 +1,7 @@
 import { availableParallelism } from "node:os";
+export const X265_MAX_THREADS = 16;
 /** x264/x265 bitstreams depend on the thread count, so it comes from the CPU quota, never ffmpeg's host-core guess. */
-export function appendSoftwareEncoderThreadsArg(args, parallelism = availableParallelism()) {
-    args.push("-threads", String(Math.max(1, Math.floor(parallelism))));
+export function appendSoftwareEncoderThreadsArg(args, encoder, parallelism = availableParallelism()) {
+    const cap = encoder === "libx265" ? X265_MAX_THREADS : Infinity;
+    args.push("-threads", String(Math.min(cap, Math.max(1, Math.floor(parallelism)))));
 }

package/dist/services/streamingEncoder.js

@@ -181,7 +181,7 @@ export function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
         else {
             const encoderName = codec === "h264" ? "libx264" : "libx265";
             args.push("-c:v", encoderName, "-preset", preset);
-            appendSoftwareEncoderThreadsArg(args);
+            appendSoftwareEncoderThreadsArg(args, encoderName);
             if (bitrate)
                 args.push("-b:v", bitrate);
             else

package/dist/services/videoFrameExtractor.d.ts

@@ -6,7 +6,7 @@
  */
 import { resolveProjectRelativeSrc } from "@hyperframes/parsers/asset-resolution";
 import { type RateSpec, type FpsInput } from "@hyperframes/core";
-import { type VideoMetadata } from "../utils/ffprobe.js";
+import { resolvePlayableVideoDuration, type VideoMetadata } from "../utils/ffprobe.js";
 import { type HdrTransfer } from "../utils/hdr.js";
 import { type EngineConfig } from "../config.js";
 import { type CacheFrameFormat } from "./extractionCache.js";
@@ -60,6 +60,17 @@ export declare function isVideoFrameFormat(value: unknown): value is VideoFrameF
  * rejected because the two paths disagree by one frame.
  */
 export declare function extractionFrameCountForDuration(durationSeconds: number, fps: FpsInput, isVFR: boolean): number;
+/** Slots of a window reaching the source's end that hold a frame, from the stored final frame; null if unsure. */
+export declare function tailFramesFromFinalFrame(input: {
+    startTime: number;
+    firstFrame: number;
+    tailFrames: number;
+    outputFps: number;
+    sourceFps: number;
+    finalFrameSeconds: number;
+    streamLeadSeconds: number;
+    lastPacketSeconds?: number;
+}): number | null;
 export interface FrameRange {
     firstFrame: number;
     frames: number;
@@ -100,6 +111,8 @@ export interface ExtractionOptions {
     collectProbeFailures?: boolean;
     /** Extract only these runs of output frames, named as a full extraction names them. CFR only. */
     frameRanges?: readonly FrameRange[];
+    /** A short decode of a remote source, only to count its frames: it waits on the network, so it runs wider. */
+    tailProbe?: boolean;
     /**
      * Leave CFR windows longer than a second unextracted, returning `deferredRange` and an exact
      * `totalFrames` so another process can extract just the frames it needs with `frameRanges`.
@@ -259,7 +272,7 @@ export declare function classifyFfmpegSpawnError(error: unknown, stderr?: string
  * the container duration when ffprobe omits the stream duration; keep the
  * explicit fallback here for callers supplying older/manual metadata.
  */
-export declare function resolvePlayableVideoDuration(metadata: VideoMetadata): number;
+export { resolvePlayableVideoDuration };
 export interface TimelineExtractionWindow {
     compositionStart: number;
     mediaStart: number;

package/dist/services/videoFrameExtractor.js

@@ -17,7 +17,7 @@ import { alphaDecoderFor } from "@hyperframes/parsers/media-alpha";
 import { MEDIA_RENDER_ID_ATTR, isAudibleVideoElement, fpsToFfmpegArg, fpsToNumber, MEDIA_DURATION_CLAMP_EPSILON_SECONDS, normalizeRateSpec, readElementRateSpec, shiftRateLane, sourceTimeAt, timeAtSourceTime, exportClipWindow, hasClipStarted, isInClipWindow, parseStrictFiniteTimingNumber, readMediaStart, toFps, firstFrameColourArgs, hdrToSdrToneMapFilter, parseFirstFrameColour, } from "@hyperframes/core";
 import { resolveReferencedStart } from "./referenceResolver.js";
 import { isKnownInactiveTimelineWindow } from "./mediaTimelineWindow.js";
-import { extractFinalVideoFrameTimestamp, extractMediaMetadata, mediaFileIdentity, readMetadataCache, writeMetadataCache, } from "../utils/ffprobe.js";
+import { extractFinalVideoFrameTimestamp, extractMediaMetadata, mediaFileIdentity, readMetadataCache, readStoredFinalFrame, resolvePlayableVideoDuration, writeMetadataCache, } from "../utils/ffprobe.js";
 import { inputAlphaOpaqueWarning, probeInputAlphaPlane } from "../utils/alphaPlaneProbe.js";
 import { redactUrlQueriesInError, urlInputArgs } from "../utils/urlInput.js";
 import { analyzeCompositionHdr, isHdrColorSpace as isHdrColorSpaceUtil, } from "../utils/hdr.js";
@@ -109,6 +109,32 @@ export function extractionFrameCountForDuration(durationSeconds, fps, isVFR) {
     const frames = Number(frameCount);
     return Math.max(1, Number.isSafeInteger(frames) ? frames : Number.MAX_SAFE_INTEGER);
 }
+/** The exact rate behind a probed one (rounded to 0.01): a whole number or its 1000/1001 NTSC form. */
+function exactSourceRate(probed) {
+    const nominal = Math.round(probed * 1.001);
+    return ([nominal, (nominal * 1000) / 1001].find((rate) => Math.abs(rate - probed) <= 0.005 + 1e-9) ??
+        null);
+}
+/** Slots of a window reaching the source's end that hold a frame, from the stored final frame; null if unsure. */
+export function tailFramesFromFinalFrame(input) {
+    const sourceRate = exactSourceRate(input.sourceFps);
+    if (!sourceRate || !(input.outputFps > 0))
+        return null;
+    // A late-starting stream ends where its last packet does, and ffmpeg shortens the last frame
+    // to a short packet in ways the stored facts cannot predict: trust only a full-frame packet.
+    const lead = input.streamLeadSeconds;
+    if (lead !== 0 && !(Math.abs((input.lastPacketSeconds ?? NaN) - 1 / sourceRate) <= 1e-4)) {
+        return null;
+    }
+    const seek = input.startTime + input.firstFrame / input.outputFps;
+    const slots = (lead + input.finalFrameSeconds + 1 / sourceRate - seek) * input.outputFps;
+    const distanceToSlot = Math.abs(slots - Math.round(slots));
+    // ffprobe prints the final time to 1 us; a slot closer than 50 us/fps to the end is a tie, up to 500 us/fps unknown.
+    if (distanceToSlot >= 5e-5 && distanceToSlot < 5e-4)
+        return null;
+    const count = Math.min(input.tailFrames, Math.ceil(slots - 5e-5));
+    return count > 0 ? count : null;
+}
 const DOWNLOAD_SUBDIR = "_downloads";
 export const EXTRACT_CACHE_MIN_AGE_MS = 60 * 60 * 1000;
 const GC_STALENESS_MS = 24 * 60 * 60 * 1000;
@@ -468,6 +494,8 @@ function undoTickRoundingOnTheSourceFrameGrid(seek, lead) {
 // Caps extraction ffmpeg runs across all clips; uncapped, dozens of clips starved each other into timeouts.
 const EXTRACTION_SLOTS = Math.max(1, Math.floor(cpus().length / 2));
 const inExtractionSlot = createConcurrencyLimit(EXTRACTION_SLOTS);
+const TAIL_PROBE_SLOTS = Math.max(1, Number(process.env.HF_TAIL_PROBE_SLOTS) || 16);
+const inTailProbeSlot = createConcurrencyLimit(TAIL_PROBE_SLOTS);
 /** Split runs so no single ffmpeg process extracts more than `segmentFrames` frames. */
 function splitFrameRanges(ranges, segmentFrames) {
     const segments = [];
@@ -482,7 +510,7 @@ function splitFrameRanges(ranges, segmentFrames) {
     return segments;
 }
 async function runSegmentedExtraction(job) {
-    const { decodeArgs, filterAndEncodeArgs, videoPath, startTime, fps, segments } = job;
+    const { decodeArgs, filterAndEncodeArgs, videoPath, startTime, fps, segments, gate } = job;
     const segmentCount = segments.length;
     // One failed segment fails the range, so stop the others instead of finishing them.
     const failed = new AbortController();
@@ -496,7 +524,7 @@ async function runSegmentedExtraction(job) {
             const index = next++;
             const { firstFrame, frames } = segments[index];
             const seek = startTime + firstFrame / fps;
-            const result = await inExtractionSlot(() => runFfmpeg([
+            const result = await gate(() => runFfmpeg([
                 ...decodeArgs,
                 "-noaccurate_seek",
                 "-ss",
@@ -677,6 +705,7 @@ outputDirOverride) {
             videoPath,
             startTime,
             fps,
+            gate: options.tailProbe ? inTailProbeSlot : inExtractionSlot,
             segments: splitFrameRanges(options.frameRanges ?? [{ firstFrame: 0, frames: totalFrames }], segmentFrames),
             runOptions,
         })
@@ -772,12 +801,7 @@ function resolveSegmentDuration(requested, mediaStart, sourceDuration) {
  * the container duration when ffprobe omits the stream duration; keep the
  * explicit fallback here for callers supplying older/manual metadata.
  */
-export function resolvePlayableVideoDuration(metadata) {
-    return Number.isFinite(metadata.videoStreamDurationSeconds) &&
-        metadata.videoStreamDurationSeconds > 0
-        ? (metadata.videoStreamLeadSeconds ?? 0) + metadata.videoStreamDurationSeconds
-        : metadata.durationSeconds;
-}
+export { resolvePlayableVideoDuration };
 function canHoldFinalFramePastEof(video) {
     const timelineDuration = video.end - video.start;
     return !video.loop && Number.isFinite(timelineDuration) && timelineDuration > 0;
@@ -1499,16 +1523,7 @@ export async function extractAllVideoFrames(videos, baseDir, options, signal, co
         const tailFrames = Math.min(expectedFrames, Math.ceil(fps));
         if (expectedFrames <= tailFrames)
             return null;
-        const probeDir = join(options.outputDir, `${work.video.id}.tail-probe`);
-        try {
-            const tail = await extractVideoFramesRange(work.videoPath, work.video.id, work.extractionMediaStart, work.videoDuration, {
-                ...scopedExtractionOptions(work),
-                frameRanges: [{ firstFrame: expectedFrames - tailFrames, frames: tailFrames }],
-            }, signal, config, probeDir);
-            const totalFrames = expectedFrames - tailFrames + tail.totalFrames;
-            // A full extraction this short rewrites the probed duration; let it.
-            if (totalFrames <= expectedFrames * 0.6)
-                return null;
+        const deferred = (totalFrames) => {
             const outputDir = join(options.outputDir, work.video.id);
             mkdirSync(outputDir, { recursive: true });
             return {
@@ -1526,6 +1541,42 @@ export async function extractAllVideoFrames(videos, baseDir, options, signal, co
                     format: work.format,
                 },
             };
+        };
+        // A window that ends a second or more inside the source cannot run out of frames: its count is the expected one.
+        if (work.extractionMediaStart + work.videoDuration + 1 <=
+            resolvePlayableVideoDuration(work.metadata)) {
+            return deferred(expectedFrames);
+        }
+        const firstTailFrame = expectedFrames - tailFrames;
+        const storedFinalFrame = await readStoredFinalFrame(work.videoPath, work.metadata);
+        const storedTailFrames = storedFinalFrame === undefined
+            ? null
+            : tailFramesFromFinalFrame({
+                startTime: work.extractionMediaStart,
+                firstFrame: firstTailFrame,
+                tailFrames,
+                outputFps: fps,
+                sourceFps: work.metadata.fps,
+                finalFrameSeconds: storedFinalFrame.seconds,
+                lastPacketSeconds: storedFinalFrame.lastPacketSeconds,
+                streamLeadSeconds: work.metadata.videoStreamLeadSeconds ?? 0,
+            });
+        if (storedTailFrames !== null) {
+            const totalFrames = firstTailFrame + storedTailFrames;
+            return totalFrames <= expectedFrames * 0.6 ? null : deferred(totalFrames);
+        }
+        const probeDir = join(options.outputDir, `${work.video.id}.tail-probe`);
+        try {
+            const tail = await extractVideoFramesRange(work.videoPath, work.video.id, work.extractionMediaStart, work.videoDuration, {
+                ...scopedExtractionOptions(work),
+                frameRanges: [{ firstFrame: firstTailFrame, frames: tailFrames }],
+                tailProbe: isHttpUrl(work.videoPath),
+            }, signal, config, probeDir);
+            const totalFrames = firstTailFrame + tail.totalFrames;
+            // A full extraction this short rewrites the probed duration; let it.
+            if (totalFrames <= expectedFrames * 0.6)
+                return null;
+            return deferred(totalFrames);
         }
         catch {
             return null;

package/dist/utils/ffprobe.d.ts

@@ -100,9 +100,20 @@ export interface MediaProbeProfile {
     hasAudioStream: boolean;
     visualKind: "none" | "still" | "moving";
 }
+/** A URL whose bytes can never change (its path holds their hash), so probes of it are cacheable. */
+export declare function declareContentAddressedUrl(url: string, sha256: string): void;
+/** Where the ffprobe JSON of a content-addressed URL was stored beforehand: reading it replaces probing the file. */
+export declare function declareProbeFactsUrl(url: string, factsUrl: string): void;
 export declare function mediaFileIdentity(filePath: string): string | null;
 export declare function readMetadataCache<T>(cache: Map<string, MediaProbeCacheEntry<T>>, key: string, identity: string | null): Promise<T> | undefined;
 export declare function writeMetadataCache<T>(cache: Map<string, MediaProbeCacheEntry<T>>, key: string, identity: string | null, promise: Promise<T>): void;
+/** Part of the name a stored probe is kept under: bump it with the args below. */
+export declare const PROBE_FACTS_VERSION = "v2";
+/** The ffprobe JSON `probeMediaOutput` works from; a declared URL's stored copy is read in place of probing it. */
+export declare function readProbeJson(filePath: string, signal?: AbortSignal): Promise<string>;
+/** What a site stores beside a video: its ffprobe JSON and the final-frame facts a plan would otherwise probe for. */
+export declare function buildProbeFactsText(filePath: string, signal?: AbortSignal): Promise<string>;
+export declare function resolvePlayableVideoDuration(metadata: VideoMetadata): number;
 /**
  * Probe stream capabilities without assuming the caller's element type.
  * File extensions and HTTP MIME are deliberately ignored: extensionless
@@ -152,6 +163,11 @@ export declare function parseFrameRate(frameRateStr: string | undefined): number
  * can be used uniformly for any visual asset the HDR pipeline encounters.
  */
 export declare function extractMediaMetadata(filePath: string): Promise<VideoMetadata>;
+/** Stored final-frame facts for this stream window; none if undeclared (no await then, so a probe spawns at once). */
+export declare function readStoredFinalFrame(filePath: string, metadata: Pick<VideoMetadata, "videoStreamDurationSeconds" | "videoStreamStartSeconds">): Promise<{
+    seconds: number;
+    lastPacketSeconds?: number;
+} | undefined> | undefined;
 /**
  * Return the FFmpeg input-seek position of the final decoded video frame.
  *

package/dist/utils/ffprobe.js

@@ -140,6 +140,7 @@ const videoMetadataCache = new Map();
 const finalVideoFrameTimestampCache = new Map();
 const finalVideoFrameTimestampSignalCaches = new WeakMap();
 const audioMetadataCache = new Map();
+const audioMetadataSignalCaches = new WeakMap();
 const mediaProbeOutputCache = new Map();
 const mediaProbeOutputSignalCaches = new WeakMap();
 const MEDIA_PROBE_OUTPUT_CACHE_MAX_ENTRIES = 128;
@@ -210,7 +211,22 @@ function isPngImageProbe(output) {
     return (formatNames.includes("png_pipe") ||
         output.streams.some((stream) => stream.codec_type === "video" && stream.codec_name?.toLowerCase() === "png"));
 }
+const contentAddressedUrls = new Map();
+const withoutQuery = (url) => url.split(/[?#]/, 1)[0] ?? url;
+/** A URL whose bytes can never change (its path holds their hash), so probes of it are cacheable. */
+export function declareContentAddressedUrl(url, sha256) {
+    contentAddressedUrls.set(withoutQuery(url), sha256);
+}
+const probeFactsUrls = new Map();
+/** Where the ffprobe JSON of a content-addressed URL was stored beforehand: reading it replaces probing the file. */
+export function declareProbeFactsUrl(url, factsUrl) {
+    probeFactsUrls.set(withoutQuery(url), factsUrl);
+}
 export function mediaFileIdentity(filePath) {
+    if (/^https?:\/\//i.test(filePath)) {
+        const sha256 = contentAddressedUrls.get(withoutQuery(filePath));
+        return sha256 ? `sha256:${sha256}` : null;
+    }
     try {
         const stat = statSync(filePath, { bigint: true });
         return [stat.dev, stat.ino, stat.size, stat.mtimeNs, stat.ctimeNs].join(":");
@@ -235,6 +251,88 @@ export function writeMetadataCache(cache, key, identity, promise) {
             cache.delete(key);
     });
 }
+/** Part of the name a stored probe is kept under: bump it with the args below. */
+export const PROBE_FACTS_VERSION = "v2";
+const PROBE_JSON_ARGS = ["-print_format", "json", "-show_format", "-show_streams"];
+const storedFacts = new Map();
+/** The facts stored for a declared URL, fetched once; null when there are none or they cannot be read. */
+function readStoredFacts(filePath) {
+    if (!/^https?:\/\//i.test(filePath))
+        return undefined;
+    const factsUrl = probeFactsUrls.get(withoutQuery(filePath));
+    if (!factsUrl)
+        return undefined;
+    let facts = storedFacts.get(factsUrl);
+    if (!facts) {
+        facts = (async () => {
+            try {
+                const response = await fetch(factsUrl, { signal: AbortSignal.timeout(10_000) });
+                if (!response.ok)
+                    return null;
+                const parsed = JSON.parse(await response.text());
+                return Array.isArray(parsed.ffprobe?.streams) ? parsed : null;
+            }
+            catch {
+                return null;
+            }
+        })();
+        storedFacts.set(factsUrl, facts);
+    }
+    return facts;
+}
+/** The ffprobe JSON `probeMediaOutput` works from; a declared URL's stored copy is read in place of probing it. */
+export function readProbeJson(filePath, signal) {
+    const pending = readStoredFacts(filePath);
+    if (!pending)
+        return runFfprobe(filePath, PROBE_JSON_ARGS, signal);
+    return pending.then((stored) => stored ? JSON.stringify(stored.ffprobe) : runFfprobe(filePath, PROBE_JSON_ARGS, signal));
+}
+let runtimeFfprobeMajor;
+/** The major version of the ffprobe this process runs; undefined when it cannot be read. */
+function ffprobeMajor() {
+    runtimeFfprobeMajor ??= new Promise((resolve) => {
+        let out = "";
+        const binary = getFfprobeBinary();
+        const proc = spawn(binary, ["-version"], { stdio: ["ignore", "pipe", "ignore"] });
+        proc.stdout.on("data", (chunk) => (out += String(chunk)));
+        proc.on("error", () => resolve(undefined));
+        proc.on("close", () => resolve(Number(/version n?(\d+)/.exec(out)?.[1]) || undefined));
+    });
+    return runtimeFfprobeMajor;
+}
+/** What a site stores beside a video: its ffprobe JSON and the final-frame facts a plan would otherwise probe for. */
+export async function buildProbeFactsText(filePath, signal) {
+    const facts = {
+        ffprobe: parseProbeJson(await runFfprobe(filePath, PROBE_JSON_ARGS, signal)),
+        ffprobeMajor: await ffprobeMajor(),
+    };
+    try {
+        const metadata = await extractMediaMetadata(filePath);
+        const window = resolveStreamWindow(filePath, {
+            videoStreamStartSeconds: metadata.videoStreamStartSeconds,
+            videoStreamDurationSeconds: resolvePlayableVideoDuration(metadata) - (metadata.videoStreamLeadSeconds ?? 0),
+        });
+        if (window.videoStreamDurationSeconds > 0) {
+            facts.finalFrame = {
+                streamStart: window.videoStreamStartSeconds,
+                streamDuration: window.videoStreamDurationSeconds,
+                seconds: await extractFinalVideoFrameTimestamp(filePath, window, signal),
+                lastPacketSeconds: await extractFinalPacketDuration(filePath, window, signal),
+            };
+        }
+    }
+    catch {
+        if (signal?.aborted)
+            throw signal.reason;
+    }
+    return JSON.stringify(facts);
+}
+export function resolvePlayableVideoDuration(metadata) {
+    return Number.isFinite(metadata.videoStreamDurationSeconds) &&
+        metadata.videoStreamDurationSeconds > 0
+        ? (metadata.videoStreamLeadSeconds ?? 0) + metadata.videoStreamDurationSeconds
+        : metadata.durationSeconds;
+}
 async function probeMediaOutput(filePath, signal) {
     let cache = mediaProbeOutputCache;
     if (signal) {
@@ -253,7 +351,7 @@ async function probeMediaOutput(filePath, signal) {
         }
         return cached.promise;
     }
-    const promise = runFfprobe(filePath, ["-print_format", "json", "-show_format", "-show_streams"], signal).then(parseProbeJson);
+    const promise = readProbeJson(filePath, signal).then(parseProbeJson);
     if (identity !== null) {
         cache.set(filePath, { identity, promise });
         if (!signal && cache.size > MEDIA_PROBE_OUTPUT_CACHE_MAX_ENTRIES) {
@@ -661,6 +759,45 @@ function resolveStreamWindow(filePath, metadata) {
     const cacheKey = `${filePath}\0${String(videoStreamStartSeconds)}\0${String(videoStreamDurationSeconds)}`;
     return { videoStreamStartSeconds, videoStreamDurationSeconds, cacheKey };
 }
+/** Stored final-frame facts for this stream window; none if undeclared (no await then, so a probe spawns at once). */
+export function readStoredFinalFrame(filePath, metadata) {
+    const { videoStreamStartSeconds, videoStreamDurationSeconds } = resolveStreamWindow(filePath, metadata);
+    return readStoredFacts(filePath)?.then(async (facts) => {
+        const stored = facts?.finalFrame;
+        // Another major version may place the final frame or stream start differently: probe instead.
+        if (facts?.ffprobeMajor !== undefined && facts.ffprobeMajor !== (await ffprobeMajor()))
+            return undefined;
+        return stored &&
+            stored.streamStart === videoStreamStartSeconds &&
+            stored.streamDuration === videoStreamDurationSeconds
+            ? stored
+            : undefined;
+    });
+}
+/**
+ * `duration_time` of the stream's last packet (by presentation time), read from the same final
+ * second the final-frame probe reads; undefined when ffprobe reports none.
+ */
+async function extractFinalPacketDuration(filePath, window, signal) {
+    const streamEnd = window.videoStreamStartSeconds + window.videoStreamDurationSeconds;
+    const intervalStart = Math.max(window.videoStreamStartSeconds, streamEnd - 1);
+    const stdout = await runFfprobe(filePath, [
+        "-select_streams",
+        "v:0",
+        "-read_intervals",
+        `${intervalStart}%${streamEnd}`,
+        "-show_entries",
+        "packet=pts_time,duration_time",
+        "-of",
+        "csv=p=0",
+    ], signal, { retainTail: true, maxChars: 64 * 1024 });
+    const packets = stdout
+        .split("\n")
+        .map((line) => line.trim().split(",").map(Number))
+        .filter(([pts, duration]) => Number.isFinite(pts) && Number.isFinite(duration));
+    const last = packets.reduce((best, packet) => (!best || packet[0] > best[0] ? packet : best), undefined);
+    return last?.[1];
+}
 /**
  * Return the FFmpeg input-seek position of the final decoded video frame.
  *
@@ -694,6 +831,10 @@ export async function extractFinalVideoFrameTimestamp(filePath, metadata, signal
     if (cached)
         return cached;
     const probePromise = (async () => {
+        const pendingStored = readStoredFinalFrame(filePath, metadata);
+        const stored = pendingStored && (await pendingStored);
+        if (stored)
+            return stored.seconds;
         if (!(videoDurationSeconds > 0) || !Number.isFinite(videoDurationSeconds)) {
             throw new Error(`[FFmpeg] Cannot locate final video frame for invalid duration ${String(videoDurationSeconds)}`);
         }
@@ -740,49 +881,53 @@ export async function extractFinalVideoFrameTimestamp(filePath, metadata, signal
  */
 export const extractVideoMetadata = extractMediaMetadata;
 export async function extractAudioMetadata(filePath, options) {
-    // A caller-owned abort signal cannot safely share a cached in-flight probe:
-    // cancelling one consumer would also cancel unrelated consumers. Signal-bound
-    // probes therefore bypass the process-promise cache.
+    // A probe bound to a caller's abort signal is shared only among callers of that same signal,
+    // and only when the file has an identity to key it by.
     const identity = mediaFileIdentity(filePath);
-    const cached = options?.signal
-        ? undefined
-        : readMetadataCache(audioMetadataCache, filePath, identity);
+    const signal = options?.signal;
+    if (signal && identity === null)
+        return probeAudioMetadata(filePath, signal);
+    let cache = audioMetadataCache;
+    if (signal) {
+        cache = audioMetadataSignalCaches.get(signal) ?? new Map();
+        audioMetadataSignalCaches.set(signal, cache);
+    }
+    const cached = readMetadataCache(cache, filePath, identity);
     if (cached)
         return cached;
-    const probePromise = (async () => {
-        const output = await probeMediaOutput(filePath, options?.signal);
-        const audioStream = output.streams.find((s) => s.codec_type === "audio");
-        if (!audioStream)
-            throw new Error("[FFmpeg] No audio stream found");
-        let durationSeconds = output.format.duration ? parseFloat(output.format.duration) : 0;
-        const streamDuration = audioStream.duration ? parseFloat(audioStream.duration) : undefined;
-        const sampleRate = audioStream.sample_rate ? parseInt(audioStream.sample_rate) : 44100;
-        const audioCodec = audioStream.codec_name || "unknown";
-        // Container summaries can undercount intact audio, so the decoded last frame wins.
-        // The probe returns null instead of throwing: a throw here drops the audio element.
-        if (sampleRate > 0) {
-            const decoded = await probeDecodedAudioDuration(filePath, sampleRate, audioStartSeconds(audioStream, output.format), durationSeconds, options?.signal);
-            if (decoded !== null) {
-                durationSeconds = reconcileAudioDuration(durationSeconds, decoded, output.format);
-            }
-        }
-        return {
-            durationSeconds,
-            streamDurationSeconds: streamDuration && streamDuration > 0 ? streamDuration : undefined,
-            sampleRate,
-            channels: audioStream.channels || 2,
-            audioCodec,
-            bitrate: output.format.bit_rate ? parseInt(output.format.bit_rate) : undefined,
-            latestStreamLeadSeconds: latestStreamLeadSeconds(output),
-            audioStreamLeadSeconds: streamLeadSeconds(output, audioStream),
-            audioStreamCount: output.streams.filter((s) => s.codec_type === "audio").length,
-        };
-    })();
-    if (options?.signal)
-        return probePromise;
-    writeMetadataCache(audioMetadataCache, filePath, identity, probePromise);
+    const probePromise = probeAudioMetadata(filePath, signal);
+    writeMetadataCache(cache, filePath, identity, probePromise);
     return probePromise;
 }
+async function probeAudioMetadata(filePath, signal) {
+    const output = await probeMediaOutput(filePath, signal);
+    const audioStream = output.streams.find((s) => s.codec_type === "audio");
+    if (!audioStream)
+        throw new Error("[FFmpeg] No audio stream found");
+    let durationSeconds = output.format.duration ? parseFloat(output.format.duration) : 0;
+    const streamDuration = audioStream.duration ? parseFloat(audioStream.duration) : undefined;
+    const sampleRate = audioStream.sample_rate ? parseInt(audioStream.sample_rate) : 44100;
+    const audioCodec = audioStream.codec_name || "unknown";
+    // Container summaries can undercount intact audio, so the decoded last frame wins.
+    // The probe returns null instead of throwing: a throw here drops the audio element.
+    if (sampleRate > 0) {
+        const decoded = await probeDecodedAudioDuration(filePath, sampleRate, audioStartSeconds(audioStream, output.format), durationSeconds, signal);
+        if (decoded !== null) {
+            durationSeconds = reconcileAudioDuration(durationSeconds, decoded, output.format);
+        }
+    }
+    return {
+        durationSeconds,
+        streamDurationSeconds: streamDuration && streamDuration > 0 ? streamDuration : undefined,
+        sampleRate,
+        channels: audioStream.channels || 2,
+        audioCodec,
+        bitrate: output.format.bit_rate ? parseInt(output.format.bit_rate) : undefined,
+        latestStreamLeadSeconds: latestStreamLeadSeconds(output),
+        audioStreamLeadSeconds: streamLeadSeconds(output, audioStream),
+        audioStreamCount: output.streams.filter((s) => s.codec_type === "audio").length,
+    };
+}
 /** Chrome's media time 0 is the earliest of these; a stream starting later plays that much in. */
 function audioVideoStreamStarts(output) {
     return (output?.streams ?? [])

package/dist/utils/htmlTemplate.js

@@ -22,7 +22,7 @@ function getSingleMeaningfulChild(container) {
  */
 export function unwrapTemplate(html) {
     const lowered = html.toLowerCase();
-    if (!lowered.includes("<template") || !lowered.includes("</template>")) {
+    if (!lowered.includes("<template") || !/<\/template[ \t\n\r\f]*>/.test(lowered)) {
         return html;
     }
     const { body } = parseHTMLContent(html);

package/dist/utils/processRss.js

@@ -78,8 +78,11 @@ export async function sampleProcessRss(pids, exec = defaultExec(), platform = pr
         if (platform === "win32") {
             const results = [];
             for (const pid of unique) {
-                const { stdout } = await exec("tasklist", ["/FO", "CSV", "/NH", "/FI", `PID eq ${pid}`]);
-                results.push(...parseTasklistCsv(pid, stdout));
+                try {
+                    const { stdout } = await exec("tasklist", ["/FO", "CSV", "/NH", "/FI", `PID eq ${pid}`]);
+                    results.push(...parseTasklistCsv(pid, stdout));
+                }
+                catch { }
             }
             return results;
         }

package/dist/utils/renameWithRetry.d.ts

@@ -0,0 +1,12 @@
+interface Options {
+    platform?: NodeJS.Platform;
+}
+/** `renameSync` that rides out Windows' transient file locks; other platforms and errors throw at once. */
+export declare function renameWithRetry(from: string, to: string, options?: Options & {
+    rename?: (from: string, to: string) => void;
+}): void;
+/** Async twin of {@link renameWithRetry}. */
+export declare function renameWithRetryAsync(from: string, to: string, options?: Options & {
+    rename?: (from: string, to: string) => Promise<void>;
+}): Promise<void>;
+export {};