pup-recorder 0.4.2 → 0.4.4

package/biome.json

@@ -0,0 +1,30 @@
+{
+  "$schema": "https://biomejs.dev/schemas/latest/schema.json",
+  "root": false,
+  "formatter": { "indentStyle": "space", "indentWidth": 2, "lineWidth": 120 },
+  "javascript": { "formatter": { "quoteStyle": "double", "semicolons": "always", "trailingCommas": "all" } },
+  "linter": {
+    "rules": {
+      "complexity": { "useLiteralKeys": "off" },
+      "style": {
+        "noNonNullAssertion": "off",
+        "useBlockStatements": "error",
+        "useNamingConvention": {
+          "level": "error",
+          "options": {
+            "strictCase": false,
+            "conventions": [
+              { "selector": { "kind": "classProperty", "modifiers": ["private"] }, "match": "_(.+)" },
+              { "selector": { "kind": "classMethod", "modifiers": ["private"] }, "match": "[^_].*" },
+              { "selector": { "kind": "typeProperty" }, "match": "__.+|[a-z][A-Za-z0-9]*|[a-z][a-z0-9]*(?:_[a-z0-9]+)*|[A-Z][A-Za-z0-9]*|[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*" },
+              { "selector": { "kind": "objectLiteralProperty" }, "formats": ["camelCase", "snake_case", "PascalCase", "CONSTANT_CASE"] },
+              { "selector": { "kind": "variable" }, "formats": ["camelCase", "snake_case", "PascalCase", "CONSTANT_CASE"] },
+              { "selector": { "kind": "enumMember" }, "formats": ["PascalCase", "CONSTANT_CASE"] }
+            ]
+          }
+        }
+      }
+    }
+  },
+  "files": { "includes": ["src/**/*.ts"] }
+}

package/build.ts

@@ -7,9 +7,12 @@ import { dependencies } from "./package.json";
 
 const require = createRequire(import.meta.url);
 const tsPath = require.resolve("@typescript/native-preview/package.json");
-const tsgo = join(tsPath, "..", "bin", "tsgo.js");
+const tsgo = join(tsPath, "..", require(tsPath).bin.tsgo);
+const biomePath = require.resolve("@biomejs/biome/package.json");
+const biome = join(biomePath, "..", "bin", "biome");
 
 await $`${tsgo}`;
+await $`${biome} check --write --error-on-warnings`;
 await rm("dist", { recursive: true, force: true });
 
 const common: Options = {
@@ -38,8 +41,8 @@ await build({
   ...common,
   entry: [
     "src/app.ts", //
-    "src/audio_preload.ts",
-    "src/iframe_preload.ts",
+    "src/runtime/audio_preload.ts",
+    "src/runtime/iframe_preload.ts",
   ],
   format: "cjs",
   outDir: "dist",

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

@@ -3,33 +3,41 @@ import { AV_SAMPLE_FMT_FLTP } from 'node-av/constants';
 import { AVColorRange } from 'node-av/constants';
 import { AVPixelFormat } from 'node-av/constants';
 import { BrowserWindow } from 'electron';
-import { ChildProcess } from 'child_process';
+import { ChildProcess } from 'node:child_process';
 import { Codec } from 'node-av';
 import { CodecContext } from 'node-av';
-import { Debugger } from 'electron';
-import { EventEmitter } from 'events';
+import type { Debugger } from 'electron';
+import { Demuxer } from 'node-av/api';
+import { EventEmitter } from 'node:events';
 import { FFAudioEncoder } from 'node-av/constants';
-import { FFVideoEncoder } from 'node-av/constants';
-import { FormatContext } from 'node-av';
+import type { FFVideoEncoder } from 'node-av/constants';
 import { Frame } from 'node-av';
 import { HardwareContext } from 'node-av/api';
 import { HardwareFramesContext } from 'node-av';
 import type { NativeImage } from 'electron';
 import { Packet } from 'node-av';
-import { Size } from 'electron';
+import type { Size } from 'electron';
 import { SoftwareScaleContext } from 'node-av';
-import { SpawnOptions } from 'child_process';
+import { SpawnOptions } from 'node:child_process';
 import { Stream } from 'node-av';
-import { WebContents } from 'electron';
+import type { WebContents } from 'electron';
 import type { WebFrameMain } from 'electron';
 import z from 'zod';
 
+export declare function abortable<T>(p: Promise<T>, signal?: AbortSignal): Promise<T>;
+
 /** 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 interface AdvanceOptions {
+    frame: WebFrameMain | undefined;
+    timestampMs: number;
+    signal?: AbortSignal;
+}
+
+export declare function advanceVideos({ frame, timestampMs, signal }: AdvanceOptions): Promise<void>;
 
 export declare function advanceVirtualTime(cdp: Debugger, budget: number): Promise<void>;
 
@@ -135,7 +143,7 @@ export declare function buildStegoHTML(targetURL: string, size: Size): string;
 export declare function buildUnifiedExtradata(opts: UnifiedExtradataOptions): Buffer;
 
 export declare interface CancelMsg {
-    type: IpcMsgType.CANCEL;
+    type: IpcMsgType.Cancel;
     reason?: string;
 }
 
@@ -189,7 +197,7 @@ export declare class ConcurrencyLimiter {
 export declare type ConsoleCallback = (level: string, message: string) => void;
 
 export declare interface ConsoleMsg {
-    type: IpcMsgType.CONSOLE;
+    type: IpcMsgType.Console;
     level: string;
     message: string;
 }
@@ -200,22 +208,32 @@ export declare function createStegoURL(src: string, size: Size): string;
 
 export declare function debounce<T extends (...args: unknown[]) => void>(fn: T, delay?: number): T;
 
+export declare interface DecodedFrame {
+    idx: number;
+    buf: Buffer;
+}
+
+export declare function decodeFrames(src: string, meta: VideoMeta, signal: AbortSignal): AsyncGenerator<DecodedFrame>;
+
 export declare class DecodeSession {
     readonly meta: VideoMeta;
-    private readonly src;
-    private buf;
-    private ready;
-    private want;
-    private done;
-    private closed;
-    private gen;
-    private ctrl;
-    private waiters;
-    private resume;
-    private restart;
-    constructor(meta: VideoMeta, src: string);
+    private readonly _src;
+    private _buf;
+    private _ready;
+    private _want;
+    private _done;
+    private _closed;
+    private _gen;
+    private _ctrl;
+    private _waiters;
+    private _resume;
+    private _restart;
+    private readonly _leadFrames;
+    private readonly _keepCount;
+    private readonly _pumpDone;
+    constructor(meta: VideoMeta, _src: string);
     getFrame(idx: number): Promise<Buffer>;
-    close(): void;
+    close(): Promise<void>;
     private wait;
     private wake;
     private requestRestart;
@@ -247,12 +265,16 @@ declare const DEFAULT_WIDTH = 1920;
 export { DEFAULT_WIDTH }
 export { DEFAULT_WIDTH as DEFAULT_WIDTH_alias_1 }
 
+declare const DEFAULT_WINDOW_TIMEOUT = 10;
+export { DEFAULT_WINDOW_TIMEOUT }
+export { DEFAULT_WINDOW_TIMEOUT as DEFAULT_WINDOW_TIMEOUT_alias_1 }
+
 export declare const defaultRenderOptions: RenderOptions;
 
 export declare function disposeWindow(win: BrowserWindow): Promise<void>;
 
 export declare interface DoneMsg {
-    type: IpcMsgType.DONE;
+    type: IpcMsgType.Done;
     payload: IpcDonePayload;
 }
 
@@ -310,7 +332,7 @@ export declare interface EncoderPipelineOptions {
 export declare type EnvParser<T> = (value: unknown) => T;
 
 export declare interface ErrorMsg {
-    type: IpcMsgType.ERROR;
+    type: IpcMsgType.Error;
     error: string;
 }
 
@@ -327,8 +349,9 @@ export declare function fitRect(srcW: number, srcH: number, dstW: number, dstH:
 export declare class FormatMuxer {
     private readonly _ctx;
     private _opened;
+    private _disposed;
     constructor(outPath: string, formatName?: string);
-    addStream(codecCtx: CodecContext, codecTag?: string): ReturnType<FormatContext["newStream"]>;
+    addStream(codecCtx: CodecContext, codecTag?: string): Stream;
     open(): Promise<void>;
     writePacket(pkt: Packet): Promise<void>;
     [Symbol.asyncDispose](): Promise<void>;
@@ -339,9 +362,9 @@ export declare const FRAME_SYNC_MARKER_HEIGHT = 1;
 export declare const FRAME_SYNC_MARKER_WIDTH = 32;
 
 export declare class FrameCache {
-    private caches;
+    private _caches;
     cacheOf(id: string): VideoCache;
-    fetch(state: VideoState, idx: number): Promise<ImageBitmap | null>;
+    fetch(state: VideoState, idx: number): Promise<ImageBitmap | undefined>;
     prefetch(state: VideoState, fromIdx: number, count: number): void;
     evict(c: VideoCache): void;
     release(id: string, state: VideoState): void;
@@ -382,19 +405,16 @@ export declare class FrameDropStats {
 }
 
 export declare class FrameServer {
-    private sessions;
-    private srcs;
-    private inFlightOpens;
-    private closed;
+    private readonly _useInnerProxy;
+    private _sessions;
+    private _closed;
+    constructor(_useInnerProxy: boolean);
     open(opts: OpenOptions): Promise<VideoMeta>;
-    private openInner;
     getFrame(id: string, idx: number): Promise<Buffer>;
-    close(id: string): void;
+    close(id: string): Promise<void>;
     closeAll(): Promise<void>;
 }
 
-export declare const frameServer: FrameServer;
-
 export declare const HAVE_ENOUGH_DATA = 4;
 
 export declare const HAVE_METADATA = 1;
@@ -445,12 +465,12 @@ export declare interface IpcEvents {
 
 export declare type IpcMsg = ConsoleMsg | ProgressMsg | DoneMsg | ErrorMsg | CancelMsg;
 
-export declare const enum IpcMsgType {
-    CONSOLE = "console",
-    PROGRESS = "progress",
-    DONE = "done",
-    ERROR = "error",
-    CANCEL = "cancel"
+export declare enum IpcMsgType {
+    Console = "console",
+    Progress = "progress",
+    Done = "done",
+    Error = "error",
+    Cancel = "cancel"
 }
 
 export declare class IpcReader extends EventEmitter<IpcEvents> {
@@ -579,7 +599,7 @@ export declare interface NetworkOptions {
 
 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;
+declare function noerr<A extends unknown[], R, D>(fn: (...args: A) => R, defaultValue: D): (...args: A) => R | D;
 export { noerr }
 export { noerr as noerr_alias_1 }
 
@@ -606,6 +626,8 @@ export declare interface NvencHevcConfig {
     ppsHasLoopFilterAcrossSlicesFlag: boolean;
 }
 
+export declare function openInput(src: string, signal?: AbortSignal): Promise<Demuxer>;
+
 export declare interface OpenOptions {
     src: string;
     fps: number;
@@ -616,7 +638,7 @@ export declare interface OpenOptions {
     fit?: string;
 }
 
-export declare function openSession(hook: VideoHook, args: AttachArgs): Promise<VideoState | null>;
+export declare function openSession(hook: VideoHook, args: AttachArgs): Promise<VideoState | undefined>;
 
 export declare function openVideoCtx(opts: VideoCtxOptions, label: string): Promise<CodecContext>;
 
@@ -661,7 +683,7 @@ declare function penv<T>(name: string, parser: EnvParser<T>, defaultValue?: T):
 export { penv }
 export { penv as penv_alias_1 }
 
-declare function periodical(callback: (count: number) => Promise<void> | void, ms: number): () => void;
+declare function periodical(callback: (count: number) => Promise<number | undefined> | undefined, ms: number): () => void;
 export { periodical }
 export { periodical as periodical_alias_1 }
 
@@ -671,6 +693,8 @@ export declare interface ProbeResult {
     width: number;
     height: number;
     duration: number;
+    /** PTS (s) of the first decodable frame; a corrupt/empty leading run is held on it, like Chrome. */
+    leadGap: number;
 }
 
 export declare interface ProcessHandle {
@@ -705,7 +729,7 @@ export { ProgressCallback }
 export { ProgressCallback as ProgressCallback_alias_1 }
 
 export declare interface ProgressMsg {
-    type: IpcMsgType.PROGRESS;
+    type: IpcMsgType.Progress;
     value: number;
 }
 
@@ -745,7 +769,7 @@ export declare function removeEmulationPrevention(data: Buffer): Buffer;
 
 export declare function render(options: IPCRenderOptions): Promise<IpcDonePayload>;
 
-declare type RenderOptions = z.infer<typeof RenderSchema>;
+declare type RenderOptions = z.infer<typeof renderSchema>;
 export { RenderOptions }
 export { RenderOptions as RenderOptions_alias_1 }
 
@@ -758,7 +782,7 @@ declare interface RenderResult {
 export { RenderResult }
 export { RenderResult as RenderResult_alias_1 }
 
-export declare const RenderSchema: z.ZodObject<{
+export declare const renderSchema: z.ZodObject<{
     duration: z.ZodNumber;
     width: z.ZodNumber;
     height: z.ZodNumber;
@@ -770,11 +794,12 @@ export declare const RenderSchema: z.ZodObject<{
     disableGpu: z.ZodBoolean;
     disableHwCodec: z.ZodBoolean;
     windowTolerant: z.ZodBoolean;
+    windowTimeout: z.ZodNumber;
 }, z.core.$strip>;
 
 export declare function resizeDrawable(cdp: Debugger, size: Size): Promise<void>;
 
-declare interface RetryOptions<Args extends any[], Ret> {
+declare interface RetryOptions<Args extends unknown[], Ret> {
     fn: (...args: Args) => Promise<Ret>;
     maxAttempts?: number;
     timeout?: number;
@@ -816,8 +841,6 @@ export declare function setInterceptor({ source, window, useInnerProxy, cancelMe
 
 export declare function setupCanvas(video: HTMLVideoElement, snap: OffscreenCanvas | undefined): HTMLCanvasElement;
 
-export declare function setupFrameProtocol(): void;
-
 export declare function setupPupProtocol(): void;
 
 export declare function shoot(options: IPCRenderOptions): Promise<IpcDonePayload>;
@@ -844,15 +867,6 @@ 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>;
@@ -867,7 +881,7 @@ export declare function syncOverlay(video: HTMLVideoElement, cv: HTMLCanvasEleme
 
 export declare const TAG = "[VideoHook]";
 
-export declare function tick(frame: WebFrameMain | undefined, timestampMs: number): Promise<void>;
+export declare function tick(args: AdvanceOptions): Promise<void>;
 
 export declare const TICK_SYMBOL = "__pup_tick__";
 
@@ -888,7 +902,9 @@ export declare interface UnifiedExtradataOptions {
 
 export declare function unsetInterceptor(window: BrowserWindow): void;
 
-declare function useRetry<Args extends any[], Ret>({ fn, maxAttempts, timeout, signal }: RetryOptions<Args, Ret>): (...args: Args) => Promise<Ret>;
+export declare function useFrameProtocol(useInnerProxy: boolean): AsyncDisposable;
+
+declare function useRetry<Args extends unknown[], Ret>({ fn, maxAttempts, timeout, signal, }: RetryOptions<Args, Ret>): (...args: Args) => Promise<Ret>;
 export { useRetry }
 export { useRetry as useRetry_alias_1 }
 
@@ -896,7 +912,7 @@ declare type Vec4 = [number, number, number, number];
 
 export declare interface VideoCache {
     bitmaps: Map<number, ImageBitmap>;
-    inFlight: Map<number, Promise<ImageBitmap | null>>;
+    inFlight: Map<number, Promise<ImageBitmap | undefined>>;
     readers: Map<VideoState, number>;
 }
 
@@ -950,13 +966,15 @@ export declare interface VideoFrameMeta {
 
 export declare class VideoHook {
     readonly sessions: WeakMap<HTMLVideoElement, VideoState>;
-    readonly attaching: WeakMap<HTMLVideoElement, Promise<VideoState | null>>;
+    readonly attaching: WeakMap<HTMLVideoElement, Promise<VideoState | undefined>>;
+    readonly opening: Set<Promise<unknown>>;
     readonly cache: FrameCache;
     rvfcSeq: number;
     currMs: number;
-    private lastSnapshot;
+    private _lastSnapshot;
     install(): void;
-    attach(video: HTMLVideoElement, native?: boolean): Promise<VideoState | null>;
+    attach(video: HTMLVideoElement, native?: boolean): Promise<VideoState | undefined>;
+    ready(): Promise<void>;
     resume(video: HTMLVideoElement, state: VideoState): void;
     detach(video: HTMLVideoElement): void;
     onSrcChange(video: HTMLVideoElement): void;
@@ -974,6 +992,8 @@ export declare interface VideoMeta {
     frameHeight: number;
     fps: number;
     duration: number;
+    /** Seconds of corrupt/empty leading content held on the first decodable frame. */
+    leadGap: number;
 }
 
 export declare interface VideoMeta_alias_1 {
@@ -995,7 +1015,7 @@ export declare interface VideoSetup {
 }
 
 export declare interface VideoState {
-    meta: VideoMeta_alias_1 | null;
+    meta?: VideoMeta_alias_1;
     cv: HTMLCanvasElement;
     ctx: CanvasRenderingContext2D;
     paused: boolean;