pup-recorder 0.2.8 → 0.3.1

package/README.md

@@ -1,78 +1,45 @@
-# pup-recorder(1)
+# PUP-RECORDER(1)
 
 ## NAME
 
-pup-recorder - record web pages as video
+pup-recorder — record web pages as video
 
 ## SYNOPSIS
 
-```
-pup source [-W width] [-H height] [-f fps] [-t duration] [-o file] [-a] [-d] [--use-inner-proxy]
-```
+    pup source [-W width] [-H height] [-f fps] [-t duration] [-o file] [-a] [-d]
 
 ## OPTIONS
 
-```
-source                    file://, http(s)://, or data: URI
-
--W, --width <number>      default: 1920
--H, --height <number>     default: 1080
--f, --fps <number>        default: 30
--t, --duration <number>   default: 5
--o, --out-file <path>     default: output.mp4
--a, --with-audio
--d, --deterministic       frame-by-frame rendering mode
---use-inner-proxy         use Bilibili inner proxy
-```
+    source                    file://, http(s)://, or data: URI
+    -W, --width <number>      default: 1920
+    -H, --height <number>     default: 1080
+    -f, --fps <number>        default: 30
+    -t, --duration <number>   default: 5
+    -o, --out-file <path>     default: output.mp4
+    -a, --with-audio
+    -d, --deterministic       frame-by-frame rendering mode
+    --use-inner-proxy         use Bilibili inner proxy
 
 ## ENVIRONMENT
 
-```
-PUP_LOG_LEVEL        0=error 1=warn 2=info 3=debug. default: 2
-PUP_USE_INNER_PROXY  1=on
-PUP_DISABLE_GPU      1=on
-PUP_DETERMINISTIC    1=on
-```
+    PUP_LOG_LEVEL              0=error 1=warn 2=info 3=debug (default: 2)
+    PUP_USE_INNER_PROXY        1=on
+    PUP_DISABLE_GPU            1=on
+    PUP_DETERMINISTIC          1=on
+    PUP_EXPERIMENTAL_PUPPETEER 1=on (Linux puppeteer mode)
 
 ## API
 
-```typescript
+```ts
 import { pup } from "pup-recorder";
 
 const result = await pup(source, {
-  width?: number,
-  height?: number,
-  fps?: number,
-  duration?: number,
-  outFile?: string,
-  withAudio?: boolean,
-  deterministic?: boolean,
-  useInnerProxy?: boolean,
-  signal?: AbortSignal,
-  onProgress?: (progress: number) => void,
+  width, height, fps, duration, outFile,
+  withAudio, deterministic, useInnerProxy,
+  signal, onProgress,
 });
-// result: { options, written, jank, outFile, audio? }
-```
-
-## FILES
-
-```
-dist/cli.cjs
-dist/index.js
-```
-
-## EXAMPLES
-
-```sh
-pup https://example.com -t 5
-pup file:///path/to/page.html -d -t 10
-pup https://example.com -a -W 1280 -H 720 -f 60 -t 10
 ```
 
 ## SEE ALSO
 
-pup-recorder-mcp(1), pup-server(1), pup(7)
-
-## AUTHOR
-
-qq1909698494@gmail.com
+pup-server(1), pup-recorder-mcp(1), pup(7)

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

@@ -1,8 +1,10 @@
 import { AV_SAMPLE_FMT_FLT } from 'node-av/constants';
 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 { Codec } from 'node-av';
 import { CodecContext } from 'node-av';
 import type { Debugger } from 'electron';
 import { EventEmitter } from 'events';
@@ -10,16 +12,23 @@ import { FFAudioEncoder } from 'node-av/constants';
 import { FFVideoEncoder } from 'node-av/constants';
 import { FormatContext } from 'node-av';
 import { Frame } from 'node-av';
+import { HardwareContext } from 'node-av/api';
 import type { NativeImage } from 'electron';
 import { Packet } from 'node-av';
 import { Size } from 'electron';
 import { Socket } from 'net';
 import { SoftwareScaleContext } from 'node-av';
 import { SpawnOptions } from 'child_process';
+import { Stream } from 'node-av';
 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 advanceVirtualTime(cdp: Debugger, budget: number): Promise<void>;
 
+export declare const ANNEX_B_START_CODE: Buffer<ArrayBuffer>;
+
 export declare interface AudioCapture {
     teardown(): Promise<void>;
 }
@@ -63,6 +72,33 @@ export declare interface AudioEncoderOptions {
     muxer: FormatMuxer;
 }
 
+export declare class BitReader {
+    private _bits;
+    pos: number;
+    constructor(data: Buffer);
+    get bits(): number[];
+    read(n: number): number;
+    readUe(): number;
+}
+
+export declare class BitWriter {
+    bits: number[];
+    w(val: number, n: number): void;
+    flag(val: boolean | number): void;
+    ue(val: number): void;
+    align(pad: number): void;
+    copy(src: number[], start: number, len: number): void;
+}
+
+export declare function buildAlphaChannelInfoSEI(): Buffer;
+
+/**
+ * Build a complete alpha VPS from scratch, using the original NVENC VPS
+ * only as a source for the PTL (profile/tier/level) bytes.
+ * Matches x265 4.1 ENABLE_ALPHA VPS structure.
+ */
+export declare function buildAlphaVPS(vpsData: Buffer, width: number, height: number): Buffer;
+
 export declare function buildRust(): Promise<void>;
 
 export declare function buildStegoHTML(targetURL: string, size: Size): string;
@@ -76,11 +112,13 @@ export declare function buildStegoHTML(targetURL: string, size: Size): string;
  */
 export declare function buildTickInjector(opts?: TickInjectorOptions): string;
 
+export declare function buildUnifiedExtradata(opts: UnifiedExtradataOptions): Buffer;
+
 export declare const canIUseGPU: Promise<boolean>;
 
 export declare function checkHTML(source: string): void;
 
-export declare function chromiumOptions(): Promise<string[]>;
+export declare function chromiumOptions(disableGpu: boolean): Promise<string[]>;
 
 export declare interface CLIOptions {
     name: string;
@@ -102,6 +140,7 @@ declare class CodecState_2 implements Disposable {
      * across frames, so a shared instance corrupts output when decoding standalone PNGs.
      */
     png(): Promise<CodecContext>;
+    decodePNG(pngData: Buffer): Promise<Frame>;
     get sws(): SoftwareScaleContext;
     [Symbol.dispose](): void;
 }
@@ -111,13 +150,15 @@ declare class ConcurrencyLimiter {
     readonly maxConcurrency: number;
     private _active;
     private _queue;
-    private _ended;
+    private _signals;
+    private _resolve?;
     constructor(maxConcurrency: number);
     get active(): number;
     get pending(): number;
     get stats(): string;
-    schedule<T>(fn: () => Promise<T>): Promise<T>;
-    end(): Promise<void>;
+    schedule<T>(fn: () => Promise<T>, signal?: AbortSignal): Promise<T>;
+    drain(): Promise<void>;
+    private flush;
     private next;
 }
 export { ConcurrencyLimiter }
@@ -129,6 +170,10 @@ export declare function createIpcServer(socketPath: string): Promise<IpcServer>;
 
 export declare function createStegoURL(src: string, size: Size): string;
 
+export declare function createVideoEncoder(opts: VideoFactoryOptions, muxer: FormatMuxer): Promise<VideoSetup>;
+
+export declare function debounce<T extends (...args: unknown[]) => void>(fn: T, delay?: number): T;
+
 export declare function decodeStego(bitmap: Buffer, size: Size): number | undefined;
 
 declare const DEFAULT_DURATION = 5;
@@ -161,15 +206,14 @@ export declare function doProcess(timestampMs: number): string;
 
 export declare function doPuppeteer(source: string, options: RenderOptions, onProgress?: (p: number) => void): Promise<IpcDonePayload>;
 
-export declare function electronOpts(): Promise<string[]>;
+export declare function drainPackets(ctx: CodecContext, pkt: Packet, stream: Stream, muxer: FormatMuxer): Promise<void>;
+
+export declare function electronOpts(disableGpu: boolean): Promise<string[]>;
+
+export declare function encodeNalHeader(type: number, layerId: number, temporalId: number): [number, number];
 
 declare class EncoderPipeline {
-    private _video;
-    private _audio;
-    private _muxer;
-    private _limiter;
-    private _outFile;
-    private _codec;
+    private _s;
     private _disposed;
     private constructor();
     static create(opts: EncoderPipelineOptions): Promise<EncoderPipeline>;
@@ -180,6 +224,7 @@ declare class EncoderPipeline {
     finish(): Promise<string>;
     [Symbol.asyncDispose](): Promise<void>;
     private free;
+    private bgraFrame;
 }
 export { EncoderPipeline }
 export { EncoderPipeline as EncoderPipeline_alias_1 }
@@ -190,6 +235,7 @@ declare interface EncoderPipelineOptions {
     fps: number;
     outFile: string;
     withAudio?: boolean;
+    disableHwCodec?: boolean;
 }
 export { EncoderPipelineOptions }
 export { EncoderPipelineOptions as EncoderPipelineOptions_alias_1 }
@@ -258,6 +304,19 @@ export declare class FrameDropStats {
     finalize(): FrameDropScore;
 }
 
+export declare type HwEncoder = VideoToolboxEncoder | NvencDualLayerEncoder;
+
+export declare interface HwVideoEncoderOptions {
+    width: number;
+    height: number;
+    fps: number;
+    hw: HardwareContext;
+    bitrate: number;
+    muxer: FormatMuxer;
+}
+
+export declare function interleaveAccessUnits(baseNals: NalUnit[], alphaNals: NalUnit[]): Buffer;
+
 export declare interface IpcDonePayload {
     written: number;
     jank: number;
@@ -350,6 +409,18 @@ export { LoggerLike as LoggerLike_alias_1 }
 
 export declare function makeCLI(options: CLIOptions): Promise<void>;
 
+export declare function makeFrame(width: number, height: number, pixFmt: AVPixelFormat): Frame;
+
+export declare function makePacket(): Packet;
+
+export declare const NAL_HEADER_SIZE = 2;
+
+export declare interface NalUnit {
+    type: number;
+    layerId: number;
+    data: Buffer;
+}
+
 export declare interface NetworkOptions {
     source: string;
     window: BrowserWindow;
@@ -360,6 +431,25 @@ declare function noerr<Fn extends (...args: any[]) => any, D>(fn: Fn, defaultVal
 export { noerr }
 export { noerr as noerr_alias_1 }
 
+export declare class NvencDualLayerEncoder implements Disposable {
+    private _s;
+    private _seiBuffer;
+    private _pts;
+    private _seiInjected;
+    private _alphaBuf?;
+    private _alphaFrame?;
+    private constructor();
+    static create(opts: HwVideoEncoderOptions): Promise<NvencDualLayerEncoder>;
+    encode(bgraFrame: Frame, muxer: FormatMuxer): Promise<void>;
+    flush(muxer: FormatMuxer): Promise<void>;
+    [Symbol.dispose](): void;
+    private drainInterleaved;
+}
+
+export declare function openVideoCtx(opts: VideoCtxOptions, label: string): Promise<CodecContext>;
+
+export declare function packBits(bits: number[]): Buffer;
+
 declare function pargs(): string[];
 export { pargs }
 export { pargs as pargs_alias_1 }
@@ -413,6 +503,10 @@ declare const pupDisableGPU: boolean;
 export { pupDisableGPU }
 export { pupDisableGPU as pupDisableGPU_alias_1 }
 
+declare const pupDisableHwCodec: boolean;
+export { pupDisableHwCodec }
+export { pupDisableHwCodec as pupDisableHwCodec_alias_1 }
+
 declare const pupExperimentalPuppeteer: boolean;
 export { pupExperimentalPuppeteer }
 export { pupExperimentalPuppeteer as pupExperimentalPuppeteer_alias_1 }
@@ -449,6 +543,9 @@ declare const pupUseInnerProxy: boolean;
 export { pupUseInnerProxy }
 export { pupUseInnerProxy as pupUseInnerProxy_alias_1 }
 
+/** Remove emulation prevention bytes (00 00 03 → 00 00) from RBSP. */
+export declare function removeEmulationPrevention(data: Buffer): Buffer;
+
 export declare function render(writer: IpcWriter, source: string, options: RenderOptions): Promise<IpcDonePayload>;
 
 declare type RenderOptions = z.infer<typeof RenderSchema>;
@@ -473,6 +570,8 @@ declare const RenderSchema: z.ZodObject<{
     outFile: z.ZodString;
     useInnerProxy: z.ZodBoolean;
     deterministic: z.ZodBoolean;
+    disableGpu: z.ZodBoolean;
+    disableHwCodec: z.ZodBoolean;
 }, z.core.$strip>;
 export { RenderSchema }
 export { RenderSchema as RenderSchema_alias_1 }
@@ -485,6 +584,9 @@ declare interface RetryOptions<Args extends any[], Ret> {
 export { RetryOptions }
 export { RetryOptions as RetryOptions_alias_1 }
 
+/** Rewrite nuh_layer_id in a NAL unit (returns copy). */
+export declare function rewriteNalLayerId(nal: Buffer, layerId: number): Buffer;
+
 export declare function runElectronApp(size: Size, args: unknown[], ipcSocketPath: string): Promise<ProcessHandle>;
 
 export declare function setInterceptor({ source, window, useInnerProxy }: NetworkOptions): void;
@@ -499,6 +601,9 @@ declare function sleep(ms: number): Promise<void>;
 export { sleep }
 export { sleep as sleep_alias_1 }
 
+/** Split Annex B bitstream into NAL units. */
+export declare function splitNalUnits(bitstream: Buffer): NalUnit[];
+
 export declare function startStego(cdp: Debugger): Promise<any>;
 
 export declare function stopStego(cdp: Debugger): Promise<any>;
@@ -514,12 +619,31 @@ export declare interface TickInjectorOptions {
     skipFrameGuard?: boolean;
 }
 
+export declare interface UnifiedExtradataOptions {
+    baseExtradata: Buffer;
+    alphaExtradata: Buffer;
+    width: number;
+    height: number;
+}
+
 export declare function unsetInterceptor(window: BrowserWindow): void;
 
 declare function useRetry<Args extends any[], Ret>({ fn, maxAttempts, timeout }: RetryOptions<Args, Ret>): (...args: Args) => Promise<Ret>;
 export { useRetry }
 export { useRetry as useRetry_alias_1 }
 
+export declare interface VideoCtxOptions {
+    codec: Codec;
+    width: number;
+    height: number;
+    fps: number;
+    bitrate: number;
+    pixelFormat: AVPixelFormat;
+    codecTag?: string;
+    colorRange?: AVColorRange;
+    options?: Record<string, string>;
+}
+
 declare class VideoEncoder_2 implements Disposable {
     private readonly _ctx;
     private readonly _pkt;
@@ -540,13 +664,40 @@ export declare interface VideoEncoderOptions {
     fps: number;
     codecName: FFVideoEncoder;
     codecTag?: string;
-    globalHeader: boolean;
     codecOpts: Record<string, string>;
     bitrate: number;
     pixelFormat: AVPixelFormat;
     muxer: FormatMuxer;
 }
 
+export declare interface VideoFactoryOptions {
+    width: number;
+    height: number;
+    fps: number;
+    bitrate?: number;
+    disableHwCodec?: boolean;
+}
+
+export declare interface VideoSetup {
+    video?: VideoEncoder_2;
+    hwVideo?: HwEncoder;
+    codec?: CodecState_2;
+    hw?: HardwareContext;
+}
+
+export declare class VideoToolboxEncoder implements Disposable {
+    private _ctx;
+    private _pkt;
+    private _stream;
+    private _pts;
+    private constructor();
+    static create(opts: HwVideoEncoderOptions): Promise<VideoToolboxEncoder>;
+    encode(bgraFrame: Frame, muxer: FormatMuxer): Promise<void>;
+    flush(muxer: FormatMuxer): Promise<void>;
+    [Symbol.dispose](): void;
+    private drain;
+}
+
 export declare class WaitableEvent {
     private _promise?;
     private _resolve?;