supervision 0.1.7 → 0.2.0-next.0

package/dist/web-video-engine/diagnostics.d.ts

@@ -0,0 +1,316 @@
+import type { FrameCacheStats } from "./frame-cache";
+import type { FrameId } from "./frame-timeline";
+import type { GopStats } from "./keyframe-index";
+import type { FrameQuality, SchedulerStats } from "./scrub-cursor";
+import type { PresentationMode } from "./types";
+/** Which render backend is painting the display canvas. */
+export type RendererName = "2d" | "webgpu";
+/** Resolved track facts worth surfacing for diagnostics. decodeWidth/Height
+ *  explain cache slot counts: the exact tier is RAM-budgeted, so large frames
+ *  mean few slots. */
+export interface DiagnosticsTrack {
+    readonly decodeWidth: number;
+    readonly decodeHeight: number;
+    readonly nativeFps: number | null;
+    readonly durationS: number;
+}
+/**
+ * Engine-level diagnostics snapshot the worker assembles on demand. Combines the
+ * renderer (controller-owned), track facts, and the scheduler stats (cursor-
+ * owned, null on the uncached cursor). All plain data, so it crosses the worker
+ * boundary by structured clone.
+ *
+ * This is the legacy getStats shape, kept as a back-compat subset of the richer
+ * DiagnosticsSnapshot the broadcast plane carries. Existing getStats consumers
+ * read these three fields; the diagnostics instrument reads the superset.
+ */
+export interface EngineDiagnostics {
+    readonly renderer: RendererName | null;
+    readonly track: DiagnosticsTrack | null;
+    readonly scheduler: SchedulerStats | null;
+}
+/** Per-paint realtime needles. effectivePaintFps is the painted rate over a
+ *  trailing window of broadcast intervals (see PaintRateMeter), null unless
+ *  playback was up across the whole window, so every snapshot in a series
+ *  carries its own reading. ticks and paints reset at each play start, so they
+ *  count the current play session rather than the source's lifetime.
+ *  catchUpMs is how far the clock ran past the last painted frame.
+ *  playQueueDepth is the decode-ahead buffer's current length: 0 while playing is
+ *  the imminent-stall tell. */
+export interface RealtimeDiagnostics {
+    readonly effectivePaintFps: number | null;
+    readonly catchUpMs: number;
+    readonly lateFrames: number;
+    readonly stalls: number;
+    readonly ticks: number;
+    readonly paints: number;
+    readonly playQueueDepth: number;
+    /** Decoded frames thrown away before reaching the canvas: ones that arrived
+     *  for a position playback had left, buffered ones overtaken by the clock
+     *  moving backwards, and the ones the present cadence declines once the rate
+     *  asks for more frames a second than it. The first two are decode bandwidth
+     *  spent on frames nobody ever saw; the third is the cadence doing its job,
+     *  and at a high rate it dominates the count. */
+    readonly droppedFrames: number;
+}
+/**
+ * Lifetime frame ledger across the decode-to-screen pipe: what the decoder
+ * produced, what reached the canvas, what was discarded on the way. These three
+ * are only meaningful read together; the ratio between decoded and painted is
+ * the cost of every frame nobody saw. Monotonic from load, never reset by a
+ * play session. decodedFrames is null when the decode path cannot report it
+ * (the uncached cursor).
+ */
+export interface PipelineDiagnostics {
+    readonly decodedFrames: number | null;
+    readonly paintedFrames: number;
+    readonly droppedFrames: number;
+}
+/** Last painted frame and its quality; see DiagnosticsSnapshot.screen. */
+export interface ScreenDiagnostics {
+    /** Which frame of the source is up, by the engine's own frame table. */
+    readonly frameId: FrameId;
+    readonly mediaTimeMs: number;
+    readonly quality: FrameQuality;
+}
+/** Cache occupancy in bytes, derived from resident slot counts and frame dims.
+ *  exactBytesPct is the exact tier's fill against its RAM ceiling; a high value
+ *  with a low hit rate is the starved-cache tell. */
+export interface CacheBytesDiagnostics {
+    readonly exactBytes: number;
+    readonly previewBytes: number;
+    readonly exactBudgetBytes: number;
+    readonly exactBytesPct: number;
+}
+/** Track geometry that explains decode cost. nativeWidth/Height come from the
+ *  source track (omitted when the track exposes no native dims). downscaleRatio
+ *  is decodeWidth/nativeWidth; decodeVsDisplayAreaRatio compares the decoded
+ *  frame area to the bound canvas area (>1 means decoding larger than painted). */
+export interface TrackGeometryDiagnostics {
+    readonly nativeWidth: number | null;
+    readonly nativeHeight: number | null;
+    readonly decodeWidth: number;
+    readonly decodeHeight: number;
+    readonly downscaleRatio: number | null;
+    readonly decodeVsDisplayAreaRatio: number | null;
+    readonly boundCanvasWidth: number | null;
+    readonly boundCanvasHeight: number | null;
+}
+/** GOP distribution plus the labelled estimates. estimatedGopWalkDepthFrames is
+ *  an ESTIMATE: frames a worst-case off-anchor scrub would decode, derived from
+ *  avg GOP and native fps, never measured inside the decode loop. */
+export interface GopDiagnostics extends GopStats {
+    /** Media seconds from the playhead to the closest anchor the keyframe index
+     *  has discovered so far. The index fills lazily, so this reads null until it
+     *  holds one and tightens as it walks further. */
+    readonly distanceToNearestKeyframeS: number | null;
+    readonly estimatedGopWalkDepthFrames: number;
+}
+/** Scrub responsiveness aggregates lifted from the scheduler. cacheHitRatePct
+ *  reads 0 when nothing has looked the cache up yet, which is indistinguishable
+ *  from every lookup missing; cacheLookups() is the denominator that tells the
+ *  two apart. */
+export interface ScrubDiagnostics {
+    readonly samples: number;
+    readonly avgMs: number;
+    readonly maxMs: number;
+    readonly p50Ms: number;
+    readonly p95Ms: number;
+    readonly targetVsLandedMs: number;
+    readonly timeToCrispMs: number;
+    readonly cacheHitRatePct: number;
+}
+/**
+ * Seeks served by re-anchoring the running playback walk, the path a seek
+ * issued while playing takes, with the wall time each waited for its crisp
+ * frame. They never reach the cursor, so nothing in ScrubDiagnostics and no
+ * cache lookup counts them. samples is the denominator of avgMs and maxMs: it
+ * trails seeks whenever one is superseded, or the transport stopped under it,
+ * before its crisp frame arrived.
+ */
+export interface PlaySeekDiagnostics {
+    readonly seeks: number;
+    readonly samples: number;
+    readonly avgMs: number;
+    readonly maxMs: number;
+}
+/** Decode/seek/prefetch counters lifted from the scheduler. */
+export interface CounterDiagnostics {
+    readonly foregroundDecodes: number;
+    readonly prefetchExact: number;
+    readonly prefetchPreview: number;
+    readonly keyframeAnchored: number;
+    readonly exactSeeks: number;
+    readonly keySeeks: number;
+    readonly seekCoalesceDepth: number;
+    readonly probeRoundTrips: number;
+    readonly prefetchInFlight: boolean;
+    /**
+     * Background sweeps cancelled since the source opened, as a running total, so
+     * a rate is only ever the delta between two snapshots. Playback schedules no
+     * sweeps, so a clip that only plays never moves this.
+     */
+    readonly prefetchGeneration: number;
+    readonly nextPending: number;
+    /** How long the cursor has been draining a seek uninterrupted, in ms; 0 when
+     *  none is in flight. Every play pull is refused for the whole of it. */
+    readonly seekDrainingForMs: number;
+}
+/**
+ * The page's JS heap in use. Blink exposes performance.memory on Window only,
+ * never in a worker scope, so the worker cannot read this at all: it leaves the
+ * field null and the main thread fills it on receipt, as it does
+ * webgpuAvailable. Null off Blink, and null in a trace, which is assembled
+ * inside the worker.
+ */
+export interface MemoryDiagnostics {
+    readonly jsHeapUsedBytes: number | null;
+}
+/** Severity of a diagnosis, ordered info < warn < critical for sorting. */
+export type WarningSeverity = "info" | "warn" | "critical";
+/**
+ * One self-explaining diagnosis. id is the stable rule key; scenario names what
+ * the runtime is doing wrong in plain language; advice is the fix; evidence is
+ * the human-readable metric values that tripped the rule, so a trace explains
+ * itself to a human or an agent without re-deriving the thresholds.
+ */
+export interface Warning {
+    readonly id: string;
+    readonly severity: WarningSeverity;
+    readonly title: string;
+    readonly scenario: string;
+    readonly advice: string;
+    readonly evidence: string;
+}
+/**
+ * The clone-safe wire snapshot the worker broadcasts at BROADCAST_HZ. A superset
+ * of EngineDiagnostics: it keeps renderer/track/scheduler verbatim so legacy
+ * readers still resolve, and adds the realtime needles, the pipeline ledger,
+ * derived cache bytes, track geometry, GOP block, scrub aggregates, the
+ * play-time seek block, counters, memory, the clock/screen pair, and the
+ * worker-evaluated warnings. Only plain data crosses the boundary.
+ *
+ * webgpuAvailable and memory.jsHeapUsedBytes are the fields the worker leaves at
+ * their empty value for the main thread to fill after the broadcast, so a rule
+ * in evaluateWarnings (which runs in the worker) can never read them, and an
+ * exported trace, assembled worker-side, carries the unfilled value. Warnings
+ * are evaluated once, worker-side, so the HUD and an exported trace always show
+ * the same diagnoses.
+ */
+/**
+ * Source bytes this process holds, for a host that wants to show a viewer how
+ * much of the clip is local. Null unless the engine was loaded with
+ * `sourceResidency`; nothing else in the runtime can answer it, because the
+ * demuxer's own reads and the browser cache are both opaque from here.
+ */
+export interface SourceResidencyDiagnostics {
+    readonly ranges: readonly {
+        readonly start: number;
+        readonly end: number;
+    }[];
+    readonly residentBytes: number;
+    readonly totalBytes: number | null;
+    readonly prefetchedBytes: number;
+    readonly warming: boolean;
+}
+export interface DiagnosticsSnapshot {
+    /**
+     * Which presentation the engine was loaded for. `renderer` and the geometry
+     * fields that need a bound canvas are null for the whole life of a "frames"
+     * engine, which holds none by design; without this a reader cannot tell that
+     * from a "canvas" engine whose renderer has not resolved yet.
+     */
+    readonly presentation: PresentationMode;
+    readonly renderer: RendererName | null;
+    readonly track: DiagnosticsTrack | null;
+    readonly scheduler: SchedulerStats | null;
+    readonly realtime: RealtimeDiagnostics;
+    readonly pipeline: PipelineDiagnostics;
+    readonly cacheBytes: CacheBytesDiagnostics;
+    readonly geometry: TrackGeometryDiagnostics;
+    readonly gop: GopDiagnostics;
+    readonly scrub: ScrubDiagnostics;
+    readonly playSeek: PlaySeekDiagnostics;
+    readonly counters: CounterDiagnostics;
+    readonly memory: MemoryDiagnostics;
+    readonly sourceResidency: SourceResidencyDiagnostics | null;
+    readonly nativeFps: number | null;
+    /** Media seconds per wall second the transport was told to run at. */
+    readonly rate: number;
+    /**
+     * The same figure measured off the canvas: media seconds of picture actually
+     * presented per wall second, over a trailing window; null unless playback was
+     * up across the whole of it. Read against `rate` it answers the one question
+     * a commanded rate cannot, which is whether the picture is really moving that
+     * fast. Falling short means frames are arriving slower than the clock wants
+     * them, so the picture lags further behind the playhead every second.
+     *
+     * It is a window over whole paints, so it quantises when paints are sparse: a
+     * slow rate on a low-fps source reads low from a healthy pipeline. Read it
+     * against catchUpMs before concluding anything from a shortfall.
+     */
+    readonly presentedRate: number | null;
+    /** The engine clock at assembly, ms; null before load. Paused, it holds the
+     *  last commanded target; playing, it advances at rate. The one value the
+     *  instruments draw the playhead from, so the playhead and the coverage
+     *  lanes cannot disagree about where "now" is. */
+    readonly playheadMs: number | null;
+    /** What is actually on the canvas: last painted position and its quality;
+     *  null before the first paint. Its distance from playheadMs is the live
+     *  landing error (paused) or catch-up depth (playing). A sampled
+     *  observation for instruments; frame identity for consumers still travels
+     *  only on the paint event. */
+    readonly screen: ScreenDiagnostics | null;
+    readonly status: string;
+    readonly webgpuAvailable: boolean;
+    readonly warnings: Warning[];
+}
+/**
+ * Painted-frame rate over a trailing window of broadcast intervals, fed once
+ * per snapshot. A single interval can only hold whole paints, so its rate
+ * quantises hard; the trailing window smooths that without collapsing the
+ * series into a whole-capture average, which could confirm "playback is slow"
+ * but never locate it in time.
+ */
+export declare class PaintRateMeter {
+    private readonly windowSize;
+    private readonly samples;
+    constructor(windowSize?: number);
+    /** Rate in paints/second, or null unless playback was up across the whole
+     *  window. A pause or a paints reset (each play session restarts the
+     *  counter) invalidates the window, not just the sample. */
+    sample(atMs: number, paints: number, playing: boolean): number | null;
+}
+/**
+ * Playback speed measured off what reached the canvas: media seconds presented
+ * per wall second, over the same trailing window PaintRateMeter uses. Fed the
+ * last painted media position once per snapshot.
+ *
+ * It reads painted positions, not paint counts: a source can paint at a healthy
+ * 30fps while the clock runs at 4x, and only the distance the picture travelled
+ * shows that the two disagree.
+ */
+export declare class PresentedRateMeter {
+    private readonly windowSize;
+    private readonly samples;
+    constructor(windowSize?: number);
+    /** Rate in media seconds per wall second, or null unless playback was up
+     *  across the whole window with the picture moving forward through it. */
+    sample(atMs: number, paintedMs: number | null, playing: boolean): number | null;
+    /** Drops the window, so a rate change is not measured across its own edge. */
+    reset(): void;
+}
+/**
+ * Cache lookups across every tier. Only an exact seek looks the cache up, so
+ * playback and key seeks never move this and a play-only session sits at zero.
+ * A rule or readout that reads the hit rate without this denominator reports a
+ * cold cache as a failing one.
+ */
+export declare function cacheLookups(cache: FrameCacheStats | null | undefined): number;
+/**
+ * Pure threshold evaluator. Reads a snapshot and returns the active diagnoses,
+ * critical first. Used both in the worker (so the broadcast carries warnings the
+ * UI and the trace share) and in tests. No I/O, no side effects.
+ */
+export declare function evaluateWarnings(snapshot: DiagnosticsSnapshot): Warning[];
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/web-video-engine/diagnostics.d.ts.map

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

package/dist/web-video-engine/embedded-engine-worker.d.ts

@@ -0,0 +1,2 @@
+export declare const EMBEDDED_ENGINE_WORKER_SOURCE = "__SUPERVISION_JS_EMBEDDED_ENGINE_WORKER_SOURCE__";
+//# sourceMappingURL=embedded-engine-worker.d.ts.map

package/dist/web-video-engine/embedded-engine-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedded-engine-worker.d.ts","sourceRoot":"","sources":["../src/embedded-engine-worker.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,6BAA6B,qDACU,CAAC"}

package/dist/web-video-engine/engine-core.d.ts

@@ -0,0 +1,258 @@
+import { type MediaClock } from "./clock";
+import type { FrameLanding } from "./frame-timeline";
+import { type EngineDiagnostics } from "./diagnostics";
+import { type SeekIntent } from "./scrub-cursor";
+import { type EngineTrace } from "./trace-recorder";
+import { type EngineReadySnapshot } from "./types";
+import { type DiagnosticsEvent, type EngineLoadConfig, type MirrorEvent, type PresentedFrameEvent, type SerializedViewport } from "./worker-protocol";
+export interface EngineCoreOptions {
+    /** Sink for broadcast state. The worker host serializes each event onto
+     *  the state plane; tests collect them to assert transitions. */
+    emit: (event: MirrorEvent) => void;
+    /** Sink for the diagnostics broadcast (the non-mirror 'diag' arm). Optional:
+     *  when absent the broadcaster has nowhere to post, so a consumer that never
+     *  wires it pays nothing. The worker host wires it to the same postMessage. */
+    emitDiagnostics?: (event: DiagnosticsEvent) => void;
+    /** Sink for the pixel plane, which carries frames only in "frames"
+     *  presentation mode. The VideoFrame is handed over on the transfer list, so
+     *  a host wiring this to postMessage detaches the worker's reference by
+     *  posting it. Unwired there is no receiver, so the core closes each frame
+     *  instead of leaking it. */
+    emitPresentedFrame?: (event: PresentedFrameEvent, transfer: Transferable[]) => void;
+    /** Clock seam. Defaults to the wall-clock PerformanceMediaClock; tests
+     *  inject a fake so they can drive media time deterministically. */
+    clock?: MediaClock;
+}
+/**
+ * The engine, with every main-thread concern removed. Owns the clock, cursor,
+ * and render controller; runs entirely inside the worker. It never touches the
+ * DOM, a React store, the playhead, or the imperative handle.
+ *
+ * It speaks two languages. Broadcast state (time, frame index, status,
+ * duration, seeking) leaves through the `emit` callback. Command results that
+ * the main thread cannot predict (load metadata, the frame a step lands on)
+ * are method return values the worker host correlates back to the caller.
+ *
+ * Time is emitted only while playing. Paused positions are owned by the main
+ * thread (written optimistically on scrub, or applied from step's return), so
+ * the core never emits a competing time that would yank a settled playhead.
+ */
+export declare class EngineCore {
+    private readonly emit;
+    private readonly emitDiagnostics;
+    private readonly emitPresentedFrame;
+    private readonly clock;
+    private cursor;
+    private residency;
+    private controller;
+    private canvas;
+    private viewport;
+    /** The box the host said it paints these frames into, kept from the load
+     *  command. Under "frames" presentation nothing ever measures a canvas here,
+     *  so this is the only display geometry the engine is ever given. */
+    private displayBox;
+    private metadata;
+    /**
+     * The decoder failure the runtime has given up on, latched. Nothing the
+     * transport is asked to do afterwards can decode a frame, so nothing it is
+     * asked to do may report otherwise: a play() that answered "playing" over a
+     * decoder that had already been condemned is how a source with one unusable
+     * entry point read as healthy for the rest of the session.
+     */
+    private decodeFailure;
+    private presentation;
+    private durationMs;
+    private paintSeq;
+    private playing;
+    /** The frame the last step landed on. A serialized burst resolves each
+     *  step before its rAF paints, so getLastPaintedMs lags by one or more
+     *  steps; basing the next step on the actual landing keeps every step in a
+     *  burst advancing exactly one frame instead of re-stepping a stale base. */
+    private lastStepLanded;
+    /** Where the current seek's walk actually landed, known once a crisp frame
+     *  for it has painted. A requested time is not a frame time: it comes from a
+     *  marker rail or a pointer, so it usually sits between two samples. Walking
+     *  backward from it reaches the sample already on screen and the press reads
+     *  as dead. Null until that crisp paint arrives, so a step pressed before it
+     *  still falls back to the clock. */
+    private seekLanded;
+    /** The seek still waiting on that paint, or null when none is. Every paint
+     *  the engine makes runs through this latch, and the render loop paints one
+     *  frame per animation frame from a stash a previous seek may have filled,
+     *  so without the target on it any leftover frame answers for the seek in
+     *  flight and publishes itself as the playhead. */
+    private awaitedSeek;
+    /** Wall stamp of a seek being served by re-anchoring the playback walk, or
+     *  null when no such seek is waiting on its crisp frame. */
+    private playSeekStartedAtMs;
+    private playSeeks;
+    private playSeekSamples;
+    private playSeekSumMs;
+    private playSeekMaxMs;
+    /** The frame the last paint put up, for the diagnostics screen readout. */
+    private lastPaintedId;
+    /** Mirrors VideoEngine's interactive-seek latch: true when a drag paused a
+     *  playing engine, so endInteractiveSeek knows to resume. */
+    private resumeAfterInteractiveSeek;
+    /** Worker-realm broadcast timer handle, or null when diagnostics are off. */
+    private diagnosticsTimer;
+    /** Wall time the cursor was first seen draining a seek, or null while it is
+     *  not. How long a state has lasted is a diagnostics question, so it is
+     *  timed here rather than on the scheduler, whose clock is the seam tests
+     *  drive latency measurements through. */
+    private drainingSinceMs;
+    private readonly paintRateMeter;
+    private readonly presentedRateMeter;
+    /** Lazily allocated on traceArm, freed on disarm; zero memory off. */
+    private traceRecorder;
+    /** The last assembled trace, kept after disarm so a stopped capture stays
+     *  downloadable until the next arm. Null while armed or never captured. */
+    private stoppedTrace;
+    constructor(options: EngineCoreOptions);
+    /**
+     * Receives the transferred display canvas and its measured box. Stored
+     * even when the controller does not exist yet (bindCanvas can arrive
+     * before load) and bound as soon as load builds the controller. Passing
+     * null tears the binding down and stops the render loop.
+     */
+    setCanvas(canvas: OffscreenCanvas | null, viewport?: SerializedViewport): void;
+    load(config: EngineLoadConfig): Promise<EngineReadySnapshot>;
+    play(): void;
+    pause(): void;
+    togglePlayback(): void;
+    /**
+     * Sets how fast media time runs against wall time. The clock re-anchors, so
+     * a change mid-playback bends the slope without moving the playhead, and the
+     * decode-ahead buffer keeps its frames: they are positions in media time,
+     * which a rate change does not touch. Applied while paused it simply waits,
+     * since a paused clock advances at no rate at all.
+     *
+     * Throws on a rate outside the supported forward range.
+     */
+    setPlaybackRate(rate: number): void;
+    getPlaybackRate(): number;
+    /** Fire-and-forget seek onto a named frame. Emits no playhead: the main
+     *  thread snapped the gesture and wrote it. Paints a cache preview, then
+     *  walks the cursor. */
+    scrub(frameIndex: number, intent?: SeekIntent): void;
+    /** Moves a running playback walk to `tSec`. The clock is already there. */
+    private reanchorPlayback;
+    /** Closes the wait of a seek served by re-anchoring, at the crisp paint that
+     *  ends it. A seek that walked the cursor leaves no stamp; the scheduler
+     *  times those. Stopping the transport abandons the wait: its frame can
+     *  still paint minutes later, and the idle time between is not a wait
+     *  anyone had, so the seek keeps its count and loses its sample. */
+    private closePlaySeekWait;
+    commit(frameIndex: number): Promise<FrameLanding | null>;
+    seekToKey(timeMs: number): Promise<FrameLanding | null>;
+    /**
+     * Moves one frame along the source in presentation order and returns where
+     * it landed, or null at either end. Only the worker knows which frame a
+     * decode produced, so the landing is the command's return value. The stepped
+     * frame paints worker-side via the controller and emits a paint like any
+     * other.
+     */
+    step(direction: 1 | -1): Promise<FrameLanding | null>;
+    /** Append a runtime event to the trace ring, stamped with worker-clock time
+     *  since arm. Predicted-false and free when no trace is armed. */
+    private pushTraceEvent;
+    /** Broadcast a status transition and record it on the trace ring, so an
+     *  exported trace shows the playback-state timeline alongside paints/seeks. */
+    private emitStatus;
+    /**
+     * The decoder cannot decode this source, and nothing else was going to say
+     * so: a stalled decoder keeps accepting commands and the clock keeps
+     * running, so playback reads as healthy over a canvas that will never change
+     * again. Stop the transport first, then report, so the status a consumer
+     * sees and what the engine is doing agree.
+     */
+    private handleDecodeFailure;
+    /** Says the failure again for whoever just asked the transport to move. A
+     *  consumer that only listens for changes has already been told; one that
+     *  reads the status after its own command has to find the same answer. */
+    private republishFailure;
+    beginInteractiveSeek(): void;
+    endInteractiveSeek(): void;
+    dispose(): Promise<void>;
+    /** True only when the cursor exists and reports settled. Mirrors
+     *  VideoEngine.isIdle for tests; the facade derives its own from state. */
+    isIdle(): boolean;
+    /** Engine diagnostics snapshot (renderer, track facts, scheduler stats), or
+     *  null before load. The scheduler field is null on the uncached cursor. */
+    getStats(): EngineDiagnostics | null;
+    private observeSeekIdle;
+    private handleEnded;
+    private awaitSeekLanding;
+    private forgetSeekLanding;
+    /** Releases the latch of a seek that has already answered its caller. The
+     *  landing rode back on the return value, so a paint arriving after it would
+     *  move the playhead to somewhere the caller was never told about. */
+    private closeSeekLanding;
+    /**
+     * Whether this paint is the landing of the seek waiting on one.
+     *
+     * An exact walk answers at or before the frame it aimed at, and no further
+     * back than the sample next to it, so the target falls inside the answering
+     * frame's own span. That span is the whole test: a frame decoded for some
+     * earlier position sits outside it however recently it was painted.
+     */
+    private answersAwaitedSeek;
+    /** The frame table of the loaded source. Reached only from paths that have
+     *  already established a cursor, which is what carries it. */
+    private timeline;
+    private landingOf;
+    /**
+     * Points the background walk at where the viewer is, as a byte offset. The
+     * file's own byte layout is not exposed, so this reads position as a share of
+     * duration: enough to order the walk outward from the playhead, and wrong by
+     * at most the amount the bitrate varies.
+     */
+    private aimResidency;
+    private onPaint;
+    /**
+     * Posts one frame with the identity of the paint it came from, in the same
+     * message. With no sink wired there is no receiver, so the frame is closed
+     * here: the controller has already let go of it, and a frame left open pins
+     * a decoder buffer.
+     */
+    private present;
+    /**
+     * Starts the worker-realm broadcast timer at hz (default BROADCAST_HZ) and
+     * flips the controller's per-rAF counter gate on. Decode-independent: the
+     * timer callback does synchronous reads plus one post, never an await and
+     * never the sink, so it runs between event-loop tasks, not inside a decode.
+     */
+    diagnosticsStart(hz?: number): void;
+    diagnosticsStop(): void;
+    /** Lazily allocate the trace rings and begin capturing. windowMs sizes the
+     *  snapshot ring alone: the event ring is fed by paints and gestures at no
+     *  fixed rate, so wall clock cannot size it. */
+    traceArm(windowMs: number): void;
+    /** Stop capturing and free the rings, but keep the assembled trace so it can
+     *  still be exported. A record-then-stop-then-download flow would otherwise
+     *  lose the capture, since stop used to null the recorder outright. */
+    traceDisarm(): void;
+    /** The current capture if still armed, else the last stopped capture. Non
+     *  destructive so a download can be retried; a new arm clears the stopped one. */
+    traceExport(): EngineTrace | null;
+    /**
+     * Assembles ONE snapshot and posts it as the 'diag' event. When a trace is
+     * armed, the SAME reference is ring-appended, so there is no second
+     * serialization. Synchronous: reads current stats, never awaits, never paints.
+     */
+    private broadcastDiagnostics;
+    private assembleSnapshot;
+    private statusString;
+    /**
+     * CSS width the picture occupies inside the box the host declared, native
+     * aspect fitted into it, or null when no box was declared. A portrait source
+     * in a landscape box paints far narrower than the box, so the fit is what the
+     * ratio has to be measured against.
+     */
+    private paintedBoxCssWidth;
+    /** The ratio whichever side measured one reported, or null when neither did.
+     *  The engine has no window of its own to read it off. */
+    private devicePixelRatio;
+    private traceEnvironment;
+}
+//# sourceMappingURL=engine-core.d.ts.map

package/dist/web-video-engine/engine-core.d.ts.map

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

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

@@ -0,0 +1,26 @@
+export { VideoEngine } from "./video-engine";
+export type { VideoEngineHandle, VideoEngineOptions } from "./video-engine";
+export { SourceKind } from "./types";
+export type { BlobVideoSource, StreamVideoSource, UrlSourceReadConfig, UrlVideoSource, VideoMetadata, VideoSource, } from "./types";
+export { PlaybackStatus } from "./types";
+export type { EngineChannel, EngineReadySnapshot, PaintSeq, PlaybackState, } from "./types";
+export type { PresentationMode } from "./types";
+export type { PresentedFrame } from "./worker-protocol";
+export type { PresentedFrameHandler } from "./video-engine";
+export type { FrameQuality } from "./scrub-cursor";
+export type { Rotation } from "./rotation";
+export { FrameTimeline } from "./frame-timeline";
+export type { FrameId, FrameLanding, FrameTimelineData, TickRate, } from "./frame-timeline";
+export type { SeekIntent } from "./scrub-cursor";
+export type { SeekTarget } from "./video-engine";
+export { PLAYBACK_RATE } from "./constants";
+export { asFps, asPaintSeq, asSec } from "./types";
+export type { Fps, Sec } from "./types";
+export { cappedResolution, displayBoxResolution, nativeResolution, viewportResolution, } from "./decode-resolution";
+export type { DecodeResolutionStrategy, DisplayBoxResolutionOptions, ViewportResolutionOptions, } from "./decode-resolution";
+export { VideoEngineError, VideoEngineErrorCode } from "./types";
+export type { Warning, WarningSeverity } from "./diagnostics";
+export type { DiagnosticsSnapshot, SourceResidencyDiagnostics, } from "./diagnostics";
+export type { SourceResidencyConfig } from "./worker-protocol";
+export { DIAGNOSTICS, TRACE_RING_BOUNDS } from "./constants";
+//# sourceMappingURL=engine.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,YAAY,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAG5E,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,YAAY,EACV,eAAe,EACf,iBAAiB,EACjB,mBAAmB,EACnB,cAAc,EACd,aAAa,EACb,WAAW,GACZ,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AACzC,YAAY,EACV,aAAa,EACb,mBAAmB,EACnB,QAAQ,EACR,aAAa,GACd,MAAM,SAAS,CAAC;AAGjB,YAAY,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAChD,YAAY,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,YAAY,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAC5D,YAAY,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,YAAY,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,YAAY,EACV,OAAO,EACP,YAAY,EACZ,iBAAiB,EACjB,QAAQ,GACT,MAAM,kBAAkB,CAAC;AAG1B,YAAY,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,YAAY,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACnD,YAAY,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,SAAS,CAAC;AAGxC,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EACV,wBAAwB,EACxB,2BAA2B,EAC3B,yBAAyB,GAC1B,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AACjE,YAAY,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAG9D,YAAY,EACV,mBAAmB,EACnB,0BAA0B,GAC3B,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC"}