@remotion/lambda 3.2.42 → 3.2.44

package/dist/api/render-media-on-lambda.d.ts

@@ -44,6 +44,7 @@ export declare type RenderMediaOnLambdaOutput = {
     renderId: string;
     bucketName: string;
     cloudWatchLogs: string;
+    folderInS3Console: string;
 };
 /**
  * @description Triggers a render on a lambda given a composition and a lambda function.

package/dist/api/render-media-on-lambda.js

@@ -5,7 +5,7 @@ const version_1 = require("remotion/version");
 const call_lambda_1 = require("../shared/call-lambda");
 const constants_1 = require("../shared/constants");
 const convert_to_serve_url_1 = require("../shared/convert-to-serve-url");
-const get_cloudwatch_stream_url_1 = require("../shared/get-cloudwatch-stream-url");
+const get_aws_urls_1 = require("../shared/get-aws-urls");
 const serialize_input_props_1 = require("../shared/serialize-input-props");
 const validate_download_behavior_1 = require("../shared/validate-download-behavior");
 const validate_frames_per_lambda_1 = require("../shared/validate-frames-per-lambda");
@@ -89,12 +89,17 @@ const renderMediaOnLambda = async ({ functionName, serveUrl, inputProps, codec,
         return {
             renderId: res.renderId,
             bucketName: res.bucketName,
-            cloudWatchLogs: (0, get_cloudwatch_stream_url_1.getCloudwatchStreamUrl)({
+            cloudWatchLogs: (0, get_aws_urls_1.getCloudwatchStreamUrl)({
                 functionName,
                 method: constants_1.LambdaRoutines.renderer,
                 region,
                 renderId: res.renderId,
             }),
+            folderInS3Console: (0, get_aws_urls_1.getS3RenderUrl)({
+                bucketName: res.bucketName,
+                renderId: res.renderId,
+                region,
+            }),
         };
     }
     catch (err) {

package/dist/api/render-still-on-lambda.js

@@ -5,7 +5,7 @@ const version_1 = require("remotion/version");
 const call_lambda_1 = require("../shared/call-lambda");
 const constants_1 = require("../shared/constants");
 const convert_to_serve_url_1 = require("../shared/convert-to-serve-url");
-const get_cloudwatch_stream_url_1 = require("../shared/get-cloudwatch-stream-url");
+const get_aws_urls_1 = require("../shared/get-aws-urls");
 const serialize_input_props_1 = require("../shared/serialize-input-props");
 /**
  * @description Renders a still frame on Lambda
@@ -64,7 +64,7 @@ const renderStillOnLambda = async ({ functionName, serveUrl, inputProps, imageFo
             sizeInBytes: res.size,
             bucketName: res.bucketName,
             renderId: res.renderId,
-            cloudWatchLogs: (0, get_cloudwatch_stream_url_1.getCloudwatchStreamUrl)({
+            cloudWatchLogs: (0, get_aws_urls_1.getCloudwatchStreamUrl)({
                 functionName,
                 method: constants_1.LambdaRoutines.still,
                 region,

package/dist/cli/commands/render/progress.d.ts

@@ -22,10 +22,11 @@ declare type DownloadedInfo = {
     downloaded: number;
     doneIn: number | null;
 };
-export declare const makeProgressString: ({ progress, steps, downloadInfo, retriesInfo, }: {
+export declare const makeProgressString: ({ progress, steps, downloadInfo, retriesInfo, verbose, }: {
     progress: MultiRenderProgress;
     steps: number;
     downloadInfo: DownloadedInfo | null;
     retriesInfo: ChunkRetry[];
+    verbose: boolean;
 }) => string;
 export {};

package/dist/cli/commands/render/progress.js

@@ -57,10 +57,17 @@ const makeEncodingProgress = ({ encodingProgress, chunkProgress, totalSteps, })
             : cli_1.CliInternals.chalk.gray(`${doneIn}ms`),
     ].join(' ');
 };
-const makeCleanupProgress = (cleanupInfo, totalSteps) => {
+const makeCleanupProgress = (cleanupInfo, totalSteps, skipped) => {
     if (!cleanupInfo) {
         return '';
     }
+    if (skipped) {
+        return [
+            '🪣 ',
+            `(4/${totalSteps})`,
+            cli_1.CliInternals.chalk.blueBright(`Not cleaning up because --log=verbose was set`),
+        ].join(' ');
+    }
     const { doneIn, filesDeleted, minFilesToDelete } = cleanupInfo;
     const progress = filesDeleted / minFilesToDelete;
     return [
@@ -116,7 +123,7 @@ const makeMultiProgressFromStatus = (status) => {
     };
 };
 exports.makeMultiProgressFromStatus = makeMultiProgressFromStatus;
-const makeProgressString = ({ progress, steps, downloadInfo, retriesInfo, }) => {
+const makeProgressString = ({ progress, steps, downloadInfo, retriesInfo, verbose, }) => {
     return [
         makeInvokeProgress(progress.lambdaInvokeProgress, steps, retriesInfo),
         makeChunkProgress({
@@ -129,7 +136,7 @@ const makeProgressString = ({ progress, steps, downloadInfo, retriesInfo, }) =>
             chunkProgress: progress.chunkProgress,
             totalSteps: steps,
         }),
-        makeCleanupProgress(progress.cleanupInfo, steps),
+        makeCleanupProgress(progress.cleanupInfo, steps, verbose),
         downloadInfo ? makeDownloadProgress(downloadInfo, steps) : null,
     ]
         .filter(remotion_1.Internals.truthy)

package/dist/cli/commands/render/render.js

@@ -100,7 +100,9 @@ const renderCommand = async (args) => {
     const progressBar = cli_1.CliInternals.createOverwriteableCliOutput(cli_1.CliInternals.quietFlagProvided());
     log_1.Log.info(cli_1.CliInternals.chalk.gray(`bucket = ${res.bucketName}, function = ${functionName}`));
     log_1.Log.info(cli_1.CliInternals.chalk.gray(`renderId = ${res.renderId}, codec = ${codec} (${reason})`));
+    const verbose = renderer_1.RenderInternals.isEqualOrBelowLogLevel(cli_1.ConfigInternals.Logging.getLogLevel(), 'verbose');
     log_1.Log.verbose(`CloudWatch logs (if enabled): ${res.cloudWatchLogs}`);
+    log_1.Log.verbose(`Render folder: ${res.folderInS3Console}`);
     const status = await (0, get_render_progress_1.getRenderProgress)({
         functionName,
         bucketName: res.bucketName,
@@ -113,6 +115,7 @@ const renderCommand = async (args) => {
         steps: totalSteps,
         downloadInfo: null,
         retriesInfo: status.retriesInfo,
+        verbose,
     }));
     // eslint-disable-next-line no-constant-condition
     while (true) {
@@ -129,6 +132,7 @@ const renderCommand = async (args) => {
             steps: totalSteps,
             retriesInfo: newStatus.retriesInfo,
             downloadInfo: null,
+            verbose,
         }));
         if (newStatus.done) {
             progressBar.update((0, progress_1.makeProgressString)({
@@ -136,6 +140,7 @@ const renderCommand = async (args) => {
                 steps: totalSteps,
                 downloadInfo: null,
                 retriesInfo: newStatus.retriesInfo,
+                verbose,
             }));
             if (downloadName) {
                 const downloadStart = Date.now();
@@ -154,6 +159,7 @@ const renderCommand = async (args) => {
                                 downloaded,
                                 totalSize,
                             },
+                            verbose,
                         }));
                     },
                 });
@@ -166,6 +172,7 @@ const renderCommand = async (args) => {
                         downloaded: sizeInBytes,
                         totalSize: sizeInBytes,
                     },
+                    verbose,
                 }));
                 log_1.Log.info();
                 log_1.Log.info();

package/dist/functions/chunk-optimization/can-use-optimization.d.ts

@@ -0,0 +1,6 @@
+import type { OptimizationProfile } from './types';
+export declare const canUseOptimization: ({ optimization, framesPerLambda, frameRange, }: {
+    optimization: OptimizationProfile | null;
+    framesPerLambda: number;
+    frameRange: [number, number];
+}) => boolean;

package/dist/functions/chunk-optimization/can-use-optimization.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canUseOptimization = void 0;
+const version_1 = require("remotion/version");
+const canUseOptimization = ({ optimization, framesPerLambda, frameRange, }) => {
+    if (!optimization) {
+        return false;
+    }
+    if (optimization.framesPerLambda !== framesPerLambda) {
+        return false;
+    }
+    if (optimization.lambdaVersion !== version_1.VERSION) {
+        return false;
+    }
+    if (optimization.frameRange[0] !== frameRange[0]) {
+        return false;
+    }
+    if (optimization.frameRange[1] !== frameRange[1]) {
+        return false;
+    }
+    return true;
+};
+exports.canUseOptimization = canUseOptimization;

package/dist/functions/chunk-optimization/collect-data.d.ts

@@ -0,0 +1,9 @@
+import type { AwsRegion } from '../../pricing/aws-regions';
+export declare const collectChunkInformation: ({ bucketName, renderId, region, expectedBucketOwner, }: {
+    bucketName: string;
+    renderId: string;
+    region: AwsRegion;
+    expectedBucketOwner: string;
+}) => Promise<(Omit<import("./types").ObjectChunkTimingData, "timings"> & {
+    timings: number[];
+})[]>;

package/dist/functions/chunk-optimization/collect-data.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectChunkInformation = void 0;
+const constants_1 = require("../../shared/constants");
+const stream_to_string_1 = require("../../shared/stream-to-string");
+const io_1 = require("../helpers/io");
+const collectChunkInformation = async ({ bucketName, renderId, region, expectedBucketOwner, }) => {
+    const prefix = (0, constants_1.lambdaTimingsPrefix)(renderId);
+    const timingFiles = await (0, io_1.lambdaLs)({
+        bucketName,
+        prefix,
+        region,
+        expectedBucketOwner,
+    });
+    const timingFileContents = await Promise.all(timingFiles.map(async (file) => {
+        const contents = await (0, io_1.lambdaReadFile)({
+            bucketName,
+            key: file.Key,
+            region,
+            expectedBucketOwner,
+        });
+        const string = await (0, stream_to_string_1.streamToString)(contents);
+        return JSON.parse(string);
+    }));
+    return timingFileContents;
+};
+exports.collectChunkInformation = collectChunkInformation;

package/dist/functions/chunk-optimization/get-frame-ranges-from-profile.d.ts

@@ -0,0 +1,3 @@
+import type { TimingProfile } from './types';
+export declare const getFrameRangesFromProfile: (profile: TimingProfile) => [number, number][];
+export declare const sortProfileByFrameRanges: (profile: TimingProfile) => import("./types").ChunkTimingData[];

package/dist/functions/chunk-optimization/get-frame-ranges-from-profile.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortProfileByFrameRanges = exports.getFrameRangesFromProfile = void 0;
+const getFrameRangesFromProfile = (profile) => {
+    return profile.map((p) => p.frameRange);
+};
+exports.getFrameRangesFromProfile = getFrameRangesFromProfile;
+const sortProfileByFrameRanges = (profile) => {
+    return profile.slice().sort((a, b) => a.frameRange[0] - b.frameRange[0]);
+};
+exports.sortProfileByFrameRanges = sortProfileByFrameRanges;

package/dist/functions/chunk-optimization/get-profile-duration.d.ts

@@ -0,0 +1,3 @@
+import type { ChunkTimingData, TimingProfile } from './types';
+export declare const getTimingEndTimestamps: (chunk: ChunkTimingData) => number[];
+export declare const getProfileDuration: (chunks: TimingProfile) => number;

package/dist/functions/chunk-optimization/get-profile-duration.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProfileDuration = exports.getTimingEndTimestamps = void 0;
+const getTimingEndTimestamps = (chunk) => {
+    return chunk.timings.map((timing) => chunk.startDate + timing);
+};
+exports.getTimingEndTimestamps = getTimingEndTimestamps;
+const getProfileTimestamps = (chunks) => {
+    return chunks.map((c) => (0, exports.getTimingEndTimestamps)(c));
+};
+const getProfileDuration = (chunks) => {
+    const startTimeStamps = chunks.map((c) => c.startDate).flat(1);
+    const endTimestamps = getProfileTimestamps(chunks).flat(1);
+    const earliest = Math.min(...startTimeStamps);
+    const latest = Math.max(...endTimestamps);
+    return latest - earliest;
+};
+exports.getProfileDuration = getProfileDuration;

package/dist/functions/chunk-optimization/is-valid-profile.d.ts

@@ -0,0 +1,2 @@
+import type { TimingProfile } from './types';
+export declare const isValidOptimizationProfile: (profile: TimingProfile) => boolean;

package/dist/functions/chunk-optimization/is-valid-profile.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidOptimizationProfile = void 0;
+const renderer_1 = require("@remotion/renderer");
+const isValidOptimizationProfile = (profile) => {
+    return profile.every((timing) => {
+        const frames = renderer_1.RenderInternals.getFramesToRender(timing.frameRange, 1);
+        const values = Object.values(timing.timings);
+        return frames.length === values.length && values.every((v) => v > 0);
+    });
+};
+exports.isValidOptimizationProfile = isValidOptimizationProfile;

package/dist/functions/chunk-optimization/optimize-invocation-order.d.ts

@@ -0,0 +1,2 @@
+import type { TimingProfile } from './types';
+export declare const optimizeInvocationOrder: (profile: TimingProfile) => TimingProfile;

package/dist/functions/chunk-optimization/optimize-invocation-order.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optimizeInvocationOrder = void 0;
+const sort_by_duration_1 = require("./sort-by-duration");
+const optimizeInvocationOrder = (profile) => {
+    const sortedByDuration = (0, sort_by_duration_1.sortProfileByDuration)(profile).reverse();
+    const sortedByStartTime = profile
+        .slice()
+        .map((a) => a.startDate)
+        .sort((a, b) => a - b);
+    const result = sortedByStartTime.map((prof, i) => {
+        return {
+            ...sortedByDuration[i],
+            startDate: prof,
+        };
+    });
+    return result;
+};
+exports.optimizeInvocationOrder = optimizeInvocationOrder;

package/dist/functions/chunk-optimization/optimize-profile.d.ts

@@ -0,0 +1,9 @@
+import type { TimingProfile } from './types';
+export declare const assignFrameToOther: ({ frameRanges, fromChunk, toChunk, framesToShift, }: {
+    frameRanges: [number, number][];
+    fromChunk: number;
+    toChunk: number;
+    framesToShift: number;
+}) => [number, number][];
+export declare const optimizeProfile: (_profile: TimingProfile) => TimingProfile;
+export declare const optimizeProfileRecursively: (profile: TimingProfile, amount: number) => TimingProfile;

package/dist/functions/chunk-optimization/optimize-profile.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optimizeProfileRecursively = exports.optimizeProfile = exports.assignFrameToOther = void 0;
+const get_frame_ranges_from_profile_1 = require("./get-frame-ranges-from-profile");
+const simulate_frame_ranges_1 = require("./simulate-frame-ranges");
+const sort_by_duration_1 = require("./sort-by-duration");
+const assignFrameToOther = ({ frameRanges, fromChunk, toChunk, framesToShift, }) => {
+    if (fromChunk < toChunk) {
+        return frameRanges.map((frameRange, i) => {
+            if (i === fromChunk) {
+                return [frameRange[0], frameRange[1] - framesToShift];
+            }
+            if (i === toChunk) {
+                return [frameRange[0] - framesToShift, frameRange[1]];
+            }
+            if (i > fromChunk && i < toChunk) {
+                return [frameRange[0] - framesToShift, frameRange[1] - framesToShift];
+            }
+            return frameRange;
+        });
+    }
+    return frameRanges.map((frameRange, i) => {
+        if (i === fromChunk) {
+            return [frameRange[0] + framesToShift, frameRange[1]];
+        }
+        if (i === toChunk) {
+            return [frameRange[0], frameRange[1] + framesToShift];
+        }
+        if (i > toChunk && i < fromChunk) {
+            return [frameRange[0] + framesToShift, frameRange[1] + framesToShift];
+        }
+        return frameRange;
+    });
+};
+exports.assignFrameToOther = assignFrameToOther;
+const optimizeProfile = (_profile) => {
+    const sortedByStart = _profile
+        .slice()
+        .sort((a, b) => a.frameRange[0] - b.frameRange[0]);
+    const sortedByDuration = (0, sort_by_duration_1.sortProfileByDuration)(sortedByStart);
+    const indexOfFastest = sortedByStart.indexOf(sortedByDuration[0]);
+    if (indexOfFastest === -1) {
+        throw new Error('invalid timing profile: ' + JSON.stringify(_profile));
+    }
+    const slowest = sortedByDuration[sortedByDuration.length - 1];
+    const indexOfSlowest = sortedByStart.indexOf(slowest);
+    if (indexOfSlowest === -1) {
+        throw new Error('invalid timing profile: ' + JSON.stringify(_profile));
+    }
+    const frameRanges = (0, get_frame_ranges_from_profile_1.getFrameRangesFromProfile)(sortedByStart);
+    if (indexOfFastest === indexOfSlowest) {
+        return _profile;
+    }
+    const newFrameRanges = (0, exports.assignFrameToOther)({
+        frameRanges,
+        fromChunk: indexOfSlowest,
+        toChunk: indexOfFastest,
+        framesToShift: Math.max(1, Math.min(2, Math.floor(slowest.timings.length / 3))),
+    });
+    const simulated = (0, simulate_frame_ranges_1.simulateFrameRanges)({
+        profile: sortedByStart,
+        newFrameRanges,
+    });
+    return simulated;
+};
+exports.optimizeProfile = optimizeProfile;
+const optimizeProfileRecursively = (profile, amount) => {
+    let optimized = profile;
+    for (let i = 0; i < amount; i++) {
+        optimized = (0, exports.optimizeProfile)(optimized);
+    }
+    return optimized;
+};
+exports.optimizeProfileRecursively = optimizeProfileRecursively;

package/dist/functions/chunk-optimization/plan-frame-ranges.d.ts

@@ -3,5 +3,8 @@ export declare const planFrameRanges: ({ framesPerLambda, frameRange, everyNthFr
     frameRange: [number, number];
     everyNthFrame: number;
 }) => {
-    chunks: [number, number][];
+    chunks: [
+        number,
+        number
+    ][];
 };

package/dist/functions/chunk-optimization/s3-optimization-file.d.ts

@@ -0,0 +1,17 @@
+import type { AwsRegion } from '../../pricing/aws-regions';
+import type { OptimizationProfile } from './types';
+export declare const writeOptimization: ({ bucketName, optimization, compositionId, siteId, region, expectedBucketOwner, }: {
+    bucketName: string;
+    optimization: OptimizationProfile;
+    compositionId: string;
+    siteId: string;
+    region: AwsRegion;
+    expectedBucketOwner: string;
+}) => Promise<void>;
+export declare const getOptimization: ({ siteId, compositionId, bucketName, region, expectedBucketOwner, }: {
+    bucketName: string;
+    siteId: string;
+    compositionId: string;
+    region: AwsRegion;
+    expectedBucketOwner: string;
+}) => Promise<OptimizationProfile | null>;

package/dist/functions/chunk-optimization/s3-optimization-file.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOptimization = exports.writeOptimization = void 0;
+const constants_1 = require("../../shared/constants");
+const stream_to_string_1 = require("../../shared/stream-to-string");
+const io_1 = require("../helpers/io");
+const writeOptimization = async ({ bucketName, optimization, compositionId, siteId, region, expectedBucketOwner, }) => {
+    await (0, io_1.lambdaWriteFile)({
+        bucketName,
+        body: JSON.stringify(optimization),
+        key: (0, constants_1.optimizationProfile)(siteId, compositionId) + '.json',
+        region,
+        privacy: 'private',
+        expectedBucketOwner,
+        downloadBehavior: null,
+        customCredentials: null,
+    });
+};
+exports.writeOptimization = writeOptimization;
+const getOptimization = async ({ siteId, compositionId, bucketName, region, expectedBucketOwner, }) => {
+    const prefix = (0, constants_1.optimizationProfile)(siteId, compositionId);
+    const dir = await (0, io_1.lambdaLs)({
+        bucketName,
+        prefix,
+        region,
+        expectedBucketOwner,
+    });
+    const files = dir
+        .sort((a, b) => {
+        var _a, _b;
+        return ((_a = a.LastModified) === null || _a === void 0 ? void 0 : _a.getTime()) -
+            ((_b = b.LastModified) === null || _b === void 0 ? void 0 : _b.getTime());
+    })
+        .reverse();
+    if (files.length === 0) {
+        return null;
+    }
+    const body = await (0, io_1.lambdaReadFile)({
+        bucketName,
+        key: files[0].Key,
+        region,
+        expectedBucketOwner,
+    });
+    const str = await (0, stream_to_string_1.streamToString)(body);
+    return JSON.parse(str);
+};
+exports.getOptimization = getOptimization;

package/dist/functions/chunk-optimization/simulate-frame-ranges.d.ts

@@ -0,0 +1,7 @@
+import type { ChunkTimingData, TimingProfile } from './types';
+export declare const getTimingForFrame: (profile: TimingProfile, frame: number) => number;
+export declare const getSimulatedTimingForFrameRange: (profile: TimingProfile, frameRange: [number, number]) => ChunkTimingData['timings'];
+export declare const simulateFrameRanges: ({ profile, newFrameRanges, }: {
+    profile: TimingProfile;
+    newFrameRanges: [number, number][];
+}) => TimingProfile;

package/dist/functions/chunk-optimization/simulate-frame-ranges.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simulateFrameRanges = exports.getSimulatedTimingForFrameRange = exports.getTimingForFrame = void 0;
+const getTimingForFrame = (profile, frame) => {
+    for (const timingInfo of profile) {
+        if (timingInfo.frameRange[0] > frame || timingInfo.frameRange[1] < frame) {
+            continue;
+        }
+        let lastTime = timingInfo.startDate;
+        for (let i = 0; i < timingInfo.timings.length; i++) {
+            const actualFrame = i + timingInfo.frameRange[0];
+            const timing = timingInfo.timings[i];
+            const absolute = timing + timingInfo.startDate;
+            if (actualFrame === frame) {
+                return absolute - lastTime;
+            }
+            lastTime = absolute;
+        }
+    }
+    throw new Error(`Frame ${frame} was not rendered`);
+};
+exports.getTimingForFrame = getTimingForFrame;
+const getSimulatedTimingForFrameRange = (profile, frameRange) => {
+    const timings = [];
+    let totalDuration = 0;
+    for (let i = frameRange[0]; i <= frameRange[1]; i++) {
+        const timingForFrame = (0, exports.getTimingForFrame)(profile, i);
+        timings.push(timingForFrame + totalDuration);
+        totalDuration += timingForFrame;
+    }
+    return timings;
+};
+exports.getSimulatedTimingForFrameRange = getSimulatedTimingForFrameRange;
+const simulateFrameRanges = ({ profile, newFrameRanges, }) => {
+    if (profile.length !== newFrameRanges.length) {
+        throw new Error('Expected previous and new frame ranges to be equal');
+    }
+    return newFrameRanges.map((range, i) => {
+        return {
+            timings: (0, exports.getSimulatedTimingForFrameRange)(profile, range),
+            chunk: i,
+            frameRange: range,
+            startDate: profile[i].startDate,
+        };
+    });
+};
+exports.simulateFrameRanges = simulateFrameRanges;

package/dist/functions/chunk-optimization/sort-by-duration.d.ts

@@ -0,0 +1,2 @@
+import type { ChunkTimingData, TimingProfile } from './types';
+export declare const sortProfileByDuration: (profile: TimingProfile) => ChunkTimingData[];

package/dist/functions/chunk-optimization/sort-by-duration.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortProfileByDuration = void 0;
+const get_profile_duration_1 = require("./get-profile-duration");
+const durationCache = new Map();
+const getChunkDuration = (chunk) => {
+    const inCache = durationCache.get(chunk);
+    if (inCache) {
+        return inCache;
+    }
+    const timestamps = (0, get_profile_duration_1.getTimingEndTimestamps)(chunk);
+    const duration = Math.max(...timestamps) - chunk.startDate;
+    durationCache.set(chunk, duration);
+    return duration;
+};
+const sortProfileByDuration = (profile) => {
+    const sortedByDuration = profile.slice().sort((a, b) => {
+        const aDuration = getChunkDuration(a);
+        const bDuration = getChunkDuration(b);
+        return aDuration - bDuration;
+    });
+    durationCache.clear();
+    return sortedByDuration;
+};
+exports.sortProfileByDuration = sortProfileByDuration;

package/dist/functions/launch.js

@@ -66,6 +66,7 @@ const innerLaunchHandler = async (params, options) => {
     const startedDate = Date.now();
     let webhookInvoked = false;
     console.log(`Function has ${Math.max(options.getRemainingTimeInMillis() - 1000, 1000)} before it times out`);
+    const verbose = renderer_1.RenderInternals.isEqualOrBelowLogLevel(params.logLevel, 'verbose');
     const webhookDueToTimeout = setTimeout(async () => {
         if (params.webhook && !webhookInvoked) {
             try {
@@ -108,7 +109,7 @@ const innerLaunchHandler = async (params, options) => {
             }
         }
     }, Math.max(options.getRemainingTimeInMillis() - 1000, 1000));
-    const browserInstance = await (0, get_browser_instance_1.getBrowserInstance)(renderer_1.RenderInternals.isEqualOrBelowLogLevel(params.logLevel, 'verbose'), params.chromiumOptions);
+    const browserInstance = await (0, get_browser_instance_1.getBrowserInstance)(verbose, params.chromiumOptions);
     const downloadMap = renderer_1.RenderInternals.makeDownloadMap();
     const inputPropsPromise = (0, deserialize_input_props_1.deserializeInputProps)({
         bucketName: params.bucketName,
@@ -403,12 +404,14 @@ const innerLaunchHandler = async (params, options) => {
         chunkCount,
         renderId: params.renderId,
     });
-    const deletProm = (0, delete_chunks_1.cleanupFiles)({
-        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-        bucket: params.bucketName,
-        contents,
-        jobs,
-    });
+    const deletProm = verbose
+        ? Promise.resolve(0)
+        : (0, delete_chunks_1.cleanupFiles)({
+            region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+            bucket: params.bucketName,
+            contents,
+            jobs,
+        });
     const cleanupSerializedInputPropsProm = (0, cleanup_serialized_input_props_1.cleanupSerializedInputProps)({
         bucketName: params.bucketName,
         region: (0, get_current_region_1.getCurrentRegionInFunction)(),

package/dist/shared/get-aws-url.d.ts

@@ -0,0 +1,8 @@
+import type { AwsRegion } from '../client';
+import type { LambdaRoutines } from './constants';
+export declare const getCloudwatchStreamUrl: ({ region, functionName, method, renderId, }: {
+    region: AwsRegion;
+    functionName: string;
+    method: LambdaRoutines;
+    renderId: string;
+}) => string;

package/dist/shared/get-aws-url.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCloudwatchStreamUrl = void 0;
+const getCloudwatchStreamUrl = ({ region, functionName, method, renderId, }) => {
+    return `https://${region}.console.aws.amazon.com/cloudwatch/home?region=${region}#logsV2:log-groups/log-group/$252Faws$252Flambda$252F${functionName}/log-events$3FfilterPattern$3D$2522method$253D${method}$252CrenderId$253D${renderId}$2522`;
+};
+exports.getCloudwatchStreamUrl = getCloudwatchStreamUrl;

package/dist/shared/get-aws-urls.d.ts

@@ -0,0 +1,13 @@
+import type { AwsRegion } from '../client';
+import type { LambdaRoutines } from './constants';
+export declare const getCloudwatchStreamUrl: ({ region, functionName, method, renderId, }: {
+    region: AwsRegion;
+    functionName: string;
+    method: LambdaRoutines;
+    renderId: string;
+}) => string;
+export declare const getS3RenderUrl: ({ renderId, region, bucketName, }: {
+    renderId: string;
+    region: AwsRegion;
+    bucketName: string;
+}) => string;

package/dist/shared/get-aws-urls.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getS3RenderUrl = exports.getCloudwatchStreamUrl = void 0;
+const getCloudwatchStreamUrl = ({ region, functionName, method, renderId, }) => {
+    return `https://${region}.console.aws.amazon.com/cloudwatch/home?region=${region}#logsV2:log-groups/log-group/$252Faws$252Flambda$252F${functionName}/log-events$3FfilterPattern$3D$2522method$253D${method}$252CrenderId$253D${renderId}$2522`;
+};
+exports.getCloudwatchStreamUrl = getCloudwatchStreamUrl;
+const getS3RenderUrl = ({ renderId, region, bucketName, }) => {
+    return `https://s3.console.aws.amazon.com/s3/buckets/${bucketName}?region=${region}&prefix=renders/${renderId}/`;
+};
+exports.getS3RenderUrl = getS3RenderUrl;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remotion/lambda",
-	"version": "3.2.42",
+	"version": "3.2.44",
 	"description": "Distributed renderer for Remotion based on AWS Lambda",
 	"main": "dist/index.js",
 	"sideEffects": false,
@@ -31,12 +31,12 @@
 		"@aws-sdk/client-service-quotas": "3.190.0",
 		"@aws-sdk/lib-storage": "3.190.0",
 		"@aws-sdk/s3-request-presigner": "3.190.0",
-		"@remotion/bundler": "3.2.42",
-		"@remotion/cli": "3.2.42",
-		"@remotion/renderer": "3.2.42",
+		"@remotion/bundler": "3.2.44",
+		"@remotion/cli": "3.2.44",
+		"@remotion/renderer": "3.2.44",
 		"aws-policies": "^1.0.1",
 		"mime-types": "2.1.34",
-		"remotion": "3.2.42"
+		"remotion": "3.2.44"
 	},
 	"peerDependencies": {
 		"react": ">=16.8.0",
@@ -59,5 +59,5 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"gitHead": "d297af4ecea4d09948bbf05eeb66dfa701be3787"
+	"gitHead": "443b4b387b78905e747ebe69b3b91ee85966796d"
 }