pup-recorder 0.2.1 → 0.2.2

package/dist/chunk-CNRKD76V.js

@@ -0,0 +1,555 @@
+import 'source-map-support/register.js';
+import { createRequire } from 'module';
+import { dirname, join } from 'path';
+import { spawn } from 'child_process';
+import z from 'zod';
+import { readdir, readFile } from 'fs/promises';
+import electron from 'electron';
+import { platform } from 'os';
+import { graphics } from 'systeminformation';
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decoratorStart = (base) => [, , , __create(null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) fns[i].call(self) ;
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var it, done, ctx, access, k = flags & 7, s = false, p = false;
+  var j = 2 , key = __decoratorStrings[k + 5];
+  var extraInitializers = array[j] || (array[j] = []);
+  var desc = ((target = target.prototype), __getOwnPropDesc(target , name));
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: (x) => name in x };
+      access.get = (x) => x[name];
+    }
+    it = (0, decorators[i])(desc[key]  , ctx), done._ = 1;
+    __expectFn(it) && (desc[key] = it );
+  }
+  return desc && __defProp(target, name, desc), target;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+
+// src/base/env.ts
+function penv(name, parser, defaultValue) {
+  try {
+    return parser(process.env[name]);
+  } catch {
+    return defaultValue;
+  }
+}
+
+// src/base/parser.ts
+function parseNumber(x) {
+  if (typeof x === "number") {
+    return x;
+  }
+  const num = Number(x);
+  if (Number.isNaN(num)) {
+    throw new Error(`Value ${x} is not a valid number`);
+  }
+  return num;
+}
+function parseString(x) {
+  if (typeof x === "string") return x;
+  return String(x);
+}
+var require2 = createRequire(import.meta.url);
+var env = process.env;
+var pupLogLevel = penv("PUP_LOG_LEVEL", parseNumber, 2);
+var pupUseInnerProxy = env["PUP_USE_INNER_PROXY"] === "1";
+var pupDisableGPU = env["PUP_DISABLE_GPU"] === "1";
+var pupPkgRoot = dirname(require2.resolve("pup-recorder/package.json"));
+var pupApp = join(pupPkgRoot, "dist", "app.cjs");
+
+// src/base/logging.ts
+var DEBUG = "<pup@debug>";
+var INFO = "<pup@info>";
+var WARN = "<pup@warn>";
+var ERROR = "<pup@error>";
+var FATAL = "<pup@fatal>";
+function stackHook(target, _context) {
+  return function(...messages) {
+    const processed = messages.map((msg) => {
+      return msg instanceof Error ? msg.stack ?? String(msg) : msg;
+    });
+    return target.call(this, ...processed);
+  };
+}
+var _fatal_dec, _error_dec, _warn_dec, _info_dec, _debug_dec, _init;
+_debug_dec = [stackHook], _info_dec = [stackHook], _warn_dec = [stackHook], _error_dec = [stackHook], _fatal_dec = [stackHook];
+var Logger = class {
+  constructor(_level = pupLogLevel) {
+    this._level = _level;
+    __runInitializers(_init, 5, this);
+    __publicField(this, "_impl");
+    this.impl = console;
+  }
+  get level() {
+    return this._level;
+  }
+  set level(value) {
+    this._level = value;
+    this.impl = this._impl ?? console;
+  }
+  get impl() {
+    return this._impl;
+  }
+  set impl(value) {
+    const debug = value.debug ?? console.debug;
+    const info = value.info ?? console.info;
+    const warn = value.warn ?? console.warn;
+    const error = value.error ?? console.error;
+    const lv = this._level;
+    this._impl = {
+      debug: lv >= 3 ? debug : void 0,
+      info: lv >= 2 ? info : void 0,
+      warn: lv >= 1 ? warn : void 0,
+      error: lv >= 0 ? error : void 0
+    };
+  }
+  debug(...messages) {
+    this.impl?.debug?.(DEBUG, ...messages);
+  }
+  info(...messages) {
+    this.impl?.info?.(INFO, ...messages);
+  }
+  warn(...messages) {
+    this.impl?.warn?.(WARN, ...messages);
+  }
+  error(...messages) {
+    this.impl?.error?.(ERROR, ...messages);
+  }
+  fatal(...messages) {
+    this.impl?.error?.(FATAL, ...messages);
+    process.exit(1);
+  }
+  dispatch(message) {
+    if (message.startsWith(DEBUG)) {
+      this.debug(message.slice(DEBUG.length + 1));
+    } else if (message.startsWith(INFO)) {
+      this.info(message.slice(INFO.length + 1));
+    } else if (message.startsWith(WARN)) {
+      this.warn(message.slice(WARN.length + 1));
+    } else if (message.startsWith(ERROR)) {
+      this.error(message.slice(ERROR.length + 1));
+    } else {
+      this.info(message);
+    }
+  }
+  attach(proc, name) {
+    return new Promise((resolve, reject) => {
+      this.debug(`${name}.attach`);
+      let fatal = "";
+      const dispatch = (data) => {
+        const message = data.toString();
+        if (message.startsWith(FATAL)) {
+          fatal += message.slice(FATAL.length + 1);
+        } else {
+          this.dispatch(message);
+        }
+      };
+      proc.stderr?.on("data", dispatch);
+      proc.stdout?.on("data", dispatch);
+      proc.on("message", dispatch).on("error", (err) => {
+        fatal += err.message;
+        proc.kill();
+      }).once("close", (code, signal) => {
+        if (code || signal || fatal) {
+          fatal ||= `command failed: ${proc.spawnargs.join(" ")}`;
+          this.debug(`${name}.close`, { code, signal, fatal });
+          reject(new Error(fatal));
+        } else {
+          this.debug(`${name}.close`);
+          resolve();
+        }
+      }).on("unhandledRejection", (reason) => {
+        this.error(`${name}.unhandled`, reason);
+      }).on("uncaughtExceptionMonitor", (err) => {
+        this.error(`${name}.unhandled`, err);
+      });
+    });
+  }
+};
+_init = __decoratorStart();
+__decorateElement(_init, 1, "debug", _debug_dec, Logger);
+__decorateElement(_init, 1, "info", _info_dec, Logger);
+__decorateElement(_init, 1, "warn", _warn_dec, Logger);
+__decorateElement(_init, 1, "error", _error_dec, Logger);
+__decorateElement(_init, 1, "fatal", _fatal_dec, Logger);
+__decoratorMetadata(_init, Logger);
+var logger = new Logger();
+
+// src/base/noerr.ts
+function noerr(fn, defaultValue) {
+  return (...args) => {
+    try {
+      const ret = fn(...args);
+      if (ret instanceof Promise) {
+        return ret.catch(() => defaultValue);
+      }
+      return ret;
+    } catch {
+      return defaultValue;
+    }
+  };
+}
+var PUP_ARGS_KEY = "--pup-priv-args";
+function pargs() {
+  const argv = process.argv;
+  let priv = argv.find((arg) => arg.startsWith(PUP_ARGS_KEY));
+  if (!priv) {
+    logger.debug("procargv", argv);
+    return process.argv;
+  }
+  const args = ["exec", ...argv.slice(-1)];
+  priv = Buffer.from(priv.split("=")[1], "base64").toString();
+  args.push(...JSON.parse(priv));
+  logger.debug("pupargs", args);
+  return args;
+}
+function exec(cmd, options) {
+  const parts = cmd.split(" ").filter((s) => s.length);
+  const [command, ...args] = parts;
+  if (!command) throw new Error("empty command");
+  const proc = spawn(command, args, {
+    stdio: "inherit",
+    ...options
+  });
+  return { process: proc, wait: logger.attach(proc, command) };
+}
+var DEFAULT_WIDTH = 1920;
+var DEFAULT_HEIGHT = 1080;
+var DEFAULT_FPS = 30;
+var DEFAULT_DURATION = 5;
+var DEFAULT_OUT_DIR = "out";
+var VIDEO_FORMATS = ["mp4", "webm"];
+function isVideoFormat(s) {
+  return VIDEO_FORMATS.includes(s);
+}
+var RenderSchema = z.object({
+  duration: z.number().optional().default(DEFAULT_DURATION).describe("Duration in seconds"),
+  width: z.number().optional().default(DEFAULT_WIDTH).describe("Video width"),
+  height: z.number().optional().default(DEFAULT_HEIGHT).describe("Video height"),
+  fps: z.number().optional().default(DEFAULT_FPS).describe("Frames per second"),
+  formats: z.array(z.enum(VIDEO_FORMATS)).optional().default(["mp4"]).describe(`Output video formats, allow ${VIDEO_FORMATS.join(", ")}`),
+  withAudio: z.boolean().optional().default(false).describe("Capture and encode audio"),
+  outDir: z.string().optional().default(DEFAULT_OUT_DIR).describe("Output directory"),
+  useInnerProxy: z.boolean().optional().default(false).describe("Use bilibili inner proxy for resource access"),
+  deterministic: z.boolean().optional().default(false).describe("Render by frame rather than recording")
+});
+
+// src/base/abort.ts
+var AbortLink = class _AbortLink {
+  constructor(query, interval = 1e3) {
+    this.query = query;
+    this.interval = interval;
+    if (query) {
+      this.tick();
+    }
+  }
+  _callback;
+  _aborted;
+  _stopped = false;
+  static start(query, interval) {
+    return new _AbortLink(query, interval);
+  }
+  get aborted() {
+    return !this._stopped && this._aborted;
+  }
+  get stopped() {
+    return this._stopped;
+  }
+  async onAbort(callback) {
+    if (this._aborted) {
+      await callback();
+    } else {
+      this._callback = callback;
+    }
+  }
+  wait(...handles) {
+    const abort = new Promise((_, reject) => {
+      this.onAbort(async () => {
+        handles.forEach((h) => h.process.kill());
+        reject(new Error("aborted"));
+      });
+    });
+    return Promise.race([
+      abort,
+      Promise.all(handles.map((h) => h.wait))
+      //
+    ]);
+  }
+  stop() {
+    this._stopped = true;
+  }
+  tick() {
+    setTimeout(async () => {
+      if (this._stopped) {
+        return;
+      }
+      this._aborted = await this.query?.();
+      if (this._stopped) {
+        return;
+      }
+      if (this._aborted) {
+        await this._callback?.();
+      } else {
+        this.tick();
+      }
+    }, this.interval);
+  }
+};
+
+// src/base/limiter.ts
+var ConcurrencyLimiter = class {
+  constructor(maxConcurrency) {
+    this.maxConcurrency = maxConcurrency;
+  }
+  _active = 0;
+  _queue = [];
+  _ended = false;
+  get active() {
+    return this._active;
+  }
+  get pending() {
+    return this._queue.length;
+  }
+  get stats() {
+    return `active: ${this.active}, pending: ${this.pending}`;
+  }
+  async schedule(fn) {
+    if (this._ended) {
+      throw new Error("ended");
+    }
+    return new Promise((resolve, reject) => {
+      const run = () => {
+        this._active++;
+        fn().then((v) => {
+          this._active--;
+          resolve(v);
+          this.next();
+        }).catch((e) => {
+          this._active--;
+          reject(e);
+          this.next();
+        });
+      };
+      this._queue.push(run);
+      this.next();
+    });
+  }
+  async end() {
+    if (this._ended) {
+      return;
+    }
+    this._ended = true;
+    while (this._active > 0 || this.pending > 0) {
+      await new Promise((r) => setTimeout(r, 50));
+    }
+  }
+  next() {
+    if (this._active < this.maxConcurrency) {
+      this._queue.shift()?.();
+    }
+  }
+};
+var TAG = "[HWAccel]";
+var softwareVendors = ["microsoft", "vmware", "virtualbox", "llvmpipe", "softpipe", "swiftshader"];
+function isSoftwareRenderer(vendor) {
+  const lower = vendor.toLowerCase();
+  return softwareVendors.some((v) => lower.includes(v));
+}
+async function detectGPUDriver() {
+  const { controllers } = await graphics();
+  if (platform() === "linux") {
+    try {
+      const files = await readdir("/dev/dri");
+      return files.some((f) => f.startsWith("renderD"));
+    } catch {
+      return false;
+    }
+  }
+  logger.debug(TAG, "GPU controllers:", controllers);
+  return controllers.some((c) => c.vendor.length > 0 && !isSoftwareRenderer(c.vendor));
+}
+var canIUseGPU = detectGPUDriver().then((result) => {
+  logger.debug(TAG, "gpu:", result);
+  return result;
+});
+
+// src/renderer/electron.ts
+async function electronOpts() {
+  const opts = [
+    // 容器沙箱
+    "no-sandbox",
+    "disable-dev-shm-usage",
+    // 跨域/安全
+    "disable-web-security",
+    "disable-site-isolation-trials",
+    "ignore-certificate-errors",
+    // 录制行为
+    "disable-blink-features=AutomationControlled",
+    "mute-audio",
+    "autoplay-policy=no-user-gesture-required",
+    "disable-extensions",
+    // 渲染
+    "headless=new",
+    "force-device-scale-factor=1",
+    "force-color-profile=srgb",
+    "ignore-gpu-blocklist",
+    "use-gl=angle",
+    // 资源控制
+    "num-raster-threads=2",
+    "disable-background-networking",
+    "js-flags=--max-old-space-size=4096"
+  ];
+  if (pupLogLevel < 3) {
+    opts.push("log-level=3");
+  }
+  const enableGpu = await canIUseGPU && !pupDisableGPU;
+  if (!enableGpu) {
+    opts.push("use-angle=swiftshader", "enable-unsafe-swiftshader");
+    return opts;
+  }
+  opts.push("disable-gpu-sandbox", "enable-unsafe-webgpu");
+  const plat = platform();
+  if (plat === "darwin") {
+    opts.push("use-angle=metal");
+  } else if (plat === "win32") {
+    opts.push("use-angle=d3d11");
+  } else {
+    opts.push("use-angle=vulkan", "enable-features=Vulkan", "disable-vulkan-surface");
+  }
+  return opts;
+}
+var TAG2 = "[Electron]";
+async function runElectronApp(size, args) {
+  const cmdParts = [];
+  const plat = platform();
+  if (plat === "linux") {
+    cmdParts.push(`xvfb-run`, `--auto-servernum`, `--server-args="-screen 0 ${size.width}x${size.height}x24"`);
+  }
+  const opts = await electronOpts();
+  const electronArgs = opts.map((a) => `--${a}`);
+  const base64Args = Buffer.from(JSON.stringify(args)).toString("base64");
+  electronArgs.push(`${PUP_ARGS_KEY}=${base64Args}`);
+  cmdParts.push(electron, ...electronArgs, pupApp);
+  const cmd = cmdParts.join(" ");
+  logger.debug(TAG2, cmd);
+  return exec(cmd, {
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: plat === "linux",
+    env: { ...process.env, RUST_BACKTRACE: "full" }
+  });
+}
+
+// src/pup.ts
+var TAG3 = "[pup]";
+var PROGRESS_TAG = " progress: ";
+async function runPupApp(source, options) {
+  logger.debug(TAG3, `runPupApp`, source, options);
+  const args = [source];
+  if (options.width) args.push("--width", `${options.width}`);
+  if (options.height) args.push("--height", `${options.height}`);
+  if (options.fps) args.push("--fps", `${options.fps}`);
+  if (options.duration) args.push("--duration", `${options.duration}`);
+  if (options.outDir) args.push("--out-dir", options.outDir);
+  if (options.formats?.length) args.push("--formats", options.formats.join(","));
+  if (options.withAudio) args.push("--with-audio");
+  if (options.useInnerProxy) args.push("--use-inner-proxy");
+  if (options.deterministic) args.push("--deterministic");
+  const w = options.width ?? DEFAULT_WIDTH;
+  const h = options.height ?? DEFAULT_HEIGHT;
+  const handle = await runElectronApp({ width: w, height: h }, args);
+  const counter = new ConcurrencyLimiter(1);
+  handle.process.stdout?.on("data", (data) => {
+    let message = data.toString().trim();
+    let start = message.indexOf(PROGRESS_TAG);
+    if (start < 0) {
+      return;
+    }
+    message = message.slice(start + PROGRESS_TAG.length);
+    const end = message.indexOf("%");
+    if (end < 0) {
+      return;
+    }
+    const progressStr = message.slice(0, end);
+    const progress = parseNumber(progressStr);
+    counter.schedule(async () => {
+      await options.onProgress?.(progress);
+    });
+  });
+  return { handle, counter };
+}
+async function pup(source, options) {
+  logger.debug(TAG3, `pup`, source, options);
+  const link = AbortLink.start(options.cancelQuery);
+  const outDir = options.outDir ?? "out";
+  const t0 = performance.now();
+  const { handle, counter } = await runPupApp(source, { ...options, outDir });
+  await link.wait(handle);
+  await counter.end();
+  link.stop();
+  logger.info(TAG3, `done in ${Math.round(performance.now() - t0)}ms`);
+  const sumPath = join(outDir, "summary.json");
+  return JSON.parse(await readFile(sumPath, "utf-8"));
+}
+
+export { AbortLink, ConcurrencyLimiter, DEFAULT_DURATION, DEFAULT_FPS, DEFAULT_HEIGHT, DEFAULT_OUT_DIR, DEFAULT_WIDTH, Logger, PUP_ARGS_KEY, RenderSchema, VIDEO_FORMATS, __callDispose, __using, exec, isVideoFormat, logger, noerr, pargs, parseNumber, parseString, penv, pup, pupApp, pupDisableGPU, pupLogLevel, pupPkgRoot, pupUseInnerProxy };
+//# sourceMappingURL=chunk-CNRKD76V.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/base/env.ts","../src/base/parser.ts","../src/base/constants.ts","../src/base/logging.ts","../src/base/noerr.ts","../src/base/process.ts","../src/renderer/schema.ts","../src/base/abort.ts","../src/base/limiter.ts","../src/base/hwaccel.ts","../src/renderer/electron.ts","../src/pup.ts"],"names":["require","platform","TAG","join"],"mappings":"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","file":"chunk-CNRKD76V.js","sourcesContent":["// Created by Autokaka (qq1909698494@gmail.com) on 2026/02/25.\n\nexport type EnvParser<T> = (value: unknown) => T;\n\nexport function penv<T>(name: string, parser: EnvParser<T>, defaultValue: T): T;\nexport function penv<T>(name: string, parser: EnvParser<T>, defaultValue?: T): T | undefined;\nexport function penv<T>(name: string, parser: EnvParser<T>, defaultValue?: T): T | undefined {\n  try {\n    return parser(process.env[name]);\n  } catch {\n    return defaultValue;\n  }\n}\n","// Created by Autokaka (qq1909698494@gmail.com) on 2026/01/30.\n\nexport function parseNumber(x: unknown): number {\n  if (typeof x === \"number\") {\n    return x;\n  }\n  const num = Number(x);\n  if (Number.isNaN(num)) {\n    throw new Error(`Value ${x} is not a valid number`);\n  }\n  return num;\n}\n\nexport function parseString(x: unknown): string {\n  if (typeof x === \"string\") return x;\n  return String(x);\n}\n","// Created by Autokaka (qq1909698494@gmail.com) on 2026/02/09.\n\nimport { createRequire } from \"module\";\nimport { dirname, join } from \"path\";\nimport { penv } from \"./env\";\nimport { parseNumber } from \"./parser\";\n\nconst require = createRequire(import.meta.url);\nconst env = process.env;\n\nexport const pupLogLevel = penv(\"PUP_LOG_LEVEL\", parseNumber, 2);\nexport const pupUseInnerProxy = env[\"PUP_USE_INNER_PROXY\"] === \"1\";\nexport const pupDisableGPU = env[\"PUP_DISABLE_GPU\"] === \"1\";\n\nexport const pupPkgRoot = dirname(require.resolve(\"pup-recorder/package.json\"));\nexport const pupApp = join(pupPkgRoot, \"dist\", \"app.cjs\");\n","// Created by Autokaka (qq1909698494@gmail.com) on 2026/02/06.\n\nimport { ChildProcess, type Serializable } from \"child_process\";\nimport { pupLogLevel } from \"./constants\";\n\nexport interface LoggerLike {\n  debug?(this: void, ...messages: unknown[]): void;\n\n  info?(this: void, ...messages: unknown[]): void;\n\n  warn?(this: void, ...messages: unknown[]): void;\n\n  error?(this: void, ...messages: unknown[]): void;\n}\n\nconst DEBUG = \"<pup@debug>\";\nconst INFO = \"<pup@info>\";\nconst WARN = \"<pup@warn>\";\nconst ERROR = \"<pup@error>\";\nconst FATAL = \"<pup@fatal>\";\n\nfunction stackHook(target: Function, _context: ClassMethodDecoratorContext) {\n  return function (this: Logger, ...messages: unknown[]) {\n    const processed = messages.map((msg) => {\n      return msg instanceof Error ? (msg.stack ?? String(msg)) : msg;\n    });\n    return target.call(this, ...processed);\n  };\n}\n\nexport class Logger implements LoggerLike {\n  private _impl?: LoggerLike;\n\n  get level(): number {\n    return this._level;\n  }\n\n  set level(value: number) {\n    this._level = value;\n    this.impl = this._impl ?? console;\n  }\n\n  get impl(): LoggerLike | undefined {\n    return this._impl;\n  }\n\n  set impl(value: LoggerLike) {\n    const debug = value.debug ?? console.debug;\n    const info = value.info ?? console.info;\n    const warn = value.warn ?? console.warn;\n    const error = value.error ?? console.error;\n    const lv = this._level;\n    this._impl = {\n      debug: lv >= 3 ? debug : undefined,\n      info: lv >= 2 ? info : undefined,\n      warn: lv >= 1 ? warn : undefined,\n      error: lv >= 0 ? error : undefined,\n    };\n  }\n\n  constructor(private _level: number = pupLogLevel) {\n    this.impl = console;\n  }\n\n  @stackHook\n  debug(...messages: unknown[]): void {\n    this.impl?.debug?.(DEBUG, ...messages);\n  }\n\n  @stackHook\n  info(...messages: unknown[]): void {\n    this.impl?.info?.(INFO, ...messages);\n  }\n\n  @stackHook\n  warn(...messages: unknown[]): void {\n    this.impl?.warn?.(WARN, ...messages);\n  }\n\n  @stackHook\n  error(...messages: unknown[]): void {\n    this.impl?.error?.(ERROR, ...messages);\n  }\n\n  @stackHook\n  fatal(...messages: unknown[]): void {\n    this.impl?.error?.(FATAL, ...messages);\n    process.exit(1);\n  }\n\n  private dispatch(message: string) {\n    if (message.startsWith(DEBUG)) {\n      this.debug(message.slice(DEBUG.length + 1));\n    } else if (message.startsWith(INFO)) {\n      this.info(message.slice(INFO.length + 1));\n    } else if (message.startsWith(WARN)) {\n      this.warn(message.slice(WARN.length + 1));\n    } else if (message.startsWith(ERROR)) {\n      this.error(message.slice(ERROR.length + 1));\n    } else {\n      this.info(message);\n    }\n  }\n\n  attach(proc: ChildProcess, name: string) {\n    return new Promise<void>((resolve, reject) => {\n      this.debug(`${name}.attach`);\n      let fatal: string = \"\";\n      const dispatch = (data: Buffer | Serializable) => {\n        const message = data.toString();\n        if (message.startsWith(FATAL)) {\n          fatal += message.slice(FATAL.length + 1);\n        } else {\n          this.dispatch(message);\n        }\n      };\n      proc.stderr?.on(\"data\", dispatch);\n      proc.stdout?.on(\"data\", dispatch);\n      proc\n        .on(\"message\", dispatch)\n        .on(\"error\", (err) => {\n          fatal += err.message;\n          proc.kill();\n        })\n        .once(\"close\", (code, signal) => {\n          if (code || signal || fatal) {\n            fatal ||= `command failed: ${proc.spawnargs.join(\" \")}`;\n            this.debug(`${name}.close`, { code, signal, fatal });\n            reject(new Error(fatal));\n          } else {\n            this.debug(`${name}.close`);\n            resolve();\n          }\n        })\n        .on(\"unhandledRejection\", (reason) => {\n          this.error(`${name}.unhandled`, reason);\n        })\n        .on(\"uncaughtExceptionMonitor\", (err) => {\n          this.error(`${name}.unhandled`, err);\n        });\n    });\n  }\n}\n\nconst logger = new Logger();\n\nexport { logger };\n","// Created by Autokaka (qq1909698494@gmail.com) on 2026/02/24.\n\nexport function noerr<Fn extends (...args: any[]) => any, D>(\n  fn: Fn,\n  defaultValue: D,\n): (...args: Parameters<Fn>) => ReturnType<Fn> | D {\n  return (...args) => {\n    try {\n      const ret = fn(...args);\n      if (ret instanceof Promise) {\n        return ret.catch(() => defaultValue);\n      }\n      return ret;\n    } catch {\n      return defaultValue;\n    }\n  };\n}\n","// Created by Autokaka (qq1909698494@gmail.com) on 2026/01/30.\n\nimport { spawn, type ChildProcess, type SpawnOptions } from \"child_process\";\nimport { logger } from \"./logging\";\n\nexport const PUP_ARGS_KEY = \"--pup-priv-args\";\n\nexport function pargs() {\n  const argv = process.argv;\n  let priv = argv.find((arg) => arg.startsWith(PUP_ARGS_KEY));\n  if (!priv) {\n    logger.debug(\"procargv\", argv);\n    return process.argv;\n  }\n  const args = [\"exec\", ...argv.slice(-1)];\n  priv = Buffer.from(priv.split(\"=\")[1]!, \"base64\").toString();\n  args.push(...JSON.parse(priv));\n  logger.debug(\"pupargs\", args);\n  return args;\n}\n\nexport interface ProcessHandle {\n  process: ChildProcess;\n  wait: Promise<void>;\n}\n\nexport function exec(cmd: string, options?: SpawnOptions): ProcessHandle {\n  const parts = cmd.split(\" \").filter((s) => s.length);\n  const [command, ...args] = parts;\n  if (!command) throw new Error(\"empty command\");\n  const proc = spawn(command, args, {\n    stdio: \"inherit\",\n    ...options,\n  });\n  return { process: proc, wait: logger.attach(proc, command) };\n}\n","// Created by Autokaka (qq1909698494@gmail.com) on 2026/02/06.\n\nimport z from \"zod\";\n\nexport interface VideoFiles {\n  cover: string;\n  mp4?: string;\n  webm?: string;\n}\n\nexport const DEFAULT_WIDTH = 1920;\nexport const DEFAULT_HEIGHT = 1080;\nexport const DEFAULT_FPS = 30;\nexport const DEFAULT_DURATION = 5;\nexport const DEFAULT_OUT_DIR = \"out\";\nexport const VIDEO_FORMATS = [\"mp4\", \"webm\"] as const;\n\nexport type VideoFormat = (typeof VIDEO_FORMATS)[number];\n\nexport function isVideoFormat(s: string): s is VideoFormat {\n  return VIDEO_FORMATS.includes(s as VideoFormat);\n}\n\nexport const RenderSchema = z.object({\n  duration: z.number().optional().default(DEFAULT_DURATION).describe(\"Duration in seconds\"),\n  width: z.number().optional().default(DEFAULT_WIDTH).describe(\"Video width\"),\n  height: z.number().optional().default(DEFAULT_HEIGHT).describe(\"Video height\"),\n  fps: z.number().optional().default(DEFAULT_FPS).describe(\"Frames per second\"),\n  formats: z\n    .array(z.enum(VIDEO_FORMATS))\n    .optional()\n    .default([\"mp4\"])\n    .describe(`Output video formats, allow ${VIDEO_FORMATS.join(\", \")}`),\n  withAudio: z.boolean().optional().default(false).describe(\"Capture and encode audio\"),\n  outDir: z.string().optional().default(DEFAULT_OUT_DIR).describe(\"Output directory\"),\n  useInnerProxy: z.boolean().optional().default(false).describe(\"Use bilibili inner proxy for resource access\"),\n  deterministic: z.boolean().optional().default(false).describe(\"Render by frame rather than recording\"),\n});\n\nexport type RenderOptions = z.infer<typeof RenderSchema>;\n\nexport interface RenderResult {\n  options: RenderOptions;\n  written: number;\n  files: VideoFiles;\n}\n","// Created by Autokaka (qq1909698494@gmail.com) on 2026/02/11.\n\nimport type { ProcessHandle } from \"./process\";\n\nexport type AsyncTask = () => Promise<void> | void;\nexport type AbortQuery = () => Promise<boolean> | boolean;\n\nexport class AbortLink {\n  private _callback?: AsyncTask;\n  private _aborted?: boolean;\n  private _stopped = false;\n\n  private constructor(\n    readonly query?: AbortQuery,\n    readonly interval: number = 1000,\n  ) {\n    if (query) {\n      this.tick();\n    }\n  }\n\n  static start(query?: AbortQuery, interval?: number) {\n    return new AbortLink(query, interval);\n  }\n\n  get aborted() {\n    return !this._stopped && this._aborted;\n  }\n\n  get stopped() {\n    return this._stopped;\n  }\n\n  async onAbort(callback: AsyncTask) {\n    if (this._aborted) {\n      await callback();\n    } else {\n      this._callback = callback;\n    }\n  }\n\n  wait(...handles: ProcessHandle[]) {\n    const abort = new Promise((_, reject) => {\n      this.onAbort(async () => {\n        handles.forEach((h) => h.process.kill());\n        reject(new Error(\"aborted\"));\n      });\n    });\n    return Promise.race([\n      abort,\n      Promise.all(handles.map((h) => h.wait)), //\n    ]);\n  }\n\n  stop() {\n    this._stopped = true;\n  }\n\n  private tick() {\n    setTimeout(async () => {\n      if (this._stopped) {\n        return;\n      }\n      this._aborted = await this.query?.();\n      if (this._stopped) {\n        return;\n      }\n      if (this._aborted) {\n        await this._callback?.();\n      } else {\n        this.tick();\n      }\n    }, this.interval);\n  }\n}\n","// Created by Autokaka (qq1909698494@gmail.com) on 2026/01/30.\n\nexport class ConcurrencyLimiter {\n  private _active = 0;\n  private _queue: VoidFunction[] = [];\n  private _ended = false;\n\n  constructor(readonly maxConcurrency: number) {}\n\n  get active(): number {\n    return this._active;\n  }\n\n  get pending(): number {\n    return this._queue.length;\n  }\n\n  get stats(): string {\n    return `active: ${this.active}, pending: ${this.pending}`;\n  }\n\n  async schedule<T>(fn: () => Promise<T>): Promise<T> {\n    if (this._ended) {\n      throw new Error(\"ended\");\n    }\n    return new Promise<T>((resolve, reject) => {\n      const run = () => {\n        this._active++;\n        fn()\n          .then((v) => {\n            this._active--;\n            resolve(v);\n            this.next();\n          })\n          .catch((e) => {\n            this._active--;\n            reject(e);\n            this.next();\n          });\n      };\n      this._queue.push(run);\n      this.next();\n    });\n  }\n\n  async end() {\n    if (this._ended) {\n      return;\n    }\n    this._ended = true;\n    while (this._active > 0 || this.pending > 0) {\n      await new Promise((r) => setTimeout(r, 50));\n    }\n  }\n\n  private next() {\n    if (this._active < this.maxConcurrency) {\n      this._queue.shift()?.();\n    }\n  }\n}\n","// Created by Autokaka (qq1909698494@gmail.com) on 2026/02/27.\n\nimport { readdir } from \"fs/promises\";\nimport { platform } from \"os\";\nimport { graphics } from \"systeminformation\";\nimport { logger } from \"./logging\";\n\nconst TAG = \"[HWAccel]\";\n\nconst softwareVendors = [\"microsoft\", \"vmware\", \"virtualbox\", \"llvmpipe\", \"softpipe\", \"swiftshader\"];\n\nfunction isSoftwareRenderer(vendor: string) {\n  const lower = vendor.toLowerCase();\n  return softwareVendors.some((v) => lower.includes(v));\n}\n\nasync function detectGPUDriver() {\n  const { controllers } = await graphics();\n  if (platform() === \"linux\") {\n    try {\n      const files = await readdir(\"/dev/dri\");\n      return files.some((f) => f.startsWith(\"renderD\"));\n    } catch {\n      return false;\n    }\n  }\n  logger.debug(TAG, \"GPU controllers:\", controllers);\n  return controllers.some((c) => c.vendor.length > 0 && !isSoftwareRenderer(c.vendor));\n}\n\nexport const canIUseGPU = detectGPUDriver().then((result) => {\n  logger.debug(TAG, \"gpu:\", result);\n  return result;\n});\n","// Created by Autokaka (qq1909698494@gmail.com) on 2026/02/25.\n\nimport electron, { type Size } from \"electron\";\nimport { platform } from \"os\";\nimport { pupApp, pupDisableGPU, pupLogLevel } from \"../base/constants\";\nimport { canIUseGPU } from \"../base/hwaccel\";\nimport { logger } from \"../base/logging\";\nimport { exec, PUP_ARGS_KEY } from \"../base/process\";\n\nexport async function electronOpts() {\n  const opts = [\n    // 容器沙箱\n    \"no-sandbox\",\n    \"disable-dev-shm-usage\",\n    // 跨域/安全\n    \"disable-web-security\",\n    \"disable-site-isolation-trials\",\n    \"ignore-certificate-errors\",\n    // 录制行为\n    \"disable-blink-features=AutomationControlled\",\n    \"mute-audio\",\n    \"autoplay-policy=no-user-gesture-required\",\n    \"disable-extensions\",\n    // 渲染\n    \"headless=new\",\n    \"force-device-scale-factor=1\",\n    \"force-color-profile=srgb\",\n    \"ignore-gpu-blocklist\",\n    \"use-gl=angle\",\n    // 资源控制\n    \"num-raster-threads=2\",\n    \"disable-background-networking\",\n    \"js-flags=--max-old-space-size=4096\",\n  ];\n  if (pupLogLevel < 3) {\n    opts.push(\"log-level=3\");\n  }\n\n  const enableGpu = (await canIUseGPU) && !pupDisableGPU;\n  if (!enableGpu) {\n    opts.push(\"use-angle=swiftshader\", \"enable-unsafe-swiftshader\");\n    return opts;\n  }\n\n  opts.push(\"disable-gpu-sandbox\", \"enable-unsafe-webgpu\");\n  const plat = platform();\n  if (plat === \"darwin\") {\n    opts.push(\"use-angle=metal\");\n  } else if (plat === \"win32\") {\n    opts.push(\"use-angle=d3d11\");\n  } else {\n    opts.push(\"use-angle=vulkan\", \"enable-features=Vulkan\", \"disable-vulkan-surface\");\n  }\n  return opts;\n}\n\nconst TAG = \"[Electron]\";\n\nexport async function runElectronApp(size: Size, args: unknown[]) {\n  const cmdParts: unknown[] = [];\n  const plat = platform();\n  if (plat === \"linux\") {\n    cmdParts.push(`xvfb-run`, `--auto-servernum`, `--server-args=\"-screen 0 ${size.width}x${size.height}x24\"`);\n  }\n  const opts = await electronOpts();\n  const electronArgs = opts.map((a) => `--${a}`);\n  const base64Args = Buffer.from(JSON.stringify(args)).toString(\"base64\");\n  electronArgs.push(`${PUP_ARGS_KEY}=${base64Args}`);\n  cmdParts.push(electron, ...electronArgs, pupApp);\n  const cmd = cmdParts.join(\" \");\n  logger.debug(TAG, cmd);\n  return exec(cmd, {\n    stdio: [\"ignore\", \"pipe\", \"pipe\"],\n    shell: plat === \"linux\",\n    env: { ...process.env, RUST_BACKTRACE: \"full\" },\n  });\n}\n","// Created by Autokaka (qq1909698494@gmail.com) on 2026/02/09.\n\nimport { readFile } from \"fs/promises\";\nimport { join } from \"path\";\nimport { AbortLink, type AbortQuery } from \"./base/abort\";\nimport { ConcurrencyLimiter } from \"./base/limiter\";\nimport { logger } from \"./base/logging\";\nimport { parseNumber } from \"./base/parser\";\nimport { runElectronApp } from \"./renderer/electron\";\nimport { DEFAULT_HEIGHT, DEFAULT_WIDTH, type RenderOptions, type RenderResult } from \"./renderer/schema\";\n\nconst TAG = \"[pup]\";\nconst PROGRESS_TAG = \" progress: \";\n\nexport type PupProgressCallback = (progress: number) => Promise<void> | void;\n\nexport interface PupOptions extends Partial<RenderOptions> {\n  cancelQuery?: AbortQuery;\n  onProgress?: PupProgressCallback;\n}\n\nexport interface PupResult extends RenderResult {}\n\nasync function runPupApp(source: string, options: PupOptions) {\n  logger.debug(TAG, `runPupApp`, source, options);\n\n  const args: string[] = [source];\n  if (options.width) args.push(\"--width\", `${options.width}`);\n  if (options.height) args.push(\"--height\", `${options.height}`);\n  if (options.fps) args.push(\"--fps\", `${options.fps}`);\n  if (options.duration) args.push(\"--duration\", `${options.duration}`);\n  if (options.outDir) args.push(\"--out-dir\", options.outDir);\n  if (options.formats?.length) args.push(\"--formats\", options.formats.join(\",\"));\n  if (options.withAudio) args.push(\"--with-audio\");\n  if (options.useInnerProxy) args.push(\"--use-inner-proxy\");\n  if (options.deterministic) args.push(\"--deterministic\");\n\n  const w = options.width ?? DEFAULT_WIDTH;\n  const h = options.height ?? DEFAULT_HEIGHT;\n  const handle = await runElectronApp({ width: w, height: h }, args);\n  const counter = new ConcurrencyLimiter(1);\n  handle.process.stdout?.on(\"data\", (data: Buffer) => {\n    let message = data.toString().trim();\n    let start = message.indexOf(PROGRESS_TAG);\n    if (start < 0) {\n      return;\n    }\n    message = message.slice(start + PROGRESS_TAG.length);\n    const end = message.indexOf(\"%\");\n    if (end < 0) {\n      return;\n    }\n    const progressStr = message.slice(0, end);\n    const progress = parseNumber(progressStr);\n    counter.schedule(async () => {\n      await options.onProgress?.(progress);\n    });\n  });\n  return { handle, counter };\n}\n\nexport async function pup(source: string, options: PupOptions): Promise<PupResult> {\n  logger.debug(TAG, `pup`, source, options);\n\n  const link = AbortLink.start(options.cancelQuery);\n  const outDir = options.outDir ?? \"out\";\n\n  const t0 = performance.now();\n  const { handle, counter } = await runPupApp(source, { ...options, outDir });\n\n  await link.wait(handle);\n  await counter.end();\n  link.stop();\n  logger.info(TAG, `done in ${Math.round(performance.now() - t0)}ms`);\n\n  const sumPath = join(outDir, \"summary.json\");\n  return JSON.parse(await readFile(sumPath, \"utf-8\")) as RenderResult;\n}\n"]}

package/dist/cli.js

@@ -1,5 +1,5 @@
 import 'source-map-support/register.js';
-import { RenderSchema, DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FPS, DEFAULT_DURATION, DEFAULT_OUT_DIR, pupUseInnerProxy, parseString, isVideoFormat, noerr, parseNumber, logger, pargs, pup } from './chunk-A5IYURQQ.js';
+import { RenderSchema, DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FPS, DEFAULT_DURATION, DEFAULT_OUT_DIR, pupUseInnerProxy, parseString, isVideoFormat, noerr, parseNumber, logger, pargs, pup } from './chunk-CNRKD76V.js';
 import { program } from 'commander';
 
 async function makeCLI(name, callback) {

package/dist/index.d.ts

@@ -4,6 +4,8 @@ export { AbortLink } from './_tsup-dts-rollup.js';
 export { pupLogLevel } from './_tsup-dts-rollup.js';
 export { pupUseInnerProxy } from './_tsup-dts-rollup.js';
 export { pupDisableGPU } from './_tsup-dts-rollup.js';
+export { pupPkgRoot } from './_tsup-dts-rollup.js';
+export { pupApp } from './_tsup-dts-rollup.js';
 export { penv } from './_tsup-dts-rollup.js';
 export { EnvParser } from './_tsup-dts-rollup.js';
 export { Lazy } from './_tsup-dts-rollup.js';