@hyperframes/engine 0.8.223 → 0.8.225

package/dist/index.d.ts

@@ -47,7 +47,7 @@ export { beginFrameCapture, pageScreenshotCapture, getCdpSession, injectVideoFra
 export { buildEncoderArgs, encodeFramesFromDir, buildConcatArgs, concatVideoFiles, encodeFramesChunkedConcat, muxVideoWithAudio, applyFaststart, packageHls, detectGpuEncoder, getCachedGpuEncoder, ENCODER_PRESETS, getEncoderPreset, PRORES_PROFILES, PRORES_PROFILE_NAMES, isProresProfile, type ProresProfile, appendRateCapArgs, keyframeIntervalToGopSize, 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, rebaseVideoToWindow, resolveFinalFrameExtractionWindow, resolveFrameFormat, resolveVideoExtractionDuration, resolvePlayableVideoDuration, videoStartOnMediaTimeline, ffmpegSeekSeconds, 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, sdrCanvasColourFilters, } from "./services/videoFrameExtractor.js";
+export { parseVideoElements, hasGradedCanvas, parseImageElements, extractVideoFramesRange, extractAllVideoFrames, isVideoPastTimelineEnd, resolveTimelineExtractionWindow, resolveVideoExtractionWindow, rebaseVideoToWindow, resolveFinalFrameExtractionWindow, resolveFrameFormat, resolveVideoExtractionDuration, resolvePlayableVideoDuration, videoStartOnMediaTimeline, ffmpegSeekSeconds, 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, sdrCanvasColourFilters, } from "./services/videoFrameExtractor.js";
 export { isSelfOrAncestorHidden } from "./services/mediaHidden.js";
 export { directorySizeBytes, gcExtractionCache } from "./services/extractionCache.js";
 export { resolveReferencedStart, resolveReferencedDuration, type RefResolverEl, type RefResolverDoc, } from "./services/referenceResolver.js";
@@ -86,7 +86,7 @@ export { type TransitionFn, TRANSITIONS, crossfade, sampleRgb48le, hdrToLinear,
 export { initHdrReadback, uploadAndReadbackHdrFrame, float16ToPqRgb, buildHdrChromeArgs, launchHdrBrowser, } from "./services/hdrCapture.js";
 export { captureScreenshotWithAlpha } from "./services/screenshotService.js";
 export { hideVideoElements, showVideoElements, queryVideoElementBounds, queryElementStacking, measureVideoShownBoxes, type ShownBox, type VideoElementBounds, type ElementStackingInfo, } from "./services/videoFrameInjector.js";
-export { isHdrColorSpace, detectTransfer, getHdrEncoderColorParams, analyzeCompositionHdr, findHdrAutoPromotion, formatHdrAutoPromotionWarning, sanitizeHdrAutoPromotionAsset, DEFAULT_HDR10_MASTERING, HDR_AUTO_PROMOTION_PIPELINE, type HdrTransfer, type HdrEncoderColorParams, type HdrAutoPromotion, type CompositionHdrInfo, type HdrMasteringMetadata, } from "./utils/hdr.js";
+export { isHdrColorSpace, detectTransfer, getHdrEncoderColorParams, analyzeCompositionHdr, findHdrAutoPromotion, gradingKeepsSdr, formatHdrAutoPromotionWarning, sanitizeHdrAutoPromotionAsset, DEFAULT_HDR10_MASTERING, HDR_AUTO_PROMOTION_PIPELINE, type HdrTransfer, type HdrEncoderColorParams, type HdrAutoPromotion, type CompositionHdrInfo, type HdrMasteringMetadata, } from "./utils/hdr.js";
 export type { VideoColorSpace } from "./utils/ffprobe.js";
 export { renderProvenanceArgs, appendRenderProvenanceArgs, readRenderProvenance, PROVENANCE_RENDERER_TAG, PROVENANCE_VERSION_TAG, PROVENANCE_RENDERER_NAME, PROVENANCE_VERSION, type RenderProvenance, } from "./utils/renderProvenance.js";
 export { DrawElementCaptureError, isDrawElementCaptureError, } from "./services/drawElementCaptureError.js";

package/dist/index.js

@@ -51,7 +51,7 @@ export { beginFrameCapture, pageScreenshotCapture, getCdpSession, injectVideoFra
 export { buildEncoderArgs, encodeFramesFromDir, buildConcatArgs, concatVideoFiles, encodeFramesChunkedConcat, muxVideoWithAudio, applyFaststart, packageHls, detectGpuEncoder, getCachedGpuEncoder, ENCODER_PRESETS, getEncoderPreset, PRORES_PROFILES, PRORES_PROFILE_NAMES, isProresProfile, appendRateCapArgs, keyframeIntervalToGopSize, 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, rebaseVideoToWindow, resolveFinalFrameExtractionWindow, resolveFrameFormat, resolveVideoExtractionDuration, resolvePlayableVideoDuration, videoStartOnMediaTimeline, ffmpegSeekSeconds, extractionFrameCountForDuration, resolveProjectRelativeSrc, getFrameAtTime, isVideoHiddenBeforeStreamStart, createFrameLookupTable, FrameLookupTable, analyzeClipMediaFit, classifyVideoExtractionError, isVideoSourceExtractionError, runVideoExtractionWithRetry, safeVideoExtractionSourceIdentity, VideoSourceExtractionError, VIDEO_FRAME_FORMATS, isVideoFrameFormat, EXTRACT_CACHE_MIN_AGE_MS, sdrCanvasColourFilters, } from "./services/videoFrameExtractor.js";
+export { parseVideoElements, hasGradedCanvas, parseImageElements, extractVideoFramesRange, extractAllVideoFrames, isVideoPastTimelineEnd, resolveTimelineExtractionWindow, resolveVideoExtractionWindow, rebaseVideoToWindow, resolveFinalFrameExtractionWindow, resolveFrameFormat, resolveVideoExtractionDuration, resolvePlayableVideoDuration, videoStartOnMediaTimeline, ffmpegSeekSeconds, extractionFrameCountForDuration, resolveProjectRelativeSrc, getFrameAtTime, isVideoHiddenBeforeStreamStart, createFrameLookupTable, FrameLookupTable, analyzeClipMediaFit, classifyVideoExtractionError, isVideoSourceExtractionError, runVideoExtractionWithRetry, safeVideoExtractionSourceIdentity, VideoSourceExtractionError, VIDEO_FRAME_FORMATS, isVideoFrameFormat, EXTRACT_CACHE_MIN_AGE_MS, sdrCanvasColourFilters, } from "./services/videoFrameExtractor.js";
 export { isSelfOrAncestorHidden } from "./services/mediaHidden.js";
 export { directorySizeBytes, gcExtractionCache } from "./services/extractionCache.js";
 export { resolveReferencedStart, resolveReferencedDuration, } from "./services/referenceResolver.js";
@@ -93,7 +93,7 @@ export { TRANSITIONS, crossfade, sampleRgb48le, hdrToLinear, linearToHdr, conver
 export { initHdrReadback, uploadAndReadbackHdrFrame, float16ToPqRgb, buildHdrChromeArgs, launchHdrBrowser, } from "./services/hdrCapture.js";
 export { captureScreenshotWithAlpha } from "./services/screenshotService.js";
 export { hideVideoElements, showVideoElements, queryVideoElementBounds, queryElementStacking, measureVideoShownBoxes, } from "./services/videoFrameInjector.js";
-export { isHdrColorSpace, detectTransfer, getHdrEncoderColorParams, analyzeCompositionHdr, findHdrAutoPromotion, formatHdrAutoPromotionWarning, sanitizeHdrAutoPromotionAsset, DEFAULT_HDR10_MASTERING, HDR_AUTO_PROMOTION_PIPELINE, } from "./utils/hdr.js";
+export { isHdrColorSpace, detectTransfer, getHdrEncoderColorParams, analyzeCompositionHdr, findHdrAutoPromotion, gradingKeepsSdr, formatHdrAutoPromotionWarning, sanitizeHdrAutoPromotionAsset, DEFAULT_HDR10_MASTERING, HDR_AUTO_PROMOTION_PIPELINE, } from "./utils/hdr.js";
 export { renderProvenanceArgs, appendRenderProvenanceArgs, readRenderProvenance, PROVENANCE_RENDERER_TAG, PROVENANCE_VERSION_TAG, PROVENANCE_RENDERER_NAME, PROVENANCE_VERSION, } from "./utils/renderProvenance.js";
 export { DrawElementCaptureError, isDrawElementCaptureError, } from "./services/drawElementCaptureError.js";
 export { inAgentSandbox, isOneProcessOverPipe, machServiceDenied, oneProcessOverPipe, pipeLaunchClosedOnMac, sandboxDeniedRemediation, } from "./services/sandboxLaunch.js";

package/dist/services/audioMixer.js

@@ -5,7 +5,7 @@ import { renameWithRetry } from "@hyperframes/core/rename-retry";
 import { removeScratch } from "@hyperframes/core/remove-scratch";
 import { join, dirname, isAbsolute, relative } from "path";
 import { parseHTML } from "linkedom";
-import { extractAudioMetadata, ffmpegSeekSeconds } from "../utils/ffprobe.js";
+import { extractAudioMetadata, ffmpegSeekSeconds, formatFfmpegSeconds, } from "../utils/ffprobe.js";
 import { isNotMediaPayload } from "../utils/notMediaPayload.js";
 import { urlInputArgs } from "../utils/urlInput.js";
 import { clampAudioGain, clipGain } from "@hyperframes/core/audio-gain";
@@ -550,7 +550,7 @@ async function extractAudioSegment(srcPath, outputPath, stage, mediaStart, durat
                 "-stream_loop",
                 "-1",
                 "-t",
-                String(sourceDuration),
+                formatFfmpegSeconds(sourceDuration),
                 "-i",
                 cyclePath,
                 "-vn",
@@ -560,7 +560,7 @@ async function extractAudioSegment(srcPath, outputPath, stage, mediaStart, durat
                 "48000",
                 ...outputArgs,
                 "-t",
-                String(duration),
+                formatFfmpegSeconds(duration),
                 "-y",
                 outputPath,
             ], { signal, timeout: ffmpegProcessTimeout });
@@ -598,14 +598,19 @@ async function extractAudioSegment(srcPath, outputPath, stage, mediaStart, durat
         ...(readsUrl ? FAIL_ON_READ_ERROR_INSTEAD_OF_ENDING_THERE : []),
         ...urlInputArgs(readFrom),
         ...(inputSeek
-            ? ["-ss", String(ffmpegStart - warmUp), "-t", String(sourceDuration + warmUp)]
+            ? [
+                "-ss",
+                formatFfmpegSeconds(ffmpegStart - warmUp),
+                "-t",
+                formatFfmpegSeconds(sourceDuration + warmUp),
+            ]
             : []),
         "-i",
         readFrom,
     ];
     args.push("-vn", "-acodec", "pcm_s16le", "-ar", "48000", ...outputArgs);
     if (normalizedPlaybackRate !== 1 || options?.padToDuration)
-        args.push("-t", String(duration));
+        args.push("-t", formatFfmpegSeconds(duration));
     args.push("-y", outputPath);
     const result = await runFfmpeg(args, { signal, timeout: ffmpegProcessTimeout });
     if (signal?.aborted) {
@@ -660,7 +665,7 @@ async function generateSilence(outputPath, duration, signal, config) {
         "-i",
         "anullsrc=r=48000:cl=stereo",
         "-t",
-        String(duration),
+        formatFfmpegSeconds(duration),
         "-acodec",
         "pcm_s16le",
         "-y",
@@ -761,7 +766,7 @@ async function mixAudioTracksFlat(tracks, outputPath, totalDuration, signal, con
             "-ar",
             "48000",
             "-t",
-            String(totalDuration),
+            formatFfmpegSeconds(totalDuration),
             "-y",
             outputPath,
         ];
@@ -923,7 +928,7 @@ async function mixGroupMembersFlat(memberTracks, outputPath, totalDuration, sign
                 "-ar",
                 "48000",
                 "-t",
-                String(totalDuration),
+                formatFfmpegSeconds(totalDuration),
                 "-y",
                 outputPath,
             ];

package/dist/services/videoFrameExtractor.d.ts

@@ -21,6 +21,7 @@ export interface VideoElement {
     loop: boolean;
     hasAudio: boolean;
     hidden?: boolean;
+    graded?: boolean;
 }
 export interface ExtractedFrames {
     videoId: string;
@@ -263,7 +264,9 @@ export interface ImageElement {
     src: string;
     start: number;
     end: number;
+    graded?: boolean;
 }
+export declare function hasGradedCanvas(html: string): boolean;
 export declare function parseImageElements(html: string): ImageElement[];
 export declare function sdrCanvasColourFilters(metadata: VideoMetadata, toneMappedToSdr?: boolean): string[];
 export declare function extractVideoFramesRange(...args: Parameters<typeof extractVideoFramesRangeUnredacted>): Promise<ExtractedFrames>;
@@ -310,6 +313,7 @@ export interface TimelineExtractionWindow {
 }
 type TimelineWindowVideo = Pick<VideoElement, "start" | "end" | "mediaStart"> & Partial<Pick<VideoElement, "playbackRate">> & Partial<Pick<VideoElement, "loop">>;
 export declare function isVideoPastTimelineEnd(video: Pick<VideoElement, "start">, timelineEnd: number): boolean;
+export declare function alignClipStartToFirstOutputFrame(video: VideoElement, fps: number): void;
 /** Move a clip to its extraction window; a rate lane is shifted so it keeps integrating from the new origin. */
 export declare function rebaseVideoToWindow(video: VideoElement, window: TimelineExtractionWindow): void;
 /**

package/dist/services/videoFrameExtractor.js

@@ -11,13 +11,14 @@ import { basename, join } from "path";
 import { cpus } from "os";
 import { createConcurrencyLimit } from "../utils/concurrencyLimit.js";
 import { parseHTML } from "linkedom";
+import { HF_COLOR_GRADING_ATTR } from "@hyperframes/core";
 import { isPathInside } from "@hyperframes/parsers/asset-paths";
 import { resolveProjectRelativeSrc } from "@hyperframes/parsers/asset-resolution";
 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, mediaElementTime, parseStrictFiniteTimingNumber, readMediaStart, toFps, firstFrameColourArgs, hdrToSdrToneMapFilter, parseFirstFrameColour, } from "@hyperframes/core";
 import { resolveReferencedStart } from "./referenceResolver.js";
 import { isKnownInactiveTimelineWindow } from "./mediaTimelineWindow.js";
-import { extractFinalVideoFrameTimestamp, extractMediaMetadata, ffmpegSeekSeconds, keyframeGapSeconds, mediaFileIdentity, readMetadataCache, readStoredFinalFrame, resolvePlayableVideoDuration, videoStartOnMediaTimeline, writeMetadataCache, } from "../utils/ffprobe.js";
+import { extractFinalVideoFrameTimestamp, extractMediaMetadata, ffmpegSeekSeconds, formatFfmpegSeconds, keyframeGapSeconds, mediaFileIdentity, readMetadataCache, readStoredFinalFrame, resolvePlayableVideoDuration, videoStartOnMediaTimeline, 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";
@@ -427,10 +428,15 @@ export function parseVideoElements(html) {
                 (isAudibleVideoElement(el) && isMemberGroupHidden(groupsById, el))
                 ? { hidden: true }
                 : {}),
+            ...(el.hasAttribute(HF_COLOR_GRADING_ATTR) ? { graded: true } : {}),
         });
     }
     return videos;
 }
+export function hasGradedCanvas(html) {
+    return (parseHTML(unwrapTemplate(html)).document.querySelector(`canvas[${HF_COLOR_GRADING_ATTR}]`) !==
+        null);
+}
 export function parseImageElements(html) {
     const images = [];
     const { document } = parseHTML(unwrapTemplate(html));
@@ -465,7 +471,13 @@ export function parseImageElements(html) {
         else {
             end = Infinity;
         }
-        images.push({ id, src, start, end });
+        images.push({
+            id,
+            src,
+            start,
+            end,
+            ...(el.hasAttribute(HF_COLOR_GRADING_ATTR) ? { graded: true } : {}),
+        });
     }
     return images;
 }
@@ -581,12 +593,12 @@ async function runSegmentedExtraction(job) {
                 ...decodeArgs,
                 "-noaccurate_seek",
                 "-ss",
-                String(job.ffmpegSeek(seek)),
+                formatFfmpegSeconds(job.ffmpegSeek(seek)),
                 "-i",
                 videoPath,
                 // Read one frame past the segment and keep exactly its own frames.
                 "-t",
-                String((frames + 1) / fps),
+                formatFfmpegSeconds((frames + 1) / fps),
                 "-frames:v",
                 String(frames),
                 "-start_number",
@@ -697,13 +709,13 @@ outputDirOverride) {
         // sample. This is intentionally reserved for the one-frame path: input
         // seeking is faster, but valid unindexed transports (notably MPEG-TS with
         // a negative timestamp base) can seek to EOF and emit zero frames.
-        args.push("-i", videoPath, "-ss", String(Math.max(0, ffmpegSeek(startTime))), "-frames:v", "1");
+        args.push("-i", videoPath, "-ss", formatFfmpegSeconds(Math.max(0, ffmpegSeek(startTime))), "-frames:v", "1");
     }
     else {
         // An accurate seek drops the frame on screen at startTime; the fps sampling below needs it.
         if (sampleAtOutputFps)
             args.push("-noaccurate_seek");
-        args.push("-ss", String(ffmpegSeek(startTime)), "-i", videoPath, "-t", String(duration));
+        args.push("-ss", formatFfmpegSeconds(ffmpegSeek(startTime)), "-i", videoPath, "-t", formatFfmpegSeconds(duration));
     }
     const vfFilters = [];
     if (keepsHdrForChrome) {
@@ -905,14 +917,17 @@ const FINAL_FRAME_LOGICAL_DURATION_SECONDS = 1e-6;
 export function isVideoPastTimelineEnd(video, timelineEnd) {
     return video.start >= timelineEnd;
 }
-function alignClipStartToFirstOutputFrame(video, fps) {
+export function alignClipStartToFirstOutputFrame(video, fps) {
     if (video.loop || !Number.isFinite(video.start) || video.start < 0 || !(fps > 0))
         return;
     const position = exportClipWindow(video.start, Infinity, fps).start * fps;
     const firstFrame = Math.abs(position - Math.round(position)) < 1e-6 ? Math.round(position) : Math.ceil(position);
     const shift = firstFrame / fps - video.start;
-    if (shift === 0)
+    // Float dust (a sum landing a hair off the grid) snaps the start; it never reaches mediaStart.
+    if (Math.abs(shift) < 1e-9) {
+        video.start = firstFrame / fps;
         return;
+    }
     const playbackRate = normalizeRateSpec(video.playbackRate);
     video.mediaStart += sourceTimeAt(playbackRate, shift);
     video.playbackRate = shiftRateLane(playbackRate, shift);

package/dist/utils/ffprobe.d.ts

@@ -128,6 +128,7 @@ export declare function readProbeJson(filePath: string, signal?: AbortSignal): P
 /** 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 videoStartOnMediaTimeline(metadata: Pick<VideoMetadata, "videoStreamLeadSeconds" | "mediaTimeOffsetSeconds">): number;
+export declare function formatFfmpegSeconds(seconds: number): string;
 export declare function ffmpegSeekSeconds(metadata: Pick<VideoMetadata, "mediaTimeOffsetSeconds">, mediaTime: number): number;
 export declare function resolvePlayableVideoDuration(metadata: VideoMetadata): number;
 /**

package/dist/utils/ffprobe.js

@@ -336,6 +336,10 @@ export async function buildProbeFactsText(filePath, signal) {
 export function videoStartOnMediaTimeline(metadata) {
     return (metadata.videoStreamLeadSeconds ?? 0) + (metadata.mediaTimeOffsetSeconds ?? 0);
 }
+export function formatFfmpegSeconds(seconds) {
+    const text = String(seconds);
+    return text.includes("e") ? String(+seconds.toFixed(6)) : text;
+}
 export function ffmpegSeekSeconds(metadata, mediaTime) {
     return mediaTime - (metadata.mediaTimeOffsetSeconds ?? 0);
 }
@@ -860,7 +864,7 @@ async function extractFinalPacketDuration(filePath, window, signal) {
         "-select_streams",
         "v:0",
         "-read_intervals",
-        `${intervalStart}%${streamEnd}`,
+        `${formatFfmpegSeconds(intervalStart)}%${formatFfmpegSeconds(streamEnd)}`,
         "-show_entries",
         "packet=pts_time,duration_time",
         "-of",
@@ -939,7 +943,8 @@ export async function extractFinalVideoFrameTimestamp(filePath, metadata, signal
             });
             return parseFinalTimestamp(stdout);
         };
-        const timestamp = (await probe(`${intervalStart}%${streamEnd}`)) ?? (await probe( /* full scan */));
+        const timestamp = (await probe(`${formatFfmpegSeconds(intervalStart)}%${formatFfmpegSeconds(streamEnd)}`)) ??
+            (await probe( /* full scan */));
         if (timestamp === undefined) {
             throw new Error("[FFmpeg] ffprobe found no decodable final video frame");
         }
@@ -1114,7 +1119,7 @@ export async function analyzeKeyframeIntervals(filePath, metadata) {
 export async function keyframeGapSeconds(filePath, seekSeconds, signal) {
     const stdout = await runFfprobe(filePath, [
         ...["-select_streams", "v:0", "-show_entries", "packet=pts_time", "-of", "csv=p=0"],
-        ...["-read_intervals", `${seekSeconds}%+#1`],
+        ...["-read_intervals", `${formatFfmpegSeconds(seekSeconds)}%+#1`],
     ], signal);
     const keyframe = parseFloat(stdout.split("\n")[0] ?? "");
     return Number.isFinite(keyframe) ? Math.max(0, seekSeconds - keyframe) : 0;

package/dist/utils/hdr.d.ts

@@ -88,6 +88,16 @@ export declare function findHdrAutoPromotion(sources: readonly {
     asset: string;
     colorSpace: VideoColorSpace | null;
 }[]): HdrAutoPromotion | null;
+/** Grading is SDR-only, so in auto mode a composition with graded media renders SDR, as `--sdr` does. */
+export declare function gradingKeepsSdr(hdrMode: "auto" | "force-hdr" | "force-sdr" | undefined, media: {
+    videos: readonly {
+        graded?: boolean;
+    }[];
+    images: readonly {
+        graded?: boolean;
+    }[];
+    gradedCanvas?: boolean;
+}): boolean;
 export declare function formatHdrAutoPromotionWarning(promotion: HdrAutoPromotion): string;
 /**
  * Analyze a set of video color spaces to determine if the composition

package/dist/utils/hdr.js

@@ -84,6 +84,12 @@ export function findHdrAutoPromotion(sources) {
         }
         : null;
 }
+/** Grading is SDR-only, so in auto mode a composition with graded media renders SDR, as `--sdr` does. */
+export function gradingKeepsSdr(hdrMode, media) {
+    return ((hdrMode ?? "auto") === "auto" &&
+        (media.gradedCanvas === true ||
+            [...media.videos, ...media.images].some(({ graded }) => graded === true)));
+}
 export function formatHdrAutoPromotionWarning(promotion) {
     return `[Render] HDR auto-promotion triggered by "${promotion.triggeringAsset}", output: ${promotion.output.colorSpace} / ${promotion.output.codec}`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperframes/engine",
-  "version": "0.8.223",
+  "version": "0.8.225",
   "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/core": "^0.8.223",
-    "@hyperframes/parsers": "^0.8.223"
+    "@hyperframes/core": "^0.8.225",
+    "@hyperframes/parsers": "^0.8.225"
   },
   "devDependencies": {
     "@types/node": "^25.0.10",