pup-recorder 0.2.6 → 0.2.8

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

@@ -1,9 +1,11 @@
 import { AV_SAMPLE_FMT_FLT } from 'node-av/constants';
 import { AV_SAMPLE_FMT_FLTP } from 'node-av/constants';
+import { AVPixelFormat } from 'node-av/constants';
 import { BrowserWindow } from 'electron';
 import { ChildProcess } from 'child_process';
 import { CodecContext } from 'node-av';
 import type { Debugger } from 'electron';
+import { EventEmitter } from 'events';
 import { FFAudioEncoder } from 'node-av/constants';
 import { FFVideoEncoder } from 'node-av/constants';
 import { FormatContext } from 'node-av';
@@ -11,23 +13,31 @@ import { Frame } from 'node-av';
 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 z from 'zod';
 
 export declare function advanceVirtualTime(cdp: Debugger, budget: number): Promise<void>;
 
 export declare interface AudioCapture {
-    teardown(): Promise<AudioSpec | undefined>;
+    teardown(): Promise<void>;
+}
+
+export declare interface AudioCaptureOptions {
+    encoder: EncoderPipeline;
+    getVideoTimeMs: () => number;
+    onError: (error: Error) => void;
 }
 
 declare class AudioEncoder_2 implements Disposable {
-    private readonly _ctx;
-    private readonly _stream;
-    private readonly _outRate;
-    private readonly _outFmt;
-    private readonly _frameSize;
-    private readonly _pkt;
-    private readonly _filterFrame;
+    private _ctx;
+    private _stream;
+    private _pkt;
+    private _outRate;
+    private _outFmt;
+    private _frameSize;
+    private _filterFrame;
     private _graph?;
     private _bufSrc?;
     private _bufSink?;
@@ -35,14 +45,12 @@ declare class AudioEncoder_2 implements Disposable {
     private _pts;
     private constructor();
     static create(opts: AudioEncoderOptions): Promise<AudioEncoder_2>;
-    /** Must be called once when the page's actual sample rate is known. */
     setInputRate(inSampleRate: number): void;
     encode(pcm: Buffer, muxer: FormatMuxer): Promise<void>;
     flush(muxer: FormatMuxer): Promise<void>;
     [Symbol.dispose](): void;
-    private drainFilter;
+    private drain;
     private drainCodec;
-    private disposeGraph;
 }
 export { AudioEncoder_2 as AudioEncoder }
 
@@ -55,36 +63,50 @@ export declare interface AudioEncoderOptions {
     muxer: FormatMuxer;
 }
 
-declare interface AudioSpec {
-    pcmFile: string;
-    pcmStartMs: number;
-    pcmSampleRate: number;
-}
-export { AudioSpec }
-export { AudioSpec as AudioSpec_alias_1 }
-
 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;
 
 export declare const canIUseGPU: Promise<boolean>;
 
 export declare function checkHTML(source: string): void;
 
+export declare function chromiumOptions(): 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>;
+    get sws(): SoftwareScaleContext;
+    [Symbol.dispose](): void;
+}
+export { CodecState_2 as CodecState }
+
 declare class ConcurrencyLimiter {
     readonly maxConcurrency: number;
     private _active;
@@ -101,6 +123,10 @@ declare class ConcurrencyLimiter {
 export { ConcurrencyLimiter }
 export { ConcurrencyLimiter as ConcurrencyLimiter_alias_1 }
 
+export declare function connectIpc(socketPath: string): Promise<IpcWriter>;
+
+export declare function createIpcServer(socketPath: string): Promise<IpcServer>;
+
 export declare function createStegoURL(src: string, size: Size): string;
 
 export declare function decodeStego(bitmap: Buffer, size: Size): number | undefined;
@@ -133,31 +159,27 @@ export declare function doEject(): string;
 
 export declare function doProcess(timestampMs: number): string;
 
-export declare function electronOpts(): Promise<string[]>;
-
-export declare function encodeBgra({ summary, outFile, signal, onProgress }: EncodeBgraOptions): Promise<RenderResult>;
+export declare function doPuppeteer(source: string, options: RenderOptions, onProgress?: (p: number) => void): Promise<IpcDonePayload>;
 
-export declare interface EncodeBgraOptions {
-    summary: RenderResult;
-    outFile: string;
-    signal?: AbortSignal;
-    onProgress?: PupProgressCallback;
-}
+export declare function electronOpts(): Promise<string[]>;
 
 declare class EncoderPipeline {
-    private readonly _state;
-    private readonly _sws;
-    private readonly _srcFrame;
-    private readonly _yuvaFrame;
+    private _video;
+    private _audio;
+    private _muxer;
+    private _limiter;
+    private _outFile;
+    private _codec;
     private _disposed;
     private constructor();
-    static create({ width, height, fps, outFile, withAudio, videoBitrate, audioBitrate, }: EncoderPipelineOptions): Promise<EncoderPipeline>;
+    static create(opts: EncoderPipelineOptions): Promise<EncoderPipeline>;
     setupAudio(sampleRate: number): void;
-    encodeFrame(input: Buffer | Frame): 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 freeShared;
+    private free;
 }
 export { EncoderPipeline }
 export { EncoderPipeline as EncoderPipeline_alias_1 }
@@ -168,8 +190,6 @@ declare interface EncoderPipelineOptions {
     fps: number;
     outFile: string;
     withAudio?: boolean;
-    videoBitrate?: number;
-    audioBitrate?: number;
 }
 export { EncoderPipelineOptions }
 export { EncoderPipelineOptions as EncoderPipelineOptions_alias_1 }
@@ -193,7 +213,7 @@ export declare const FixedBufferWriter: FixedBufferWriter;
 declare class FormatMuxer {
     private readonly _ctx;
     private _opened;
-    constructor(outPath: string);
+    constructor(outPath: string, formatName?: string);
     addStream(codecCtx: CodecContext, codecTag?: string): ReturnType<FormatContext["newStream"]>;
     open(): Promise<void>;
     writePacket(pkt: Packet): Promise<void>;
@@ -238,6 +258,49 @@ export declare class FrameDropStats {
     finalize(): FrameDropScore;
 }
 
+export declare interface IpcDonePayload {
+    written: number;
+    jank: number;
+    outFile: string;
+}
+
+export declare const enum IpcMsgType {
+    PROGRESS = 1,
+    DONE = 2,
+    ERROR = 3
+}
+
+export declare class IpcReader extends EventEmitter<{
+    progress: [value: number];
+    message: [type: IpcMsgType, buffer: Buffer];
+    done: [payload: IpcDonePayload];
+    error: [error: Error];
+    close: [];
+}> {
+    private readonly _socket;
+    private _chunks;
+    private _buffered;
+    constructor(_socket: Socket);
+    private onData;
+    private flush;
+    private peek;
+    private consume;
+}
+
+export declare interface IpcServer {
+    waitForConnection(): Promise<IpcReader>;
+    close(): void;
+}
+
+export declare class IpcWriter {
+    private readonly _socket;
+    constructor(_socket: Socket);
+    writeProgress(value: number): void;
+    writeError(error: string): void;
+    writeDone(payload: IpcDonePayload): void;
+    private write;
+}
+
 export declare function isEmpty(image: NativeImage): boolean;
 
 declare class Lazy<T> {
@@ -251,7 +314,7 @@ declare class Lazy<T> {
 export { Lazy }
 export { Lazy as Lazy_alias_1 }
 
-export declare function loadWindow(source: string, options: RenderOptions): Promise<BrowserWindow>;
+export declare function loadWindow({ source, onCreated, renderer }: WindowOptions): Promise<BrowserWindow>;
 
 declare class Logger implements LoggerLike {
     private _level;
@@ -350,6 +413,14 @@ 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 }
+
 declare const pupLogLevel: number;
 export { pupLogLevel }
 export { pupLogLevel as pupLogLevel_alias_1 }
@@ -378,7 +449,7 @@ declare const pupUseInnerProxy: boolean;
 export { pupUseInnerProxy }
 export { pupUseInnerProxy as pupUseInnerProxy_alias_1 }
 
-export declare function render(source: string, options: RenderOptions): Promise<void>;
+export declare function render(writer: IpcWriter, source: string, options: RenderOptions): Promise<IpcDonePayload>;
 
 declare type RenderOptions = z.infer<typeof RenderSchema>;
 export { RenderOptions }
@@ -389,7 +460,6 @@ declare interface RenderResult {
     written: number;
     jank: number;
     outFile: string;
-    audio?: AudioSpec;
 }
 export { RenderResult }
 export { RenderResult as RenderResult_alias_1 }
@@ -415,15 +485,15 @@ declare interface RetryOptions<Args extends any[], Ret> {
 export { RetryOptions }
 export { RetryOptions as RetryOptions_alias_1 }
 
-export declare function runElectronApp(size: Size, args: unknown[]): Promise<ProcessHandle>;
+export declare function runElectronApp(size: Size, args: unknown[], ipcSocketPath: string): Promise<ProcessHandle>;
 
 export declare function setInterceptor({ source, window, useInnerProxy }: NetworkOptions): void;
 
-export declare function setupAudioCapture(outDir: string, getVideoTimeMs: () => number): Promise<AudioCapture>;
+export declare function setupAudioCapture({ encoder, getVideoTimeMs, onError, }: AudioCaptureOptions): Promise<AudioCapture>;
 
 export declare function setupPupProtocol(): void;
 
-export declare function shoot(source: string, options: RenderOptions): Promise<void>;
+export declare function shoot(writer: IpcWriter, source: string, options: RenderOptions): Promise<IpcDonePayload>;
 
 declare function sleep(ms: number): Promise<void>;
 export { sleep }
@@ -435,6 +505,15 @@ 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>;
@@ -464,6 +543,7 @@ export declare interface VideoEncoderOptions {
     globalHeader: boolean;
     codecOpts: Record<string, string>;
     bitrate: number;
+    pixelFormat: AVPixelFormat;
     muxer: FormatMuxer;
 }
 
@@ -480,4 +560,11 @@ export declare interface WaitOptions {
     onTimeout?: () => void;
 }
 
+export declare interface WindowOptions {
+    source: string;
+    onCreated?: (window: BrowserWindow) => Promise<void>;
+    renderer: RenderOptions;
+    warmup?: boolean;
+}
+
 export { }