@hyperframes/core 0.8.188 → 0.8.190

package/dist/index.d.ts

@@ -32,7 +32,7 @@ export { clearGifFramesBeforeNext, gifClearsAfterLeavingFrameInPlace, parseAnima
 export { HF_COLOR_GRADING_ATTR, HF_COLOR_GRADING_ADJUST_KEYS, HF_COLOR_GRADING_ACTIVE_EFFECT_KEYS, HF_COLOR_GRADING_ANIMATABLE_PROPERTIES, HF_COLOR_GRADING_CANVAS_ID_PREFIX, HF_COLOR_GRADING_COLOR_SPACE, HF_COLOR_GRADING_CURVE_KEYS, HF_COLOR_GRADING_DETAIL_KEYS, HF_COLOR_GRADING_EFFECT_APPLY_DEFAULTS, HF_COLOR_GRADING_EFFECT_KEYS, HF_COLOR_GRADING_EFFECT_PRESETS, HF_COLOR_GRADING_GRADE_PRESETS, HF_COLOR_GRADING_HUE_CURVE_KEYS, HF_COLOR_GRADING_LUT_KEYS, HF_COLOR_GRADING_PALETTES, HF_COLOR_GRADING_PRESETS, HF_COLOR_GRADING_TOP_LEVEL_KEYS, HF_COLOR_GRADING_WHEEL_KEYS, getHfColorGradingCapabilities, hasHfColorGradingAuthoredValues, isHfColorGradingActive, normalizeHfColorGrading, normalizeHfColorGradingWithVariables, resolveHfColorGradingVariables, serializeHfColorGrading, type HfColorGrading, type HfColorGradingAdjust, type HfColorGradingAdjustKey, type HfColorGradingAnimatablePath, type HfColorGradingActiveEffectKey, type HfColorGradingDetailKey, type HfColorGradingDetails, type HfColorGradingEffectKey, type HfColorGradingEffects, type HfColorGradingLutRef, type HfColorGradingPreset, type HfColorGradingPresetId, type HfColorGradingTarget, type HfColorGradingVariableMap, type HfColorGradingCapabilities, type HfColorGradingCurveKey, type HfColorGradingCurves, type HfColorGradingHueCurveKey, type HfColorGradingHueCurves, type HfColorGradingHueRange, type HfColorGradingSecondary, type HfColorGradingSecondaryCorrection, type HfColorGradingSoftRange, type HfColorGradingTonalWheel, type HfColorGradingWheelKey, type HfColorGradingWheels, type HfColorCurvePoint, type HfHueCurvePoint, type NormalizedHfColorGrading, type NormalizedHfColorGradingCurves, type NormalizedHfColorGradingHueCurves, type NormalizedHfColorGradingSecondary, type NormalizedHfColorGradingWheels, type ResolvedHfColorGrading, } from "./colorGrading.js";
 export { parseCubeLut, CubeLutParseError, type ParseCubeLutOptions } from "./colorLuts.js";
 export { firstFrameColourArgs, hdrToSdrToneMapFilter, parseFirstFrameColour, type ToneMapSourceColour, } from "./hdrToneMap.js";
-export { PREVIEW_PROXY_BOX_PARAM, formatPreviewProxyBox, parsePreviewProxyBox, type PreviewProxyBox, } from "./previewProxyBox.js";
+export { PREVIEW_PROXY_BOX_PARAM, formatPreviewProxyBox, parsePreviewProxyBox, quantizePreviewProxyBox, type PreviewProxyBox, } from "./previewProxyBox.js";
 export { HYPERFRAME_RUNTIME_ARTIFACTS, HYPERFRAME_RUNTIME_CONTRACT, loadHyperframeRuntimeSource, type HyperframeRuntimeContract, } from "./inline-scripts/hyperframe.js";
 export { HYPERFRAME_RUNTIME_GLOBALS, HYPERFRAME_BRIDGE_SOURCES, HYPERFRAME_CONTROL_ACTIONS, type HyperframeControlAction, } from "./inline-scripts/runtimeContract.js";
 export { getHyperframeRuntimeScript } from "./generated/runtime-inline.js";

package/dist/index.js

@@ -28,7 +28,7 @@ export { clearGifFramesBeforeNext, gifClearsAfterLeavingFrameInPlace, parseAnima
 export { HF_COLOR_GRADING_ATTR, HF_COLOR_GRADING_ADJUST_KEYS, HF_COLOR_GRADING_ACTIVE_EFFECT_KEYS, HF_COLOR_GRADING_ANIMATABLE_PROPERTIES, HF_COLOR_GRADING_CANVAS_ID_PREFIX, HF_COLOR_GRADING_COLOR_SPACE, HF_COLOR_GRADING_CURVE_KEYS, HF_COLOR_GRADING_DETAIL_KEYS, HF_COLOR_GRADING_EFFECT_APPLY_DEFAULTS, HF_COLOR_GRADING_EFFECT_KEYS, HF_COLOR_GRADING_EFFECT_PRESETS, HF_COLOR_GRADING_GRADE_PRESETS, HF_COLOR_GRADING_HUE_CURVE_KEYS, HF_COLOR_GRADING_LUT_KEYS, HF_COLOR_GRADING_PALETTES, HF_COLOR_GRADING_PRESETS, HF_COLOR_GRADING_TOP_LEVEL_KEYS, HF_COLOR_GRADING_WHEEL_KEYS, getHfColorGradingCapabilities, hasHfColorGradingAuthoredValues, isHfColorGradingActive, normalizeHfColorGrading, normalizeHfColorGradingWithVariables, resolveHfColorGradingVariables, serializeHfColorGrading, } from "./colorGrading.js";
 export { parseCubeLut, CubeLutParseError } from "./colorLuts.js";
 export { firstFrameColourArgs, hdrToSdrToneMapFilter, parseFirstFrameColour, } from "./hdrToneMap.js";
-export { PREVIEW_PROXY_BOX_PARAM, formatPreviewProxyBox, parsePreviewProxyBox, } from "./previewProxyBox.js";
+export { PREVIEW_PROXY_BOX_PARAM, formatPreviewProxyBox, parsePreviewProxyBox, quantizePreviewProxyBox, } from "./previewProxyBox.js";
 // Inline scripts
 export { HYPERFRAME_RUNTIME_ARTIFACTS, HYPERFRAME_RUNTIME_CONTRACT, loadHyperframeRuntimeSource, } from "./inline-scripts/hyperframe.js";
 export { HYPERFRAME_RUNTIME_GLOBALS, HYPERFRAME_BRIDGE_SOURCES, HYPERFRAME_CONTROL_ACTIONS, } from "./inline-scripts/runtimeContract.js";

package/dist/runtime/media.js

@@ -9,6 +9,7 @@ import { rateAt, sourceTimeAt, timeAtSourceTime } from "../speedRamp.js";
 import { clampAudioGain, clipGain, gainTimesLane } from "../audioGain.js";
 import { isMemberGroupHidden } from "../audioGroups.js";
 import { findInjectedRenderFrame } from "./renderFrameSibling.js";
+import { isRenderFrameVideo } from "./preloadMedia.js";
 import { registerSeekCompletion } from "./adapters/seek-dispatch.js";
 import { cutToHostSlots } from "../mediaTiming.js";
 export { readElementPlaybackRate, readElementRateSpec, resolveNaturalMediaTimelineDuration, } from "./playbackRate.js";
@@ -401,7 +402,7 @@ export function syncRuntimeMedia(params) {
             // past the buffered range. Setting this on every tick is cheap
             // (no-op when already "auto") and catches elements whose preload
             // was overridden after init.ts set it.
-            if (el.preload !== "auto")
+            if (el.preload !== "auto" && !isRenderFrameVideo(el))
                 el.preload = "auto";
             // Per-element rate × global transport rate
             const baseRate = rateAt(clipRate, params.timeSeconds - origin) * params.playbackRate;

package/dist/runtime/preloadMedia.d.ts

@@ -0,0 +1,11 @@
+type PreloadableMedia = Pick<HTMLMediaElement, "id" | "tagName" | "getAttribute" | "preload" | "readyState" | "networkState" | "load">;
+export declare function isRenderFrameVideo(media: Pick<Element, "getAttribute" | "id" | "tagName">): boolean;
+export declare function preloadMedia(media: PreloadableMedia): void;
+/** Ends a fetch in flight for good, which preload none alone does not. */
+export declare function stopMediaDownload(media: HTMLMediaElement): void;
+export declare function releaseMedia(media: HTMLMediaElement): void;
+export declare function lengthIsAuthored(media: Element): boolean;
+/** Preview only: later clips parse at preload none, as Chromium ignores a none set mid-fetch.
+ * One watcher per page: a runtime evaluated again replaces the last one's. */
+export declare function deferMediaUntilDue(): void;
+export {};

package/dist/runtime/preloadMedia.js

@@ -0,0 +1,65 @@
+import { parseStrictFiniteTimingNumber } from "./playbackRate.js";
+import { createRuntimeStartTimeResolver } from "./startResolver.js";
+import { readMediaRenderId } from "./renderFrameSibling.js";
+import { defersMedia } from "./timedClipHide.js";
+export function isRenderFrameVideo(media) {
+    const ids = window
+        .__HF_RENDER_FRAME_VIDEO_IDS;
+    return media.tagName === "VIDEO" && ids?.includes(readMediaRenderId(media) ?? "") === true;
+}
+export function preloadMedia(media) {
+    if (isRenderFrameVideo(media))
+        return;
+    if (media.preload !== "auto")
+        media.preload = "auto";
+    // load() resets an in-flight video fetch, discarding its selected resource and buffered data.
+    const videoAlreadyLoading = media.tagName === "VIDEO" && media.networkState === 2;
+    if (media.readyState < 3 && !videoAlreadyLoading)
+        media.load();
+}
+/** Ends a fetch in flight for good, which preload none alone does not. */
+export function stopMediaDownload(media) {
+    for (const source of media.querySelectorAll("source"))
+        source.remove();
+    media.removeAttribute("src");
+    media.load();
+}
+export function releaseMedia(media) {
+    if (media.querySelector("source"))
+        return;
+    const src = media.getAttribute("src");
+    stopMediaDownload(media);
+    if (src !== null)
+        media.setAttribute("src", src);
+}
+export function lengthIsAuthored(media) {
+    return parseStrictFiniteTimingNumber(media.getAttribute("data-duration")) != null;
+}
+/** Preview only: later clips parse at preload none, as Chromium ignores a none set mid-fetch.
+ * One watcher per page: a runtime evaluated again replaces the last one's. */
+export function deferMediaUntilDue() {
+    const win = window;
+    win.__hfMediaDeferral?.disconnect();
+    win.__hfMediaDeferral = undefined;
+    if (!defersMedia())
+        return;
+    const defer = (el, startInFilm) => {
+        const start = parseStrictFiniteTimingNumber(el.getAttribute("data-start"));
+        if (start != null && lengthIsAuthored(el) && startInFilm(el) > 0)
+            el.preload = "none";
+    };
+    win.__hfMediaDeferral = new MutationObserver((records) => {
+        const startInFilm = createRuntimeStartTimeResolver({}).resolveMediaStartForElement;
+        for (const record of records)
+            for (const node of record.addedNodes) {
+                if (node.nodeType !== 1)
+                    continue;
+                const el = node;
+                if (el.matches("video, audio"))
+                    defer(el, startInFilm);
+                for (const media of el.querySelectorAll("video, audio"))
+                    defer(media, startInFilm);
+            }
+    });
+    win.__hfMediaDeferral.observe(document.documentElement, { childList: true, subtree: true });
+}

package/dist/runtime/renderFrameSibling.d.ts

@@ -20,7 +20,7 @@
  * when the compiler stamped this document, else its author id. The two are
  * the same string whenever no collision forced a suffix.
  */
-export declare function readMediaRenderId(media: Element): string | null;
+export declare function readMediaRenderId(media: Pick<Element, "getAttribute" | "id">): string | null;
 /**
  * Affixes of the sibling id. Exported so the engine can build the same id
  * inside `page.evaluate`, where it cannot import: it passes these through as

package/dist/runtime/timedClipHide.d.ts

@@ -0,0 +1,9 @@
+export declare const SKIPPED_CLIP = "[data-start]:not(video, audio, img, [data-hf-upcoming], [data-hf-autostamped])[style*=\"visibility: hidden\"]";
+export declare const CLIP_HIDDEN_ATTR = "data-hf-clip-hidden";
+export declare function showHiddenClips(): () => void;
+export declare function defersMedia(): boolean;
+/** True in Studio's preview, where hidden clips' images are neither fetched nor decoded until due. */
+export declare function skipsHiddenImages(): boolean;
+export declare function hideTimedClipsUntilFirstPass(): void;
+/** True when this call lifted the rule; callers then re-register what skipped hidden elements (grading). */
+export declare function revealTimedClipsAfterFirstPass(): boolean;

package/dist/runtime/timedClipHide.js

@@ -0,0 +1,74 @@
+import { RUNTIME_STAMPED_ATTR, STUDIO_PREVIEW_CAPTURE_MODE, STUDIO_PREVIEW_MARK_META, STUDIO_PREVIEW_UPCOMING_ATTR, } from "../studioPreviewMark.js";
+// Hides timed non-media clips from script evaluation until the first visibility pass decides them;
+// before it, a paused page painted every clip at once. Media is left to init's media pass.
+// The rule and its flag live on the page, so every runtime copy shares them.
+const HIDE_ATTR = "data-hf-first-pass-hide";
+const HIDE_UNTIL_FIRST_PASS = "[data-start]:not(video, audio, img) { visibility: hidden !important; }";
+const PREVIEW_HIDE_UNTIL_FIRST_PASS = 'img[loading="lazy"] { display: none !important; }';
+const SKIP_ATTR = "data-hf-skip-hidden-images";
+export const SKIPPED_CLIP = `[data-start]:not(video, audio, img, [${STUDIO_PREVIEW_UPCOMING_ATTR}], [${RUNTIME_STAMPED_ATTR}])[style*="visibility: hidden"]`;
+const SKIP_HIDDEN_IMAGES = `${SKIPPED_CLIP} img { display: none !important; }`;
+const STUDIO_PREVIEW_MARK = `meta[name="${STUDIO_PREVIEW_MARK_META}"]`;
+export const CLIP_HIDDEN_ATTR = "data-hf-clip-hidden";
+const CONTENTS_ATTR = "data-hf-hidden-clip-contents";
+const HIDDEN_CLIP = `[${CLIP_HIDDEN_ATTR}][style*="visibility: hidden"]`;
+const HIDE_HIDDEN_CLIP_CONTENTS = `${HIDDEN_CLIP} * { visibility: hidden !important; }`;
+const FILTER_OUTPUT_LAYERS = [HIDDEN_CLIP, `${HIDDEN_CLIP} *`]
+    .flatMap((layer) => [layer, `${layer}::before`, `${layer}::after`])
+    .join(", ");
+const HIDE_FILTER_OUTPUT = `${FILTER_OUTPUT_LAYERS} { filter: none !important; }`;
+export function showHiddenClips() {
+    const hidden = Array.from(document.querySelectorAll(`[${CLIP_HIDDEN_ATTR}]`));
+    for (const el of hidden)
+        el.style.visibility = "visible";
+    return () => {
+        for (const el of hidden)
+            el.style.visibility = "hidden";
+    };
+}
+function appendStyle(parent, attr, css) {
+    const style = document.createElement("style");
+    style.setAttribute(attr, "");
+    style.textContent = css;
+    parent.appendChild(style);
+}
+export function defersMedia() {
+    return document.querySelector(STUDIO_PREVIEW_MARK) !== null;
+}
+/** True in Studio's preview, where hidden clips' images are neither fetched nor decoded until due. */
+export function skipsHiddenImages() {
+    return document.querySelector(`style[${SKIP_ATTR}]`) !== null;
+}
+export function hideTimedClipsUntilFirstPass() {
+    if (typeof document === "undefined")
+        return;
+    const parent = document.head ?? document.documentElement;
+    if (!parent)
+        return;
+    const mark = document.querySelector(STUDIO_PREVIEW_MARK);
+    const preview = mark !== null;
+    const capture = mark?.getAttribute("content") === STUDIO_PREVIEW_CAPTURE_MODE;
+    if (preview && !capture && !skipsHiddenImages())
+        appendStyle(parent, SKIP_ATTR, SKIP_HIDDEN_IMAGES);
+    if (!document.querySelector(`style[${CONTENTS_ATTR}]`))
+        appendStyle(parent, CONTENTS_ATTR, `${HIDE_HIDDEN_CLIP_CONTENTS} ${HIDE_FILTER_OUTPUT}`);
+    const win = window;
+    // A runtime that already initialised may never run another pass to lift a new rule.
+    if (win.__hfFirstPassHidden || win.__hyperframeRuntimeBootstrapped)
+        return;
+    const css = preview
+        ? `${HIDE_UNTIL_FIRST_PASS} ${PREVIEW_HIDE_UNTIL_FIRST_PASS}`
+        : HIDE_UNTIL_FIRST_PASS;
+    appendStyle(parent, HIDE_ATTR, css);
+    win.__hfFirstPassHidden = true;
+}
+/** True when this call lifted the rule; callers then re-register what skipped hidden elements (grading). */
+export function revealTimedClipsAfterFirstPass() {
+    const win = window;
+    if (!win.__hfFirstPassHidden)
+        return false;
+    win.__hfFirstPassHidden = false;
+    for (const style of document.querySelectorAll(`style[${HIDE_ATTR}]`))
+        style.remove();
+    return true;
+}

package/dist/studioPreviewMark.d.ts

@@ -1,4 +1,5 @@
 export declare const STUDIO_PREVIEW_MARK_META = "hyperframes-studio-preview";
+export declare const STUDIO_PREVIEW_CAPTURE_MODE = "capture";
 export declare const STUDIO_PREVIEW_UPCOMING_ATTR = "data-hf-upcoming";
 export declare const STUDIO_PREVIEW_LAZY_ATTR = "data-hf-preview-lazy";
 export declare const STUDIO_PREVIEW_ERRORS = "__hfPreviewErrors";

package/dist/studioPreviewMark.js

@@ -1,4 +1,5 @@
 export const STUDIO_PREVIEW_MARK_META = "hyperframes-studio-preview";
+export const STUDIO_PREVIEW_CAPTURE_MODE = "capture";
 export const STUDIO_PREVIEW_UPCOMING_ATTR = "data-hf-upcoming";
 export const STUDIO_PREVIEW_LAZY_ATTR = "data-hf-preview-lazy";
 export const STUDIO_PREVIEW_ERRORS = "__hfPreviewErrors";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperframes/core",
-  "version": "0.8.188",
+  "version": "0.8.190",
   "description": "",
   "repository": {
     "type": "git",
@@ -385,9 +385,9 @@
     "linkedom": "^0.18.12",
     "postcss": "^8.5.8",
     "wawoff2": "^2.0.1",
-    "@hyperframes/parsers": "0.8.188",
-    "@hyperframes/studio-server": "0.8.188",
-    "@hyperframes/lint": "0.8.188"
+    "@hyperframes/lint": "0.8.190",
+    "@hyperframes/parsers": "0.8.190",
+    "@hyperframes/studio-server": "0.8.190"
   },
   "devDependencies": {
     "@fontsource/archivo-black": "^5.2.8",