@ksp-gonogo/sitrep-sdk 0.0.1 → 0.2.0-rc.12

package/dist/media/frame-delay.d.ts

@@ -0,0 +1,204 @@
+/**
+ * The per-frame video delay pipeline.
+ *
+ * Delaying at the `MediaStream` *reference* level, one keyframe per stream, is
+ * not enough: a reference changes only on a camera switch or reconnect, so only
+ * *when a feed became visible* is delayed, while ongoing motion inside that
+ * stream plays live. This module reads the real video
+ * track frame-by-frame (WebCodecs "Breakout Box": `MediaStreamTrackProcessor`
+ * / `MediaStreamTrackGenerator`, see `webcodecs-track-io.d.ts`), stamps EACH
+ * frame with the live interpolated capture UT, and gates release through
+ * the SAME `DelayedPlayoutBuffer` telemetry uses (never `arrival + delay`,
+ * only `confirmedEdgeUt()`, the single-authority guarantee).
+ *
+ * `runFrameDelayPipeline` is the pure engine: deliberately decoupled from
+ * the real WebCodecs constructors (source/sink are the minimal
+ * `ReadableStreamDefaultReader`/`WritableStreamDefaultWriter` shapes, which
+ * a real processor/generator satisfy directly with no adapter) so it can be
+ * driven with synthetic frames + a manual clock in
+ * `frame-delay.block-colour.test.ts`: the real per-frame proof that would
+ * have caught the original gap. `createFrameDelayStream` is the thin
+ * browser-facing wrapper that supplies the real objects.
+ *
+ * Browser support: `MediaStreamTrackProcessor`/`Generator` are Chromium-only
+ * as of writing. `isFrameDelaySupported()` feature-detects, and the caller
+ * (the camera feed) tries the worker backends in `worker/` when this one is
+ * unsupported. When none can delay the feed it shows no video: a feed that
+ * cannot be delayed is never shown live.
+ *
+ * Buffer cap: `DelayedPlayoutBuffer`'s existing `maxBufferedBytes` cap
+ * doubles here as a FRAME-COUNT cap (every queued item counts `bytes: 1`,
+ * real per-frame byte sizes aren't tracked). Default 300 frames is ~10s of
+ * headroom at 30fps, comfortably above the realistic multi-second delay
+ * range this app models; over-cap eviction drops the oldest queued frame
+ * (closing it via `onDrop`) rather than growing unboundedly.
+ */
+import { type DelayClockLike } from "./delayed-playout-buffer.js";
+/**
+ * A frame the delay can hold. A decoded `VideoFrame` holds browser resources
+ * and must be closed exactly once, so the delay calls `close` on every frame it
+ * is done with. An encoded frame has nothing to close, so `close` is optional.
+ *
+ * @category Delayed video
+ */
+export interface FrameLike {
+    close?(): void;
+}
+/**
+ * Where the delay reads frames from: a `ReadableStreamDefaultReader`, such as
+ * the one `MediaStreamTrackProcessor.readable.getReader()` returns.
+ *
+ * @category Delayed video
+ */
+export type FrameSource<Frame extends FrameLike> = Pick<ReadableStreamDefaultReader<Frame>, "read" | "cancel">;
+/**
+ * Where the delay writes frames to: a `WritableStreamDefaultWriter`, such as
+ * the one `MediaStreamTrackGenerator.writable.getWriter()` returns.
+ *
+ * @category Delayed video
+ */
+export type FrameSink<Frame extends FrameLike> = Pick<WritableStreamDefaultWriter<Frame>, "write" | "close">;
+/**
+ * Options for `runFrameDelayPipeline`.
+ *
+ * @category Delayed video
+ */
+export interface FrameDelayPipelineOptions<Frame extends FrameLike> {
+    /**
+     * The app's view clock, the same one telemetry is read by.
+     */
+    view: DelayClockLike;
+    /**
+     * Returns the UT to stamp a frame with, called once for each frame as it is
+     * read from `source`.
+     */
+    captureUt(): number;
+    source: FrameSource<Frame>;
+    sink: FrameSink<Frame>;
+    /**
+     * The most frames to hold before dropping the oldest. Defaults to 300. With
+     * `frameBytes` supplied, the cap counts bytes instead.
+     */
+    maxBufferedFrames?: number;
+    /** Non-fatal pipeline errors (a read/write rejection), reported here,
+     *  never thrown across the internal pump loop. */
+    onError?(error: unknown): void;
+    /**
+     * Whether a frame is a keyframe. Defaults to never, which suits decoded
+     * frames; for encoded video, supply `(f) => f.type === "key"`.
+     */
+    isKeyframe?(frame: Frame): boolean;
+    /**
+     * A frame's size for the cap. Defaults to 1, so the cap counts frames; for
+     * encoded video, supply `(f) => f.data.byteLength`.
+     */
+    frameBytes?(frame: Frame): number;
+    /**
+     * Passed to {@link DelayedPlayoutBuffer}: `true` for encoded video, unset for
+     * decoded.
+     */
+    gopSafeEviction?: boolean;
+    /**
+     * Spaces released frames out by their own UT intervals rather than writing
+     * them at once (see {@link PresentationPacer}). Unset, each frame is written
+     * as it is released. When set, call `pipeline.tickPacing(nowWall)` about 60
+     * times a second, as {@link startPacingTicker} does.
+     */
+    pacing?: {
+        /** See `PresentationPacerOptions.maxBacklogSeconds`. */
+        maxBacklogSeconds: number;
+    };
+}
+/**
+ * A running frame delay pipeline, as `runFrameDelayPipeline` returns it.
+ *
+ * @category Delayed video
+ */
+export interface FrameDelayPipeline {
+    /** Drop (closing) whatever's currently queued, WITHOUT tearing down
+     *  source/sink: the timeline-reset case (revert/quickload/scene reload): the
+     *  track keeps flowing, only the pre-reset backlog is discarded so it can
+     *  never surface once the clock sweeps back past those UTs post-reset. */
+    flush(): void;
+    /** Stop reading, close the sink, and drop (closing) anything still
+     *  queued. Idempotent: safe to call more than once. */
+    dispose(): void;
+    /** No-op when `pacing` wasn't supplied to `runFrameDelayPipeline`.
+     *  Otherwise drains any presentation due at `nowWall` (wall-clock
+     *  seconds, same basis the caller's own clock reads) through the
+     *  pacer: see `pacing`'s doc above. */
+    tickPacing(nowWall: number): void;
+}
+/**
+ * Reads frames from `source`, holds each until the clock reaches its UT, and
+ * writes it to `sink`. Every frame read is closed exactly once: after it is
+ * written, when it is dropped (over the buffer's cap, on `flush()`, or still
+ * held at `dispose()`), or at once if it arrives after `dispose()`.
+ *
+ * @category Delayed video
+ */
+export declare function runFrameDelayPipeline<Frame extends FrameLike>(opts: FrameDelayPipelineOptions<Frame>): FrameDelayPipeline;
+/**
+ * Calls `tickPacing` about 60 times a second until the returned function is
+ * called: on each animation frame where there is one, and every 16 ms where
+ * there is not, as in a worker.
+ *
+ * @category Delayed video
+ */
+export declare function startPacingTicker(tickPacing: (nowWall: number) => void, nowWall?: () => number): () => void;
+/**
+ * Whether this browser has the WebCodecs track APIs
+ * (`MediaStreamTrackProcessor` and `MediaStreamTrackGenerator`) that
+ * {@link createFrameDelayStream} needs.
+ *
+ * @category Delayed video
+ */
+export declare function isFrameDelaySupported(): boolean;
+/**
+ * Options for `createFrameDelayStream`.
+ *
+ * @category Delayed video
+ */
+export interface CreateFrameDelayStreamOptions {
+    view: DelayClockLike;
+    captureUt(): number;
+    maxBufferedFrames?: number;
+    onError?(error: unknown): void;
+    /** Override the presentation pacer's backlog threshold: see
+     *  `DEFAULT_PACING_MAX_BACKLOG_SECONDS`. Pacing itself can't be disabled
+     *  here: this backend always paces (that's the actual jank fix; see
+     *  `worker/presentation-pacer.ts`'s module doc), only the threshold is
+     *  tunable. */
+    maxPacingBacklogSeconds?: number;
+}
+/**
+ * A delayed copy of a video stream, as `createFrameDelayStream` returns it.
+ *
+ * @category Delayed video
+ */
+export interface FrameDelayStream {
+    /** The delayed output: feed this to a `<video>`'s `srcObject`. */
+    stream: MediaStream;
+    dispose(): void;
+    flush(): void;
+}
+/**
+ * The whole of `MediaStream` this reads. Narrower than the DOM type on purpose:
+ * a `MediaStream` cannot be constructed outside a browser, so a test standing in
+ * for one would otherwise have to be minted through an assertion.
+ */
+export interface VideoTrackSource {
+    getVideoTracks(): MediaStreamTrack[];
+}
+/**
+ * A delayed copy of the first video track of `raw`, the `MediaStream` as it
+ * arrived, such as the one a WebRTC connection hands over. Returns `null`, and never
+ * throws, when that cannot be built here: the browser lacks the APIs, `raw`
+ * has no video track, or building the track pipeline threw. Show no video in
+ * that case, and say the delay is unavailable. Never show `raw`: it is the
+ * live picture, ahead of everything else the operator is looking at.
+ *
+ * @category Delayed video
+ */
+export declare function createFrameDelayStream(raw: VideoTrackSource, opts: CreateFrameDelayStreamOptions): FrameDelayStream | null;
+//# sourceMappingURL=frame-delay.d.ts.map

package/dist/media/frame-delay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame-delay.d.ts","sourceRoot":"","sources":["../../src/media/frame-delay.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,EACL,KAAK,cAAc,EAEpB,MAAM,0BAA0B,CAAC;AAGlC;;;;;;GAMG;AACH,MAAM,WAAW,SAAS;IACxB,KAAK,CAAC,IAAI,IAAI,CAAC;CAChB;AAED;;;;;GAKG;AACH,MAAM,MAAM,WAAW,CAAC,KAAK,SAAS,SAAS,IAAI,IAAI,CACrD,2BAA2B,CAAC,KAAK,CAAC,EAClC,MAAM,GAAG,QAAQ,CAClB,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,SAAS,CAAC,KAAK,SAAS,SAAS,IAAI,IAAI,CACnD,2BAA2B,CAAC,KAAK,CAAC,EAClC,OAAO,GAAG,OAAO,CAClB,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,yBAAyB,CAAC,KAAK,SAAS,SAAS;IAChE;;OAEG;IACH,IAAI,EAAE,cAAc,CAAC;IACrB;;;OAGG;IACH,SAAS,IAAI,MAAM,CAAC;IACpB,MAAM,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC;IAC3B,IAAI,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC;IACvB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;sDACkD;IAClD,OAAO,CAAC,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAC/B;;;OAGG;IACH,UAAU,CAAC,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC;IACnC;;;OAGG;IACH,UAAU,CAAC,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC;IAClC;;;OAGG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;OAKG;IACH,MAAM,CAAC,EAAE;QACP,wDAAwD;QACxD,iBAAiB,EAAE,MAAM,CAAC;KAC3B,CAAC;CACH;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;8EAG0E;IAC1E,KAAK,IAAI,IAAI,CAAC;IACd;2DACuD;IACvD,OAAO,IAAI,IAAI,CAAC;IAChB;;;2CAGuC;IACvC,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAID;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,SAAS,SAAS,EAC3D,IAAI,EAAE,yBAAyB,CAAC,KAAK,CAAC,GACrC,kBAAkB,CAkFpB;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,EACrC,OAAO,GAAE,MAAM,MAAuC,GACrD,MAAM,IAAI,CAiBZ;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,IAAI,OAAO,CAK/C;AAUD;;;;GAIG;AACH,MAAM,WAAW,6BAA6B;IAC5C,IAAI,EAAE,cAAc,CAAC;IACrB,SAAS,IAAI,MAAM,CAAC;IACpB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAC/B;;;;mBAIe;IACf,uBAAuB,CAAC,EAAE,MAAM,CAAC;CAClC;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,kEAAkE;IAClE,MAAM,EAAE,WAAW,CAAC;IACpB,OAAO,IAAI,IAAI,CAAC;IAChB,KAAK,IAAI,IAAI,CAAC;CACf;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,cAAc,IAAI,gBAAgB,EAAE,CAAC;CACtC;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,gBAAgB,EACrB,IAAI,EAAE,6BAA6B,GAClC,gBAAgB,GAAG,IAAI,CAqDzB"}

package/dist/media/frame-delay.js

@@ -0,0 +1,237 @@
+/// <reference path="./webcodecs-track-io.d.ts" />
+/**
+ * The per-frame video delay pipeline.
+ *
+ * Delaying at the `MediaStream` *reference* level, one keyframe per stream, is
+ * not enough: a reference changes only on a camera switch or reconnect, so only
+ * *when a feed became visible* is delayed, while ongoing motion inside that
+ * stream plays live. This module reads the real video
+ * track frame-by-frame (WebCodecs "Breakout Box": `MediaStreamTrackProcessor`
+ * / `MediaStreamTrackGenerator`, see `webcodecs-track-io.d.ts`), stamps EACH
+ * frame with the live interpolated capture UT, and gates release through
+ * the SAME `DelayedPlayoutBuffer` telemetry uses (never `arrival + delay`,
+ * only `confirmedEdgeUt()`, the single-authority guarantee).
+ *
+ * `runFrameDelayPipeline` is the pure engine: deliberately decoupled from
+ * the real WebCodecs constructors (source/sink are the minimal
+ * `ReadableStreamDefaultReader`/`WritableStreamDefaultWriter` shapes, which
+ * a real processor/generator satisfy directly with no adapter) so it can be
+ * driven with synthetic frames + a manual clock in
+ * `frame-delay.block-colour.test.ts`: the real per-frame proof that would
+ * have caught the original gap. `createFrameDelayStream` is the thin
+ * browser-facing wrapper that supplies the real objects.
+ *
+ * Browser support: `MediaStreamTrackProcessor`/`Generator` are Chromium-only
+ * as of writing. `isFrameDelaySupported()` feature-detects, and the caller
+ * (the camera feed) tries the worker backends in `worker/` when this one is
+ * unsupported. When none can delay the feed it shows no video: a feed that
+ * cannot be delayed is never shown live.
+ *
+ * Buffer cap: `DelayedPlayoutBuffer`'s existing `maxBufferedBytes` cap
+ * doubles here as a FRAME-COUNT cap (every queued item counts `bytes: 1`,
+ * real per-frame byte sizes aren't tracked). Default 300 frames is ~10s of
+ * headroom at 30fps, comfortably above the realistic multi-second delay
+ * range this app models; over-cap eviction drops the oldest queued frame
+ * (closing it via `onDrop`) rather than growing unboundedly.
+ */
+import { DelayedPlayoutBuffer, } from "./delayed-playout-buffer.js";
+import { PresentationPacer } from "./worker/presentation-pacer.js";
+const DEFAULT_MAX_BUFFERED_FRAMES = 300; // ~10s @ 30fps; see module docstring
+/**
+ * Reads frames from `source`, holds each until the clock reaches its UT, and
+ * writes it to `sink`. Every frame read is closed exactly once: after it is
+ * written, when it is dropped (over the buffer's cap, on `flush()`, or still
+ * held at `dispose()`), or at once if it arrives after `dispose()`.
+ *
+ * @category Delayed video
+ */
+export function runFrameDelayPipeline(opts) {
+    let disposed = false;
+    const writeAndClose = (data) => {
+        opts.sink
+            .write(data)
+            .catch((err) => opts.onError?.(err))
+            .finally(() => {
+            data.close?.();
+        });
+    };
+    // See `FrameDelayPipelineOptions.pacing`'s doc: omitted (the default)
+    // preserves the exact pre-pacer behaviour every existing test here
+    // exercises: write-and-close synchronously, on release.
+    const pacer = opts.pacing
+        ? new PresentationPacer({
+            maxBacklogSeconds: opts.pacing.maxBacklogSeconds,
+            onPresent: (f) => writeAndClose(f.data),
+            onSkip: (f) => f.data.close?.(),
+        })
+        : null;
+    const buffer = new DelayedPlayoutBuffer({
+        view: opts.view,
+        maxBufferedBytes: opts.maxBufferedFrames ?? DEFAULT_MAX_BUFFERED_FRAMES,
+        gopSafeEviction: opts.gopSafeEviction,
+        onRelease: (frame) => {
+            const data = frame.data;
+            if (!data)
+                return;
+            if (pacer) {
+                pacer.submit({ ut: frame.ut, data });
+            }
+            else {
+                writeAndClose(data);
+            }
+        },
+        onDrop: (frame) => {
+            frame.data?.close?.();
+        },
+    });
+    async function pump() {
+        while (!disposed) {
+            let result;
+            try {
+                result = await opts.source.read();
+            }
+            catch (err) {
+                opts.onError?.(err);
+                return;
+            }
+            if (result.done)
+                return;
+            const frame = result.value;
+            if (disposed) {
+                frame.close?.();
+                return;
+            }
+            buffer.push({
+                ut: opts.captureUt(),
+                keyframe: opts.isKeyframe?.(frame) ?? false,
+                data: frame,
+                bytes: opts.frameBytes?.(frame) ?? 1,
+            });
+        }
+    }
+    void pump();
+    return {
+        flush() {
+            buffer.flush();
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            buffer.dispose();
+            pacer?.dispose();
+            void Promise.resolve(opts.source.cancel()).catch(() => { });
+            void Promise.resolve(opts.sink.close()).catch(() => { });
+        },
+        tickPacing(nowWall) {
+            pacer?.tick(nowWall);
+        },
+    };
+}
+/**
+ * Calls `tickPacing` about 60 times a second until the returned function is
+ * called: on each animation frame where there is one, and every 16 ms where
+ * there is not, as in a worker.
+ *
+ * @category Delayed video
+ */
+export function startPacingTicker(tickPacing, nowWall = () => performance.now() / 1000) {
+    const hasRaf = typeof requestAnimationFrame === "function";
+    let cancelled = false;
+    let handle;
+    const tick = () => {
+        if (cancelled)
+            return;
+        tickPacing(nowWall());
+        handle = hasRaf ? requestAnimationFrame(tick) : setTimeout(tick, 16);
+    };
+    handle = hasRaf ? requestAnimationFrame(tick) : setTimeout(tick, 16);
+    return () => {
+        cancelled = true;
+        if (hasRaf)
+            cancelAnimationFrame(handle);
+        else
+            clearTimeout(handle);
+    };
+}
+/**
+ * Whether this browser has the WebCodecs track APIs
+ * (`MediaStreamTrackProcessor` and `MediaStreamTrackGenerator`) that
+ * {@link createFrameDelayStream} needs.
+ *
+ * @category Delayed video
+ */
+export function isFrameDelaySupported() {
+    return (typeof MediaStreamTrackProcessor !== "undefined" &&
+        typeof MediaStreamTrackGenerator !== "undefined");
+}
+/** Default backlog threshold for the main-thread backend's presentation
+ *  pacer (see `runFrameDelayPipeline`'s `pacing` option): generous enough
+ *  to never trip during normal sample-clamped bursts (telemetry confirms
+ *  at up to ~10Hz, i.e. ~100ms between edge steps) while still catching a
+ *  genuine stall (a backgrounded tab, GC pause, etc.) well before it grows
+ *  into visible added latency. */
+const DEFAULT_PACING_MAX_BACKLOG_SECONDS = 0.5;
+/**
+ * A delayed copy of the first video track of `raw`, the `MediaStream` as it
+ * arrived, such as the one a WebRTC connection hands over. Returns `null`, and never
+ * throws, when that cannot be built here: the browser lacks the APIs, `raw`
+ * has no video track, or building the track pipeline threw. Show no video in
+ * that case, and say the delay is unavailable. Never show `raw`: it is the
+ * live picture, ahead of everything else the operator is looking at.
+ *
+ * @category Delayed video
+ */
+export function createFrameDelayStream(raw, opts) {
+    if (!isFrameDelaySupported())
+        return null;
+    const track = raw.getVideoTracks()[0];
+    if (!track)
+        return null;
+    try {
+        const processor = new MediaStreamTrackProcessor({ track });
+        const generator = new MediaStreamTrackGenerator({ kind: "video" });
+        const pipeline = runFrameDelayPipeline({
+            view: opts.view,
+            captureUt: opts.captureUt,
+            maxBufferedFrames: opts.maxBufferedFrames,
+            source: processor.readable.getReader(),
+            sink: generator.writable.getWriter(),
+            onError: opts.onError,
+            pacing: {
+                maxBacklogSeconds: opts.maxPacingBacklogSeconds ?? DEFAULT_PACING_MAX_BACKLOG_SECONDS,
+            },
+        });
+        // Drive the pacer from a ~60Hz loop for as long as this pipeline lives,
+        // the F3 jank fix applies here too (main-thread Breakout Box has no
+        // sample-rate limitation of its own; the stutter comes from
+        // `ViewClock.confirmedEdgeUt()`'s sample clamp, which affects every
+        // backend equally). `requestAnimationFrame` is always available on the
+        // real main thread this backend runs on; the `setTimeout` fallback only
+        // matters for a non-browser/SSR-like test context.
+        const stopTicking = startPacingTicker(pipeline.tickPacing);
+        return {
+            stream: new MediaStream([generator]),
+            dispose: () => {
+                stopTicking();
+                pipeline.dispose();
+            },
+            flush: pipeline.flush,
+        };
+    }
+    catch (err) {
+        // Fail OPEN, not through: pipeline construction runs synchronously right
+        // after the PRIOR pipeline's un-awaited `source.cancel()` (fired from
+        // `dispose()`, never awaited: see `runFrameDelayPipeline`'s own
+        // `dispose`). When a build effect rebuilds on the SAME track before that
+        // release has actually landed, React StrictMode's mount→unmount→mount
+        // cycle, or any effect dep change that isn't `raw`, Chrome can throw
+        // `InvalidStateError` ("a MediaStreamTrack may only have one processor
+        // at a time"). Treat it exactly like every other can't-build-a-pipeline
+        // case: report via `onError` and return null so the caller falls back to
+        // live passthrough instead of the throw escaping the effect.
+        opts.onError?.(err);
+        return null;
+    }
+}
+//# sourceMappingURL=frame-delay.js.map

package/dist/media/frame-delay.js.map

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

package/dist/media/index.d.ts

@@ -0,0 +1,17 @@
+export type { CaptureClockSample } from "./capture-clock.js";
+export { interpolateCaptureUt } from "./capture-clock.js";
+export type { DelayClockLike, DelayedPlayoutBufferOptions, StampedFrame, } from "./delayed-playout-buffer.js";
+export { DelayedPlayoutBuffer } from "./delayed-playout-buffer.js";
+export type { EncodedFrameDelayOptions, EncodedTransformerLike, EncodedVideoFrameLike, } from "./encoded-frame-delay.js";
+export { attachEncodedFrameDelayTransform, DEFAULT_MAX_BUFFERED_BYTES, } from "./encoded-frame-delay.js";
+export type { CreateFrameDelayStreamOptions, FrameDelayPipeline, FrameDelayPipelineOptions, FrameDelayStream, FrameLike, FrameSink, FrameSource, } from "./frame-delay.js";
+export { createFrameDelayStream, isFrameDelaySupported, runFrameDelayPipeline, startPacingTicker, } from "./frame-delay.js";
+export type { RadioSupport, RadioUnsupportedReason } from "./radio-support.js";
+export { isRadioSupported, RADIO_CHUNK_FRAMES, RADIO_DECODER_CONFIG, RADIO_ENCODER_CONFIG, RADIO_REQUIRED_GLOBALS, radioSupportStatus, } from "./radio-support.js";
+export type { BuiltDelayedStream, DelayedStreamBuild, DelayedStreamBuildContext, DelayedStreamLease, } from "./shared-delayed-streams.js";
+export { SharedDelayedStreams } from "./shared-delayed-streams.js";
+export type { AttachEncodedFrameDelayOptions, CreateWorkerFrameDelayStreamOptions, EncodedFrameDelayHandle, SnapshottableDelayClock, } from "./worker/delay-worker-client.js";
+export { attachEncodedWorkerFrameDelay, createWorkerFrameDelayStream, } from "./worker/delay-worker-client.js";
+export type { PacedFrame, PresentationPacerOptions, } from "./worker/presentation-pacer.js";
+export { PresentationPacer } from "./worker/presentation-pacer.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/media/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/media/index.ts"],"names":[],"mappings":"AAaA,YAAY,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACvD,YAAY,EACV,cAAc,EACd,2BAA2B,EAC3B,YAAY,GACb,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,YAAY,EACV,wBAAwB,EACxB,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,gCAAgC,EAChC,0BAA0B,GAC3B,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,6BAA6B,EAC7B,kBAAkB,EAClB,yBAAyB,EACzB,gBAAgB,EAChB,SAAS,EACT,SAAS,EACT,WAAW,GACZ,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,sBAAsB,EACtB,qBAAqB,EACrB,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,YAAY,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAC5E,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,sBAAsB,EACtB,kBAAkB,GACnB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EACV,kBAAkB,EAClB,kBAAkB,EAClB,yBAAyB,EACzB,kBAAkB,GACnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,YAAY,EACV,8BAA8B,EAC9B,mCAAmC,EACnC,uBAAuB,EACvB,uBAAuB,GACxB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,6BAA6B,EAC7B,4BAA4B,GAC7B,MAAM,8BAA8B,CAAC;AAQtC,YAAY,EACV,UAAU,EACV,wBAAwB,GACzB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC"}

package/dist/media/index.js

@@ -0,0 +1,21 @@
+// Generic delayed-media infrastructure: media + time, riding the same
+// `ViewClock` delay authority telemetry reads. None of it is mod-specific: a
+// `DelayedPlayoutBuffer` consumes the clock STRUCTURALLY via `DelayClockLike`,
+// and every camera Uplink needs the same buffer / per-frame pipeline /
+// per-camera sharing. It stays decoupled from any camera SDK: the caller
+// injects the clock, the raw `MediaStream`, and (for the shared cache) the
+// build function.
+//
+// A SUBPATH (`@ksp-gonogo/sitrep-sdk/media`) rather than part of the root
+// barrel, because it pulls WebCodecs/Worker machinery no telemetry-only Uplink
+// wants. A consumer that never imports the subpath never loads any of it, which
+// does not depend on tree-shaking to hold.
+export { interpolateCaptureUt } from "./capture-clock.js";
+export { DelayedPlayoutBuffer } from "./delayed-playout-buffer.js";
+export { attachEncodedFrameDelayTransform, DEFAULT_MAX_BUFFERED_BYTES, } from "./encoded-frame-delay.js";
+export { createFrameDelayStream, isFrameDelaySupported, runFrameDelayPipeline, startPacingTicker, } from "./frame-delay.js";
+export { isRadioSupported, RADIO_CHUNK_FRAMES, RADIO_DECODER_CONFIG, RADIO_ENCODER_CONFIG, RADIO_REQUIRED_GLOBALS, radioSupportStatus, } from "./radio-support.js";
+export { SharedDelayedStreams } from "./shared-delayed-streams.js";
+export { attachEncodedWorkerFrameDelay, createWorkerFrameDelayStream, } from "./worker/delay-worker-client.js";
+export { PresentationPacer } from "./worker/presentation-pacer.js";
+//# sourceMappingURL=index.js.map

package/dist/media/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/media/index.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,6EAA6E;AAC7E,+EAA+E;AAC/E,uEAAuE;AACvE,yEAAyE;AACzE,2EAA2E;AAC3E,kBAAkB;AAClB,EAAE;AACF,0EAA0E;AAC1E,+EAA+E;AAC/E,gFAAgF;AAChF,2CAA2C;AAG3C,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAMvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAMhE,OAAO,EACL,gCAAgC,EAChC,0BAA0B,GAC3B,MAAM,uBAAuB,CAAC;AAU/B,OAAO,EACL,sBAAsB,EACtB,qBAAqB,EACrB,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,sBAAsB,EACtB,kBAAkB,GACnB,MAAM,iBAAiB,CAAC;AAOzB,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAOhE,OAAO,EACL,6BAA6B,EAC7B,4BAA4B,GAC7B,MAAM,8BAA8B,CAAC;AAYtC,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC"}

package/dist/media/radio-support.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Capability detection for the WebCodecs Opus path the push-to-talk radio
+ * rides.
+ *
+ * The shape mirrors `isFrameDelaySupported()` next door: a synchronous feature
+ * detect a caller runs before building anything, so an unsupported browser gets
+ * a reported fact instead of a broken pipeline. **A presence check alone is
+ * wrong in both directions.** `AudioEncoder`/`AudioDecoder` need a secure
+ * context, and on a plain-http origin chromium and firefox leave both
+ * constructors `undefined` while webkit exposes them and fails later, at
+ * `getUserMedia`.
+ *
+ * `radioSupportStatus()` therefore asks about the context FIRST and names
+ * an insecure origin as its own outcome, so a caller can say "this page is
+ * not a secure origin" rather than the falsehood "your browser has no
+ * codec". That distinction is operator-facing: the dev server binds the LAN
+ * (`packages/app/vite.config.ts`, `server: { host: true }`), so a station
+ * opened at `http://<lan-ip>:5173` lands in exactly this state every time.
+ * Production over https, and `localhost` dev, are both secure and fine.
+ *
+ * `tests/playwright/radio-capability.spec.ts` is the cross-engine ratchet
+ * over the same facts, including a live encode/decode round trip.
+ */
+/**
+ * The WebCodecs constructors the radio needs: `AudioEncoder`, `AudioDecoder`,
+ * `AudioData` and `EncodedAudioChunk`. {@link radioSupportStatus} checks for
+ * them.
+ *
+ * @category Radio
+ */
+export declare const RADIO_REQUIRED_GLOBALS: readonly ["AudioEncoder", "AudioDecoder", "AudioData", "EncodedAudioChunk"];
+/**
+ * The encoder configuration the radio transmits at, and the one the probe
+ * measures: 20 ms chunks of mono 48 kHz audio at a voice-radio bitrate.
+ * `bitrate` is a target that some browsers exceed, so size buffers by the
+ * measured rate rather than this number.
+ *
+ * @category Radio
+ */
+export declare const RADIO_ENCODER_CONFIG: {
+    readonly codec: "opus";
+    readonly sampleRate: 48000;
+    readonly numberOfChannels: 1;
+    readonly bitrate: 12000;
+};
+/** The decoder half of {@link RADIO_ENCODER_CONFIG}: no bitrate, since a
+ *  decoder is told what the stream is rather than what to aim for.
+ *
+ * @category Radio
+ */
+export declare const RADIO_DECODER_CONFIG: {
+    readonly codec: "opus";
+    readonly sampleRate: 48000;
+    readonly numberOfChannels: 1;
+};
+/** Samples per encoded chunk at {@link RADIO_ENCODER_CONFIG}'s sample
+ *  rate: 20 ms, as Opus and the radio's wire frames both use.
+ *
+ * @category Radio
+ */
+export declare const RADIO_CHUNK_FRAMES = 960;
+/** Why the radio cannot run here. `insecure-context` the operator can fix
+ *  by opening the page over https or on localhost; `no-codec` they cannot.
+ *
+ * @category Radio
+ */
+export type RadioUnsupportedReason = "insecure-context" | "no-codec";
+/**
+ * Whether this browser can carry radio audio, and why not when it cannot.
+ *
+ * @category Radio
+ */
+export type RadioSupport = {
+    supported: true;
+} | {
+    supported: false;
+    reason: RadioUnsupportedReason;
+    /** The names from {@link RADIO_REQUIRED_GLOBALS} that were absent.
+     *  Empty for `insecure-context`, which is diagnosed before the
+     *  globals are consulted at all. */
+    missing: readonly string[];
+};
+/**
+ * Returns whether this browser can run the radio, and why not when it
+ * cannot. Use it rather than {@link isRadioSupported} wherever the result is
+ * shown, so a page served over plain http says so.
+ *
+ * @category Radio
+ */
+export declare function radioSupportStatus(): RadioSupport;
+/** Returns whether this page can run the radio: a secure page with every
+ *  WebCodecs constructor it needs. {@link radioSupportStatus} also says why
+ *  not.
+ *
+ * @category Radio
+ */
+export declare function isRadioSupported(): boolean;
+//# sourceMappingURL=radio-support.d.ts.map

package/dist/media/radio-support.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-support.d.ts","sourceRoot":"","sources":["../../src/media/radio-support.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,6EAKzB,CAAC;AAEX;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB;;;;;CAKvB,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;CAIvB,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,MAAM,CAAC;AAEtC;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG,kBAAkB,GAAG,UAAU,CAAC;AAErE;;;;GAIG;AACH,MAAM,MAAM,YAAY,GACpB;IAAE,SAAS,EAAE,IAAI,CAAA;CAAE,GACnB;IACE,SAAS,EAAE,KAAK,CAAC;IACjB,MAAM,EAAE,sBAAsB,CAAC;IAC/B;;wCAEoC;IACpC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5B,CAAC;AAEN;;;;;;GAMG;AACH,wBAAgB,kBAAkB,IAAI,YAAY,CAoBjD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAE1C"}