// fallow-ignore-file code-duplication complexity import { wallClearTimeout, wallSetTimeout } from "./wallClock"; import { setPreviewRasterScale } from "./previewRasterHints"; import { createFarSceneSkip } from "./farScenes"; import { clipLengthsWritten, ownWindow, hostOf as sceneHostOf, isParked, parkedClips, parkedSceneMarkup, parkedTimelineScenes, park as parkScene, rememberScene, scenesWanted, unpark, windowedScenes, } from "./sceneWindow"; import { clipsFirstRenderedIn } from "./firstRenderReveal"; import { refreshSvgSelectorAliases } from "../compiler/svgSelectorAliases"; import { RUNTIME_FILLER } from "./protocol"; import { giveBackWhenDue, isLongSource, preloadMedia, prepareUpcomingMedia, releaseMedia, lengthIsAuthored, stopMediaDownload, } from "./preloadMedia"; import { heldByMedia, notePlaybackFrame, noteDisplayScale, watchMediaFetches, } from "./playbackHealth"; import { hasFrozenPicture } from "./frozenPicture"; import { createPreviewSeek } from "./previewSeek"; import { createPausedVideoFrames, releasePausedVideoFrame } from "./pausedVideoFrames"; import { copiesReady } from "./previewCopies"; import { installRuntimeControlBridge, postRuntimeMessage, setRuntimeProtocolFps } from "./bridge"; import { createScrubAudio } from "./scrubAudio"; import { installEditingAgent } from "./editingAgent"; import { instantTolerance } from "../clipFacts"; import { isClipVisibleAt, isInClipWindow } from "./clipWindow"; import { isWebKit, mediaElementTime } from "./mediaClock"; import { CLIP_HIDDEN_ATTR, revealTimedClipsAfterFirstPass, SKIPPED_CLIP, showClips, showHiddenClips, defersMedia, skipsHiddenImages, } from "./timedClipHide"; import { capturePageIn, inPlayerFrame, STUDIO_PREVIEW_MARK_META, PREVIEW_ONLY_ATTRS, RUNTIME_STAMPED_ATTR, STUDIO_PREVIEW_FAR_SCENE_ATTR as FAR_SCENE_ATTR, STUDIO_PREVIEW_PARKED_SCENE_ATTR, STUDIO_PREVIEW_LAZY_ATTR, STUDIO_PREVIEW_UPCOMING_ATTR, } from "../studioPreviewMark"; import { initRuntimeAnalytics, emitAnalyticsEvent } from "./analytics"; import { injectCompositionCssVariables } from "./getVariables"; import { createCssAdapter } from "./adapters/css"; import { createGsapAdapter, holdFrameMarks, muteDiscreteCallbacks, rerenderGsapTimelineAt, gsapTimelineOf, seekGsapTimeline, type GsapStructureKey, } from "./adapters/gsap"; import { stampAuthoredOrder } from "./adapters/gsapAuthoredOrder"; import { createAnimeJsAdapter } from "./adapters/animejs"; import { createLottieAdapter } from "./adapters/lottie"; import { createThreeAdapter } from "./adapters/three"; import { createMapboxAdapter } from "./adapters/mapbox"; import { createLeafletAdapter } from "./adapters/leaflet"; import { createGoogleMapsAdapter } from "./adapters/google-maps"; import { createMaplibreAdapter } from "./adapters/maplibre"; import { createD3Adapter } from "./adapters/d3"; import { createTypegpuAdapter } from "./adapters/typegpu"; import { createFrameSourceAdapter } from "./frameSources"; import { patchVideoTextureCompat, patchWebGLVideoTextureCompat, patchCanvasVideoFrameCompat, patchExternalVideoTextureCompat, } from "./adapters/video-texture-compat"; import { forceDispatchSeekEvent, hasPendingSeekCompletion, registerSeekCompletion, seekCompletionsSettled, waitForSeekCompletion, } from "./adapters/seek-dispatch"; import { sourceTimeAt } from "../speedRamp"; import { createWaapiAdapter } from "./adapters/waapi"; import { MEDIA_SYNC_TOLERANCE_SECONDS, MEDIA_HARD_SYNC_SECONDS, isUnplayable, mediaSourceTimeAt, primeMediaForLaterStarts, readElementPlaybackRate, readElementPlaybackStart, readElementRateSpec, refreshRuntimeMediaCache, resolveNaturalMediaTimelineDuration, resolveRuntimeMediaClipDuration, syncRuntimeMedia, MEDIA_PRESEEK_SECONDS, type RuntimeMediaClip, } from "./media"; import { PREVIEW_QUALITY_LEVELS, type PreviewQuality } from "../previewProxyBox"; import { handleErrorForProxy, handleMetadataForProxy, isRenderMode, maybeProxyProactively, describeVideoSources, levelsWithLighterCopies, retryPreviewCopies, setPreviewQuality, setCopiesAhead, setProxyDisplayScale, } from "./mediaProxy"; import { probeAndCacheElementVolume, volumeMoversOf, type VolumeKeyframe, type VolumeMovers, } from "./mediaVolumeEnvelope.js"; import { createPickerModule } from "./picker"; import { createRuntimePlayer, resolveRenderSeekTime, type RuntimePlayerTransport } from "./player"; import { createRuntimeState } from "./state"; import { collectRuntimeTimelinePayload, isRuntimeElementVisibleAt, runtimeElementWindow, parseAuthoredTrack, } from "./timeline"; import { findRootCompositionElement, parseLayoutDimension } from "./compositionDimension"; import { resolveCompositionDuration } from "@hyperframes/parsers/composition-duration"; import { sceneCssUrlMatches } from "@hyperframes/parsers/css-url-scans"; import { LOOP_INFLATED_TIMELINE_SECONDS, MIN_VALID_TIMELINE_DURATION_SECONDS, readCompositionSize, resolveAuthoredCompositionFloorSeconds, longestMediaWindow as longestMediaWindowIn, resolveCompositionLength, type CompositionLengthFrom, resolveContentDerivedDuration as resolveContentDerivedDurationFor, } from "./compositionLength"; import { createRuntimeStartTimeResolver } from "./startResolver"; import { createClipTree } from "./clipTree"; import { loadCompositions } from "./compositionLoader"; import { runScriptsAfterFonts, waitForFonts } from "./afterFonts"; import { applyCaptionOverrides, applyFetchedCaptionOverrides, fetchCaptionOverrides, } from "./captionOverrides"; import { SCENE_FONTS_ATTR, SCENE_NO_SWAP_ATTR, SCENE_PART_ATTR, SCENE_PARTS_META, fontFaceBlocks, type SceneParts, } from "../sceneParts"; import { applyPositionEdits, EDIT_ORIGINAL_TRANSLATE_ATTR, forgetPositionEdit, installPositionEditsSeekReapply, } from "./positionEdits"; import { stillStandsIn, unheldPoster, unproxiedSrc } from "./proxySrc"; import { applyVariableBindings, unproxiedMediaSrc } from "./applyVariableBindings"; import { createColorGradingRuntime, type RuntimeColorGradingApi } from "./colorGrading"; import { COLOR_GRADING_AUTHORED_OPACITY_ATTR } from "../colorGrading"; import { initVfx, paintVfx, rebuildLostVfx } from "./vfx"; import { watchSceneWebglContexts } from "./webglContextRecovery"; import { captureMotionBlurBusy, initCaptureMotionBlur, motionBlurLighterLevels, paintCaptureMotionBlur, releaseCaptureMotionBlurFrame, setMotionBlurPreviewQuality, teardownCaptureMotionBlur, } from "./captureMotionBlur"; import { TransportClock } from "./clock"; import { WebAudioTransport } from "./webAudioTransport"; import { watchAudioLoadErrors } from "./mediaLoadFailure"; import { classifyWebAudioMediaRoute, isRouteSelectionSettled, reportWebAudioMediaRoute, } from "./webAudioRoute.js"; import { audioGroupOf, ensureAudioGroupInertStyle, HF_AUDIO_GROUP_TAG, isMemberGroupHidden, readMasterFxChain, } from "../audioGroups"; import { ensureColorGroupInertStyle } from "../colorGroups"; import { clampNativeMediaVolume } from "../audioGain"; import { quantizeTimeToFrame } from "../inline-scripts/parityContract"; import { createManualEditGestureWatch } from "./manualEditGestureWatch"; import type { HeldSeek, RuntimeDeterministicAdapter, RuntimeJson, RuntimeSeekOptions, RuntimeTimelineChildLike, RuntimeTimelineLike, SceneAnimation, } from "./types"; import type { PlayerAPI } from "../core.types"; import { parseFps } from "../fps"; import { recordBuildReadyRejection, recordStartupError, SCENE_CALLBACK_ERROR_PREFIX, swallow, } from "./diagnostics"; import { readTimelineDurationSeconds } from "./timelineDuration"; import { CHANGE_DRIVEN_SERVICE_MIN_INTERVAL_MS, MEDIA_BIND_INTERVAL_FRAMES, PLAYING_POLL_INTERVAL_MS, TIMELINE_POST_INTERVAL_FRAMES, shouldAttemptPeriodicTimelineBind, } from "./timelineRebindPolicy"; import { installStudioCustomEase } from "./customEase"; import { parseStrictFiniteTimingNumber, resolveMediaElementDurationSeconds } from "./playbackRate"; import { cutToHostSlots, MEDIA_START_BASIS_ATTR } from "../mediaTiming"; import { settleFirstFrameCompositionReadiness } from "../compositionReadiness"; import { AUTHORED_DURATION_ATTR, AUTHORED_END_ATTR } from "./authoredTiming"; import { createTimingRecordFilter } from "./mutationRecords"; import { clearRuntimeData, setRuntimeData, setRuntimeDataAppliedReporter, setRuntimeDataErrorReporter, } from "./runtimeData"; import { isAudioElement, isElementNode, isHtmlElement, isImageElement, isMediaElement, isStylableElement, isVideoElement, type StylableElement, } from "./domRealm"; import { audibleVideoNeedsWebAudio, isAudibleVideoElement } from "../audibleVideo"; /** * A `window.__timelines` entry is authored content and may be a PARTIAL * RuntimeTimelineLike — e.g. duration/seek only, no `pause()`. Such * compositions render fine (the render path only seeks and never pauses), so * timeline resolution stays permissive by design; the interactive transport * must not crash on the missing method (top recurring studio:unhandled_error: * "E.pause is not a function"). One analytics event per page so the * composition author can find the partial timeline. */ let warnedTimelineMissingPause = false; function pauseTimelineIfPossible(tl: RuntimeTimelineLike | null | undefined): void { if (!tl) return; if (typeof tl.pause !== "function") { if (!warnedTimelineMissingPause) { warnedTimelineMissingPause = true; emitAnalyticsEvent("timeline_missing_pause", {}); } return; } try { tl.pause(); } catch (err) { swallow("runtime.timeline.pause", err); } } /** A timeline the runtime already padded is padded again from scratch, as a fresh load pads it. */ function dropRuntimeFillers(timeline: RuntimeTimelineLike): void { const removable = timeline as RuntimeTimelineLike & { remove?: (child: unknown) => unknown }; if (typeof removable.remove !== "function") return; for (const child of timeline.getChildren?.(false, true, false) ?? []) { if (child.data === RUNTIME_FILLER) removable.remove(child); } } type ExportRenderFpsResolution = { fps: number | null; source: "render-options" | "default" | "unknown"; rawFpsSource: unknown; rawFps: unknown; fallbackReason?: "missing" | "invalid"; }; function resolveExportRenderFps(): ExportRenderFpsResolution { const config = window.__HF_EXPORT_RENDER_SEEK_CONFIG; const rawFps = config?.fps; const rawFpsSource = config?.fpsSource; const fps = Number(rawFps); if (!config || rawFps == null) { return { fps: null, source: "default", rawFpsSource, rawFps, fallbackReason: "missing" }; } if (!Number.isFinite(fps) || fps <= 0) { return { fps: null, source: "default", rawFpsSource, rawFps, fallbackReason: "invalid" }; } const source = rawFpsSource === "render-options" || rawFpsSource === "default" ? rawFpsSource : "unknown"; return { fps, source, rawFpsSource, rawFps, fallbackReason: config.fpsFallbackReason, }; } /** Levels below Full that make the preview lighter: a heavy video's copy, or blur's fewer copies. */ function lighterLevels(): PreviewQuality[] { const videos = levelsWithLighterCopies(); const blur = motionBlurLighterLevels(); return PREVIEW_QUALITY_LEVELS.filter((level) => videos.includes(level) || blur.includes(level)); } function compositionFps(): number | null { const declared = parseFps(findRootCompositionElement()?.getAttribute("data-fps") ?? ""); return declared.ok ? declared.value.num / declared.value.den : null; } function samePromiseSet(a: PromiseLike[], b: PromiseLike[] | null): boolean { return b !== null && a.length === b.length && a.every((p, i) => p === b[i]); } class BuildReadyRejection extends Error { constructor( readonly key: string, readonly reason: unknown, ) { super(`window.__hf.buildReady[${JSON.stringify(key)}] rejected`); } } // `Promise.all` allocates a fresh promise every call, so comparing ITS // identity across repeat polls is never stable — that re-arms a `.then()` // on every poll and never lets the caller observe "settled", even once the // underlying work is done. Compares the source promises themselves instead. function createSettledTracker( collectPromises: () => PromiseLike[], onSettled: () => void, onError: (err: unknown) => void, ): () => boolean { let tracked: PromiseLike[] | null = null; let settled = true; return () => { const promises = collectPromises(); if (promises.length === 0) { tracked = null; settled = true; return true; } if (samePromiseSet(promises, tracked)) return settled; tracked = promises; settled = false; const combined: PromiseLike = promises.length === 1 ? promises[0]! : Promise.all(promises); void Promise.resolve(combined).then( () => { if (tracked !== promises) return; settled = true; onSettled(); }, (err) => { if (tracked !== promises) return; settled = true; onError(err); onSettled(); }, ); return settled; }; } function readSceneParts(doc: Document): SceneParts | null { const content = doc.querySelector(`meta[name="${SCENE_PARTS_META}"]`)?.getAttribute("content"); if (!content) return null; try { return JSON.parse(content) as SceneParts; } catch { return null; } } // A media element's attributes and content, less the grading capture stamped on it at parse time. const authoredShape = (el: Element): string => JSON.stringify([ Array.from(el.attributes, (a) => [a.name, a.value]).filter( ([name]) => name !== COLOR_GRADING_AUTHORED_OPACITY_ATTR, ), el.innerHTML, ]); // What the runtime writes on a video or audio: style (reset on a kept one), preload, the opacity stamp, a moved // element's original translate, preview marks and its own __hf- classes. A proxied src is compared as written. const RUNTIME_MEDIA_ATTRS = new Set([ "style", "preload", "src", COLOR_GRADING_AUTHORED_OPACITY_ATTR, EDIT_ORIGINAL_TRANSLATE_ATTR, CLIP_HIDDEN_ATTR, ...PREVIEW_ONLY_ATTRS, ]); const ownClasses = (value: string) => value .split(/\s+/) .filter((c) => c && !c.startsWith("__hf-")) .join(" "); const writtenShape = (el: Element): string => JSON.stringify([ Array.from(el.attributes, ({ name, value }) => [ name, name === "class" ? ownClasses(value) : name === "poster" ? unheldPoster(el) : value, ]) .filter( ([name, value]) => !RUNTIME_MEDIA_ATTRS.has(name!) && !((name === "class" || name === "poster") && !value), ) .sort(([a], [b]) => (a! < b! ? -1 : 1)), el.hasAttribute("data-var-src") ? null : unproxiedSrc(el), el.innerHTML, ]); // Each video and audio as written, recorded as the page parses: a scene script can write to it before init. const authoredMedia = new WeakMap(); const isMedia = (el: Element) => el.localName === "video" || el.localName === "audio"; const recordAuthoredMedia = (node: Node) => { if (!isElementNode(node)) return; // The parser adds one childless element at a time, so most nodes stop at the first check. const media = isMedia(node) ? [node] : node.firstElementChild ? node.querySelectorAll("video, audio") : []; for (const el of media) if (!authoredMedia.has(el)) authoredMedia.set(el, authoredShape(el)); }; let authoredMediaObserver: MutationObserver | null = null; /** On a page with a scene manifest, records media as it parses, before scene scripts run; init stops it. */ export function installAuthoredMediaCapture(): void { if (typeof MutationObserver === "undefined" || !readSceneParts(document)) return; recordAuthoredMedia(document.documentElement); authoredMediaObserver = new MutationObserver((records) => { for (const record of records) { record.addedNodes.forEach(recordAuthoredMedia); // The parser can yield inside a