pup-recorder 0.2.7 → 0.3.0

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/build.ts

@@ -3,15 +3,12 @@ import { rm } from "fs/promises";
 import { createRequire } from "module";
 import { join } from "path";
 import { build, type Options } from "tsup";
-import { buildRust } from "./build_rust";
 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");
 
-await buildRust();
-
 await $`${tsgo}`;
 await rm("dist", { recursive: true, force: true });
 

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

@@ -10,15 +10,20 @@ 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';
 
 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>;
 }
@@ -62,39 +67,77 @@ export declare interface AudioEncoderOptions {
     muxer: FormatMuxer;
 }
 
+/**
+ * Build alpha_channel_info SEI message (payloadType=165).
+ * Layout from x265 SEIAlphaChannelInfo::writeSEI.
+ */
+export declare function buildAlphaChannelInfoSEI(): Buffer;
+
 export declare function buildRust(): Promise<void>;
 
 export declare function buildStegoHTML(targetURL: string, size: Size): string;
 
 /**
- * Builds the JS injector that hooks all time-related globals in the target iframe.
- * Guards against running in the wrapper (top-level) frame so the stego canvas is unaffected.
+ * Builds the JS injector that hooks all time-related globals in the target frame.
+ * In Electron/stego mode (default), guards against running in the top-level frame.
+ * In Puppeteer mode (skipFrameGuard: true), injects directly into the main document.
  * Must be injected via Page.addScriptToEvaluateOnNewDocument AND directly into
- * already-loaded sub-frames.
+ * already-loaded frames.
  */
-export declare function buildTickInjector(): string;
+export declare function buildTickInjector(opts?: TickInjectorOptions): string;
+
+/**
+ * Build unified extradata: base VPS (patched for alpha) + interleaved SPS/PPS.
+ * Alpha SPS/PPS follow their base counterparts so the HVCC serializer
+ * groups them into the same NAL array (required for multi-layer).
+ */
+export declare function buildUnifiedExtradata(baseExtradata: Buffer, alphaExtradata: Buffer): Buffer;
 
 export declare const canIUseGPU: Promise<boolean>;
 
 export declare function checkHTML(source: string): void;
 
+export declare function chromiumOptions(disableGpu: boolean): Promise<string[]>;
+
 export declare interface CLIOptions {
     name: string;
     defaults: RenderOptions;
     run: (source: string, options: RenderOptions) => Promise<unknown>;
 }
 
+declare class CodecState_2 implements Disposable {
+    readonly src: Frame;
+    readonly dst: Frame;
+    readonly pkt: Packet;
+    private _sws?;
+    private _png?;
+    static create(width: number, height: number): Promise<CodecState_2>;
+    private constructor();
+    /**
+     * Create a fresh PNG decoder context.
+     * The FFmpeg PNG decoder accumulates APNG blending state
+     * 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;
+}
+export { CodecState_2 as CodecState }
+
 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 }
@@ -106,6 +149,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;
@@ -120,7 +167,7 @@ declare const DEFAULT_HEIGHT = 1080;
 export { DEFAULT_HEIGHT }
 export { DEFAULT_HEIGHT as DEFAULT_HEIGHT_alias_1 }
 
-declare const DEFAULT_OUT_FILE = "output.mov";
+declare const DEFAULT_OUT_FILE = "output.mp4";
 export { DEFAULT_OUT_FILE }
 export { DEFAULT_OUT_FILE as DEFAULT_OUT_FILE_alias_1 }
 
@@ -136,26 +183,27 @@ export declare function doEject(): string;
 
 export declare function doProcess(timestampMs: number): string;
 
-export declare function electronOpts(): Promise<string[]>;
+export declare function doPuppeteer(source: string, options: RenderOptions, onProgress?: (p: number) => void): Promise<IpcDonePayload>;
+
+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 _sws;
-    private _srcFrame;
-    private _dstFrame;
+    private _s;
     private _disposed;
     private constructor();
     static create(opts: EncoderPipelineOptions): Promise<EncoderPipeline>;
     setupAudio(sampleRate: number): void;
-    encodeFrame(input: Buffer): Promise<void>;
+    encodeBGRA(input: Buffer): Promise<void>;
+    encodePNG(pngData: Buffer): Promise<void>;
     encodeAudio(pcm: Buffer): Promise<void>;
     finish(): Promise<string>;
     [Symbol.asyncDispose](): Promise<void>;
     private free;
+    private bgraFrame;
 }
 export { EncoderPipeline }
 export { EncoderPipeline as EncoderPipeline_alias_1 }
@@ -166,6 +214,7 @@ declare interface EncoderPipelineOptions {
     fps: number;
     outFile: string;
     withAudio?: boolean;
+    disableGpu?: boolean;
 }
 export { EncoderPipelineOptions }
 export { EncoderPipelineOptions as EncoderPipelineOptions_alias_1 }
@@ -234,6 +283,20 @@ 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;
+}
+
+/** Interleave base and alpha NALs for a single frame. */
+export declare function interleaveAccessUnits(baseNals: NalUnit[], alphaNals: NalUnit[]): Buffer;
+
 export declare interface IpcDonePayload {
     written: number;
     jank: number;
@@ -326,6 +389,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;
@@ -336,6 +411,23 @@ 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 packBits(bits: number[]): Buffer;
+
 declare function pargs(): string[];
 export { pargs }
 export { pargs as pargs_alias_1 }
@@ -389,6 +481,10 @@ declare const pupDisableGPU: boolean;
 export { pupDisableGPU }
 export { pupDisableGPU as pupDisableGPU_alias_1 }
 
+declare const pupExperimentalPuppeteer: boolean;
+export { pupExperimentalPuppeteer }
+export { pupExperimentalPuppeteer as pupExperimentalPuppeteer_alias_1 }
+
 declare const pupIpcSocket: string | undefined;
 export { pupIpcSocket }
 export { pupIpcSocket as pupIpcSocket_alias_1 }
@@ -445,6 +541,7 @@ declare const RenderSchema: z.ZodObject<{
     outFile: z.ZodString;
     useInnerProxy: z.ZodBoolean;
     deterministic: z.ZodBoolean;
+    disableGpu: z.ZodBoolean;
 }, z.core.$strip>;
 export { RenderSchema }
 export { RenderSchema as RenderSchema_alias_1 }
@@ -457,6 +554,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;
@@ -471,12 +571,24 @@ 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>;
 
 export declare const TICK_SYMBOL = "__pup_tick__";
 
+export declare interface TickInjectorOptions {
+    /**
+     * When true, skips the top-frame guard so the injector runs in the main document.
+     * Required for Puppeteer mode where the page is loaded directly (no stego iframe wrapper).
+     * Default: false (Electron/stego mode — only inject in iframes).
+     */
+    skipFrameGuard?: boolean;
+}
+
 export declare function unsetInterceptor(window: BrowserWindow): void;
 
 declare function useRetry<Args extends any[], Ret>({ fn, maxAttempts, timeout }: RetryOptions<Args, Ret>): (...args: Args) => Promise<Ret>;
@@ -507,10 +619,37 @@ export declare interface VideoEncoderOptions {
     codecOpts: Record<string, string>;
     bitrate: number;
     pixelFormat: AVPixelFormat;
-    threadCount?: number;
     muxer: FormatMuxer;
 }
 
+export declare interface VideoFactoryOptions {
+    width: number;
+    height: number;
+    fps: number;
+    bitrate?: number;
+    disableGpu?: 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?;