pup-recorder 0.1.14 → 0.1.16

package/build.ts

@@ -24,7 +24,7 @@ const common: Options = {
   minify: true,
   treeshake: true,
   banner: { js: `import "source-map-support/register.js";` },
-  loader: { ".bin": "binary" },
+  loader: { ".zip": "binary" },
 };
 
 await Promise.all([

package/build_rust.ts

@@ -1,7 +1,8 @@
 // Created by Autokaka (qq1909698494@gmail.com) on 2026/02/10.
 
 import { $ } from "bun";
-import { copyFile, mkdir, writeFile } from "fs/promises";
+import { zipSync } from "fflate";
+import { mkdir, readFile, writeFile } from "fs/promises";
 import { join } from "path";
 
 function getTriple(platform: string, arch: string) {
@@ -27,38 +28,39 @@ function getArtifactName(platform: string) {
   return null;
 }
 
-async function copyArtifact(platform: string, arch: string, dir: string) {
-  const libName = getArtifactName(platform);
-  if (!libName) return;
-  const src = join(dir, libName);
-  const destDir = join("rust");
-  const dest = join(destDir, `${platform}-${arch}.bin`);
-  const dts = `declare const sth: unknown;\nexport = sth;\n`;
-  await mkdir(destDir, { recursive: true });
-  await copyFile(src, dest);
-  await writeFile(`${dest}.d.ts`, dts);
-}
+const PLATFORMS = ["darwin", "linux", "win32"];
+const ARCHS = ["x64", "arm64"];
+const RUST_DIR = "rust";
 
-async function cargoBuild(platform: string, arch: string) {
+async function cargoBuild(platform: string, arch: string): Promise<[string, Uint8Array] | undefined> {
   const triple = getTriple(platform, arch);
-  if (triple) {
-    if (platform === "win32") {
-      await $`cargo xwin build --release --quiet --target ${triple}`;
-    } else {
-      await $`cargo zigbuild --release --quiet --target ${triple}`;
-    }
-    await copyArtifact(platform, arch, `target/${triple}/release`);
+  const libName = getArtifactName(platform);
+  if (!triple || !libName) return;
+
+  if (platform === "win32") {
+    await $`cargo xwin build --release --quiet --target ${triple}`;
+  } else {
+    await $`cargo zigbuild --release --quiet --target ${triple}`;
   }
-}
 
-const PLATFORMS = ["darwin", "linux", "win32"];
-const ARCHS = ["x64", "arm64"];
+  const data = await readFile(join(`target/${triple}/release`, libName));
+  return [`${platform}-${arch}.node`, new Uint8Array(data)];
+}
 
 export async function buildRust() {
   await $`cargo install --quiet cargo-zigbuild cargo-xwin`;
+
+  const entries: [string, Uint8Array][] = [];
   for (const platform of PLATFORMS) {
     for (const arch of ARCHS) {
-      await cargoBuild(platform, arch);
+      const entry = await cargoBuild(platform, arch);
+      if (entry) entries.push(entry);
     }
   }
+
+  await mkdir(RUST_DIR, { recursive: true });
+
+  const zip = zipSync(Object.fromEntries(entries));
+  await writeFile(join(RUST_DIR, "native.zip"), zip);
+  await writeFile(join(RUST_DIR, "native.zip.d.ts"), `declare const data: Uint8Array;\nexport default data;\n`);
 }

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

@@ -3,12 +3,14 @@ import { ChildProcess } from 'child_process';
 import type { Debugger } from 'electron';
 import type { EncodedAudioChunk as EncodedAudioChunk_2 } from '@napi-rs/webcodecs';
 import type { EncodedAudioChunkMetadataJs } from '@napi-rs/webcodecs';
+import { EncodedPacket } from 'mediabunny';
 import type { EncodedVideoChunk as EncodedVideoChunk_2 } from '@napi-rs/webcodecs';
 import type { EncodedVideoChunkMetadataJs } from '@napi-rs/webcodecs';
 import { IsobmffOutputFormat } from 'mediabunny';
 import type { NativeImage } from 'electron';
 import { Size } from 'electron';
 import { SpawnOptions } from 'child_process';
+import { StreamTarget } from 'mediabunny';
 import z from 'zod';
 
 declare class AbortLink {
@@ -45,15 +47,42 @@ export declare interface AudioCapture {
     teardown(): Promise<void>;
 }
 
+declare interface AudioInit {
+    sampleRate: number;
+    numberOfChannels: number;
+    description?: Uint8Array;
+}
+export { AudioInit }
+export { AudioInit as AudioInit_alias_1 }
+
 export declare const basedir: string;
 
 export declare interface BgraConverter {
-    new (width: number, height: number): BgraConverter;
+    new (width: number, height: number, numThreads?: number): BgraConverter;
     convert(bgra: Buffer): Promise<Buffer>;
 }
 
 export declare const BgraConverter: BgraConverter;
 
+declare interface BufferedAudio {
+    data: Uint8Array;
+    type: EncodedAudioChunk_2["type"];
+    timestampS: number;
+    durationS: number;
+}
+export { BufferedAudio }
+export { BufferedAudio as BufferedAudio_alias_1 }
+
+declare interface BufferedVideo {
+    data: Uint8Array;
+    alphaSideData?: Uint8Array;
+    type: EncodedVideoChunk_2["type"];
+    timestampS: number;
+    durationS: number;
+}
+export { BufferedVideo }
+export { BufferedVideo as BufferedVideo_alias_1 }
+
 export declare function buildRust(): Promise<void>;
 
 export declare function buildWrapperHTML(targetURL: string, size: Size): string;
@@ -80,6 +109,14 @@ declare class ConcurrencyLimiter {
 export { ConcurrencyLimiter }
 export { ConcurrencyLimiter as ConcurrencyLimiter_alias_1 }
 
+declare const createMovMuxer: (opts: MuxerOptions) => HEVCIsobmffMuxer;
+export { createMovMuxer }
+export { createMovMuxer as createMovMuxer_alias_1 }
+
+declare const createMp4Muxer: (opts: MuxerOptions) => HEVCIsobmffMuxer;
+export { createMp4Muxer }
+export { createMp4Muxer as createMp4Muxer_alias_1 }
+
 export declare function decodeTimestamp(bitmap: Buffer, size: Size): number | undefined;
 
 declare const DEFAULT_DURATION = 5;
@@ -111,12 +148,12 @@ export declare class EncoderPipeline {
     private readonly _entries;
     private readonly _converter;
     private _frameIndex;
-    constructor({ width, height, fps, formats }: EncoderPipelineOptions);
+    constructor({ width, height, fps, formats, outDir }: EncoderPipelineOptions);
     setupAudio(sampleRate: number): void;
     encodeFrame(bgraBuffer: Buffer, timestampUs: number): Promise<void>;
     encodeAudio(interleavedFloat32Buffer: Buffer, sampleRate: number): void;
     flush(): Promise<void>;
-    finalize(outDir: string): Promise<Partial<Record<VideoFormat, string>>>;
+    finalize(): Promise<Partial<Record<VideoFormat, string>>>;
 }
 
 export declare interface EncoderPipelineOptions {
@@ -124,6 +161,7 @@ export declare interface EncoderPipelineOptions {
     height: number;
     fps: number;
     formats: VideoFormat[];
+    outDir: string;
 }
 
 declare type EnvParser<T> = (value: unknown) => T;
@@ -138,33 +176,11 @@ export declare const FRAME_SYNC_MARKER_HEIGHT = 1;
 
 export declare const FRAME_SYNC_MARKER_WIDTH = 32;
 
-declare class HEVCIsobmffMuxer implements MediaMuxer {
-    private readonly _width;
-    private readonly _height;
-    private readonly _format;
-    private _videoChunks;
-    private _audioChunks;
-    private _videoDesc?;
-    private _audioInit?;
-    constructor(width: number, height: number, format: IsobmffOutputFormat);
-    addVideoChunk(chunk: EncodedVideoChunk_2, meta?: EncodedVideoChunkMetadataJs): void;
-    addAudioChunk(chunk: EncodedAudioChunk_2, meta?: EncodedAudioChunkMetadataJs): void;
-    finalize(): Promise<Uint8Array>;
+declare class HEVCIsobmffMuxer extends MediaMuxer {
+    private readonly format;
+    constructor(opts: MuxerOptions, format: IsobmffOutputFormat);
+    finalize(): Promise<string>;
 }
-export { HEVCIsobmffMuxer }
-export { HEVCIsobmffMuxer as HEVCIsobmffMuxer_alias_1 }
-
-declare class HEVCMovMuxer extends HEVCIsobmffMuxer {
-    constructor(width: number, height: number);
-}
-export { HEVCMovMuxer }
-export { HEVCMovMuxer as HEVCMovMuxer_alias_1 }
-
-declare class HEVCMp4Muxer extends HEVCIsobmffMuxer {
-    constructor(width: number, height: number);
-}
-export { HEVCMp4Muxer }
-export { HEVCMp4Muxer as HEVCMp4Muxer_alias_1 }
 
 export declare function isEmpty(image: NativeImage): boolean;
 
@@ -219,14 +235,29 @@ export { LoggerLike as LoggerLike_alias_1 }
 
 export declare function makeCLI(name: string, callback: CLICallback): Promise<void>;
 
-declare interface MediaMuxer {
+declare abstract class MediaMuxer {
+    protected readonly opts: MuxerOptions;
+    protected videoChunks: BufferedVideo[];
+    protected audioChunks: BufferedAudio[];
+    protected videoDesc?: Uint8Array;
+    protected audioInit?: AudioInit;
+    constructor(opts: MuxerOptions);
     addVideoChunk(chunk: EncodedVideoChunk_2, meta?: EncodedVideoChunkMetadataJs): void;
     addAudioChunk(chunk: EncodedAudioChunk_2, meta?: EncodedAudioChunkMetadataJs): void;
-    finalize(): Promise<Uint8Array>;
+    abstract finalize(): Promise<string>;
 }
 export { MediaMuxer }
 export { MediaMuxer as MediaMuxer_alias_1 }
 
+declare interface MuxerOptions {
+    width: number;
+    height: number;
+    fps: number;
+    outPath: string;
+}
+export { MuxerOptions }
+export { MuxerOptions as MuxerOptions_alias_1 }
+
 export declare interface NetworkOptions {
     source: string;
     window: BrowserWindow;
@@ -237,6 +268,10 @@ declare function noerr<Fn extends (...args: any[]) => any, D>(fn: Fn, defaultVal
 export { noerr }
 export { noerr as noerr_alias_1 }
 
+declare const openFileStreamTarget: (path: string) => Promise<StreamTarget>;
+export { openFileStreamTarget }
+export { openFileStreamTarget as openFileStreamTarget_alias_1 }
+
 declare function pargs(): string[];
 export { pargs }
 export { pargs as pargs_alias_1 }
@@ -280,10 +315,6 @@ declare const pupDisableGPU: boolean;
 export { pupDisableGPU }
 export { pupDisableGPU as pupDisableGPU_alias_1 }
 
-declare const pupFFmpegPath: string;
-export { pupFFmpegPath }
-export { pupFFmpegPath as pupFFmpegPath_alias_1 }
-
 declare const pupLogLevel: number;
 export { pupLogLevel }
 export { pupLogLevel as pupLogLevel_alias_1 }
@@ -350,7 +381,7 @@ export { RetryOptions as RetryOptions_alias_1 }
 
 export declare function runElectronApp(size: Size, args: unknown[]): Promise<ProcessHandle>;
 
-export declare function setInterceptor({ source, window, useInnerProxy, }: NetworkOptions): void;
+export declare function setInterceptor({ source, window, useInnerProxy }: NetworkOptions): void;
 
 export declare function setupAudioCapture(pipeline: EncoderPipeline): Promise<AudioCapture>;
 
@@ -364,9 +395,13 @@ export declare function startSync(cdp: Debugger): Promise<any>;
 
 export declare function stopSync(cdp: Debugger): Promise<any>;
 
+declare const toPacket: ({ data, type, timestampS, durationS }: BufferedVideo | BufferedAudio) => EncodedPacket;
+export { toPacket }
+export { toPacket as toPacket_alias_1 }
+
 export declare function unsetInterceptor(window: BrowserWindow): void;
 
-declare function useRetry<Args extends any[], Ret>({ fn, maxAttempts, timeout, }: RetryOptions<Args, Ret>): (...args: Args) => Promise<Ret>;
+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 }
 
@@ -387,17 +422,8 @@ declare type VideoFormat = (typeof VIDEO_FORMATS)[number];
 export { VideoFormat }
 export { VideoFormat as VideoFormat_alias_1 }
 
-declare class Vp9WebMMuxer implements MediaMuxer {
-    private readonly _width;
-    private readonly _height;
-    private _videoChunks;
-    private _audioChunks;
-    private _videoDesc?;
-    private _audioInit?;
-    constructor(width: number, height: number);
-    addVideoChunk(chunk: EncodedVideoChunk_2, meta?: EncodedVideoChunkMetadataJs): void;
-    addAudioChunk(chunk: EncodedAudioChunk_2, meta?: EncodedAudioChunkMetadataJs): void;
-    finalize(): Promise<Uint8Array>;
+declare class Vp9WebMMuxer extends MediaMuxer {
+    finalize(): Promise<string>;
 }
 export { Vp9WebMMuxer }
 export { Vp9WebMMuxer as Vp9WebMMuxer_alias_1 }