@remotion/renderer 3.0.23 → 3.0.26

package/dist/faststart/options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/faststart/qt-faststart.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { QtAtom } from './atom';
+import { FaststartOptions } from './options';
+export declare function supportStreaming(infile: Buffer): boolean;
+/**
+ * Enables "faststart" for QuickTime files so that they can be streamed.
+ *
+ * @param infile QT/mp4 to faststart
+ * @returns Faststarted QT/mp4
+ */
+export default function faststart(infile: Buffer, options?: FaststartOptions): Buffer;
+/**
+ * Sorts an array of QT atoms so that the first two atoms are `ftyp`, then `moov`.
+ * Additionally updates all chunk offsets (`stco`/`co64` atoms) in `moov`.
+ *
+ * @param atoms QT atoms to sort
+ */
+export declare function sortFaststartAtoms(atoms: QtAtom[], options: FaststartOptions): QtAtom[];

package/dist/faststart/qt-faststart.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortFaststartAtoms = exports.supportStreaming = void 0;
+const atom_1 = require("./atom");
+const update_chunk_offsets_1 = __importDefault(require("./update-chunk-offsets"));
+function supportStreaming(infile) {
+    const file = Buffer.from(infile);
+    const atoms = (0, atom_1.parseAtoms)(file, 0, true);
+    const mdatIndex = atoms.findIndex((atom) => atom.kind === 'mdat');
+    const moovIndex = atoms.findIndex((atom) => atom.kind === 'moov');
+    if (moovIndex === -1 || mdatIndex === -1) {
+        return false;
+    }
+    return moovIndex < mdatIndex;
+}
+exports.supportStreaming = supportStreaming;
+/**
+ * Enables "faststart" for QuickTime files so that they can be streamed.
+ *
+ * @param infile QT/mp4 to faststart
+ * @returns Faststarted QT/mp4
+ */
+function faststart(infile, options = {}) {
+    const file = Buffer.from(infile);
+    const atoms = (0, atom_1.parseAtoms)(file);
+    console.log({ atoms });
+    const mdatIndex = atoms.findIndex((atom) => atom.kind === 'mdat');
+    if (mdatIndex === -1) {
+        throw new Error(`No mdat atom found!`);
+    }
+    const moovIndex = atoms.findIndex((atom) => atom.kind === 'moov');
+    if (moovIndex === -1) {
+        throw new Error(`No moov atom found!`);
+    }
+    const faststarted = sortFaststartAtoms(atoms, options);
+    return (0, atom_1.recurseFlattenAtoms)(faststarted);
+}
+exports.default = faststart;
+/**
+ * Sorts an array of QT atoms so that the first two atoms are `ftyp`, then `moov`.
+ * Additionally updates all chunk offsets (`stco`/`co64` atoms) in `moov`.
+ *
+ * @param atoms QT atoms to sort
+ */
+function sortFaststartAtoms(atoms, options) {
+    const faststarted = [];
+    const ftyp = atoms.find((atom) => atom.kind === 'ftyp');
+    if (!ftyp) {
+        throw new Error('Missing ftyp atom!');
+    }
+    if (ftyp.size > atom_1.MAX_FTYP_ATOM_SIZE) {
+        throw new Error(`ftyp atom is greater than ${atom_1.MAX_FTYP_ATOM_SIZE}`);
+    }
+    console.log('before', { atoms });
+    const moov = atoms.find((atom) => atom.kind === 'moov');
+    (0, update_chunk_offsets_1.default)(moov, options);
+    faststarted.push(ftyp, moov);
+    const rest = atoms.filter((atom) => !['ftyp', 'moov'].includes(atom.kind));
+    faststarted.push(...rest);
+    console.log('after', { faststarted });
+    return faststarted;
+}
+exports.sortFaststartAtoms = sortFaststartAtoms;

package/dist/faststart/update-chunk-offsets.d.ts

@@ -0,0 +1,10 @@
+import { QtAtom } from './atom';
+import { FaststartOptions } from './options';
+/**
+ * Adds the specified offset to each entry in stco/co64 atoms
+ *
+ * @param atoms QT atoms to traverse
+ * @param offset offset to add
+ * @param forceUpgrade always upgrade stco atoms to co64
+ */
+export default function updateChunkOffsets(moov: QtAtom, options: FaststartOptions): void;

package/dist/faststart/update-chunk-offsets.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-bitwise */
+const atom_1 = require("./atom");
+/**
+ * Adds the specified offset to each entry in stco/co64 atoms
+ *
+ * @param atoms QT atoms to traverse
+ * @param offset offset to add
+ * @param forceUpgrade always upgrade stco atoms to co64
+ */
+function updateChunkOffsets(moov, options) {
+    const atoms = moov.data;
+    const originalMoovSize = Number(moov.size);
+    let newChunksSize = 0;
+    let originalChunksSize = 0;
+    // First pass to count total entries, which is needed for co64 upgrades.
+    (0, atom_1.traverseAtoms)(atoms, (atom) => {
+        if (!['stco', 'co64'].includes(atom.kind) || !Buffer.isBuffer(atom.data)) {
+            return;
+        }
+        const entries = atom.data.readUInt32BE(4);
+        const originalEntrySize = isCo64(atom.kind) ? 8 : 4;
+        originalChunksSize += entries * originalEntrySize;
+        const newEntrySize = isCo64(atom.kind) || options.forceUpgradeToCo64 ? 8 : 4;
+        newChunksSize += entries * newEntrySize;
+    });
+    // Calculate new mdat offsets to add to stco/co64 chunk offset values
+    const totalOffset = originalMoovSize - originalChunksSize + newChunksSize;
+    // Second pass to actually update offsets.
+    (0, atom_1.traverseAtoms)(atoms, (atom) => {
+        if (!['stco', 'co64'].includes(atom.kind) || !Buffer.isBuffer(atom.data)) {
+            return;
+        }
+        const overflow = updateChunkAtom(atom, totalOffset, options);
+        if (!overflow) {
+            return;
+        }
+        upgradeStcoToCo64(atom, totalOffset);
+    });
+}
+exports.default = updateChunkOffsets;
+/**
+ * Updates `stco` or `co64` atoms' chunk offsets.
+ *
+ * @param atom `stco` or `co64` to update chunk offsets of
+ * @param totalOffset the total offset value to add to the existing chunk offsets
+ * @param options
+ * @returns {boolean} `true` if overflowed (did not finish updating chunks), `false` if succeeded
+ */
+function updateChunkAtom(atom, totalOffset, options) {
+    if (!Buffer.isBuffer(atom.data)) {
+        throw new Error(`${atom.kind} data is not a Buffer!`);
+    }
+    let overflow = false;
+    const entrySize = isCo64(atom.kind) ? 8 : 4;
+    const entries = atom.data.readUInt32BE(4);
+    const newData = Buffer.alloc(8 + entries * entrySize); // 8 byte header
+    atom.data.copy(newData, 0, 0, 8); // copy header
+    for (let i = 0; i < entries; i++) {
+        const cur = 8 + i * entrySize; // 8 byte header
+        if (isCo64(atom.kind)) {
+            const newVal64 = Number((BigInt(atom.data.readUInt32BE(cur)) << BigInt(32)) |
+                BigInt(atom.data.readUInt32BE(cur + 4))) + totalOffset;
+            newData.writeUInt32BE(Number((BigInt(newVal64) >> BigInt(32)) & BigInt(0xffffffff)), cur);
+            newData.writeUInt32BE(Number(BigInt(newVal64) & BigInt(0xffffffff)), cur + 4);
+            continue;
+        }
+        if (options.forceUpgradeToCo64) {
+            overflow = true;
+            break;
+        }
+        const newVal32 = atom.data.readUInt32BE(cur) + totalOffset;
+        if (newVal32 > 2 ** 32 - 1) {
+            overflow = true;
+            break;
+        }
+        newData.writeUInt32BE(newVal32, cur);
+    }
+    if (!overflow) {
+        atom.data = newData;
+    }
+    return overflow;
+}
+/**
+ * **Upgrades** `stco` atom to a `co64` atom and also updates the chunk offsets.
+ *
+ * @param atom `stco` or `co64` to update chunk offsets of
+ * @param totalOffset the total offset value to add to the existing chunk offsets
+ */
+function upgradeStcoToCo64(atom, totalOffset) {
+    if (!Buffer.isBuffer(atom.data)) {
+        throw new Error(`${atom.kind} data is not a Buffer!`);
+    }
+    // Upgrade to stco atoms to co64 atoms
+    const entries = atom.data.readUInt32BE(4);
+    const upgradedData = Buffer.alloc(8 + entries * 8); // 8-byte header, 8-byte entry size
+    atom.data.copy(upgradedData, 0, 0, 8);
+    upgradedData.writeUInt32BE((entries >> 32) & 0xffffffff, 8); // MSB 64-bit size
+    upgradedData.writeUInt32BE(entries & 0xffffffff, 12); // LSB 64-bit size
+    for (let i = 0; i < entries; i++) {
+        const cur32 = 8 + i * 4; // 8-byte header, 4-byte entry size for READS (stco)
+        const newVal = atom.data.readUInt32BE(cur32) + totalOffset;
+        const cur64 = 8 + i * 8; // 8-byte header, 8-byte entry size for WRITES (co64)
+        upgradedData.writeUInt32BE(Number((BigInt(newVal) >> BigInt(32)) & BigInt(0xffffffff)), cur64);
+        upgradedData.writeUInt32BE(Number(BigInt(newVal) & BigInt(0xffffffff)), cur64 + 4);
+    }
+    atom.kind = 'co64';
+    atom.data = upgradedData;
+    atom.size = atom_1.ATOM_PREAMBLE_SIZE * BigInt(2) + BigInt(upgradedData.byteLength);
+}
+function isCo64(atomKind) {
+    return atomKind === 'co64';
+}

package/dist/faststart/util.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+export interface Cursor {
+    pos: bigint;
+}
+export declare function numToHex(val: number): string;
+export declare function asciiToU32Be(chars: string): number;
+export declare function u32BeToAscii(u32: number): string;
+export declare function readU32(cur: Cursor, buf: Buffer): number;
+export declare function readU64(cur: Cursor, buf: Buffer): bigint;

package/dist/faststart/util.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readU64 = exports.readU32 = exports.u32BeToAscii = exports.asciiToU32Be = exports.numToHex = void 0;
+function numToHex(val) {
+    return val.toString(16);
+}
+exports.numToHex = numToHex;
+function asciiToU32Be(chars) {
+    return Buffer.from(chars.split('').map((char) => char.charCodeAt(0))).readUInt32BE(0);
+}
+exports.asciiToU32Be = asciiToU32Be;
+function u32BeToAscii(u32) {
+    const buf = Buffer.alloc(4);
+    buf.writeUInt32BE(u32, 0);
+    return buf.toString('ascii');
+}
+exports.u32BeToAscii = u32BeToAscii;
+function readU32(cur, buf) {
+    const u32 = buf.readUInt32BE(Number(cur.pos));
+    cur.pos += BigInt(4);
+    return u32;
+}
+exports.readU32 = readU32;
+function readU64(cur, buf) {
+    const long = buf.slice(Number(cur.pos), Number(cur.pos + BigInt(8)));
+    const u64 = 
+    // eslint-disable-next-line no-bitwise
+    (BigInt(long.readUInt32BE(0)) << BigInt(32)) |
+        // eslint-disable-next-line no-bitwise
+        (BigInt(long.readUInt32BE(4)) & BigInt(0xffffffff));
+    cur.pos += BigInt(8);
+    return u64;
+}
+exports.readU64 = readU64;

package/dist/get-browser-instance.d.ts

@@ -1,5 +1,6 @@
-import type { Browser, Page } from 'puppeteer-core';
 import type { BrowserExecutable } from 'remotion';
+import type { Browser } from './browser/Browser';
+import type { Page } from './browser/Page';
 import type { ChromiumOptions } from './open-browser';
 export declare const getPageAndCleanupFn: ({ passedInInstance, browserExecutable, chromiumOptions, }: {
     passedInInstance: Browser | undefined;

package/dist/get-compositions.d.ts

@@ -1,6 +1,6 @@
-import type { Browser } from 'puppeteer-core';
 import type { BrowserExecutable, FfmpegExecutable, TCompMetadata } from 'remotion';
 import type { BrowserLog } from './browser-log';
+import type { Browser } from './browser/Browser';
 import type { ChromiumOptions } from './open-browser';
 declare type GetCompositionsConfig = {
     inputProps?: object | null;

package/dist/get-compositions.js

@@ -14,8 +14,8 @@ const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
             var _a;
             (_a = config.onBrowserLog) === null || _a === void 0 ? void 0 : _a.call(config, {
                 stackTrace: log.stackTrace(),
-                text: log.text(),
-                type: log.type(),
+                text: log.text,
+                type: log.type,
             });
         });
     }
@@ -40,7 +40,7 @@ const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
         frame: null,
         args: [],
     });
-    await page.waitForFunction('window.ready === true');
+    await page.waitForFunction(page.browser, 'window.ready === true');
     const result = await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
         pageFunction: () => {
             return window.getStaticCompositions();

package/dist/get-local-browser-executable.js

@@ -5,9 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLocalBrowserExecutable = exports.ensureLocalBrowser = void 0;
 const fs_1 = __importDefault(require("fs"));
-const puppeteer_core_1 = __importDefault(require("puppeteer-core"));
-const install_1 = require("puppeteer-core/lib/cjs/puppeteer/node/install");
-const revisions_1 = require("puppeteer-core/lib/cjs/puppeteer/revisions");
+const create_browser_fetcher_1 = require("./browser/create-browser-fetcher");
+const node_1 = require("./browser/node");
+const revisions_1 = require("./browser/revisions");
 const getSearchPathsForProduct = (product) => {
     var _a;
     if (product === 'chrome') {
@@ -44,8 +44,10 @@ const getLocalBrowser = (product) => {
     return null;
 };
 const getBrowserRevision = (product) => {
-    const browserFetcher = puppeteer_core_1.default.createBrowserFetcher({
+    const browserFetcher = node_1.puppeteer.createBrowserFetcher({
         product,
+        path: null,
+        platform: null,
     });
     const revisionInfo = browserFetcher.revisionInfo(product === 'firefox'
         ? revisions_1.PUPPETEER_REVISIONS.firefox
@@ -73,7 +75,7 @@ const ensureLocalBrowser = async (browser, preferredBrowserExecutable) => {
     const status = getBrowserStatus(mapBrowserToProduct(browser), preferredBrowserExecutable);
     if (status.type === 'no-browser') {
         console.log('No local browser could be found. Downloading one from the internet...');
-        await (0, install_1.downloadBrowser)();
+        await (0, create_browser_fetcher_1.downloadBrowser)(browser);
     }
 };
 exports.ensureLocalBrowser = ensureLocalBrowser;

package/dist/get-port.js

@@ -14,7 +14,7 @@ const getAvailablePort = (portToTry) => new Promise((resolve) => {
         status = 'unavailable';
         socket.destroy();
     });
-    socket.setTimeout(1000);
+    socket.setTimeout(3000);
     socket.on('timeout', () => {
         status = 'unavailable';
         socket.destroy();
@@ -26,15 +26,9 @@ const getAvailablePort = (portToTry) => new Promise((resolve) => {
     socket.on('close', () => resolve(status));
     socket.connect(portToTry, host);
 });
-const portCheckSequence = function* (ports) {
-    if (ports) {
-        yield* ports;
-    }
-    yield 0; // Fall back to 0 if anything else failed
-};
 const getPort = async (from, to) => {
     const ports = makeRange(from, to);
-    for (const port of portCheckSequence(ports)) {
+    for (const port of ports) {
         if ((await getAvailablePort(port)) === 'available') {
             return port;
         }
@@ -71,10 +65,7 @@ const makeRange = (from, to) => {
     if (to < from) {
         throw new RangeError('`to` must be greater than or equal to `from`');
     }
-    const generator = function* (f, t) {
-        for (let port = f; port <= t; port++) {
-            yield port;
-        }
-    };
-    return generator(from, to);
+    return new Array(to - from + 1).fill(true).map((_, i) => {
+        return i + from;
+    });
 };

package/dist/get-video-info.d.ts

@@ -0,0 +1,8 @@
+import type { FfmpegExecutable } from 'remotion';
+declare type Result = {
+    specialVcodec: SpecialVCodecForTransparency;
+    needsResize: [number, number] | null;
+};
+export declare type SpecialVCodecForTransparency = 'vp9' | 'vp8' | 'none';
+export declare const getVideoInfo: (src: string, ffprobeExecutable: FfmpegExecutable) => Promise<Result>;
+export {};

package/dist/get-video-info.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVideoInfo = void 0;
+const execa_1 = __importDefault(require("execa"));
+const calculate_sar_dar_pixels_1 = require("./calculate-sar-dar-pixels");
+const p_limit_1 = require("./p-limit");
+const isVp9VideoCache = {};
+const limit = (0, p_limit_1.pLimit)(1);
+async function getVideoInfoUnlimited(src, ffprobeExecutable) {
+    var _a;
+    if (typeof isVp9VideoCache[src] !== 'undefined') {
+        return isVp9VideoCache[src];
+    }
+    const task = await (0, execa_1.default)(ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : 'ffprobe', [src]);
+    const isVp9 = task.stderr.includes('Video: vp9');
+    const isVp8 = task.stderr.includes('Video: vp8');
+    const dimensions = (_a = task.stderr
+        .split('\n')
+        .find((n) => n.trim().startsWith('Stream #'))) === null || _a === void 0 ? void 0 : _a.match(/([0-9]{2,6})x([0-9]{2,6})/);
+    const dar = task.stderr.match(/DAR\s([0-9]+):([0-9]+)/);
+    let needsResize = null;
+    if (dimensions && dar) {
+        const width = parseInt(dimensions[1], 10);
+        const height = parseInt(dimensions[2], 10);
+        const darWidth = parseInt(dar[1], 10);
+        const darHeight = parseInt(dar[2], 10);
+        const { width: actualWidth, height: actualHeight } = (0, calculate_sar_dar_pixels_1.calculateDisplayVideoSize)({
+            darX: darWidth,
+            darY: darHeight,
+            x: width,
+            y: height,
+        });
+        if (actualWidth !== width || actualHeight !== height) {
+            needsResize = [actualWidth, actualHeight];
+        }
+    }
+    const result = {
+        specialVcodec: isVp9 ? 'vp9' : isVp8 ? 'vp8' : 'none',
+        needsResize,
+    };
+    isVp9VideoCache[src] = result;
+    return isVp9VideoCache[src];
+}
+const getVideoInfo = (src, ffprobeExecutable) => {
+    return limit(() => getVideoInfoUnlimited(src, ffprobeExecutable));
+};
+exports.getVideoInfo = getVideoInfo;

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import execa from 'execa';
 import mime from 'mime-types';
 import { SymbolicateableError } from './error-handling/symbolicateable-error';
@@ -51,7 +52,7 @@ export declare const RenderInternals: {
     }) => void;
     normalizeServeUrl: (unnormalized: string) => string;
     spawnFfmpeg: (options: import("./stitch-frames-to-video").StitcherOptions) => Promise<{
-        task: Promise<void>;
+        task: Promise<Buffer | null>;
         getLogs: () => string;
     }>;
     getFileExtensionFromCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv", type: "chunk" | "final") => "mp3" | "aac" | "wav" | "mp4" | "mkv" | "mov" | "webm";
@@ -61,12 +62,17 @@ export declare const RenderInternals: {
     ensureOutputDirectory: (outputLocation: string) => void;
     getRealFrameRange: (durationInFrames: number, frameRange: import("remotion").FrameRange | null) => [number, number];
     validatePuppeteerTimeout: (timeoutInMilliseconds: unknown) => void;
-    downloadFile: (url: string, to: string, onProgress: ((progress: {
-        progress: number;
-        downloaded: number;
-        totalSize: number;
-    }) => void) | undefined) => Promise<{
+    downloadFile: ({ onProgress, url, to: toFn, }: {
+        url: string;
+        to: (contentDisposition: string | null) => string;
+        onProgress: ((progress: {
+            percent: number | null;
+            downloaded: number;
+            totalSize: number | null;
+        }) => void) | undefined;
+    }) => Promise<{
         sizeInBytes: number;
+        to: string;
     }>;
     validateScale: (scale: unknown) => void;
     killAllBrowsers: () => Promise<void>;
@@ -96,4 +102,6 @@ export declare const RenderInternals: {
         node(scriptPath: string, options?: execa.Options<string> | undefined): execa.ExecaChildProcess<string>;
         node(scriptPath: string, options?: execa.Options<null> | undefined): execa.ExecaChildProcess<Buffer>;
     };
+    registerErrorSymbolicationLock: () => number;
+    unlockErrorSymbolicationLock: (id: number) => void;
 };

package/dist/index.js

@@ -31,6 +31,7 @@ const validate_even_dimensions_with_codec_1 = require("./validate-even-dimension
 const validate_ffmpeg_1 = require("./validate-ffmpeg");
 const validate_puppeteer_timeout_1 = require("./validate-puppeteer-timeout");
 const validate_scale_1 = require("./validate-scale");
+const wait_for_symbolication_error_to_be_done_1 = require("./wait-for-symbolication-error-to-be-done");
 var combine_videos_1 = require("./combine-videos");
 Object.defineProperty(exports, "combineVideos", { enumerable: true, get: function () { return combine_videos_1.combineVideos; } });
 var handle_javascript_exception_1 = require("./error-handling/handle-javascript-exception");
@@ -80,4 +81,6 @@ exports.RenderInternals = {
     mime: mime_types_1.default,
     isPathInside: is_path_inside_1.isPathInside,
     execa: execa_1.default,
+    registerErrorSymbolicationLock: wait_for_symbolication_error_to_be_done_1.registerErrorSymbolicationLock,
+    unlockErrorSymbolicationLock: wait_for_symbolication_error_to_be_done_1.unlockErrorSymbolicationLock,
 };

package/dist/last-frame-from-video-cache.d.ts

@@ -1,5 +1,6 @@
+/// <reference types="node" />
 import type { FfmpegExecutable, OffthreadVideoImageFormat } from 'remotion';
-import type { SpecialVCodecForTransparency } from './is-vp9-video';
+import type { SpecialVCodecForTransparency } from './get-video-info';
 export declare type LastFrameOptions = {
     ffmpegExecutable: FfmpegExecutable;
     ffprobeExecutable: FfmpegExecutable;
@@ -7,6 +8,7 @@ export declare type LastFrameOptions = {
     src: string;
     specialVCodecForTransparency: SpecialVCodecForTransparency;
     imageFormat: OffthreadVideoImageFormat;
+    needsResize: [number, number] | null;
 };
 export declare const setLastFrameInCache: (options: LastFrameOptions, data: Buffer) => void;
 export declare const getLastFrameFromCache: (options: LastFrameOptions) => Buffer | null;

package/dist/offthread/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/offthread-video-server.js

@@ -45,12 +45,8 @@ const startOffthreadVideoServer = ({ ffmpegExecutable, ffprobeExecutable, downlo
         const { src, time, imageFormat } = (0, exports.extractUrlAndSourceFromUrl)(req.url);
         res.setHeader('access-control-allow-origin', '*');
         res.setHeader('content-type', `image/${imageFormat === 'jpeg' ? 'jpg' : 'png'}`);
-        const to = (0, download_and_map_assets_to_file_1.getSanitizedFilenameForAssetUrl)({ downloadDir, src });
-        (0, download_and_map_assets_to_file_1.startDownloadForSrc)({ src, downloadDir, onDownload }).catch((err) => {
-            onError(new Error(`Error while downloading asset: ${err.stack}`));
-        });
-        (0, download_and_map_assets_to_file_1.waitForAssetToBeDownloaded)(src, to)
-            .then(() => {
+        (0, download_and_map_assets_to_file_1.downloadAsset)({ src, downloadDir, onDownload })
+            .then((to) => {
             return (0, extract_frame_from_video_1.extractFrameFromVideo)({
                 time,
                 src: to,

package/dist/open-browser.d.ts

@@ -1,5 +1,6 @@
-import puppeteer from 'puppeteer-core';
 import type { Browser } from 'remotion';
+import type { Browser as PuppeteerBrowser } from './browser/Browser';
+import type { Viewport } from './browser/PuppeteerViewport';
 declare const validRenderers: readonly ["swangle", "angle", "egl", "swiftshader"];
 declare type OpenGlRenderer = typeof validRenderers[number];
 export declare type ChromiumOptions = {
@@ -14,5 +15,6 @@ export declare const openBrowser: (browser: Browser, options?: {
     browserExecutable?: string | null;
     chromiumOptions?: ChromiumOptions;
     forceDeviceScaleFactor?: number;
-}) => Promise<puppeteer.Browser>;
+    viewport?: Viewport;
+}) => Promise<PuppeteerBrowser>;
 export {};

package/dist/open-browser.js

@@ -7,8 +7,8 @@ exports.openBrowser = exports.killAllBrowsers = void 0;
 const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
-const puppeteer_core_1 = __importDefault(require("puppeteer-core"));
 const remotion_1 = require("remotion");
+const node_1 = require("./browser/node");
 const get_local_browser_executable_1 = require("./get-local-browser-executable");
 const validRenderers = ['swangle', 'angle', 'egl', 'swiftshader'];
 const getOpenGlRenderer = (option) => {
@@ -33,18 +33,17 @@ const killAllBrowsers = async () => {
 };
 exports.killAllBrowsers = killAllBrowsers;
 const openBrowser = async (browser, options) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
     if (browser === 'firefox' && !remotion_1.Internals.FEATURE_FLAG_FIREFOX_SUPPORT) {
         throw new TypeError('Firefox supported is not yet turned on. Stay tuned for the future.');
     }
     await (0, get_local_browser_executable_1.ensureLocalBrowser)(browser, (_a = options === null || options === void 0 ? void 0 : options.browserExecutable) !== null && _a !== void 0 ? _a : null);
     const executablePath = (0, get_local_browser_executable_1.getLocalBrowserExecutable)(browser, (_b = options === null || options === void 0 ? void 0 : options.browserExecutable) !== null && _b !== void 0 ? _b : null);
     const customGlRenderer = getOpenGlRenderer((_d = (_c = options === null || options === void 0 ? void 0 : options.chromiumOptions) === null || _c === void 0 ? void 0 : _c.gl) !== null && _d !== void 0 ? _d : null);
-    const browserInstance = await puppeteer_core_1.default.launch({
+    const browserInstance = await node_1.puppeteer.launch({
         executablePath,
         product: browser,
         dumpio: (_e = options === null || options === void 0 ? void 0 : options.shouldDumpIo) !== null && _e !== void 0 ? _e : false,
-        ignoreDefaultArgs: true,
         args: [
             'about:blank',
             '--allow-pre-commit-input',
@@ -61,8 +60,6 @@ const openBrowser = async (browser, options) => {
             '--no-proxy-server',
             "--proxy-server='direct://'",
             '--proxy-bypass-list=*',
-            // TODO: remove AvoidUnnecessaryBeforeUnloadCheckSync below
-            // once crbug.com/1324138 is fixed and released.
             '--disable-hang-monitor',
             '--disable-ipc-flooding-protection',
             '--disable-popup-blocking',
@@ -76,8 +73,6 @@ const openBrowser = async (browser, options) => {
             '--enable-automation',
             '--password-store=basic',
             '--use-mock-keychain',
-            // TODO(sadym): remove '--enable-blink-features=IdleDetection'
-            // once IdleDetection is turned on by default.
             '--enable-blink-features=IdleDetection',
             '--export-tagged-pdf',
             '--intensive-wake-up-throttling-policy=0',
@@ -113,6 +108,11 @@ const openBrowser = async (browser, options) => {
                 ]
                 : []),
         ].filter(Boolean),
+        defaultViewport: (_k = options === null || options === void 0 ? void 0 : options.viewport) !== null && _k !== void 0 ? _k : {
+            height: 720,
+            width: 1280,
+            deviceScaleFactor: 1,
+        },
     });
     const pages = await browserInstance.pages();
     await pages[0].close();

package/dist/prepare-server.js

@@ -8,6 +8,7 @@ const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
 const is_serve_url_1 = require("./is-serve-url");
 const serve_static_1 = require("./serve-static");
+const wait_for_symbolication_error_to_be_done_1 = require("./wait-for-symbolication-error-to-be-done");
 const prepareServer = async ({ downloadDir, ffmpegExecutable, ffprobeExecutable, onDownload, onError, webpackConfigOrServeUrl, port, }) => {
     if ((0, is_serve_url_1.isServeUrl)(webpackConfigOrServeUrl)) {
         const { port: offthreadPort, close: closeProxy } = await (0, serve_static_1.serveStatic)(null, {
@@ -20,7 +21,9 @@ const prepareServer = async ({ downloadDir, ffmpegExecutable, ffprobeExecutable,
         });
         return Promise.resolve({
             serveUrl: webpackConfigOrServeUrl,
-            closeServer: () => closeProxy(),
+            closeServer: () => {
+                return closeProxy();
+            },
             offthreadPort,
         });
     }
@@ -40,7 +43,7 @@ const prepareServer = async ({ downloadDir, ffmpegExecutable, ffprobeExecutable,
     });
     return Promise.resolve({
         closeServer: () => {
-            return close();
+            return (0, wait_for_symbolication_error_to_be_done_1.waitForSymbolicationToBeDone)().then(() => close());
         },
         serveUrl: `http://localhost:${serverPort}`,
         offthreadPort: serverPort,

package/dist/provide-screenshot.d.ts

@@ -1,11 +1,12 @@
-import type puppeteer from 'puppeteer-core';
+/// <reference types="node" />
 import type { ImageFormat } from 'remotion';
+import type { Page } from './browser/Page';
 export declare const provideScreenshot: ({ page, imageFormat, options, quality, }: {
-    page: puppeteer.Page;
+    page: Page;
     imageFormat: ImageFormat;
     quality: number | undefined;
     options: {
         frame: number;
-        output?: string;
+        output: string | null;
     };
 }) => Promise<Buffer>;