pup-recorder 0.1.9 → 0.1.11

package/README.md

@@ -7,61 +7,86 @@ pup-recorder - record web pages as video
 ## SYNOPSIS
 
 ```
-pup <source> [-w n] [-h n] [-f n] [-t n] [-o path] [-a] [-s] [--use-inner-proxy]
+pup source [-W width] [-H height] [-f fps] [-t duration] [-o dir] [-F formats] [-a] [--use-inner-proxy]
 ```
 
 ## DESCRIPTION
 
-Electron offscreen rendering to MP4 (H.264). With `-a`: WebM (VP9) + MOV (HEVC alpha).
+Renders a web page offscreen via Electron and encodes the result to one or
+more video formats. Default output is mp4 (H.264/yuv420p). Formats with
+alpha (mov, webm) use HEVC/x265 and VP9/yuva420p respectively.
 
 ## OPTIONS
 
 ```
-<source>                  file://, http(s)://, or data: URI
--w, --width <n>           default 1920
--h, --height <n>          default 1080
--f, --fps <n>             default 30
--t, --duration <n>        seconds, default 5
--o, --out-dir <path>      default "out"
--a, --with-alpha-channel  output webm+mov instead of mp4
--s, --with-audio          capture system audio
-    --use-inner-proxy
+source
+    file://, http(s)://, or data: URI of the page to record.
+
+-W width, --width=width
+    Frame width in pixels.  Default: 1920.
+
+-H height, --height=height
+    Frame height in pixels.  Default: 1080.
+
+-f fps, --fps=fps
+    Frames per second.  Default: 30.
+
+-t duration, --duration=duration
+    Recording duration in seconds.  Default: 5.
+
+-o dir, --out-dir=dir
+    Output directory.  Default: out.
+
+-F formats, --formats=formats
+    Comma-separated list of output formats.  Allowed values: mp4, mov, webm.
+    Default: mp4.
+
+-a, --with-audio
+    Capture and encode system audio.
+
+--use-inner-proxy
+    Route resource requests through the Bilibili inner proxy.
 ```
 
 ## ENVIRONMENT
 
 ```
-PUP_LOG_LEVEL        0-3, default 2
-PUP_USE_INNER_PROXY  1=on
-PUP_FFMPEG_PATH      default "ffmpeg"
-PUP_DISABLE_GPU      1=on
+PUP_LOG_LEVEL        Verbosity: 0=error 1=warn 2=info 3=debug.  Default: 2.
+PUP_USE_INNER_PROXY  Set to 1 to enable the inner proxy globally.
+PUP_FFMPEG_PATH      Path to the ffmpeg binary.  Default: ffmpeg.
+PUP_DISABLE_GPU      Set to 1 to disable GPU acceleration.
+PUP_NO_CLEANUP       Set to 1 to keep intermediate files after encoding.
 ```
 
 ## API
 
 ```typescript
-import { pup } from "pup-recorder";
+import { pup, type VideoFormat } from "pup-recorder";
 
 const { options, files } = await pup(source, {
   width?, height?, fps?, duration?, outDir?,
-  withAlphaChannel?, withAudio?, useInnerProxy?,
+  formats?: VideoFormat[],
+  withAudio?, useInnerProxy?,
   cancelQuery?, onProgress?,
 });
-// files: { mp4?, webm?, mov?, cover }
+// files: { mp4?, mov?, webm?, cover }
 ```
 
 ## FILES
 
 ```
-dist/cli.js    dist/index.js    rust/*.node    x265/
+dist/cli.js     CLI entry point
+dist/index.js   library entry point
+rust/*.node     native bindings
+x265/           bundled x265 binaries
 ```
 
 ## EXAMPLES
 
 ```sh
 pup https://example.com -t 5
-pup file:///path/to/page.html -a -t 10
-pup https://example.com -s -w 1280 -h 720 -f 60 -t 10 -o /tmp/out
+pup file:///path/to/page.html -F mov,webm -t 10
+pup https://example.com -F mp4,mov,webm -a -W 1280 -H 720 -f 60 -t 10 -o /tmp/out
 ```
 
 ## SEE ALSO

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

@@ -142,6 +142,10 @@ export declare const FRAME_SYNC_MARKER_WIDTH = 32;
 
 export declare function isEmpty(image: NativeImage): boolean;
 
+declare function isVideoFormat(s: string): s is VideoFormat;
+export { isVideoFormat }
+export { isVideoFormat as isVideoFormat_alias_1 }
+
 declare class Lazy<T> {
     readonly makeValue: () => T;
     constructor(makeValue: () => T);
@@ -200,10 +204,14 @@ declare function pargs(): string[];
 export { pargs }
 export { pargs as pargs_alias_1 }
 
-declare function parseNumber(value: unknown): number;
+declare function parseNumber(x: unknown): number;
 export { parseNumber }
 export { parseNumber as parseNumber_alias_1 }
 
+declare function parseString(x: unknown): string;
+export { parseString }
+export { parseString as parseString_alias_1 }
+
 declare function penv<T>(name: string, parser: EnvParser<T>, defaultValue: T): T;
 
 declare function penv<T>(name: string, parser: EnvParser<T>, defaultValue?: T): T | undefined;
@@ -289,7 +297,11 @@ declare const RenderSchema: z.ZodObject<{
     width: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     height: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     fps: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    withAlphaChannel: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    formats: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        mp4: "mp4";
+        mov: "mov";
+        webm: "webm";
+    }>>>>;
     withAudio: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     outDir: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     useInnerProxy: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -327,6 +339,10 @@ declare function useRetry<Args extends any[], Ret>({ fn, maxAttempts, timeout, }
 export { useRetry }
 export { useRetry as useRetry_alias_1 }
 
+declare const VIDEO_FORMATS: readonly ["mp4", "mov", "webm"];
+export { VIDEO_FORMATS }
+export { VIDEO_FORMATS as VIDEO_FORMATS_alias_1 }
+
 declare interface VideoFiles {
     mp4?: string;
     webm?: string;
@@ -341,6 +357,10 @@ declare interface VideoFilesWithCover extends VideoFiles {
 export { VideoFilesWithCover }
 export { VideoFilesWithCover as VideoFilesWithCover_alias_1 }
 
+declare type VideoFormat = (typeof VIDEO_FORMATS)[number];
+export { VideoFormat }
+export { VideoFormat as VideoFormat_alias_1 }
+
 declare interface VideoSpec {
     fps: number;
     frames: number;