@remotion/serverless-client 4.0.261

package/dist/test/most-expensive-chunks.test.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bun_test_1 = require("bun:test");
+const most_expensive_chunks_1 = require("../most-expensive-chunks");
+(0, bun_test_1.test)('Should calculate most expensive chunks', () => {
+    const most = (0, most_expensive_chunks_1.getMostExpensiveChunks)({
+        parsedTimings: [
+            {
+                chunk: 0,
+                rendered: 1000,
+                start: 0,
+            },
+            {
+                chunk: 1,
+                rendered: 4000,
+                start: 2000,
+            },
+            {
+                chunk: 2,
+                rendered: 5000,
+                start: 2000,
+            },
+            {
+                chunk: 3,
+                rendered: 3000,
+                start: 2000,
+            },
+            {
+                chunk: 4,
+                rendered: 100000,
+                start: 2000,
+            },
+            {
+                chunk: 5,
+                rendered: 2001,
+                start: 2000,
+            },
+            {
+                chunk: 6,
+                rendered: 2500,
+                start: 2000,
+            },
+        ],
+        framesPerFunction: 10,
+        firstFrame: 0,
+        lastFrame: 99,
+    });
+    (0, bun_test_1.expect)(most).toEqual([
+        { timeInMilliseconds: 98000, chunk: 4, frameRange: [40, 49] },
+        { timeInMilliseconds: 3000, chunk: 2, frameRange: [20, 29] },
+        { timeInMilliseconds: 2000, chunk: 1, frameRange: [10, 19] },
+        { timeInMilliseconds: 1000, chunk: 0, frameRange: [0, 9] },
+        { timeInMilliseconds: 1000, chunk: 3, frameRange: [30, 39] },
+    ]);
+});
+(0, bun_test_1.test)('Render starting from frame 10 should have correct offset', () => {
+    const framesPerFunction = 10;
+    const firstFrame = 10;
+    const lastFrame = 99;
+    const most = (0, most_expensive_chunks_1.getMostExpensiveChunks)({
+        parsedTimings: [
+            {
+                chunk: 0,
+                rendered: 1000,
+                start: 0,
+            },
+            {
+                chunk: 1,
+                rendered: 4000,
+                start: 2000,
+            },
+            {
+                chunk: 2,
+                rendered: 5000,
+                start: 2000,
+            },
+            {
+                chunk: 3,
+                rendered: 3000,
+                start: 2000,
+            },
+            {
+                chunk: 4,
+                rendered: 100000,
+                start: 2000,
+            },
+            {
+                chunk: 5,
+                rendered: 2001,
+                start: 2000,
+            },
+            {
+                chunk: 6,
+                rendered: 2500,
+                start: 2000,
+            },
+        ],
+        framesPerFunction,
+        firstFrame,
+        lastFrame,
+    });
+    (0, bun_test_1.expect)(most).toEqual([
+        { timeInMilliseconds: 98000, chunk: 4, frameRange: [50, 59] },
+        { timeInMilliseconds: 3000, chunk: 2, frameRange: [30, 39] },
+        { timeInMilliseconds: 2000, chunk: 1, frameRange: [20, 29] },
+        { timeInMilliseconds: 1000, chunk: 0, frameRange: [10, 19] },
+        { timeInMilliseconds: 1000, chunk: 3, frameRange: [40, 49] },
+    ]);
+});
+(0, bun_test_1.test)('Render starting from frame 10 and last chunk in most expensive should be corret', () => {
+    const framesPerFunction = 10;
+    const firstFrame = 10;
+    const lastFrame = 79;
+    const most = (0, most_expensive_chunks_1.getMostExpensiveChunks)({
+        parsedTimings: [
+            {
+                chunk: 0,
+                rendered: 1000,
+                start: 0,
+            },
+            {
+                chunk: 1,
+                rendered: 4000,
+                start: 2000,
+            },
+            {
+                chunk: 2,
+                rendered: 5000,
+                start: 2000,
+            },
+            {
+                chunk: 3,
+                rendered: 3000,
+                start: 2000,
+            },
+            {
+                chunk: 4,
+                rendered: 100000,
+                start: 2000,
+            },
+            {
+                chunk: 5,
+                rendered: 2001,
+                start: 2000,
+            },
+            {
+                chunk: 6,
+                rendered: 125000,
+                start: 2000,
+            },
+        ],
+        framesPerFunction,
+        firstFrame,
+        lastFrame,
+    });
+    (0, bun_test_1.expect)(most).toEqual([
+        { timeInMilliseconds: 123000, chunk: 6, frameRange: [70, 79] },
+        { timeInMilliseconds: 98000, chunk: 4, frameRange: [50, 59] },
+        { timeInMilliseconds: 3000, chunk: 2, frameRange: [30, 39] },
+        { timeInMilliseconds: 2000, chunk: 1, frameRange: [20, 29] },
+        { timeInMilliseconds: 1000, chunk: 0, frameRange: [10, 19] },
+    ]);
+});

package/dist/truthy.d.ts

@@ -0,0 +1,3 @@
+type Truthy<T> = T extends false | '' | 0 | null | undefined ? never : T;
+export declare function truthy<T>(value: T): value is Truthy<T>;
+export {};

package/dist/truthy.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truthy = truthy;
+function truthy(value) {
+    return Boolean(value);
+}

package/dist/types.d.ts

@@ -0,0 +1,55 @@
+import type { ServerlessPayloads, ServerlessRoutines } from './constants';
+export interface CloudProvider<Region extends string = string, ReceivedArtifactType extends Record<string, unknown> = Record<string, unknown>, CreateFunctionSpecifics extends Record<string, unknown> = Record<string, unknown>> {
+    type: string;
+    region: Region;
+    receivedArtifactType: ReceivedArtifactType;
+    creationFunctionOptions: CreateFunctionSpecifics;
+}
+export type ReceivedArtifact<Provider extends CloudProvider> = {
+    filename: string;
+    sizeInBytes: number;
+    s3Url: string;
+    s3Key: string;
+} & Provider['receivedArtifactType'];
+export type CostsInfo = {
+    accruedSoFar: number;
+    displayCost: string;
+    currency: string;
+    disclaimer: string;
+};
+export type RenderStillFunctionResponsePayload<Provider extends CloudProvider> = {
+    type: 'success';
+    output: string;
+    outKey: string;
+    size: number;
+    bucketName: string;
+    sizeInBytes: number;
+    estimatedPrice: CostsInfo;
+    renderId: string;
+    receivedArtifacts: ReceivedArtifact<Provider>[];
+};
+export type ChunkRetry = {
+    chunk: number;
+    attempt: number;
+    time: number;
+};
+export type ParsedTiming = {
+    chunk: number;
+    start: number;
+    rendered: number;
+};
+export type CallFunctionOptions<T extends ServerlessRoutines, Provider extends CloudProvider> = {
+    functionName: string;
+    type: T;
+    payload: ServerlessPayloads<Provider>[T];
+    region: Provider['region'];
+    timeoutInTest: number;
+};
+export type ObjectChunkTimingData = {
+    chunk: number;
+    frameRange: [number, number];
+    startDate: number;
+    timings: {
+        [key: number]: number;
+    };
+};

package/dist/types.js

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

package/dist/validate-bucket-name.d.ts

@@ -0,0 +1,7 @@
+export declare const validateBucketName: ({ bucketName, bucketNamePrefix, options, }: {
+    bucketName: unknown;
+    bucketNamePrefix: string;
+    options: {
+        mustStartWithRemotion: boolean;
+    };
+}) => void;

package/dist/validate-bucket-name.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBucketName = void 0;
+const validateBucketName = ({ bucketName, bucketNamePrefix, options, }) => {
+    if (typeof bucketName !== 'string') {
+        throw new TypeError(`'bucketName' must be a string, but is ${JSON.stringify(bucketName)}`);
+    }
+    if (options.mustStartWithRemotion &&
+        !bucketName.startsWith(bucketNamePrefix)) {
+        throw new Error(`The bucketName parameter must start with ${bucketNamePrefix}.`);
+    }
+    if (!bucketName.match(/^(?=^.{3,63}$)(?!^(\d+\.)+\d+$)(^(([a-z0-9]|[a-z0-9][a-z0-9-]*[a-z0-9])\.)*([a-z0-9]|[a-z0-9][a-z0-9-]*[a-z0-9])$)/)) {
+        throw new Error(`The bucket ${bucketName} `);
+    }
+};
+exports.validateBucketName = validateBucketName;

package/dist/validate-download-behavior.d.ts

@@ -0,0 +1 @@
+export declare const validateDownloadBehavior: (downloadBehavior: unknown) => null | undefined;

package/dist/validate-download-behavior.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDownloadBehavior = void 0;
+const validateDownloadBehavior = (downloadBehavior) => {
+    if (downloadBehavior === null || downloadBehavior === undefined) {
+        return null;
+    }
+    if (typeof downloadBehavior !== 'object') {
+        throw new Error('downloadBehavior must be null or an object');
+    }
+    const behavior = downloadBehavior;
+    if (behavior.type !== 'download' && behavior.type !== 'play-in-browser') {
+        throw new Error('Download behavior must be either "download" or "play-in-browser"');
+    }
+    if (behavior.type === 'download') {
+        if (typeof behavior.fileName !== 'string' && behavior.fileName !== null) {
+            throw new Error('If "downloadBehavior.type" is "download", then fileName must be "null" or a string');
+        }
+    }
+};
+exports.validateDownloadBehavior = validateDownloadBehavior;

package/dist/validate-frames-per-function.d.ts

@@ -0,0 +1,4 @@
+export declare const validateFramesPerFunction: ({ framesPerFunction, durationInFrames, }: {
+    framesPerFunction: unknown;
+    durationInFrames: number;
+}) => void;

package/dist/validate-frames-per-function.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateFramesPerFunction = void 0;
+const constants_1 = require("./constants");
+const validateFramesPerFunction = ({ framesPerFunction, durationInFrames, }) => {
+    if (framesPerFunction === null) {
+        return;
+    }
+    if (framesPerFunction === undefined) {
+        return;
+    }
+    if (typeof framesPerFunction !== 'number') {
+        throw new TypeError(`'framesPerLambda' needs to be a number, passed ${JSON.stringify(framesPerFunction)}`);
+    }
+    if (!Number.isFinite(framesPerFunction)) {
+        throw new TypeError(`'framesPerLambda' needs to be finite, passed ${framesPerFunction}`);
+    }
+    if (Number.isNaN(framesPerFunction)) {
+        throw new TypeError(`'framesPerLambda' needs to be NaN, passed ${framesPerFunction}`);
+    }
+    if (framesPerFunction % 1 !== 0) {
+        throw new TypeError(`'framesPerLambda' needs to be an integer, passed ${framesPerFunction}`);
+    }
+    const effectiveMinimum = Math.min(constants_1.MINIMUM_FRAMES_PER_FUNCTIONS, durationInFrames);
+    if (framesPerFunction < effectiveMinimum) {
+        throw new TypeError(`The framesPerLambda needs to be at least ${effectiveMinimum}, but is ${framesPerFunction}`);
+    }
+};
+exports.validateFramesPerFunction = validateFramesPerFunction;

package/dist/validate-outname.d.ts

@@ -0,0 +1,9 @@
+import type { AudioCodec, Codec } from '@remotion/renderer';
+import type { OutNameInputWithoutCredentials } from './constants';
+export declare const validateOutname: ({ outName, codec, audioCodecSetting, separateAudioTo, bucketNamePrefix, }: {
+    outName: OutNameInputWithoutCredentials | undefined | null;
+    codec: Codec | null;
+    audioCodecSetting: AudioCodec | null;
+    separateAudioTo: string | null;
+    bucketNamePrefix: string;
+}) => void;

package/dist/validate-outname.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOutname = void 0;
+const pure_1 = require("@remotion/renderer/pure");
+const validate_bucket_name_1 = require("./validate-bucket-name");
+const validateS3Key = (s3Key) => {
+    if (typeof s3Key !== 'string') {
+        throw new TypeError('The S3 key must be a string. Passed an object of type ' + typeof s3Key);
+    }
+    // https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html
+    if (!s3Key.match(/^([0-9a-zA-Z-!_.*'()/:&$@=;+,?]+)/g)) {
+        throw new Error("The S3 Key must match the RegExp `/^([0-9a-zA-Z-!_.*'()/:&$@=;+,?]+)/g`. You passed: " +
+            s3Key +
+            '. Check for invalid characters.');
+    }
+};
+const validateOutname = ({ outName, codec, audioCodecSetting, separateAudioTo, bucketNamePrefix, }) => {
+    if (typeof outName === 'undefined' || outName === null) {
+        return;
+    }
+    if (typeof outName !== 'string') {
+        validateS3Key(outName.key);
+        (0, validate_bucket_name_1.validateBucketName)({
+            bucketName: outName.bucketName,
+            bucketNamePrefix,
+            options: {
+                mustStartWithRemotion: false,
+            },
+        });
+        return;
+    }
+    if (codec) {
+        pure_1.NoReactAPIs.validateOutputFilename({
+            codec,
+            audioCodecSetting,
+            extension: pure_1.NoReactAPIs.getExtensionOfFilename(outName),
+            preferLossless: false,
+            separateAudioTo,
+        });
+    }
+    validateS3Key(outName);
+};
+exports.validateOutname = validateOutname;

package/dist/validate-privacy.d.ts

@@ -0,0 +1,2 @@
+import type { Privacy } from './constants';
+export declare function validatePrivacy(privacy: unknown, allowPrivate: boolean): asserts privacy is Privacy;

package/dist/validate-privacy.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePrivacy = validatePrivacy;
+function validatePrivacy(privacy, allowPrivate) {
+    if (typeof privacy !== 'string') {
+        throw new TypeError('Privacy must be a string');
+    }
+    if (!allowPrivate && privacy === 'private') {
+        throw new TypeError('Privacy must be either "public" or "no-acl"');
+    }
+    if (privacy !== 'private' && privacy !== 'public' && privacy !== 'no-acl') {
+        throw new TypeError('Privacy must be either "private", "public" or "no-acl"');
+    }
+}

package/dist/validate-webhook.d.ts

@@ -0,0 +1,3 @@
+import type { WebhookOption } from './constants';
+export declare const MAX_WEBHOOK_CUSTOM_DATA_SIZE = 1024;
+export declare const validateWebhook: (webhook?: WebhookOption | null) => void;

package/dist/validate-webhook.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateWebhook = exports.MAX_WEBHOOK_CUSTOM_DATA_SIZE = void 0;
+exports.MAX_WEBHOOK_CUSTOM_DATA_SIZE = 1024;
+const validateWebhook = (webhook) => {
+    if (typeof webhook === 'undefined' || webhook === null) {
+        return;
+    }
+    if (webhook.customData) {
+        const size = JSON.stringify(webhook.customData).length;
+        if (size > exports.MAX_WEBHOOK_CUSTOM_DATA_SIZE) {
+            throw new Error(`Webhook "customData" must be less than ${exports.MAX_WEBHOOK_CUSTOM_DATA_SIZE} bytes. Current size: ${size} bytes.`);
+        }
+    }
+};
+exports.validateWebhook = validateWebhook;

package/dist/webhook-types.d.ts

@@ -0,0 +1,29 @@
+import type { AfterRenderCost } from './constants';
+import type { EnhancedErrorInfo } from './write-error-to-storage';
+type StaticWebhookPayload = {
+    renderId: string;
+    expectedBucketOwner: string;
+    bucketName: string;
+    customData: Record<string, unknown> | null;
+};
+export type WebhookErrorPayload = StaticWebhookPayload & {
+    type: 'error';
+    errors: {
+        message: string;
+        name: string;
+        stack: string;
+    }[];
+};
+export type WebhookSuccessPayload = StaticWebhookPayload & {
+    type: 'success';
+    lambdaErrors: EnhancedErrorInfo[];
+    outputUrl: string | undefined;
+    outputFile: string | undefined;
+    timeToFinish: number | undefined;
+    costs: AfterRenderCost;
+};
+export type WebhookTimeoutPayload = StaticWebhookPayload & {
+    type: 'timeout';
+};
+export type WebhookPayload = WebhookErrorPayload | WebhookSuccessPayload | WebhookTimeoutPayload;
+export {};

package/dist/webhook-types.js

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

package/dist/write-error-to-storage.d.ts

@@ -0,0 +1,24 @@
+import type { FileNameAndSize } from './get-files-in-folder';
+export type FunctionErrorInfo = {
+    type: 'renderer' | 'browser' | 'stitcher' | 'webhook' | 'artifact';
+    message: string;
+    name: string;
+    stack: string;
+    frame: number | null;
+    chunk: number | null;
+    isFatal: boolean;
+    attempt: number;
+    willRetry: boolean;
+    totalAttempts: number;
+    tmpDir: {
+        files: FileNameAndSize[];
+        total: number;
+    } | null;
+};
+export type EnhancedErrorInfo = FunctionErrorInfo & {
+    /**
+     * @deprecated Will always be an empty string.
+     */
+    s3Location: string;
+    explanation: string | null;
+};

package/dist/write-error-to-storage.js

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

package/eslint.config.mjs

@@ -0,0 +1,5 @@
+import {remotionFlatConfig} from '@remotion/eslint-config-internal';
+
+const config = remotionFlatConfig({react: false});
+
+export default config;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "repository": {
+    "url": "https://github.com/remotion-dev/remotion/tree/main/packages/serverless-client"
+  },
+  "name": "@remotion/serverless-client",
+  "version": "4.0.261",
+  "main": "dist",
+  "sideEffects": false,
+  "author": "Jonny Burger <jonny@remotion.dev>",
+  "contributors": [],
+  "license": "UNLICENSED",
+  "bugs": {
+    "url": "https://github.com/remotion-dev/remotion/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "eslint": "9.19.0",
+    "remotion": "4.0.261",
+    "@remotion/streaming": "4.0.261",
+    "@remotion/renderer": "4.0.261",
+    "@remotion/eslint-config-internal": "4.0.261"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "module": "./dist/esm/index.mjs",
+      "import": "./dist/esm/index.mjs"
+    }
+  },
+  "scripts": {
+    "lint": "eslint src",
+    "formatting": "prettier src --check",
+    "test": "bun test src",
+    "make": "tsc -d && bun --env-file=../.env.bundle bundle.ts"
+  }
+}

package/src/await.ts

@@ -0,0 +1 @@
+export type Await<T> = T extends PromiseLike<infer U> ? U : T;

package/src/calculate-chunk-times.ts

@@ -0,0 +1,42 @@
+import {max, min} from './min-max';
+import type {ParsedTiming} from './types';
+
+const getAbsoluteTime = (parsedTimings: ParsedTiming[]) => {
+	if (parsedTimings.length === 0) {
+		return 0;
+	}
+
+	const allEnds = parsedTimings.map((p) => p.rendered);
+	const allStarts = parsedTimings.map((p) => p.start);
+
+	const biggestEnd = max(allEnds);
+	const smallestStart = min(allStarts);
+
+	return Math.max(0, biggestEnd - smallestStart);
+};
+
+export const calculateChunkTimes = ({
+	type,
+	timings,
+}: {
+	type: 'combined-time-for-cost-calculation' | 'absolute-time';
+	timings: ParsedTiming[];
+}) => {
+	const parsedTimings = timings;
+
+	const absoluteTime = getAbsoluteTime(parsedTimings);
+
+	if (type === 'combined-time-for-cost-calculation') {
+		const totalEncodingTimings = parsedTimings
+			.map((p) => Math.max(0, p.rendered - p.start))
+			.reduce((a, b) => a + b, 0);
+
+		return totalEncodingTimings + absoluteTime;
+	}
+
+	if (type === 'absolute-time') {
+		return absoluteTime;
+	}
+
+	throw new Error('invalid time for calculate chunk times');
+};