supervision 0.1.7 → 0.2.0-next.0

package/dist/web-video-engine/decode-resolution.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Decode-resolution strategies. A strategy decides the pixel width each video
+ * frame is decoded to, independent of the source's native resolution. Height
+ * follows from native aspect, so a strategy only ever returns a width.
+ *
+ * Decoding below native trades preview sharpness for paint cost and frame-cache
+ * memory. It does NOT cut decode cost: the codec decodes the full coded frame
+ * regardless of target width, and CanvasSink resizes the result afterward. The
+ * win scales with the gap between source resolution and the on-screen box: a 4K
+ * source shown in a 640px surface still pays full 4K decode, but the smaller
+ * surface cuts the per-frame paint work and the cached blit size.
+ *
+ * A strategy applies wherever frames decode through this seam: the live scrub
+ * surface and the analysis / extraction path alike. AnalysisSession decodes at
+ * whatever strategy it is given (native when omitted), so a thumbnail pass can
+ * cache a small blit instead of a native-size one.
+ */
+/**
+ * Inputs a strategy reasons over. Native dimensions are the decoded track's
+ * real resolution. Display dimensions describe the on-screen canvas box at
+ * decode time; displayWidth is null when the surface has not been laid out
+ * yet (a strategy that needs it should fall back to native).
+ */
+export interface DecodeResolutionContext {
+    readonly nativeWidth: number;
+    readonly nativeHeight: number;
+    /** CSS-pixel width of the canvas box, or null when unmeasured. */
+    readonly displayWidth: number | null;
+    /** devicePixelRatio at decode time. */
+    readonly devicePixelRatio: number;
+}
+/**
+ * Resolved decode dimensions. Always a valid, native-bounded integer pair with
+ * native aspect preserved.
+ */
+export interface DecodeDimensions {
+    readonly width: number;
+    readonly height: number;
+}
+/**
+ * A decode-resolution choice as serializable data. Held as a descriptor rather
+ * than a closure so the choice can cross the worker boundary in a load command;
+ * resolveDecodeDimensions runs the width math worker-side once native dimensions
+ * are known. The resolver clamps any result above native so no strategy can
+ * upscale during decode.
+ */
+export type DecodeResolutionStrategy = {
+    readonly kind: "native";
+} | {
+    readonly kind: "viewport";
+    readonly maxDevicePixelRatio: number;
+} | {
+    readonly kind: "capped";
+    readonly maxWidth: number;
+} | {
+    readonly kind: "displayBox";
+    readonly boxWidth: number;
+    readonly boxHeight: number;
+    readonly devicePixelRatio: number;
+    readonly maxDevicePixelRatio: number;
+};
+/** Decode at native resolution. The conservative default. */
+export declare function nativeResolution(): DecodeResolutionStrategy;
+export interface ViewportResolutionOptions {
+    /**
+     * Ceiling on devicePixelRatio so a 3x display does not triple decode cost
+     * for sharpness past what the eye resolves on a moving preview. Default 2.
+     */
+    maxDevicePixelRatio?: number;
+}
+/**
+ * Decode at the on-screen size: canvas CSS width times devicePixelRatio. Best
+ * for fixed-size surfaces fed by a much larger source (frame sampler, inline
+ * players). Falls back to native while the box is unmeasured.
+ *
+ * The box it reads is the one bindCanvas measures, so this strategy resolves to
+ * native under presentation "frames", where the engine holds no canvas and
+ * nothing ever measures one. A frames-mode consumer passes displayBoxResolution
+ * instead.
+ */
+export declare function viewportResolution(options?: ViewportResolutionOptions): DecodeResolutionStrategy;
+/**
+ * Decode at no more than maxWidth regardless of display size. For consumers
+ * with a hard throughput or memory ceiling (batch surfaces, thumbnail farms).
+ */
+export declare function cappedResolution(maxWidth: number): DecodeResolutionStrategy;
+export interface DisplayBoxResolutionOptions {
+    /** CSS-pixel width of the box the consumer paints frames into. */
+    boxWidth: number;
+    /** CSS-pixel height of that box. */
+    boxHeight: number;
+    /** The consumer's own devicePixelRatio; the engine has none to read. */
+    devicePixelRatio: number;
+    /** Ceiling on that ratio. Default 2, matching viewportResolution. */
+    maxDevicePixelRatio?: number;
+}
+/**
+ * Decode at the size the frame will actually occupy inside a box the consumer
+ * describes: native aspect fitted into boxWidth x boxHeight, times the clamped
+ * device pixel ratio. Letterboxing is why the box is two numbers and not one,
+ * since a portrait source in a landscape box paints far narrower than the box.
+ *
+ * This is the strategy for presentation "frames". There the consumer owns the
+ * compositor, so it is the only side that knows the box, and viewportResolution
+ * has nothing to read.
+ */
+export declare function displayBoxResolution(options: DisplayBoxResolutionOptions): DecodeResolutionStrategy;
+/**
+ * Runs a strategy and returns native-bounded, aspect-preserving integer
+ * dimensions safe to hand to CanvasSink and to size a canvas backing store.
+ * A strategy that returns garbage (non-finite, non-positive) falls back to
+ * native rather than producing a broken surface.
+ */
+export declare function resolveDecodeDimensions(strategy: DecodeResolutionStrategy, ctx: DecodeResolutionContext): DecodeDimensions;
+//# sourceMappingURL=decode-resolution.d.ts.map

package/dist/web-video-engine/decode-resolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode-resolution.d.ts","sourceRoot":"","sources":["../src/decode-resolution.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,kEAAkE;IAClE,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,uCAAuC;IACvC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;CACnC;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,wBAAwB,GAChC;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAC3B;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAA;CAAE,GACnE;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACtD;IACE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;CACtC,CAAC;AAEN,6DAA6D;AAC7D,wBAAgB,gBAAgB,IAAI,wBAAwB,CAE3D;AAED,MAAM,WAAW,yBAAyB;IACxC;;;OAGG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,GAAE,yBAA8B,GACtC,wBAAwB,CAK1B;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,wBAAwB,CAE3E;AAED,MAAM,WAAW,2BAA2B;IAC1C,kEAAkE;IAClE,QAAQ,EAAE,MAAM,CAAC;IACjB,oCAAoC;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,wEAAwE;IACxE,gBAAgB,EAAE,MAAM,CAAC;IACzB,qEAAqE;IACrE,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,2BAA2B,GACnC,wBAAwB,CAQ1B;AAkCD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,wBAAwB,EAClC,GAAG,EAAE,uBAAuB,GAC3B,gBAAgB,CAUlB"}

package/dist/web-video-engine/decode-scheduler.d.ts

@@ -0,0 +1,356 @@
+import { type AnySourceHandle } from "./decode-source";
+import { FrameCache } from "./frame-cache";
+import type { FrameId } from "./frame-timeline";
+import { type ScrubCursor, ScrubCursorState, type ScrubFrame, type ScrubFrameListener, type ScrubTrackInfo, type SchedulerStats, type SeekIntent } from "./scrub-cursor";
+import { type Sec, VideoEngineError } from "./types";
+export interface DecodeSchedulerOptions {
+    readonly source: AnySourceHandle;
+    readonly cache: FrameCache;
+    /** A cache hit within this of the target serves a crisp frame; default 50. */
+    readonly exactToleranceMs?: number;
+    /** A coarse hit within this of the target serves a preview; default 250. */
+    readonly previewToleranceMs?: number;
+    /** Millisecond time source for latency stats; defaults to performance.now. */
+    readonly now?: () => number;
+    /**
+     * Opens a fresh source handle to replace a wedged decoder, or null when the
+     * source cannot be re-opened (a one-shot stream). mediabunny decodes take no
+     * AbortSignal, so a hung decode is uncancellable; the watchdog disposes the
+     * dead provider and rebuilds from this seam so later decodes work. Omitted in
+     * tests that do not exercise recovery, where the scheduler degrades instead.
+     */
+    readonly reopen?: (() => Promise<AnySourceHandle>) | null;
+    /**
+     * Hang ceiling for one random-access decode; defaults to the runtime
+     * constant. A decode that outruns it is treated as failed and triggers
+     * provider recovery. Overridable so a test can drive it with fake timers at a
+     * small value.
+     */
+    readonly decodeHangTimeoutMs?: number;
+    /**
+     * Hang ceiling for the first-frame seed; defaults to the runtime constant,
+     * which is tighter than the one above. Overridable so a test can drive it
+     * with fake timers at a small value.
+     */
+    readonly seedHangTimeoutMs?: number;
+    /**
+     * Called once, with the failure, when the decoder is judged unable to decode
+     * this source at all. Nothing else tells a consumer: a stalled decoder still
+     * accepts every command and answers none of them, so without this the
+     * transport reads as playing over a canvas that will never change again.
+     */
+    readonly onDecodeFailure?: (error: VideoEngineError) => void;
+}
+/**
+ * Caching scrub cursor. Wraps the same decode primitives as CanvasSinkScrubCursor
+ * but routes every random-access seek through a two-tier FrameCache and prefetches
+ * a decode window around the playhead so the next move is already in hand.
+ *
+ * A scrub first reads the cache. An exact hit needs no decode. A preview hit
+ * paints a coarse frame at once, then a crisp decode follows. A miss decodes
+ * straight away. Once the foreground frame settles, a background sweep fills the
+ * cache around the playhead, shaped by how the consumer is moving: neighbor
+ * frames while scrubbing or stepping, a coarse keyframe pass while idle.
+ *
+ * A new gesture signals the sweep to bail and proceeds without waiting for it, so
+ * speculative work never sits on the critical path; mediabunny builds a decoder
+ * per iterator, so a sweep still unwinding alongside a foreground decode costs
+ * memory, not correctness. Every decoded frame is copied into the cache, never
+ * held as a raw VideoFrame, so the decoder is never pinned.
+ */
+export declare class DecodeScheduler implements ScrubCursor {
+    private provider;
+    private readonly cache;
+    private keyframeIndex;
+    private readonly trackInfo;
+    private readonly exactTolMs;
+    private readonly previewTolMs;
+    private readonly now;
+    /** Re-opens the source after a hung decode, or null when it cannot be re-opened. */
+    private readonly reopen;
+    private readonly decodeHangTimeoutMs;
+    private readonly seedHangTimeoutMs;
+    /** Single-flight latch: a watchdog recovery already running. A second hang
+     *  during the rebuild awaits the same recovery rather than racing a second
+     *  dispose/rebuild of the provider. */
+    private recovering;
+    /** True once a hang hit a non-re-openable source: the provider is dead and
+     *  could not be rebuilt, so decodes no-op rather than hang. Surfaced via stats
+     *  so a consumer can show a degraded state instead of a silent freeze. */
+    private decoderDead;
+    /** Consecutive failed rebuilds. One is a transient read; a run of them is a
+     *  source that cannot be re-opened, which is what decoderDead describes. */
+    private failedRebuilds;
+    /** True once the decoder is judged unable to decode this source at all. See
+     *  SchedulerStats.decoderStalled; latched, and it stops the rebuild loop. */
+    private decoderStalled;
+    /** The failure markStalled latched, so a caller still awaiting a decode is
+     *  handed the same one the consumer was told about rather than a parallel
+     *  account of it. */
+    private stallFailure;
+    /** Decode requests the live provider has left unanswered in a row; see
+     *  MAX_UNANSWERED_DECODES. */
+    private unansweredDecodes;
+    private readonly onDecodeFailure;
+    private iterator;
+    private nextInFlight;
+    private nextPending;
+    private currentState;
+    private readonly listeners;
+    private idleResolvers;
+    private settleResolvers;
+    private pendingSeekTargetS;
+    private pendingSeekKeyOnly;
+    private seekDraining;
+    private closed;
+    private lastEmittedFrame;
+    private mode;
+    /** Recent scrub motion. Only its heading is read, which is what decides the
+     *  side of the playhead a scrub window spends most of its budget on. */
+    private readonly trajectory;
+    /** Outstanding background prefetch chain, or null once it unwinds. Awaited
+     *  only by close(), so teardown cannot outrun a sweep still holding a decoder. */
+    private prefetchTask;
+    /** Bumped when a running prefetch is cancelled; that prefetch bails when it
+     *  sees the token move, which is how cancellation propagates. */
+    private prefetchGen;
+    /** Whether a sweep is still depending on the live token. Cleared both by the
+     *  cancellation that supersedes the sweep and by the sweep finishing. */
+    private prefetchArmed;
+    /** Woken when the token moves, so a sweep parked on a decode unwinds at the
+     *  gesture rather than at the end of the decode it is parked on. */
+    private abandonResolvers;
+    private scrubSamples;
+    private scrubSumMs;
+    private scrubMaxMs;
+    private scrubLastMs;
+    /** Ring of recent scrub-decode latencies for p50/p95. Overwrite-oldest so the
+     *  percentile tracks the recent region, not an all-time tail. One push/seek. */
+    private readonly scrubLatencyRing;
+    private scrubLatencyCount;
+    private scrubLatencyHead;
+    private targetVsLandedLastMs;
+    private timeToCrispLastMs;
+    private foregroundDecodes;
+    private prefetchExactFrames;
+    private prefetchPreviewFrames;
+    private keyframeAnchoredEmits;
+    private exactSeeks;
+    private keySeeks;
+    private seekCoalesceOverwrites;
+    constructor(options: DecodeSchedulerOptions);
+    get state(): ScrubCursorState;
+    get track(): ScrubTrackInfo;
+    get playReadAhead(): number;
+    get isIdle(): boolean;
+    open(): Promise<void>;
+    /**
+     * The first frame, on the seed ceiling and its own attempt budget.
+     *
+     * A decoder that accepts this decode and never answers it is the one failure
+     * the rest of the machinery cannot see: nothing has been asked of it twice
+     * yet, so no request budget can run out, and open() is what the load path
+     * awaits, so the wait ends only when the caller above gives up on the whole
+     * worker. Bounding it here turns that into a decoder failure named at the
+     * point it happened.
+     *
+     * Attempts are spent against rebuilt providers wherever the source can be
+     * re-opened, so exhausting them means the source was re-opened that many
+     * times and the first frame never arrived.
+     */
+    private seedFirstFrame;
+    /**
+     * Synchronous best-effort lookup the render loop calls on scrub to paint a
+     * frame this same tick. Pure: it reads the cache and returns a paintable
+     * frame without touching decode or cursor state.
+     */
+    peekCached(timeMs: number): ScrubFrame | null;
+    /**
+     * Resolves once foreground work has settled and any background prefetch
+     * kicked by that settle has drained. The plain idle() contract excludes
+     * prefetch so commits resolve promptly; this awaits full quiescence.
+     */
+    whenSettled(): Promise<void>;
+    /**
+     * Walks the whole track's keyframes into the index, metadata only, so the
+     * diagnostics keyframe lane fills out across the entire file. Decoder-less
+     * (it rides the EncodedPacketSink probe, never the frame sink), so it does
+     * not contend with the foreground decode. Idempotent and best-effort: a
+     * failure just leaves the lane as sparse as the lazy probes made it.
+     */
+    ensureKeyframeIndex(): Promise<void>;
+    getStats(): SchedulerStats;
+    /** Percentile over the bounded recent-latency ring. Copies the live samples
+     *  into a small scratch array and sorts; bounded by SCRUB_LATENCY_RING, and
+     *  this runs only at snapshot time, never per seek. */
+    private scrubPercentile;
+    /** The targets the next prefetch sweep would decode for the current mode
+     *  and position; a pure recompute from existing state. The Idle plan is
+     *  built from the keyframes discovered so far, so it grows as the index
+     *  learns, exactly like the sweep it predicts. */
+    private prefetchPlanMs;
+    seekTo(timestamp: Sec, intent?: SeekIntent): void;
+    seekToKey(timestamp: Sec): void;
+    /** Floors a seek target to the track's first timestamp. A seek below the
+     *  origin (an offset/trimmed clip) has no sample to land on, so it would
+     *  emit nothing; clamping lands it on the first frame instead. */
+    private clampToOrigin;
+    /** Motion sampled across a pause, a step, or a stretch of playback describes
+     *  no hand still on the timeline, so leaving a scrub drops the gesture. */
+    private enterMode;
+    attachPlay(startS: number): void;
+    detachPlay(): void;
+    next(): void;
+    /**
+     * Decodes one named frame of the source and emits it.
+     *
+     * The retrieval is at-or-before a time the frame table produced, and the
+     * demuxer normalises that back to the same integer tick it came from, so it
+     * lands on that frame and no other. Nothing here walks, compares or skips,
+     * so a step across a frame boundary needs no epsilon, and a burst of steps
+     * reuses whatever decode position the session already holds, with no
+     * iterator opened per press.
+     */
+    seekToFrame(frame: FrameId): Promise<ScrubFrame | null>;
+    idle(): Promise<void>;
+    seekSettled(): Promise<void>;
+    subscribe(listener: ScrubFrameListener): () => void;
+    close(): Promise<void>;
+    private drainSeek;
+    private runSeek;
+    private runExactSeek;
+    /**
+     * Whether a decode that outlived its target still improves the picture,
+     * judged from where the gesture has since reached. A drag that outruns the
+     * decoder supersedes every decode it starts, and the screen holds something
+     * older than all of them, so refusing the lot pins the picture at whatever
+     * was up when the drag began.
+     *
+     * Only a gesture reads this way. A jump has one destination and no
+     * intermediate positions worth showing, so a superseded decode there is
+     * work for a place nobody is looking.
+     */
+    private gainsOnTarget;
+    /**
+     * Whether a cached frame earns the screen over what is already on it. A
+     * crisp frame always does. A coarse stand-in exists to bridge the wait for a
+     * decode, so it earns the screen only by landing closer to the target than
+     * what is showing: replacing a crisp frame with a blurry one at the same
+     * position is a visible drop in quality for nothing, and on a slow drag,
+     * where each step lands within a frame of the last, it repeats several times
+     * a second and reads as the picture flickering between sharp and soft.
+     */
+    private worthPainting;
+    private runKeySeek;
+    private pullForwardOne;
+    /**
+     * Bounds a decode so a hung mediabunny decode (which takes no AbortSignal and
+     * cannot be cancelled) never wedges the caller. On timeout it returns null and
+     * kicks provider recovery; the orphaned decode promise is abandoned, since
+     * there is no handle to cancel it. The healthy path resolves before the timer
+     * and behaves exactly as a bare await: the loser timer is cleared, so it adds
+     * no work to a decode that lands in time.
+     *
+     * A rejected decode takes the same route as a hung one. Every caller here is
+     * mid-gesture with no way to answer a decode failure other than to try again
+     * on a working decoder, and a throw would escape the fire-and-forget seek
+     * drain and the play pull chain as an unhandled rejection. Taking that route
+     * is also why an unanswered decode has to be counted here: the failure is
+     * absorbed at this one point, so this is the only place that can tell a
+     * decoder having a bad moment from one that will never answer again.
+     */
+    private withDecodeWatchdog;
+    /**
+     * The same watchdog over a container metadata read. Deliberately unbooked:
+     * the keyframe probe never touches the decoder, so its answer is no evidence
+     * that decoding works, and clearing the stall budget on one would keep a
+     * background sweep forgiving a decoder that answers nothing.
+     */
+    private withProbeWatchdog;
+    private watchdogged;
+    private raceWatchdog;
+    /**
+     * Books one decode the live provider failed to answer, and decides whether
+     * to rebuild or to give up. A decoder that refuses outright says so in the
+     * rejection and there is nothing to rebuild toward; otherwise the runtime
+     * rebuilds until the request budget runs out, which is what stops a source
+     * that re-opens cleanly and then decodes nothing from being rebuilt forever
+     * while every surface reads as healthy.
+     */
+    private noteUnanswered;
+    /** Latches the terminal decoder failure and hands it out exactly once. */
+    private markStalled;
+    /**
+     * Rebuilds the decoder after a hung decode. The old provider is wedged on an
+     * uncancellable decode, so it is disposed and a fresh source opened in its
+     * place; the keyframe index is repointed at the new probe since disposing the
+     * old input invalidated the old one. Single-flight: a second hang during the
+     * rebuild awaits the same recovery. When the source cannot be re-opened (a
+     * one-shot stream), the decoder is marked dead so later decodes no-op rather
+     * than hang, leaving the engine degraded but alive instead of frozen.
+     */
+    private recoverDecoder;
+    /**
+     * The only writer of the generation token, so no bump can move it without
+     * also waking the sweep it cancels. A running sweep bails at its next
+     * checkpoint and is never joined: joining it puts an unbounded background
+     * walk on the critical path of every seek and play pull. The task handle
+     * stays so close() can await teardown.
+     */
+    private abandonPrefetch;
+    /** Resolves the moment `gen` stops being the live prefetch generation. */
+    private whenAbandoned;
+    /**
+     * Kicks a background sweep around `aroundS` for the current access mode.
+     * Fire-and-forget: it waits for any prior sweep to tear down so the decoder
+     * is never used twice at once, then runs under a captured generation token.
+     */
+    private schedulePrefetch;
+    private runPrefetch;
+    private runExactWindow;
+    private runPreviewSweep;
+    private decodeInto;
+    /**
+     * One sweep pull, ended by abandonment rather than by the decode it is
+     * waiting on. A native async generator serializes its request queue, so the
+     * return() that cancellation would issue is queued behind the in-flight
+     * next() and lands only once that walk finishes; the pull itself cannot be
+     * called back. The sweep therefore stops awaiting it and leaves it orphaned,
+     * closing the sample it may still deliver, which the cache will never own.
+     */
+    private pullSwept;
+    private windowTimestamps;
+    /**
+     * How a window's slots divide between the way the gesture is heading and the
+     * way it came from. An unmoving gesture has no direction to favour, so it
+     * splits evenly, which is also what a step or an idle settle wants.
+     */
+    private splitByHeading;
+    /**
+     * Whether reaching `t` backwards is worth it, measured in frames the walk
+     * from its keyframe would decode. The index is what the runtime knows so far,
+     * so an empty one is no evidence and does not veto: guessing a source has no
+     * keyframes would throw away every backward slot on a source that has plenty.
+     */
+    private walkToTargetAffordable;
+    /**
+     * Per-side neighbor count for the current mode, clamped so the whole window
+     * (both sides plus the center already in hand) fits the exact tier. A window
+     * wider than the tier would evict its own freshly decoded frames, so a
+     * re-scrub into the swept region would still miss.
+     */
+    private perSideWindowFrames;
+    private frameIntervalS;
+    private currentPositionS;
+    private emitDecoded;
+    /** Puts a decoded frame in both tiers without painting it, and releases it.
+     *  For a frame worth keeping whose moment to be seen has passed. */
+    private cacheDecoded;
+    private emitCached;
+    private emit;
+    private frameFromCache;
+    private recordScrubLatency;
+    private flushIdleResolvers;
+    private flushSettleResolvers;
+}
+//# sourceMappingURL=decode-scheduler.d.ts.map

package/dist/web-video-engine/decode-scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode-scheduler.d.ts","sourceRoot":"","sources":["../src/decode-scheduler.ts"],"names":[],"mappings":"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"}