pup-recorder 0.4.3 → 0.4.5

package/biome.json

@@ -15,6 +15,7 @@
             "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"] },

package/build.ts

@@ -7,12 +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 src`;
+await $`${biome} check --write --error-on-warnings`;
 await rm("dist", { recursive: true, force: true });
 
 const common: Options = {

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

@@ -10,8 +10,7 @@ import type { Debugger } from 'electron';
 import { Demuxer } from 'node-av/api';
 import { EventEmitter } from 'node:events';
 import { FFAudioEncoder } from 'node-av/constants';
-import type { FFVideoEncoder } from 'node-av/constants';
-import { FormatContext } from 'node-av';
+import { FFVideoEncoder } from 'node-av/constants';
 import { Frame } from 'node-av';
 import { HardwareContext } from 'node-av/api';
 import { HardwareFramesContext } from 'node-av';
@@ -130,6 +129,18 @@ export declare class BitWriter {
     copy(src: number[], start: number, len: number): void;
 }
 
+export declare const BLANK_WARN_RATIO = 0.5;
+
+export declare class BlankFrameStats {
+    private readonly _width;
+    private readonly _height;
+    private _total;
+    private _blank;
+    constructor(width: number, height: number);
+    sample(frame: Buffer): void;
+    finalize(): number;
+}
+
 export declare function buildAlphaChannelInfoSEI(): Buffer;
 
 /**
@@ -231,14 +242,16 @@ export declare class DecodeSession {
     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;
     private pump;
     private decodePass;
+    private get demand();
     private pause;
     private untilRestart;
     private evict;
@@ -329,6 +342,8 @@ export declare interface EncoderPipelineOptions {
     disableHwCodec?: boolean;
 }
 
+export declare function encodeStubWebm({ width, height, duration }: StubEncodeOptions): Promise<Buffer>;
+
 export declare type EnvParser<T> = (value: unknown) => T;
 
 export declare interface ErrorMsg {
@@ -342,6 +357,8 @@ export declare function exec(cmd: string, options?: SpawnOptions): ProcessHandle
 
 export declare function extractAlphaToYuv420pBuffer(bgraFrame: Frame, buf: Buffer): void;
 
+export declare const FF_ENCODER_LIBVPX_VP9: FFVideoEncoder;
+
 export declare function fire(el: EventTarget, type: string): void;
 
 export declare function fitRect(srcW: number, srcH: number, dstW: number, dstH: number, fit: string): Vec4;
@@ -349,8 +366,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>;
@@ -363,7 +381,7 @@ 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>;
+    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;
@@ -404,16 +422,20 @@ export declare class FrameDropStats {
 }
 
 export declare class FrameServer {
+    private readonly _useInnerProxy;
     private _sessions;
+    private _probes;
+    private _stubs;
     private _closed;
+    constructor(_useInnerProxy: boolean);
     open(opts: OpenOptions): Promise<VideoMeta>;
+    stub(src: string): Promise<Buffer>;
     getFrame(id: string, idx: number): Promise<Buffer>;
-    close(id: string): void;
-    closeAll(): void;
+    close(id: string): Promise<void>;
+    private probeCached;
+    closeAll(): Promise<void>;
 }
 
-export declare const frameServer: FrameServer;
-
 export declare const HAVE_ENOUGH_DATA = 4;
 
 export declare const HAVE_METADATA = 1;
@@ -452,6 +474,7 @@ export declare interface IpcDonePayload {
     written: number;
     jank: number;
     outFile: string;
+    blank: number;
 }
 
 export declare interface IpcEvents {
@@ -491,6 +514,8 @@ export declare class IpcWriter {
     private send;
 }
 
+export declare function isBlankFrame(bgra: Buffer, width: number, height: number): boolean;
+
 export declare function isEmpty(image: NativeImage): boolean;
 
 declare class Lazy<T> {
@@ -593,7 +618,7 @@ export declare interface NetworkOptions {
     source: string;
     window: BrowserWindow;
     useInnerProxy?: boolean;
-    cancelMedia?: boolean;
+    stubMedia?: boolean;
 }
 
 export declare function newVideoState(video: HTMLVideoElement, cv: HTMLCanvasElement): VideoState;
@@ -637,7 +662,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>;
 
@@ -682,7 +707,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 }
 
@@ -777,6 +802,7 @@ declare interface RenderResult {
     written: number;
     jank: number;
     outFile: string;
+    blank: number;
 }
 export { RenderResult }
 export { RenderResult as RenderResult_alias_1 }
@@ -836,12 +862,10 @@ 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, cancelMedia }: NetworkOptions): void;
+export declare function setInterceptor({ source, window, useInnerProxy, stubMedia }: NetworkOptions): void;
 
 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>;
@@ -876,6 +900,12 @@ export declare const STEGO_TICK_CHANNEL = "stego-tick";
 
 export declare function stopStego(cdp: Debugger): Promise<unknown>;
 
+export declare interface StubEncodeOptions {
+    width: number;
+    height: number;
+    duration: number;
+}
+
 export declare function swapBuffer(wc: WebContents, expected: number, interval: number): Promise<void>;
 
 export declare function syncOverlay(video: HTMLVideoElement, cv: HTMLCanvasElement): void;
@@ -903,6 +933,8 @@ export declare interface UnifiedExtradataOptions {
 
 export declare function unsetInterceptor(window: BrowserWindow): void;
 
+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 }
@@ -911,7 +943,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>;
 }
 
@@ -965,14 +997,14 @@ 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;
     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;
@@ -1014,7 +1046,7 @@ export declare interface VideoSetup {
 }
 
 export declare interface VideoState {
-    meta: VideoMeta_alias_1 | null;
+    meta?: VideoMeta_alias_1;
     cv: HTMLCanvasElement;
     ctx: CanvasRenderingContext2D;
     paused: boolean;