@hyperframes/core 0.8.207 → 0.8.209

package/dist/runtime/media.d.ts

@@ -1,131 +0,0 @@
-import { type VolumeKeyframe } from "./mediaVolumeEnvelope.js";
-import { type AudioFades } from "../audioFade.js";
-import { type RateSpec } from "../speedRamp.js";
-import { type HostSlot } from "../mediaTiming.js";
-export { MEDIA_SYNC_TOLERANCE_SECONDS } from "./mediaSteer.js";
-export { readElementPlaybackRate, readElementRateSpec, resolveNaturalMediaTimelineDuration, } from "./playbackRate.js";
-export declare function readElementPlaybackStart(el: Element): number;
-export declare const HOLD_CAP_MS = 5000;
-/**
- * Resolve a media element's timeline window without conflating a video's
- * authored display slot with the amount of source left to decode.
- *
- * An explicit video slot may outlive its source and holds the final frame.
- * Audio remains source-bounded because it has no visual hold state.
- */
-export declare function resolveRuntimeMediaClipDuration(params: {
-    isVideo: boolean;
-    sourceDuration: number | null;
-    hostRemaining: number | null;
-    explicitDuration: number | null;
-}): number | null;
-export type RuntimeMediaClip = {
-    el: HTMLVideoElement | HTMLAudioElement;
-    start: number;
-    /** The clip's own t=0 when a host's in-point cut its head; source time, lanes and fades run from it. */
-    origin?: number;
-    mediaStart: number;
-    duration: number;
-    end: number;
-    volume: number | null;
-    playbackRate: number;
-    /** The rate lane when the clip has one; otherwise `playbackRate`. */
-    rate?: RateSpec;
-    loop: boolean;
-    /** Source media duration in seconds (from el.duration). Used for loop wrapping. */
-    sourceDuration: number | null;
-    /**
-     * Probed volume keyframes from the GSAP timeline (same probe the renderer
-     * uses). When present, `syncRuntimeMedia` drives volume from the envelope
-     * rather than from `data-volume` + GSAP-change tracking, eliminating the
-     * race between the 60 Hz transport tick and GSAP's own seek.
-     */
-    volumeKeyframes?: VolumeKeyframe[];
-    /** Clip-edge fades from `data-fade-in` / `data-fade-out`; see audioFade.ts. */
-    fades?: AudioFades;
-};
-export declare function refreshRuntimeMediaCache(params?: {
-    resolveStartSeconds?: (element: Element) => number;
-    resolveDurationSeconds?: (element: HTMLVideoElement | HTMLAudioElement) => number | null;
-    resolveHostSlots?: (element: HTMLVideoElement | HTMLAudioElement) => HostSlot[];
-    shouldIncludeElement?: (element: HTMLVideoElement | HTMLAudioElement) => boolean;
-    /**
-     * Build clips for exactly these elements instead of scanning the document for
-     * them. For a caller that already knows which media it needs this pass — the
-     * per-seek sync only touches the clips whose active state can change — and so
-     * should not pay to re-derive the window of every clip in the composition.
-     *
-     * Every field is still read FRESH from the element. This narrows which
-     * elements are visited, never how current the answer is: `el.duration` can be
-     * reset under the caller by an `el.load()` it did not make.
-     */
-    elements?: Array<HTMLVideoElement | HTMLAudioElement>;
-}): {
-    timedMediaEls: Array<HTMLVideoElement | HTMLAudioElement>;
-    mediaClips: RuntimeMediaClip[];
-    videoClips: RuntimeMediaClip[];
-    maxMediaEnd: number;
-};
-export declare function isUnplayable(el: HTMLMediaElement): boolean;
-/**
- * Drop every per-source sync baseline tracked for `el` — offset drift
- * samples, the seek-past-buffered-range retry latch, and the last
- * runtime-applied volume — so the next `syncRuntimeMedia` tick treats it as
- * a first tick (hard resync, fresh drift baseline) instead of comparing
- * against state computed for a different file. Used both when a clip leaves
- * its active window (below) and by the runtime's proxy-swap helper
- * (mediaProxy.ts) right after an in-place `src` swap, which points the same
- * element at a different file without ever leaving its active window.
- */
-export declare function evictMediaSyncState(el: HTMLMediaElement): void;
-/** Test-only seam: whether any per-source sync state is still tracked for `el`. */
-export declare function hasMediaSyncStateForTest(el: HTMLMediaElement): boolean;
-export declare const MEDIA_HARD_SYNC_SECONDS = 0.5;
-export declare const MEDIA_PRESEEK_SECONDS = 1.5;
-export declare function mediaSourceTimeAt(clip: RuntimeMediaClip, timeSeconds: number): number;
-export declare function syncRuntimeMedia(params: {
-    clips: RuntimeMediaClip[];
-    timeSeconds: number;
-    playing: boolean;
-    playbackRate: number;
-    /** Force-mute every element (parent-frame proxy owns all audio). Asserted per
-     *  tick so sub-composition media added mid-playback inherits the silence. */
-    outputMuted?: boolean;
-    /**
-     * User's explicit mute preference (set via `onSetMuted`). Symmetric to
-     * `outputMuted` — also asserted per tick — so a sub-composition that
-     * activates after the user mutes doesn't briefly play at author volume
-     * before the next bridge message lands.
-     */
-    userMuted?: boolean;
-    /**
-     * User's volume preference (0–1, set via `onSetVolume`). Multiplied with the
-     * per-clip author volume so `data-volume="0.5"` at user volume 0.8 yields 0.4.
-     */
-    userVolume?: number;
-    /**
-     * Invoked at most once when a media element's `play()` promise rejects with
-     * `NotAllowedError`. The caller is expected to latch and post a single
-     * outbound message; further invocations are suppressed by the caller.
-     */
-    onAutoplayBlocked?: () => void;
-    /** `clipGain` is `data-volume` for a routed clip, played ahead of its FX; 1 otherwise. */
-    onElementVolume?: (el: HTMLMediaElement, effectiveVolume: number, authorVolume: number, clipGain: number, unfadedVolume?: number) => void;
-    /** Is THIS element owned by the Web Audio transport? Owned → mute it (transport
-     *  plays it); not owned → leave audible (HTMLMedia fallback). Per-element, not a
-     *  global flag, so a not-yet-claimed track isn't muted by other tracks. */
-    isWebAudioOwned?: (el: HTMLMediaElement) => boolean;
-    /** Native media routed through WebAudio keeps its upstream element volume at
-     * unity; do not mistake that transport write for an authored volume edit. */
-    isWebAudioRouted?: (el: HTMLMediaElement) => boolean;
-    forceSync?: boolean;
-    /** False while the playhead is not moving (audio output has not started): a paused video waits for it. */
-    clockAdvancing?: boolean;
-    /** How far the next tick will move the playhead: an audio clip due within it starts now. */
-    cueAheadSeconds?: number;
-    /** Seeks a sounding element under a gain dip; false when it has no dip stage and the sync seeks it plainly. */
-    seekUnderDip?: (el: HTMLMediaElement, target: number) => boolean;
-    /** Lets a video clip that runs to the composition end hold its last frame at the terminal time.
-     *  A thunk, because deriving the duration is only worth it for a clip past its own end. */
-    getCompositionDuration: () => number;
-}): void;