pup-recorder 0.3.10 → 0.4.2

package/build.ts

@@ -25,7 +25,10 @@ const common: Options = {
 
 await build({
   ...common,
-  entry: ["src/index.ts", "src/cli.ts"],
+  entry: [
+    "src/index.ts", //
+    "src/cli.ts",
+  ],
   format: "esm",
   outDir: "dist",
   experimentalDts: true,
@@ -33,14 +36,11 @@ await build({
 
 await build({
   ...common,
-  entry: ["src/app.ts"],
-  format: "cjs",
-  outDir: "dist",
-});
-
-await build({
-  ...common,
-  entry: ["src/audio_preload.ts"],
+  entry: [
+    "src/app.ts", //
+    "src/audio_preload.ts",
+    "src/iframe_preload.ts",
+  ],
   format: "cjs",
   outDir: "dist",
 });

package/dist/_tsup-dts-rollup.d.ts

@@ -27,12 +27,24 @@ import z from 'zod';
 /** Insert emulation prevention bytes (00 00 03) for Annex B compliance. */
 export declare function addEmulationPrevention(nal: Buffer): Buffer;
 
+export declare function advance(hook: VideoHook, timestampMs: number): Promise<unknown>;
+
 export declare function advanceVideos(frame: WebFrameMain | undefined, timestampMs: number): Promise<void>;
 
 export declare function advanceVirtualTime(cdp: Debugger, budget: number): Promise<void>;
 
+export declare const AHEAD = 10;
+
 export declare const ANNEX_B_START_CODE: Buffer<ArrayBuffer>;
 
+export declare interface AttachArgs {
+    video: HTMLVideoElement;
+    state: VideoState;
+    src: string;
+    birthMs: number;
+    native: boolean;
+}
+
 export declare function attachAudioListeners({ wc, encoder, getVideoTimeMs, onError }: AudioListenerOptions): AudioDisposal;
 
 export declare const AUDIO_CHUNK_CHANNEL = "audio-chunk";
@@ -81,6 +93,16 @@ export declare interface AudioListenerOptions {
     onError: (error: Error) => void;
 }
 
+declare function barLogger(bar: ProgressBar): LoggerLike;
+export { barLogger }
+export { barLogger as barLogger_alias_1 }
+
+declare interface BarOptions {
+    total: number;
+    out: NodeJS.WriteStream;
+    showCount?: boolean;
+}
+
 export declare class BitReader {
     private _bits;
     pos: number;
@@ -148,7 +170,7 @@ declare class CodecState_2 implements Disposable {
 }
 export { CodecState_2 as CodecState }
 
-declare class ConcurrencyLimiter {
+export declare class ConcurrencyLimiter {
     readonly maxConcurrency: number;
     private _active;
     private _queue;
@@ -163,12 +185,8 @@ declare class ConcurrencyLimiter {
     private flush;
     private next;
 }
-export { ConcurrencyLimiter }
-export { ConcurrencyLimiter as ConcurrencyLimiter_alias_1 }
 
-declare type ConsoleCallback = (level: string, message: string) => void;
-export { ConsoleCallback }
-export { ConsoleCallback as ConsoleCallback_alias_1 }
+export declare type ConsoleCallback = (level: string, message: string) => void;
 
 export declare interface ConsoleMsg {
     type: IpcMsgType.CONSOLE;
@@ -185,18 +203,27 @@ export declare function debounce<T extends (...args: unknown[]) => void>(fn: T,
 export declare class DecodeSession {
     readonly meta: VideoMeta;
     private readonly src;
-    private readonly framesDir;
-    private proc;
+    private buf;
     private ready;
+    private want;
     private done;
+    private closed;
+    private gen;
+    private ctrl;
     private waiters;
-    private watcher;
-    constructor(meta: VideoMeta, src: string, framesDir: string);
+    private resume;
+    private restart;
+    constructor(meta: VideoMeta, src: string);
     getFrame(idx: number): Promise<Buffer>;
     close(): void;
     private wait;
-    private spawn;
-    private poll;
+    private wake;
+    private requestRestart;
+    private pump;
+    private decodePass;
+    private pause;
+    private untilRestart;
+    private evict;
     private drainWaiters;
 }
 
@@ -214,17 +241,13 @@ declare const DEFAULT_HEIGHT = 1080;
 export { DEFAULT_HEIGHT }
 export { DEFAULT_HEIGHT as DEFAULT_HEIGHT_alias_1 }
 
-declare const DEFAULT_OUT_FILE = "out/html.mp4,out/html.webm";
-export { DEFAULT_OUT_FILE }
-export { DEFAULT_OUT_FILE as DEFAULT_OUT_FILE_alias_1 }
+export declare const DEFAULT_OUT_FILE = "out/html.mp4,out/html.webm";
 
 declare const DEFAULT_WIDTH = 1920;
 export { DEFAULT_WIDTH }
 export { DEFAULT_WIDTH as DEFAULT_WIDTH_alias_1 }
 
-declare const defaultRenderOptions: RenderOptions;
-export { defaultRenderOptions }
-export { defaultRenderOptions as defaultRenderOptions_alias_1 }
+export declare const defaultRenderOptions: RenderOptions;
 
 export declare function disposeWindow(win: BrowserWindow): Promise<void>;
 
@@ -260,7 +283,7 @@ export declare function electronOpts(disableGpu: boolean): Promise<string[]>;
 
 export declare function encodeNalHeader(type: number, layerId: number, temporalId: number): [number, number];
 
-declare class EncoderPipeline {
+export declare class EncoderPipeline {
     private _s;
     private _disposed;
     private constructor();
@@ -274,10 +297,8 @@ declare class EncoderPipeline {
     private free;
     private bgraFrame;
 }
-export { EncoderPipeline }
-export { EncoderPipeline as EncoderPipeline_alias_1 }
 
-declare interface EncoderPipelineOptions {
+export declare interface EncoderPipelineOptions {
     width: number;
     height: number;
     fps: number;
@@ -285,12 +306,8 @@ declare interface EncoderPipelineOptions {
     withAudio?: boolean;
     disableHwCodec?: boolean;
 }
-export { EncoderPipelineOptions }
-export { EncoderPipelineOptions as EncoderPipelineOptions_alias_1 }
 
-declare type EnvParser<T> = (value: unknown) => T;
-export { EnvParser }
-export { EnvParser as EnvParser_alias_1 }
+export declare type EnvParser<T> = (value: unknown) => T;
 
 export declare interface ErrorMsg {
     type: IpcMsgType.ERROR;
@@ -299,13 +316,15 @@ export declare interface ErrorMsg {
 
 export declare function evalIn(cdp: Debugger, expression: string): Promise<unknown>;
 
-declare function exec(cmd: string, options?: SpawnOptions): ProcessHandle;
-export { exec }
-export { exec as exec_alias_1 }
+export declare function exec(cmd: string, options?: SpawnOptions): ProcessHandle;
 
 export declare function extractAlphaToYuv420pBuffer(bgraFrame: Frame, buf: Buffer): void;
 
-declare class FormatMuxer {
+export declare function fire(el: EventTarget, type: string): void;
+
+export declare function fitRect(srcW: number, srcH: number, dstW: number, dstH: number, fit: string): Vec4;
+
+export declare class FormatMuxer {
     private readonly _ctx;
     private _opened;
     constructor(outPath: string, formatName?: string);
@@ -314,13 +333,22 @@ declare class FormatMuxer {
     writePacket(pkt: Packet): Promise<void>;
     [Symbol.asyncDispose](): Promise<void>;
 }
-export { FormatMuxer }
-export { FormatMuxer as FormatMuxer_alias_1 }
 
 export declare const FRAME_SYNC_MARKER_HEIGHT = 1;
 
 export declare const FRAME_SYNC_MARKER_WIDTH = 32;
 
+export declare class FrameCache {
+    private caches;
+    cacheOf(id: string): VideoCache;
+    fetch(state: VideoState, idx: number): Promise<ImageBitmap | null>;
+    prefetch(state: VideoState, fromIdx: number, count: number): void;
+    evict(c: VideoCache): void;
+    release(id: string, state: VideoState): void;
+}
+
+export declare type FrameCb = (now: number, meta: VideoFrameMeta) => void;
+
 /**
  * Frame drop quality score (0 = perfect, 1 = worst).
  *
@@ -355,14 +383,24 @@ export declare class FrameDropStats {
 
 export declare class FrameServer {
     private sessions;
+    private srcs;
+    private inFlightOpens;
+    private closed;
     open(opts: OpenOptions): Promise<VideoMeta>;
+    private openInner;
     getFrame(id: string, idx: number): Promise<Buffer>;
     close(id: string): void;
-    closeAll(): void;
+    closeAll(): Promise<void>;
 }
 
 export declare const frameServer: FrameServer;
 
+export declare const HAVE_ENOUGH_DATA = 4;
+
+export declare const HAVE_METADATA = 1;
+
+export declare const HAVE_NOTHING = 0;
+
 export declare type HwEncoder = VideoToolboxEncoder | NvencDualLayerEncoder;
 
 export declare interface HwVideoEncoderOptions {
@@ -383,6 +421,12 @@ export declare interface HwVideoFactoryOptions {
     sharedHw?: HardwareContext;
 }
 
+export declare function installMediaShim(hook: VideoHook): void;
+
+export declare function installTickHook(): void;
+
+export declare function installVideoHook(): void;
+
 export declare function interleaveAccessUnits(baseNals: NalUnit[], alphaNals: NalUnit[], cfg: NvencHevcConfig): Buffer;
 
 export declare interface IpcDonePayload {
@@ -413,14 +457,12 @@ export declare class IpcReader extends EventEmitter<IpcEvents> {
     constructor(child: ChildProcess);
 }
 
-declare interface IPCRenderOptions extends RenderOptions {
+export declare interface IPCRenderOptions extends RenderOptions {
     source: string;
     signal: AbortSignal;
     onProgress: ProgressCallback;
     onConsole: ConsoleCallback;
 }
-export { IPCRenderOptions }
-export { IPCRenderOptions as IPCRenderOptions_alias_1 }
 
 export declare class IpcWriter {
     writeConsole(level: string, message: string): void;
@@ -443,9 +485,7 @@ declare class Lazy<T> {
 export { Lazy }
 export { Lazy as Lazy_alias_1 }
 
-export declare function loadWindow({ source, renderer, preload, onCreated, signal, }: WindowOptions): Promise<BrowserWindow>;
-
-export declare function localize(src: string): Promise<string>;
+export declare function loadWindow({ source, renderer, onCreated, signal }: WindowOptions): Promise<BrowserWindow>;
 
 declare class Logger implements LoggerLike {
     private _level;
@@ -487,6 +527,15 @@ export declare function makePacket(): Packet;
 
 export declare const MAX_RENDER_ATTEMPTS = 3;
 
+export declare const MEDIA_ERR_DECODE = 3;
+
+export declare const MEDIA_ERR_NETWORK = 2;
+
+export declare interface MediaErrorLike {
+    code: number;
+    message: string;
+}
+
 export declare const NAL_BLA_W_LP = 16;
 
 export declare const NAL_HEADER_SIZE = 2;
@@ -513,12 +562,23 @@ export declare interface NalUnit {
     data: Buffer;
 }
 
+export declare const NETWORK_EMPTY = 0;
+
+export declare const NETWORK_IDLE = 1;
+
+export declare const NETWORK_LOADING = 2;
+
+export declare const NETWORK_NO_SOURCE = 3;
+
 export declare interface NetworkOptions {
     source: string;
     window: BrowserWindow;
     useInnerProxy?: boolean;
+    cancelMedia?: boolean;
 }
 
+export declare function newVideoState(video: HTMLVideoElement, cv: HTMLCanvasElement): VideoState;
+
 declare function noerr<Fn extends (...args: any[]) => any, D>(fn: Fn, defaultValue: D): (...args: Parameters<Fn>) => ReturnType<Fn> | D;
 export { noerr }
 export { noerr as noerr_alias_1 }
@@ -549,8 +609,15 @@ export declare interface NvencHevcConfig {
 export declare interface OpenOptions {
     src: string;
     fps: number;
+    /** Display-box pixels (canvas backing store); decode is downscaled to cover this, never upscaled. */
+    dstW?: number;
+    dstH?: number;
+    /** objectFit; "none" needs 1:1 native pixels so it skips downscale. */
+    fit?: string;
 }
 
+export declare function openSession(hook: VideoHook, args: AttachArgs): Promise<VideoState | null>;
+
 export declare function openVideoCtx(opts: VideoCtxOptions, label: string): Promise<CodecContext>;
 
 export declare class OutputSink implements AsyncDisposable {
@@ -573,9 +640,7 @@ export declare class OutputSink implements AsyncDisposable {
 
 export declare function packBits(bits: number[]): Buffer;
 
-declare function pargs(): string[];
-export { pargs }
-export { pargs as pargs_alias_1 }
+export declare function pargs(): string[];
 
 declare function parseNumber(x: unknown): number;
 export { parseNumber }
@@ -583,9 +648,7 @@ export { parseNumber as parseNumber_alias_1 }
 
 export declare function parseNvencHevcConfig(extradata: Buffer): NvencHevcConfig;
 
-declare function parseString(x: unknown): string;
-export { parseString }
-export { parseString as parseString_alias_1 }
+export declare function parseString(x: unknown): string;
 
 /** Patch every VPS/SPS NAL in an Annex B bitstream so PTL matches Apple/x265. */
 export declare function patchHevcAlphaPtl(bitstream: Buffer): Buffer;
@@ -610,14 +673,32 @@ export declare interface ProbeResult {
     duration: number;
 }
 
-declare interface ProcessHandle {
+export declare interface ProcessHandle {
     process: ChildProcess;
     wait: Promise<void>;
     get killed(): boolean;
     kill(): void;
 }
-export { ProcessHandle }
-export { ProcessHandle as ProcessHandle_alias_1 }
+
+declare class ProgressBar {
+    private _written;
+    private _shown;
+    private readonly _total;
+    private readonly _out;
+    private readonly _tty;
+    private readonly _showCount;
+    constructor(opts: BarOptions);
+    get total(): number;
+    update(written: number): void;
+    updatePercent(pct: number): void;
+    clear(): void;
+    redraw(): void;
+    log(line: string): void;
+    finish(line: string): void;
+    private render;
+}
+export { ProgressBar }
+export { ProgressBar as ProgressBar_alias_1 }
 
 declare type ProgressCallback = (progress: number) => void;
 export { ProgressCallback }
@@ -634,21 +715,15 @@ declare function pup(source: string, options: Partial<PupOptions>): Promise<PupR
 export { pup }
 export { pup as pup_alias_1 }
 
-declare const PUP_ARGS_KEY = "--pup-priv-args";
-export { PUP_ARGS_KEY }
-export { PUP_ARGS_KEY as PUP_ARGS_KEY_alias_1 }
+export declare const PUP_ARGS_KEY = "--pup-priv-args";
+
+export declare const pupApp: string;
 
-declare const pupApp: string;
-export { pupApp }
-export { pupApp as pupApp_alias_1 }
+export declare const pupAudioPreload: string;
 
-declare const pupAudioPreload: string;
-export { pupAudioPreload }
-export { pupAudioPreload as pupAudioPreload_alias_1 }
+export declare const pupIframePreload: string;
 
-declare const pupLogLevel: number;
-export { pupLogLevel }
-export { pupLogLevel as pupLogLevel_alias_1 }
+export declare const pupLogLevel: number;
 
 declare interface PupOptions extends Partial<RenderOptions> {
     signal?: AbortSignal;
@@ -658,9 +733,7 @@ declare interface PupOptions extends Partial<RenderOptions> {
 export { PupOptions }
 export { PupOptions as PupOptions_alias_1 }
 
-declare const pupPkgRoot: string;
-export { pupPkgRoot }
-export { pupPkgRoot as pupPkgRoot_alias_1 }
+export declare const pupPkgRoot: string;
 
 declare interface PupResult extends RenderResult {
 }
@@ -685,7 +758,7 @@ declare interface RenderResult {
 export { RenderResult }
 export { RenderResult as RenderResult_alias_1 }
 
-declare const RenderSchema: z.ZodObject<{
+export declare const RenderSchema: z.ZodObject<{
     duration: z.ZodNumber;
     width: z.ZodNumber;
     height: z.ZodNumber;
@@ -698,8 +771,6 @@ declare const RenderSchema: z.ZodObject<{
     disableHwCodec: z.ZodBoolean;
     windowTolerant: z.ZodBoolean;
 }, z.core.$strip>;
-export { RenderSchema }
-export { RenderSchema as RenderSchema_alias_1 }
 
 export declare function resizeDrawable(cdp: Debugger, size: Size): Promise<void>;
 
@@ -737,9 +808,13 @@ export declare interface RunElectronAppOptions {
     args: unknown[];
 }
 
+export declare const SCHEME = "pup-frame://";
+
 export declare function send(cdp: Debugger, method: string, params?: object): Promise<unknown>;
 
-export declare function setInterceptor({ source, window, useInnerProxy }: NetworkOptions): void;
+export declare function setInterceptor({ source, window, useInnerProxy, cancelMedia }: NetworkOptions): void;
+
+export declare function setupCanvas(video: HTMLVideoElement, snap: OffscreenCanvas | undefined): HTMLCanvasElement;
 
 export declare function setupFrameProtocol(): void;
 
@@ -769,6 +844,15 @@ export { sleep as sleep_alias_1 }
 /** Split Annex B bitstream into NAL units. */
 export declare function splitNalUnits(bitstream: Buffer): NalUnit[];
 
+export declare class SrcCache {
+    private inFlight;
+    private ctrl;
+    localize(src: string): Promise<string>;
+    abort(): void;
+    clear(): Promise<void>;
+    private download;
+}
+
 export declare function startElectronCrashReporter(): void;
 
 export declare function startStego(cdp: Debugger): Promise<unknown>;
@@ -779,10 +863,22 @@ export declare function stopStego(cdp: Debugger): Promise<unknown>;
 
 export declare function swapBuffer(wc: WebContents, expected: number, interval: number): Promise<void>;
 
+export declare function syncOverlay(video: HTMLVideoElement, cv: HTMLCanvasElement): void;
+
+export declare const TAG = "[VideoHook]";
+
 export declare function tick(frame: WebFrameMain | undefined, timestampMs: number): Promise<void>;
 
 export declare const TICK_SYMBOL = "__pup_tick__";
 
+export declare function timeRanges(end: number): TimeRangesLike;
+
+export declare interface TimeRangesLike {
+    length: number;
+    start(i: number): number;
+    end(i: number): number;
+}
+
 export declare interface UnifiedExtradataOptions {
     baseExtradata: Buffer;
     alphaExtradata: Buffer;
@@ -796,7 +892,13 @@ declare function useRetry<Args extends any[], Ret>({ fn, maxAttempts, timeout, s
 export { useRetry }
 export { useRetry as useRetry_alias_1 }
 
-export declare const VIDEO_SYMBOL = "__pup_video__";
+declare type Vec4 = [number, number, number, number];
+
+export declare interface VideoCache {
+    bitmaps: Map<number, ImageBitmap>;
+    inFlight: Map<number, Promise<ImageBitmap | null>>;
+    readers: Map<VideoState, number>;
+}
 
 export declare interface VideoCtxOptions {
     codec: Codec;
@@ -837,14 +939,53 @@ export declare interface VideoEncoderOptions {
     muxer: FormatMuxer;
 }
 
+export declare interface VideoFrameMeta {
+    presentationTime: number;
+    expectedDisplayTime: number;
+    width: number;
+    height: number;
+    mediaTime: number;
+    presentedFrames: number;
+}
+
+export declare class VideoHook {
+    readonly sessions: WeakMap<HTMLVideoElement, VideoState>;
+    readonly attaching: WeakMap<HTMLVideoElement, Promise<VideoState | null>>;
+    readonly cache: FrameCache;
+    rvfcSeq: number;
+    currMs: number;
+    private lastSnapshot;
+    install(): void;
+    attach(video: HTMLVideoElement, native?: boolean): Promise<VideoState | null>;
+    resume(video: HTMLVideoElement, state: VideoState): void;
+    detach(video: HTMLVideoElement): void;
+    onSrcChange(video: HTMLVideoElement): void;
+    reattach(video: HTMLVideoElement, state: VideoState): void;
+    private scan;
+}
+
 export declare interface VideoMeta {
     id: string;
+    /** Intrinsic source dimensions (reported as videoWidth/videoHeight). */
     width: number;
     height: number;
+    /** Decoded+scaled frame dimensions actually served (≤ source; capped to the display box). */
+    frameWidth: number;
+    frameHeight: number;
     fps: number;
     duration: number;
 }
 
+export declare interface VideoMeta_alias_1 {
+    id: string;
+    width: number;
+    height: number;
+    frameWidth: number;
+    frameHeight: number;
+    duration: number;
+    fps: number;
+}
+
 export declare interface VideoSetup {
     video?: VideoEncoder_2;
     hwVideo?: HwEncoder;
@@ -853,6 +994,26 @@ export declare interface VideoSetup {
     ownsHw: boolean;
 }
 
+export declare interface VideoState {
+    meta: VideoMeta_alias_1 | null;
+    cv: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+    paused: boolean;
+    currentTime: number;
+    ended: boolean;
+    lastDrawnIdx: number;
+    dead: boolean;
+    objectFit: string;
+    readyState: number;
+    networkState: number;
+    seeking: boolean;
+    waiting: boolean;
+    error: MediaErrorLike | undefined;
+    presentedFrames: number;
+    maxReached: number;
+    rvfc: Map<number, FrameCb>;
+}
+
 export declare class VideoToolboxEncoder implements Disposable {
     private _ctx;
     private _pkt;
@@ -885,15 +1046,12 @@ export declare interface WindowOptions {
     source: string;
     renderer: IPCRenderOptions;
     tolerant?: boolean;
-    preload?: string;
     onCreated?: WindowCreatedCallback;
     signal?: AbortSignal;
 }
 
 export declare function withRerender<T>(signal: AbortSignal, action: () => Promise<T>): Promise<T>;
 
-declare function withTimeout<T>(p: Promise<T>, ms: number, label: string): Promise<T>;
-export { withTimeout }
-export { withTimeout as withTimeout_alias_1 }
+export declare function withTimeout<T>(p: Promise<T>, ms: number, label: string): Promise<T>;
 
 export { }