@hyperframes/engine 0.8.190 → 0.8.192

package/dist/index.d.ts

@@ -46,7 +46,7 @@ export { beginFrameCapture, pageScreenshotCapture, getCdpSession, injectVideoFra
 export { buildEncoderArgs, encodeFramesFromDir, buildConcatArgs, concatVideoFiles, encodeFramesChunkedConcat, muxVideoWithAudio, applyFaststart, packageHls, detectGpuEncoder, ENCODER_PRESETS, getEncoderPreset, HLS_MASTER_PLAYLIST, HLS_VIDEO_PLAYLIST, HLS_AUDIO_PLAYLIST, type GpuEncoder, type PackageHlsOptions, } from "./services/chunkEncoder.js";
 export type { EncoderOptions, EncodeResult, MuxResult } from "./services/chunkEncoder.types.js";
 export { spawnStreamingEncoder, createFrameReorderBuffer, type StreamingEncoder, type StreamingEncoderOptions, type StreamingEncoderResult, type FrameReorderBuffer, } from "./services/streamingEncoder.js";
-export { parseVideoElements, parseImageElements, extractVideoFramesRange, extractAllVideoFrames, isVideoPastTimelineEnd, resolveTimelineExtractionWindow, resolveVideoExtractionWindow, resolveFinalFrameExtractionWindow, resolveVideoExtractionDuration, resolvePlayableVideoDuration, extractionFrameCountForDuration, resolveProjectRelativeSrc, getFrameAtTime, isVideoHiddenBeforeStreamStart, createFrameLookupTable, FrameLookupTable, analyzeClipMediaFit, classifyVideoExtractionError, isVideoSourceExtractionError, runVideoExtractionWithRetry, safeVideoExtractionSourceIdentity, VideoSourceExtractionError, type VideoElement, type ImageElement, type ExtractedFrames, type DeferredFrameRange, type FrameRange, type ExtractionOptions, type ExtractionResult, type ExtractionPhaseBreakdown, type TimelineExtractionWindow, type VideoExtractionFailure, type VideoExtractionFailureKind, type VideoExtractionFailureGroupDetails, type VideoExtractionFailureRetry, type VideoExtractionFailureStatusClass, type SafeVideoExtractionSourceIdentity, type VideoFrameFormat, VIDEO_FRAME_FORMATS, isVideoFrameFormat, EXTRACT_CACHE_MIN_AGE_MS, } from "./services/videoFrameExtractor.js";
+export { parseVideoElements, parseImageElements, extractVideoFramesRange, extractAllVideoFrames, isVideoPastTimelineEnd, resolveTimelineExtractionWindow, resolveVideoExtractionWindow, rebaseVideoToWindow, resolveFinalFrameExtractionWindow, resolveVideoExtractionDuration, resolvePlayableVideoDuration, extractionFrameCountForDuration, resolveProjectRelativeSrc, getFrameAtTime, isVideoHiddenBeforeStreamStart, createFrameLookupTable, FrameLookupTable, analyzeClipMediaFit, classifyVideoExtractionError, isVideoSourceExtractionError, runVideoExtractionWithRetry, safeVideoExtractionSourceIdentity, VideoSourceExtractionError, type VideoElement, type ImageElement, type ExtractedFrames, type DeferredFrameRange, type FrameRange, type ExtractionOptions, type ExtractionResult, type ExtractionPhaseBreakdown, type TimelineExtractionWindow, type VideoExtractionFailure, type VideoExtractionFailureKind, type VideoExtractionFailureGroupDetails, type VideoExtractionFailureRetry, type VideoExtractionFailureStatusClass, type SafeVideoExtractionSourceIdentity, type VideoFrameFormat, VIDEO_FRAME_FORMATS, isVideoFrameFormat, EXTRACT_CACHE_MIN_AGE_MS, } from "./services/videoFrameExtractor.js";
 export { directorySizeBytes, gcExtractionCache } from "./services/extractionCache.js";
 export { resolveReferencedStart, resolveReferencedDuration, type RefResolverEl, type RefResolverDoc, } from "./services/referenceResolver.js";
 export { createVideoFrameInjector } from "./services/videoFrameInjector.js";
@@ -64,7 +64,7 @@ export type { MotionBlurOptions, MotionBlurBlendSpace } from "./services/motionB
 export type { PageMotionBlurOff } from "./types.js";
 export { assertSwiftShader, readWebGlVendorInfo, SwiftShaderAssertionError, BROWSER_GPU_NOT_SOFTWARE, } from "./utils/assertSwiftShader.js";
 export { readWebGlVendorInfoFromCanvas } from "./utils/readWebGlVendorInfoFromCanvas.js";
-export { extractMediaMetadata, extractVideoMetadata, extractFinalVideoFrameTimestamp, extractAudioMetadata, probeMediaProfile, analyzeKeyframeIntervals, type VideoMetadata, type AudioMetadata, type MediaProbeProfile, type KeyframeAnalysis, } from "./utils/ffprobe.js";
+export { extractMediaMetadata, extractVideoMetadata, extractFinalVideoFrameTimestamp, extractAudioMetadata, declareContentAddressedUrl, probeMediaProfile, analyzeKeyframeIntervals, type VideoMetadata, type AudioMetadata, type MediaProbeProfile, type KeyframeAnalysis, } from "./utils/ffprobe.js";
 export { NOT_MEDIA_PAYLOAD, NotMediaPayloadError, assertMediaPayload, fingerprintElementId, isNotMediaPayload, } from "./utils/notMediaPayload.js";
 export { assertPublicHttpsUrl, isBlockedNetworkHost, downloadToTemp, fetchPublicHttpsText, isHttpUrl, safeDownloadUrlIdentity, writeUrlDownloadTelemetry, type SafeDownloadUrlIdentity, type UrlDownloadOptions, type UrlDownloadTelemetry, type PublicHttpsTextOptions, } from "./utils/urlDownloader.js";
 export { runFfmpeg, formatFfmpegError, describeFfmpegFailure, isExternalFfmpegInterruption, type RunFfmpegOptions, type RunFfmpegResult, } from "./utils/runFfmpeg.js";

package/dist/index.js

@@ -50,7 +50,7 @@ export { beginFrameCapture, pageScreenshotCapture, getCdpSession, injectVideoFra
 export { buildEncoderArgs, encodeFramesFromDir, buildConcatArgs, concatVideoFiles, encodeFramesChunkedConcat, muxVideoWithAudio, applyFaststart, packageHls, detectGpuEncoder, ENCODER_PRESETS, getEncoderPreset, HLS_MASTER_PLAYLIST, HLS_VIDEO_PLAYLIST, HLS_AUDIO_PLAYLIST, } from "./services/chunkEncoder.js";
 export { spawnStreamingEncoder, createFrameReorderBuffer, } from "./services/streamingEncoder.js";
 // ── Media processing ───────────────────────────────────────────────────────────
-export { parseVideoElements, parseImageElements, extractVideoFramesRange, extractAllVideoFrames, isVideoPastTimelineEnd, resolveTimelineExtractionWindow, resolveVideoExtractionWindow, resolveFinalFrameExtractionWindow, resolveVideoExtractionDuration, resolvePlayableVideoDuration, extractionFrameCountForDuration, resolveProjectRelativeSrc, getFrameAtTime, isVideoHiddenBeforeStreamStart, createFrameLookupTable, FrameLookupTable, analyzeClipMediaFit, classifyVideoExtractionError, isVideoSourceExtractionError, runVideoExtractionWithRetry, safeVideoExtractionSourceIdentity, VideoSourceExtractionError, VIDEO_FRAME_FORMATS, isVideoFrameFormat, EXTRACT_CACHE_MIN_AGE_MS, } from "./services/videoFrameExtractor.js";
+export { parseVideoElements, parseImageElements, extractVideoFramesRange, extractAllVideoFrames, isVideoPastTimelineEnd, resolveTimelineExtractionWindow, resolveVideoExtractionWindow, rebaseVideoToWindow, resolveFinalFrameExtractionWindow, resolveVideoExtractionDuration, resolvePlayableVideoDuration, extractionFrameCountForDuration, resolveProjectRelativeSrc, getFrameAtTime, isVideoHiddenBeforeStreamStart, createFrameLookupTable, FrameLookupTable, analyzeClipMediaFit, classifyVideoExtractionError, isVideoSourceExtractionError, runVideoExtractionWithRetry, safeVideoExtractionSourceIdentity, VideoSourceExtractionError, VIDEO_FRAME_FORMATS, isVideoFrameFormat, EXTRACT_CACHE_MIN_AGE_MS, } from "./services/videoFrameExtractor.js";
 export { directorySizeBytes, gcExtractionCache } from "./services/extractionCache.js";
 export { resolveReferencedStart, resolveReferencedDuration, } from "./services/referenceResolver.js";
 export { createVideoFrameInjector } from "./services/videoFrameInjector.js";
@@ -68,7 +68,7 @@ export { appendSoftwareEncoderThreadsArg } from "./services/softwareEncoderThrea
 export { frameSequencePath } from "./services/extractedFrameIndex.js";
 export { assertSwiftShader, readWebGlVendorInfo, SwiftShaderAssertionError, BROWSER_GPU_NOT_SOFTWARE, } from "./utils/assertSwiftShader.js";
 export { readWebGlVendorInfoFromCanvas } from "./utils/readWebGlVendorInfoFromCanvas.js";
-export { extractMediaMetadata, extractVideoMetadata, extractFinalVideoFrameTimestamp, extractAudioMetadata, probeMediaProfile, analyzeKeyframeIntervals, } from "./utils/ffprobe.js";
+export { extractMediaMetadata, extractVideoMetadata, extractFinalVideoFrameTimestamp, extractAudioMetadata, declareContentAddressedUrl, probeMediaProfile, analyzeKeyframeIntervals, } from "./utils/ffprobe.js";
 export { NOT_MEDIA_PAYLOAD, NotMediaPayloadError, assertMediaPayload, fingerprintElementId, isNotMediaPayload, } from "./utils/notMediaPayload.js";
 export { assertPublicHttpsUrl, isBlockedNetworkHost, downloadToTemp, fetchPublicHttpsText, isHttpUrl, safeDownloadUrlIdentity, writeUrlDownloadTelemetry, } from "./utils/urlDownloader.js";
 export { runFfmpeg, formatFfmpegError, describeFfmpegFailure, isExternalFfmpegInterruption, } from "./utils/runFfmpeg.js";

package/dist/services/audioMixer.d.ts

@@ -37,5 +37,6 @@ export declare function processCompositionAudio(elements: AudioElement[], baseDi
     /** Serialised master bus chain, from `parseMasterFxChain`. */
     masterFxChain?: string;
     urlByAbsentLocalPath?: ReadonlyMap<string, string>;
+    audioSidecarUrlByLocalPath?: ReadonlyMap<string, string>;
     keepEncoderInputAt?: string;
 }, compiledDir?: string): Promise<MixResult>;

package/dist/services/audioMixer.js

@@ -133,6 +133,8 @@ function legacyFilterScriptOptionIsUnsupported(stderr) {
  */
 // Caps the ffmpeg runs that prepare clips; all of a long mix's clips at once starved the host (200 clips, 200 ffmpeg).
 const inPrepareSlot = createConcurrencyLimit(Math.max(2, Math.floor(cpus().length / 2)));
+// A clip read from a URL spends its time waiting on the network, so it needs no CPU-sized limit.
+const inRemotePrepareSlot = createConcurrencyLimit(16);
 const MAX_VOLUME_SEGMENTS = 32;
 /**
  * Volume delta below which a keyframe is collinear enough to drop. Kept tight
@@ -428,11 +430,13 @@ export function parseAudioElements(html) {
     const startCache = new Map();
     const visiting = new Set();
     const resolveStart = (el) => el.getAttribute("data-start") ? resolveReferencedStart(document, el, startCache, visiting) : 0;
-    // `end` stays a plain numeric read (the mixer derives the real segment length
-    // from data-duration / natural media downstream); guard NaN so a malformed
-    // value never poisons the mix instead of falling back to 0.
-    const parseEnd = (raw) => {
-        return parseStrictFiniteTimingNumber(raw) ?? 0;
+    // Same rule as core's compileTimingAttrs: data-end, else start + data-duration, else 0 (unknown).
+    const resolveEnd = (el) => {
+        const end = parseStrictFiniteTimingNumber(el.getAttribute("data-end"));
+        if (end != null)
+            return end;
+        const duration = parseStrictFiniteTimingNumber(el.getAttribute("data-duration"));
+        return duration != null && duration > 0 ? resolveStart(el) + duration : 0;
     };
     const isHidden = isSelfOrAncestorHidden;
     // Resolved once per parse. A group element carrying `data-hidden` drops
@@ -454,9 +458,10 @@ export function parseAudioElements(html) {
             id,
             src,
             start: resolveStart(el),
-            end: parseEnd(el.getAttribute("data-end")),
+            end: resolveEnd(el),
             mediaStart: readMediaStart(el),
             playbackRate: readElementRateSpec(el),
+            loop: el.getAttribute("loop") !== null,
             layer: layerAttr ? parseInt(layerAttr) : 0,
             volume: volumeAttr ? parseFloat(volumeAttr) : 1.0,
             ...(fades.fadeIn > 0 ? { fadeIn: fades.fadeIn } : {}),
@@ -503,16 +508,17 @@ export function parseAudioElements(html) {
     return elements;
 }
 const FAIL_ON_READ_ERROR_INSTEAD_OF_ENDING_THERE = ["-xerror"];
+const SIDECAR_WARM_UP_SECONDS = 1;
 /** Decode `duration` s of audio from `mediaStart` in Chrome's media time. Until every stream has
  * started, an input seek snaps audio to the video's first keyframe, so read by timestamp instead. */
-async function extractAudioSegment(srcPath, outputPath, stage, mediaStart, duration, playbackRate = 1, signal, config) {
+async function extractAudioSegment(srcPath, outputPath, stage, mediaStart, duration, playbackRate = 1, signal, config, audioSidecarUrl, options) {
     const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
     const outputDir = dirname(outputPath);
     if (!existsSync(outputDir))
         mkdirSync(outputDir, { recursive: true });
     const normalizedPlaybackRate = normalizeRateSpec(playbackRate);
     const sourceDuration = sourceTimeAt(normalizedPlaybackRate, duration);
-    // A failed local probe keeps FFmpeg's default channel conversion and the input seek; a URL probe
+    // A failed non-looping local probe keeps FFmpeg's channel conversion and input seek; a URL probe
     // is retried once, then fails: a blip must not change how the next, successful read is mixed.
     const readsUrl = isHttpUrl(srcPath);
     const metadata = readsUrl
@@ -521,22 +527,78 @@ async function extractAudioSegment(srcPath, outputPath, stage, mediaStart, durat
                 throw error;
             return extractAudioMetadata(srcPath, { signal });
         })
-        : await extractAudioMetadata(srcPath).catch(() => null);
+        : await extractAudioMetadata(srcPath).catch((error) => {
+            if (options?.loop)
+                throw error;
+            return null;
+        });
+    const loopDuration = (metadata?.durationSeconds ?? 0) - mediaStart;
+    if (options?.loop && loopDuration > 0 && sourceDuration > loopDuration) {
+        const cycleDir = mkdtempSync(join(outputDir, ".audio-loop-"));
+        const cyclePath = join(cycleDir, "cycle.wav");
+        try {
+            const cycle = await extractAudioSegment(srcPath, cyclePath, stage, mediaStart, loopDuration, 1, signal, config, audioSidecarUrl, { padToDuration: true });
+            if (!cycle.success)
+                return { ...cycle, outputPath };
+            const outputArgs = preparedAudioOutputArgs(metadata, normalizedPlaybackRate, duration, null);
+            const result = await runFfmpeg([
+                "-stream_loop",
+                "-1",
+                "-t",
+                String(sourceDuration),
+                "-i",
+                cyclePath,
+                "-vn",
+                "-acodec",
+                "pcm_s16le",
+                "-ar",
+                "48000",
+                ...outputArgs,
+                "-t",
+                String(duration),
+                "-y",
+                outputPath,
+            ], { signal, timeout: ffmpegProcessTimeout });
+            const failure = result.success
+                ? undefined
+                : ffmpegFailure(stage, result, ffmpegProcessTimeout);
+            return {
+                success: result.success,
+                outputPath,
+                durationMs: cycle.durationMs + result.durationMs,
+                error: failure?.detail,
+                failure,
+            };
+        }
+        finally {
+            rmSync(cycleDir, { recursive: true, force: true });
+        }
+    }
     const inputSeek = mediaStart >= (metadata?.latestStreamLeadSeconds ?? 0);
     const start = formatFilterNumber(mediaStart);
     const timestampTrim = inputSeek
         ? null
         : `atrim=start=${start}:end=${formatFilterNumber(mediaStart + sourceDuration)},asetpts=PTS-${start}/TB,aresample=async=1:first_pts=0`;
-    const outputArgs = preparedAudioOutputArgs(metadata, normalizedPlaybackRate, duration, timestampTrim);
+    const fromSidecar = audioSidecarUrl !== undefined && inputSeek && normalizedPlaybackRate === 1;
+    const warmUp = fromSidecar ? Math.min(SIDECAR_WARM_UP_SECONDS, mediaStart) : 0;
+    const outputArgs = preparedAudioOutputArgs(metadata, normalizedPlaybackRate, duration, [
+        warmUp > 0 ? `atrim=start=${warmUp},asetpts=PTS-STARTPTS` : timestampTrim,
+        ...(options?.padToDuration ? ["apad"] : []),
+    ]
+        .filter(Boolean)
+        .join(",") || null);
+    const readFrom = fromSidecar ? audioSidecarUrl : srcPath;
     const args = [
         ...(readsUrl ? FAIL_ON_READ_ERROR_INSTEAD_OF_ENDING_THERE : []),
-        ...urlInputArgs(srcPath),
-        ...(inputSeek ? ["-ss", String(mediaStart), "-t", String(sourceDuration)] : []),
+        ...urlInputArgs(readFrom),
+        ...(inputSeek
+            ? ["-ss", String(mediaStart - warmUp), "-t", String(sourceDuration + warmUp)]
+            : []),
         "-i",
-        srcPath,
+        readFrom,
     ];
     args.push("-vn", "-acodec", "pcm_s16le", "-ar", "48000", ...outputArgs);
-    if (normalizedPlaybackRate !== 1)
+    if (normalizedPlaybackRate !== 1 || options?.padToDuration)
         args.push("-t", String(duration));
     args.push("-y", outputPath);
     const result = await runFfmpeg(args, { signal, timeout: ffmpegProcessTimeout });
@@ -569,6 +631,18 @@ async function extractAudioSegment(srcPath, outputPath, stage, mediaStart, durat
         failure,
     };
 }
+function isRemoteElement(element, baseDir, compiledDir, config) {
+    if (isHttpUrl(element.src))
+        return true;
+    if (!config?.urlByAbsentLocalPath?.size)
+        return false;
+    try {
+        return config.urlByAbsentLocalPath.has(resolveProjectRelativeSrc(element.src, baseDir, compiledDir));
+    }
+    catch {
+        return false;
+    }
+}
 async function generateSilence(outputPath, duration, signal, config) {
     const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
     const outputDir = dirname(outputPath);
@@ -1047,7 +1121,9 @@ export async function processCompositionAudio(elements, baseDir, workDir, output
         else
             signal.addEventListener("abort", () => internalController.abort(), { once: true });
     }
-    await Promise.all(elements.map((element, index) => inPrepareSlot(async () => {
+    await Promise.all(elements.map((element, index) => (isRemoteElement(element, baseDir, compiledDir, config)
+        ? inRemotePrepareSlot
+        : inPrepareSlot)(async () => {
         if (effectiveSignal.aborted) {
             failures.push({
                 stage: "cancelled",
@@ -1062,11 +1138,13 @@ export async function processCompositionAudio(elements, baseDir, workDir, output
         try {
             let srcPath = element.src;
             let readInPlace = false;
+            let audioSidecarUrl;
             if (!isHttpUrl(srcPath)) {
                 // Same browser-URL path semantics as videos.
                 srcPath = resolveProjectRelativeSrc(element.src, baseDir, compiledDir);
                 const remoteUrl = config?.urlByAbsentLocalPath?.get(srcPath);
                 if (remoteUrl) {
+                    audioSidecarUrl = config?.audioSidecarUrlByLocalPath?.get(srcPath);
                     srcPath = remoteUrl;
                     readInPlace = true;
                 }
@@ -1107,6 +1185,7 @@ export async function processCompositionAudio(elements, baseDir, workDir, output
             }
             // Fallback: if no duration was specified, probe the actual file
             if (element.end - element.start <= 0) {
+                console.warn(`[audioMixer] ${element.id} has no data-duration or data-end; its length is unknown, so it plays to the end of its source`);
                 let metadata;
                 try {
                     metadata = await extractAudioMetadata(srcPath, readInPlace ? { signal: effectiveSignal } : undefined);
@@ -1123,7 +1202,7 @@ export async function processCompositionAudio(elements, baseDir, workDir, output
             let audioSrcPath = srcPath;
             if (element.type === "video") {
                 const extractedPath = join(workDir, `${element.id}-extracted.wav`);
-                const extractResult = await extractAudioSegment(srcPath, extractedPath, "extract", element.mediaStart, element.end - element.start, element.playbackRate, effectiveSignal, config);
+                const extractResult = await extractAudioSegment(srcPath, extractedPath, "extract", element.mediaStart, element.end - element.start, element.playbackRate, effectiveSignal, config, audioSidecarUrl, { loop: element.loop });
                 if (!extractResult.success) {
                     failures.push(extractResult.failure
                         ? { ...extractResult.failure, elementId: element.id }
@@ -1141,7 +1220,7 @@ export async function processCompositionAudio(elements, baseDir, workDir, output
             }
             else {
                 const trimmedPath = join(workDir, `${element.id}-trimmed.wav`);
-                const prepResult = await extractAudioSegment(srcPath, trimmedPath, "prepare", element.mediaStart, element.end - element.start, element.playbackRate, effectiveSignal, config);
+                const prepResult = await extractAudioSegment(srcPath, trimmedPath, "prepare", element.mediaStart, element.end - element.start, element.playbackRate, effectiveSignal, config, undefined, { loop: element.loop });
                 if (!prepResult.success) {
                     failures.push(prepResult.failure
                         ? { ...prepResult.failure, elementId: element.id }

package/dist/services/audioMixer.types.d.ts

@@ -11,6 +11,7 @@ export interface AudioElement {
     mediaStart: number;
     /** Normalized source-time multiplier: a constant, or the clip's `rate` lane. */
     playbackRate?: RateSpec;
+    loop?: boolean;
     layer: number;
     volume?: number;
     volumeKeyframes?: AudioVolumeKeyframe[];

package/dist/services/chunkEncoder.js

@@ -214,7 +214,7 @@ export function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = nu
         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/drawElementService.js

@@ -934,6 +934,7 @@ export async function produceDrawElementFrameBatch(page, times, width, height, q
             try {
                 if (aw.__hf && typeof aw.__hf.seek === "function")
                     aw.__hf.seek(t);
+                await aw.__hfWaitForSeekCompletion?.();
                 await aw.__hfDecodeDynamicCssBackgroundImages?.();
                 aw.__hf3d?.update();
                 const accel = (aw.__hf_accel_canvases ?? []).filter((c) => root.contains(c));

package/dist/services/extractionCache.js

@@ -172,7 +172,7 @@ function isTargetExistsRenameError(err) {
  * winner is always correct. Returns null when no winner is present.
  */
 function adoptPublishedWinner(entry, partialDir) {
-    if (!existsSync(join(entry.dir, COMPLETE_SENTINEL)))
+    if (!existsSync(join(entry.dir, COMPLETE_SENTINEL)) || !hasFrameFiles(entry.dir))
         return null;
     removeDir(partialDir);
     return { dir: entry.dir, published: true };

package/dist/services/frameCapture.d.ts

@@ -98,6 +98,7 @@ export interface CaptureSession {
      * our console output.
      */
     pendingTimelineIds?: string[];
+    isolatedCompositions?: IsolatedComposition[];
     /** The render's shared memo when the caller passed one, else this session's own. */
     subTimelineWaitMemo: SubTimelineWaitMemo;
     /** Structured readiness warnings surfaced to the producer's render policy. */
@@ -164,6 +165,12 @@ export interface CaptureSession {
      * drawElement intermittently returns an anomalously small (blank) frame with no
      * throw; a frame far below the running median is re-captured via screenshot. */
     deFrameSizes?: number[];
+    /** Absolute floor of the serial drawElement size guard. Starts at 20000 bytes and drops to
+     * half of a small frame that redraws byte-identically. */
+    deAbsFloor?: number;
+    /** The last small drawElement frame that redrew byte-identically; an equal frame is kept
+     * without a redraw. */
+    deAcceptedSmall?: Buffer;
     /** Last non-deduped encode result, reused for a static frame on the drawElement
      * worker-encode path (mirrors `lastFrameBuffer` on the screenshot path). Only set
      * when static-frame dedup is armed on the drawElement path. */
@@ -404,16 +411,25 @@ export interface HfDiagnostic {
 }
 export declare function buildZeroDurationDiagnostic(diag: HfDiagnostic): string;
 export declare function pollHfReady(page: Page, timeoutMs: number, intervalMs?: number): Promise<void>;
-export declare function waitForSubCompositionTimelines(session: CaptureSession, page: Page, timeoutMs: number): Promise<void>;
+export declare function waitForSubCompositionTimelines(session: CaptureSession, page: Page, timeoutMs: number, options?: {
+    scriptErrorGraceMs?: number;
+}): Promise<void>;
+export interface IsolatedComposition {
+    compositionId: string;
+    elementId: string | null;
+}
 export interface SubTimelinePollOptions {
     intervalMs?: number;
     getScriptLoadFailures?: () => readonly string[];
     scriptFailureGraceMs?: number;
+    getPageErrors?: () => readonly string[];
+    scriptErrorGraceMs?: number;
     onPending?: (ids: readonly string[]) => void;
     shouldStop?: () => boolean;
     knownUnregisteredIds?: readonly string[];
 }
-export declare function pollSubCompositionTimelines(page: Page, timeoutMs: number, { intervalMs, getScriptLoadFailures, scriptFailureGraceMs, onPending, shouldStop, knownUnregisteredIds, }?: SubTimelinePollOptions): Promise<SubTimelineWaitOutcome>;
+export declare function pollSubCompositionTimelines(page: Page, timeoutMs: number, { intervalMs, getScriptLoadFailures, scriptFailureGraceMs, getPageErrors, scriptErrorGraceMs, onPending, shouldStop, knownUnregisteredIds, }?: SubTimelinePollOptions): Promise<SubTimelineWaitOutcome>;
+export declare function pollVideosReady(page: Page, skipIds: readonly string[], timeoutMs: number, intervalMs?: number): Promise<boolean>;
 /** @internal exported for unit testing only */
 export declare function pollImagesReady(page: Page, timeoutMs: number, intervalMs?: number): Promise<boolean>;
 export declare function waitForImagesReady(page: Page, timeoutMs: number, onUnloaded: (sources: string) => void): Promise<boolean>;

package/dist/services/frameCapture.js

@@ -1202,16 +1202,61 @@ async function listUnregisteredTimelineIds(page) {
     // Builds a warning, so it must never throw: normalise a loosely typed result.
     return Array.isArray(evaluated) ? evaluated.map((id) => String(id)) : [];
 }
-export async function waitForSubCompositionTimelines(session, page, timeoutMs) {
+function isScriptFailure(session) {
+    const outcome = session.subTimelineWaitOutcome;
+    return outcome === "script_failure" || (outcome === "timeout" && session.pageErrors.length > 0);
+}
+/** A nested composition whose script threw gets an empty timeline, but only while another nested timeline is live. */
+async function isolateUnregisteredCompositions(page) {
+    const isolated = await page.evaluate(`(function() {
+    var timelines = (window.__timelines = window.__timelines || {});
+    var out = [];
+    if (!window.gsap) return out;
+    var broken = [];
+    var live = 0;
+    var hosts = document.querySelectorAll("[data-composition-id]");
+    for (var i = 0; i < hosts.length; i++) {
+      var host = hosts[i];
+      var id = host.getAttribute("data-composition-id");
+      if (!id || host.hasAttribute("data-no-timeline")) continue;
+      var isRoot = !host.parentElement || !host.parentElement.closest("[data-composition-id]");
+      if (timelines[id]) {
+        if (!isRoot) live++;
+      } else if (isRoot) {
+        return out;
+      } else {
+        broken.push(host);
+      }
+    }
+    if (live === 0) return out;
+    broken.forEach(function(host) {
+      var tl = window.gsap.timeline({ paused: true });
+      var duration = parseFloat(host.getAttribute("data-duration"));
+      if (duration > 0) tl.set({}, {}, duration);
+      var id = host.getAttribute("data-composition-id");
+      timelines[id] = tl;
+      out.push({ compositionId: id, elementId: host.id || host.getAttribute("data-hf-id") || null });
+    });
+    if (out.length && typeof window.__hfForceTimelineRebind === "function") window.__hfForceTimelineRebind();
+    return out;
+  })()`);
+    return Array.isArray(isolated) ? isolated : [];
+}
+export async function waitForSubCompositionTimelines(session, page, timeoutMs, options = {}) {
     const memo = session.subTimelineWaitMemo;
     session.subTimelineWaitOutcome = await pollSubCompositionTimelines(page, timeoutMs, {
         getScriptLoadFailures: () => session.scriptLoadFailures,
+        getPageErrors: () => session.pageErrors,
+        scriptErrorGraceMs: options.scriptErrorGraceMs,
         onPending: (ids) => {
             session.pendingTimelineIds = [...ids];
         },
         shouldStop: () => session.vfxFailure !== undefined,
         knownUnregisteredIds: memo.unregisteredIds,
     });
+    if (isScriptFailure(session) && session.scriptLoadFailures.length === 0) {
+        session.isolatedCompositions = await isolateUnregisteredCompositions(page);
+    }
     // Only a clean full-length timeout is replayed: a VFX stop ends early, and page or script
     // errors must reach each session so it can still classify the wait as a script failure.
     const cleanTimeout = session.subTimelineWaitOutcome === "timeout" &&
@@ -1222,7 +1267,7 @@ export async function waitForSubCompositionTimelines(session, page, timeoutMs) {
         memo.unregisteredIds = session.pendingTimelineIds ?? [];
     }
 }
-export async function pollSubCompositionTimelines(page, timeoutMs, { intervalMs = 150, getScriptLoadFailures, scriptFailureGraceMs = 2_000, onPending, shouldStop, knownUnregisteredIds = [], } = {}) {
+export async function pollSubCompositionTimelines(page, timeoutMs, { intervalMs = 150, getScriptLoadFailures, scriptFailureGraceMs = 2_000, getPageErrors, scriptErrorGraceMs = 5_000, onPending, shouldStop, knownUnregisteredIds = [], } = {}) {
     // Hosts may opt out of the timeline wait with `data-no-timeline` —
     // compositions driven purely by CSS animations / rAF (the render-compat
     // contract) never register window.__timelines[id], and without the opt-out
@@ -1244,6 +1289,8 @@ export async function pollSubCompositionTimelines(page, timeoutMs, { intervalMs
     const deadline = start + timeoutMs;
     let ready = false;
     let scriptFailureBail = false;
+    // A page error is given its grace from when it first appeared, not from when the poll began.
+    let errorSeenAt;
     for (;;) {
         ready = Boolean(await page.evaluate(expression));
         if (ready || shouldStop?.())
@@ -1252,12 +1299,18 @@ export async function pollSubCompositionTimelines(page, timeoutMs, { intervalMs
         if (now >= deadline)
             break;
         const failures = getScriptLoadFailures?.() ?? [];
-        if (failures.length > 0 && now - start >= scriptFailureGraceMs) {
+        const errors = getPageErrors?.() ?? [];
+        const failed = failures.length > 0 ? failures : errors;
+        const graceMs = failures.length > 0 ? scriptFailureGraceMs : scriptErrorGraceMs;
+        if (failed.length > 0)
+            errorSeenAt ??= now;
+        const sinceFailure = failures.length > 0 ? now - start : now - (errorSeenAt ?? now);
+        if (failed.length > 0 && sinceFailure >= graceMs) {
             scriptFailureBail = true;
             console.warn(`[FrameCapture] Sub-composition timeline wait cut short after ${now - start}ms: ` +
-                `script resource(s) failed to load (${failures.join(", ")}), so ` +
+                `script(s) failed (${failed.join(", ")}), so ` +
                 `the timeline registration they carry can never arrive. ` +
-                `Fix the script reference; the render proceeds without those animations.`);
+                `Fix the script.`);
             break;
         }
         await new Promise((resolve) => setTimeout(resolve, intervalMs));
@@ -1294,11 +1347,13 @@ export async function pollSubCompositionTimelines(page, timeoutMs, { intervalMs
     }
     return scriptFailureBail ? "script_failure" : "timeout";
 }
-async function pollVideosReady(page, skipIds, timeoutMs, intervalMs = 100) {
+export async function pollVideosReady(page, skipIds, timeoutMs, intervalMs = 100) {
     const check = async () => {
         return Boolean(await page.evaluate((skipIdList) => {
             const skip = new Set(skipIdList);
-            const vids = Array.from(document.querySelectorAll("video")).filter((v) => !skip.has(v.id));
+            const vids = Array.from(document.querySelectorAll("video"))
+                .filter((v) => !skip.has(v.id))
+                .filter((v) => !v.closest("[data-hidden]"));
             return (vids.length === 0 ||
                 vids.every((v) => {
                     const ve = v;
@@ -1449,16 +1504,33 @@ export function recordSubTimelineWarning(session, timeoutMs) {
     const outcome = session.subTimelineWaitOutcome;
     if (outcome === "ready" || !outcome)
         return;
-    const threwThenTimedOut = outcome === "timeout" && session.pageErrors.length > 0;
-    const scriptFailure = outcome === "script_failure" || threwThenTimedOut;
+    const threwThenTimedOut = session.pageErrors.length > 0 && session.scriptLoadFailures.length === 0;
+    const scriptFailure = isScriptFailure(session);
     const sources = [...session.scriptLoadFailures, ...session.pageErrors];
     const pending = session.pendingTimelineIds ?? [];
     const pendingSuffix = pending.length > 0 ? ` (still unregistered: ${pending.join(", ")})` : "";
+    const isolated = session.isolatedCompositions ?? [];
+    if (isolated.length > 0) {
+        recordCaptureWarnings(session, [
+            {
+                code: "script_error_isolated",
+                message: `A composition script failed, so its animation was skipped and the render went on: ` +
+                    `${isolated.map((c) => c.elementId ?? c.compositionId).join(", ")} (${sources.join(", ")}).`,
+                details: {
+                    sources,
+                    pendingCompositionIds: [...pending],
+                    isolatedElements: isolated,
+                    failureOwner: "user",
+                },
+            },
+        ]);
+        return;
+    }
     recordCaptureWarnings(session, [
         {
             code: scriptFailure ? "sub_timeline_script_failure" : "sub_timeline_readiness_timeout",
             message: threwThenTimedOut
-                ? `A composition script threw and a timeline did not register within ${timeoutMs}ms` +
+                ? `A composition script threw before its timeline registered` +
                     `${pendingSuffix} (${sources.join(", ")}). Fix the error; a composition animated by ` +
                     `CSS or rAF rather than a GSAP timeline must mark its host with data-no-timeline.`
                 : scriptFailure
@@ -1802,6 +1874,7 @@ export async function initializeSession(session) {
                 const skip = new Set(skipIdList);
                 return Array.from(document.querySelectorAll("video"))
                     .filter((v) => !skip.has(v.id))
+                    .filter((v) => !v.closest("[data-hidden]"))
                     .filter((v) => v.readyState < 2 && !v.error)
                     .map((v) => v.src || v.getAttribute("src") || "(no src)")
                     .join(", ");
@@ -1914,6 +1987,7 @@ export async function initializeSession(session) {
                 const skip = new Set(skipIdList);
                 return Array.from(document.querySelectorAll("video"))
                     .filter((v) => !skip.has(v.id))
+                    .filter((v) => !v.closest("[data-hidden]"))
                     .filter((v) => v.readyState < 2 && !v.error)
                     .map((v) => v.src || v.getAttribute("src") || "(no src)")
                     .join(", ");
@@ -2925,6 +2999,50 @@ export function resolveSessionMotionBlur(session) {
     }
     return plan;
 }
+/**
+ * Size guard for a serial drawElement frame. A frame far below the rolling median may be a
+ * dropped paint record, which is intermittent, so the frame is drawn once more: a byte-identical
+ * redraw is real content (a flat or dark frame) and is kept, as the streaming drain guard in the
+ * producer keeps it. Segmented capture reaches only this guard, so it must judge a small frame
+ * the same way, or a render that passes in one pass fails when segmented (GH #5685). A redraw
+ * that differs and is still small throws, and the caller restarts on a fresh screenshot page.
+ */
+async function judgeSmallDrawElementFrame(session, frameIndex, buffer, redraw) {
+    const sizes = (session.deFrameSizes ??= []);
+    const sorted = sizes.length >= 12 ? [...sizes].sort((a, b) => a - b) : null;
+    const median = sorted ? (sorted[sorted.length >> 1] ?? 0) : 0;
+    const floor = Math.max(session.deAbsFloor ?? 20000, median * 0.12);
+    let kept = buffer;
+    if (buffer.length < floor && !session.deAcceptedSmall?.equals(buffer)) {
+        const suspect = () => new DrawElementCaptureError(frameIndex, `suspect small frame (${buffer.length}B < ${Math.round(floor)}B)`);
+        // Under BeginFrame control the page paints only on the frame already sent for this index,
+        // so a second draw reads the same snapshot and cannot tell a drop from real content.
+        if (session.beginFrameTimeTicks > 0)
+            throw suspect();
+        const retry = await redraw();
+        if (retry.equals(buffer)) {
+            // Halving the floor keeps a run of similar flat frames from redrawing every frame.
+            session.deAbsFloor = Math.min(session.deAbsFloor ?? 20000, Math.floor(buffer.length / 2));
+            session.deAcceptedSmall = buffer;
+        }
+        else if (retry.length < floor) {
+            throw suspect();
+        }
+        else {
+            kept = retry;
+        }
+    }
+    if (sizes.length >= 60)
+        sizes.shift();
+    sizes.push(kept.length);
+    return kept;
+}
+/** Seek to `time` again and draw the frame once more, for {@link judgeSmallDrawElementFrame}. */
+async function redrawDrawElementFrame(session, frameIndex, time, seekOptions, heldVideoTime) {
+    const { page, options } = session;
+    await prepareFrameForCapture(session, frameIndex, time, seekOptions, heldVideoTime);
+    return captureDrawElementFrame(page, options.width, options.height, options.format ?? "jpeg", options.quality ?? 80, true);
+}
 /** Seek to `time` and capture one surface with the session's capture mode. */
 async function captureFrameSurface(session, frameIndex, time, seekOptions, heldVideoTime) {
     const { page, options } = session;
@@ -2976,20 +3094,8 @@ async function captureFrameSurface(session, frameIndex, time, seekOptions, heldV
             session.beginFrameTimeTicks === 0);
             // A tiny JPEG may be a dropped paint record. Never screenshot this page:
             // its injected canvas can still hold the preceding frame's bitmap.
-            // Restart on a fresh screenshot page even if this was a simple valid frame.
             if ((options.format ?? "jpeg") !== "png" && process.env.HF_FORCE_DRAWELEMENT !== "1") {
-                const sizes = (session.deFrameSizes ??= []);
-                const sorted = sizes.length >= 12 ? [...sizes].sort((a, b) => a - b) : null;
-                const median = sorted ? (sorted[sorted.length >> 1] ?? 0) : 0;
-                const floor = Math.max(20000, median * 0.12);
-                if (screenshotBuffer.length < floor) {
-                    throw new DrawElementCaptureError(frameIndex, `suspect small frame (${screenshotBuffer.length}B < ${Math.round(floor)}B)`);
-                }
-                else {
-                    if (sizes.length >= 60)
-                        sizes.shift();
-                    sizes.push(screenshotBuffer.length);
-                }
+                screenshotBuffer = await judgeSmallDrawElementFrame(session, frameIndex, screenshotBuffer, () => redrawDrawElementFrame(session, frameIndex, time, seekOptions, heldVideoTime));
             }
         }
         catch (err) {

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/types.d.ts

@@ -22,7 +22,7 @@ export type SubTimelineWaitOutcome = "ready" | "timeout" | "script_failure";
 export interface SubTimelineWaitMemo {
     unregisteredIds?: readonly string[];
 }
-export type CaptureWarningCode = "media_readiness_timeout" | "media_load_failed" | "audio_processing_failed" | "sub_timeline_readiness_timeout" | "sub_timeline_script_failure" | "vfx_failure" | "live_map_detected";
+export type CaptureWarningCode = "media_readiness_timeout" | "media_load_failed" | "audio_processing_failed" | "sub_timeline_readiness_timeout" | "sub_timeline_script_failure" | "script_error_isolated" | "vfx_failure" | "live_map_detected";
 /** Structured correctness warning produced while preparing a capture session. */
 export interface CaptureWarning {
     code: CaptureWarningCode;
@@ -31,6 +31,10 @@ export interface CaptureWarning {
         mediaType?: "image" | "video" | "audio";
         sources?: string[];
         pendingCompositionIds?: string[];
+        isolatedElements?: Array<{
+            compositionId: string;
+            elementId: string | null;
+        }>;
         timeoutMs?: number;
         audioFailures?: AudioFailureDiagnostic[];
         failureReasons?: string[];

package/dist/utils/ffprobe.d.ts

@@ -51,6 +51,8 @@ export interface AudioMetadata {
     bitrate?: number;
     /** Seconds after the file's media time 0 at which its last audio or video stream starts. */
     latestStreamLeadSeconds?: number;
+    audioStreamLeadSeconds?: number;
+    audioStreamCount?: number;
 }
 interface FFProbeStream {
     codec_type: string;
@@ -98,6 +100,8 @@ 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;
 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;

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,17 @@ 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);
+}
 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(":");
@@ -740,47 +751,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),
-        };
-    })();
-    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 ?? [])
@@ -858,8 +875,7 @@ async function probeDecodedAudioDuration(filePath, sampleRate, startSeconds, con
     return lastFrame.timestamp + lastFrame.nbSamples / sampleRate - startSeconds;
 }
 const keyframeCache = new Map();
-/** Intervals beyond this cause seeking issues in the headless renderer and
- *  audio/video desync — the sole threshold for `isProblematic` below. */
+/** Advisory threshold for seeking cost; GOP length alone does not establish incorrect output. */
 const PROBLEMATIC_KEYFRAME_INTERVAL_SECONDS = 2;
 /**
  * Checks keyframe intervals in a video stream; intervals over the threshold below flag `isProblematic`.

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperframes/engine",
-  "version": "0.8.190",
+  "version": "0.8.192",
   "description": "Seekable web page to video rendering engine (Puppeteer + FFmpeg)",
   "repository": {
     "type": "git",
@@ -50,8 +50,8 @@
     "linkedom": "^0.18.12",
     "puppeteer": "^25.8.0",
     "puppeteer-core": "^25.8.0",
-    "@hyperframes/core": "^0.8.190",
-    "@hyperframes/parsers": "^0.8.190"
+    "@hyperframes/core": "^0.8.192",
+    "@hyperframes/parsers": "^0.8.192"
   },
   "devDependencies": {
     "@types/node": "^25.0.10",