@mevdragon/vidfarm-devcli 0.2.11 → 0.2.13

package/dist/src/services/remotion.js

@@ -7,12 +7,22 @@ import { config } from "../config.js";
 import { createId } from "../lib/ids.js";
 const REQUIRED_VIDEO_FPS = 30;
 const RENDER_MARKUP_MULTIPLIER = 1.2;
+const RENDER_ASSET_PREFLIGHT_TIMEOUT_MS = 10_000;
+const RENDER_ASSET_PREFLIGHT_MAX_FAILURES = 5;
+const ABSOLUTE_MAX_REMOTE_VIDEO_DURATION_SECONDS = 10 * 60;
+const ABSOLUTE_MAX_DIRECT_REMOTE_VIDEO_BYTES = 50 * 1024 * 1024;
+const REMOTE_VIDEO_DOWNLOAD_BUDGET_BYTES = 1250 * 1024 * 1024;
+const DEFAULT_PARALLEL_LAMBDA_TARGET = 6;
+const MAX_PARALLEL_LAMBDA_TARGET = 24;
+const SMALL_REMOTE_VIDEO_BYTES = 12 * 1024 * 1024;
+const MEDIUM_REMOTE_VIDEO_BYTES = 25 * 1024 * 1024;
 export class RemotionService {
     async render(input) {
         const fps = input.fps ?? REQUIRED_VIDEO_FPS;
         if (fps !== REQUIRED_VIDEO_FPS) {
             throw new Error(`Vidfarm renders must be ${REQUIRED_VIDEO_FPS}fps. Received ${fps}fps.`);
         }
+        const preflightAssets = await preflightRenderAssets(input.preflightUrls ?? collectPreflightUrls(input.inputProps), { requireRemoteHttpUrls: Boolean(input.preflightUrls) });
         const serveUrl = nonBlank(input.serveUrl) ??
             nonBlank(config.REMOTION_SERVE_URL) ??
             inferHostedServeUrl(input.compositionId);
@@ -58,69 +68,89 @@ export class RemotionService {
         const hostedServeUrl = serveUrl;
         const hostedFunctionName = nonBlank(config.REMOTION_FUNCTION_NAME);
         const hostedBucketName = nonBlank(config.REMOTION_BUCKET_NAME);
-        await this.assertCompositionFps({
+        const requestedFramesPerLambda = Number.isFinite(input.framesPerLambda)
+            ? Math.max(1, Math.floor(input.framesPerLambda))
+            : 40;
+        const composition = await this.resolveComposition({
             compositionId: input.compositionId,
-            serveUrl: hostedServeUrl,
+            source: hostedServeUrl,
             inputProps: input.inputProps,
+        });
+        this.assertExpectedFps({
+            compositionId: input.compositionId,
+            actualFps: composition.fps,
             expectedFps: fps
         });
-        return withRemotionCredentials(async () => {
-            const render = await renderMediaOnLambda({
+        const renderPolicy = planLambdaRenderPolicy({
+            inputProps: input.inputProps,
+            preflightAssets,
+            requestedFramesPerLambda,
+            durationInFrames: composition.durationInFrames,
+            fps
+        });
+        const framesPerLambda = renderPolicy.framesPerLambda;
+        const render = await renderMediaOnLambda({
+            region: config.REMOTION_REGION,
+            functionName: hostedFunctionName,
+            serveUrl: hostedServeUrl,
+            composition: input.compositionId,
+            inputProps: input.inputProps,
+            codec: "h264",
+            privacy: "public",
+            forceBucketName: hostedBucketName,
+            forceWidth: 1080,
+            forceHeight: 1920,
+            framesPerLambda,
+            crf: 18,
+            overwrite: true
+        });
+        const startedAt = Date.now();
+        for (;;) {
+            const progress = await getRenderProgress({
                 region: config.REMOTION_REGION,
                 functionName: hostedFunctionName,
-                serveUrl: hostedServeUrl,
-                composition: input.compositionId,
-                inputProps: input.inputProps,
-                codec: "h264",
-                privacy: "public",
-                forceBucketName: hostedBucketName,
-                forceWidth: 1080,
-                forceHeight: 1920,
-                framesPerLambda: 40,
-                crf: 18,
-                overwrite: true
+                bucketName: hostedBucketName,
+                renderId: render.renderId
             });
-            const startedAt = Date.now();
-            for (;;) {
-                const progress = await getRenderProgress({
-                    region: config.REMOTION_REGION,
-                    functionName: hostedFunctionName,
-                    bucketName: hostedBucketName,
-                    renderId: render.renderId
-                });
-                if (progress.done) {
-                    if (!progress.outputFile) {
-                        throw new Error("Cloud render completed without an output file.");
-                    }
-                    const estimatedCostUsd = progress.costs.accruedSoFar;
-                    const chargeUsd = roundUsd(estimatedCostUsd * RENDER_MARKUP_MULTIPLIER);
-                    return {
-                        renderId: render.renderId,
-                        outputUrl: progress.outputFile,
-                        metadata: {
-                            mode: "lambda",
-                            bucketName: render.bucketName,
-                            compositionId: input.compositionId,
-                            fps,
-                            serveUrl,
-                            estimatedCostUsd,
-                            chargeUsd,
-                            costDisplay: progress.costs.displayCost,
-                            costCurrency: progress.costs.currency,
-                            costDisclaimer: progress.costs.disclaimer,
-                            estimatedBillingDurationInMilliseconds: progress.estimatedBillingDurationInMilliseconds,
-                            lambdasInvoked: progress.lambdasInvoked,
-                            overallProgress: progress.overallProgress,
-                            renderSize: progress.renderSize
-                        }
-                    };
-                }
-                if (Date.now() - startedAt > 10 * 60 * 1000) {
-                    throw new Error("Timed out waiting for cloud render output.");
+            const fatalError = summarizeFatalRenderError(progress);
+            if (fatalError) {
+                throw new Error(`Cloud render ${render.renderId} failed: ${fatalError}`);
+            }
+            if (progress.done) {
+                if (!progress.outputFile) {
+                    throw new Error(`Cloud render ${render.renderId} completed without an output file.`);
                 }
-                await new Promise((resolve) => setTimeout(resolve, 5000));
+                const estimatedCostUsd = progress.costs.accruedSoFar;
+                const chargeUsd = roundUsd(estimatedCostUsd * RENDER_MARKUP_MULTIPLIER);
+                return {
+                    renderId: render.renderId,
+                    outputUrl: progress.outputFile,
+                    metadata: {
+                        mode: "lambda",
+                        bucketName: render.bucketName,
+                        compositionId: input.compositionId,
+                        fps,
+                        framesPerLambda,
+                        estimatedLambdaCount: renderPolicy.estimatedLambdaCount,
+                        mediaPolicy: renderPolicy,
+                        serveUrl,
+                        estimatedCostUsd,
+                        chargeUsd,
+                        costDisplay: progress.costs.displayCost,
+                        costCurrency: progress.costs.currency,
+                        costDisclaimer: progress.costs.disclaimer,
+                        estimatedBillingDurationInMilliseconds: progress.estimatedBillingDurationInMilliseconds,
+                        lambdasInvoked: progress.lambdasInvoked,
+                        overallProgress: progress.overallProgress,
+                        renderSize: progress.renderSize
+                    }
+                };
             }
-        });
+            if (Date.now() - startedAt > 10 * 60 * 1000) {
+                throw new Error(`Timed out waiting for cloud render ${render.renderId} output.`);
+            }
+            await new Promise((resolve) => setTimeout(resolve, 5000));
+        }
     }
     async renderLocal(input) {
         const renderId = createId("render");
@@ -191,18 +221,6 @@ export class RemotionService {
             }
         };
     }
-    async assertCompositionFps(input) {
-        const composition = await this.resolveComposition({
-            source: input.serveUrl,
-            compositionId: input.compositionId,
-            inputProps: input.inputProps
-        });
-        this.assertExpectedFps({
-            compositionId: input.compositionId,
-            actualFps: composition.fps,
-            expectedFps: input.expectedFps
-        });
-    }
     async resolveComposition(input) {
         const compositions = await getCompositions(input.source, {
             inputProps: input.inputProps
@@ -232,43 +250,427 @@ function getOrCreateBundle(entryPoint) {
     bundleCache.set(entryPoint, created);
     return created;
 }
-async function withRemotionCredentials(work) {
-    const previousAccessKeyId = process.env.AWS_ACCESS_KEY_ID;
-    const previousSecretAccessKey = process.env.AWS_SECRET_ACCESS_KEY;
-    const previousRegion = process.env.AWS_REGION;
-    if (config.REMOTION_AWS_ACCESS_KEY_ID) {
-        process.env.AWS_ACCESS_KEY_ID = config.REMOTION_AWS_ACCESS_KEY_ID;
+function roundUsd(value) {
+    return Number(value.toFixed(6));
+}
+function collectPreflightUrls(value, path = "inputProps") {
+    if (typeof value === "string") {
+        return isRemoteHttpUrl(value) ? [{ url: value, label: path }] : [];
     }
-    if (config.REMOTION_AWS_SECRET_ACCESS_KEY) {
-        process.env.AWS_SECRET_ACCESS_KEY = config.REMOTION_AWS_SECRET_ACCESS_KEY;
+    if (Array.isArray(value)) {
+        return value.flatMap((item, index) => collectPreflightUrls(item, `${path}[${index}]`));
     }
-    process.env.AWS_REGION = config.REMOTION_REGION;
-    try {
-        return await work();
+    if (!value || typeof value !== "object") {
+        return [];
     }
-    finally {
-        if (previousAccessKeyId === undefined) {
-            delete process.env.AWS_ACCESS_KEY_ID;
+    return Object.entries(value).flatMap(([key, item]) => (collectPreflightUrls(item, `${path}.${key}`)));
+}
+async function preflightRenderAssets(inputs, options = {}) {
+    const normalized = inputs.map((input, index) => (typeof input === "string" ? { url: input, label: `preflightUrls[${index}]` } : input));
+    if (options.requireRemoteHttpUrls) {
+        const invalid = normalized
+            .filter((input) => input.url.trim() && !isRemoteHttpUrl(input.url))
+            .map((input) => `${input.label || "asset"} must be an absolute http(s) URL: ${input.url}`);
+        if (invalid.length) {
+            throw new Error(`Render asset preflight failed: ${invalid.join("; ")}`);
         }
-        else {
-            process.env.AWS_ACCESS_KEY_ID = previousAccessKeyId;
+    }
+    const targets = dedupePreflightUrls(normalized.filter((input) => isRemoteHttpUrl(input.url)));
+    if (!targets.length) {
+        return [];
+    }
+    const failures = [];
+    const assets = [];
+    for (const target of targets) {
+        const result = await preflightOneRenderAsset(target);
+        assets.push(result.asset);
+        const failure = result.failure;
+        if (failure) {
+            failures.push(failure.message);
         }
-        if (previousSecretAccessKey === undefined) {
-            delete process.env.AWS_SECRET_ACCESS_KEY;
+    }
+    if (failures.length) {
+        const shown = failures.slice(0, RENDER_ASSET_PREFLIGHT_MAX_FAILURES);
+        const remaining = failures.length - shown.length;
+        throw new Error([
+            "Render asset preflight failed:",
+            ...shown.map((failure) => `- ${failure}`),
+            remaining > 0 ? `- ${remaining} more asset${remaining === 1 ? "" : "s"} failed preflight.` : null
+        ].filter(Boolean).join("\n"));
+    }
+    return assets;
+}
+function dedupePreflightUrls(inputs) {
+    const seen = new Set();
+    const deduped = [];
+    for (const input of inputs) {
+        const key = `${input.label || ""}\n${input.url}`;
+        if (seen.has(key)) {
+            continue;
         }
-        else {
-            process.env.AWS_SECRET_ACCESS_KEY = previousSecretAccessKey;
+        seen.add(key);
+        deduped.push(input);
+    }
+    return deduped;
+}
+async function preflightOneRenderAsset(input) {
+    const maxAttempts = isVidfarmTemplateMediaUrl(input.url) ? 4 : 1;
+    let latest = null;
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+        latest = await preflightOneRenderAssetOnce(input);
+        if (!latest.failure || !isRetryablePreflightFailure(latest.failure.status, input.url)) {
+            return latest;
         }
-        if (previousRegion === undefined) {
-            delete process.env.AWS_REGION;
+        if (attempt < maxAttempts - 1) {
+            await sleep(preflightRetryDelayMs(attempt));
         }
-        else {
-            process.env.AWS_REGION = previousRegion;
+    }
+    return latest ?? preflightOneRenderAssetOnce(input);
+}
+async function preflightOneRenderAssetOnce(input) {
+    const headFailure = await requestRenderAsset(input, "HEAD");
+    if (!headFailure.failure) {
+        return headFailure;
+    }
+    if (!headFailure.failure.allowGetFallback) {
+        return headFailure;
+    }
+    const getFailure = await requestRenderAsset(input, "GET");
+    return {
+        asset: mergeAssetMetadata(headFailure.asset, getFailure.asset),
+        failure: getFailure.failure
+    };
+}
+async function requestRenderAsset(input, method) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), RENDER_ASSET_PREFLIGHT_TIMEOUT_MS);
+    try {
+        const response = await fetch(input.url, {
+            method,
+            signal: controller.signal,
+            headers: method === "GET" ? { range: "bytes=0-0" } : undefined
+        });
+        const asset = extractPreflightAssetMetadata(input, response);
+        if (response.ok) {
+            return { asset, failure: null };
         }
+        return {
+            asset,
+            failure: {
+                allowGetFallback: method === "HEAD",
+                status: response.status,
+                message: `${input.label || "asset"} returned ${response.status} ${response.statusText || "HTTP error"} for ${formatUrlForError(input.url)}`
+            }
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error && error.name === "AbortError"
+            ? `timed out after ${RENDER_ASSET_PREFLIGHT_TIMEOUT_MS / 1000}s`
+            : error instanceof Error
+                ? error.message
+                : "unknown fetch error";
+        return {
+            asset: {
+                url: input.url,
+                label: input.label,
+                contentType: null,
+                contentLengthBytes: null
+            },
+            failure: {
+                allowGetFallback: false,
+                status: null,
+                message: `${input.label || "asset"} could not be reached: ${message} (${formatUrlForError(input.url)})`
+            }
+        };
+    }
+    finally {
+        clearTimeout(timeout);
     }
 }
-function roundUsd(value) {
-    return Number(value.toFixed(6));
+function isRetryablePreflightFailure(status, url) {
+    return isVidfarmTemplateMediaUrl(url) && (status === 403 || status === 404 || status === 429 || status == null || status >= 500);
+}
+function preflightRetryDelayMs(attempt) {
+    return Math.min(250 * (2 ** attempt), 2_000);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isVidfarmTemplateMediaUrl(value) {
+    try {
+        const url = new URL(value);
+        return url.pathname === "/template-media" && Boolean(url.searchParams.get("key"));
+    }
+    catch {
+        return false;
+    }
+}
+function isRemoteHttpUrl(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === "http:" || url.protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}
+function formatUrlForError(url) {
+    return url.length > 300 ? `${url.slice(0, 300)}...` : url;
+}
+function extractPreflightAssetMetadata(input, response) {
+    return {
+        url: input.url,
+        label: input.label,
+        contentType: normalizeHeaderValue(response.headers.get("content-type")),
+        contentLengthBytes: parseContentLength(response.headers)
+    };
+}
+function mergeAssetMetadata(primary, fallback) {
+    return {
+        ...primary,
+        contentType: primary.contentType ?? fallback.contentType,
+        contentLengthBytes: primary.contentLengthBytes ?? fallback.contentLengthBytes
+    };
+}
+function normalizeHeaderValue(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : null;
+}
+function parseContentLength(headers) {
+    const contentRange = headers.get("content-range");
+    if (contentRange) {
+        const match = /\/(\d+)\s*$/u.exec(contentRange);
+        if (match) {
+            return Number.parseInt(match[1], 10);
+        }
+    }
+    const contentLength = headers.get("content-length");
+    if (!contentLength) {
+        return null;
+    }
+    const parsed = Number.parseInt(contentLength, 10);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+}
+function planLambdaRenderPolicy(input) {
+    const durationSeconds = input.durationInFrames / input.fps;
+    const outputDimensions = inferOutputDimensions(input.inputProps);
+    const outputPixels = outputDimensions.width != null && outputDimensions.height != null
+        ? outputDimensions.width * outputDimensions.height
+        : null;
+    const remoteVideoAssets = collectRemoteVideoAssets(input.inputProps, input.preflightAssets);
+    const sourceVideo = remoteVideoAssets.primary;
+    const totalRemoteVideoBytes = remoteVideoAssets.totalBytes;
+    if (durationSeconds > ABSOLUTE_MAX_REMOTE_VIDEO_DURATION_SECONDS) {
+        throw new Error(`Render duration is ${formatDurationSeconds(durationSeconds)}, which exceeds the current Vidfarm remote-video platform limit of ${formatDurationSeconds(ABSOLUTE_MAX_REMOTE_VIDEO_DURATION_SECONDS)}. Trim the source video before rendering.`);
+    }
+    const sourceVideoBytes = sourceVideo?.contentLengthBytes ?? null;
+    if (sourceVideoBytes != null && sourceVideoBytes > ABSOLUTE_MAX_DIRECT_REMOTE_VIDEO_BYTES) {
+        throw new Error(`Remote video source is ${formatBytes(sourceVideoBytes)}, which exceeds the direct Vidfarm render limit of ${formatBytes(ABSOLUTE_MAX_DIRECT_REMOTE_VIDEO_BYTES)}. Run POST /api/v1/primitives/videos/normalize first, then pass the returned normalizedVideoUrl into the template render.`);
+    }
+    const maxSafeSegmentDurationSeconds = inferMaxSafeSegmentDurationSeconds({
+        sourceVideoBytes,
+        durationSeconds,
+        outputPixels
+    });
+    const requiredLambdasByDuration = Math.max(1, Math.ceil(durationSeconds / maxSafeSegmentDurationSeconds));
+    const maxLambdasByDownloadBudget = inferMaxLambdasByDownloadBudget(totalRemoteVideoBytes);
+    const preferredLambdasByRequestedFrames = Math.max(1, Math.ceil(input.durationInFrames / Math.max(1, input.requestedFramesPerLambda)));
+    if (requiredLambdasByDuration > maxLambdasByDownloadBudget) {
+        const sourceDescriptor = sourceVideoBytes == null
+            ? `${formatDurationSeconds(durationSeconds)} remote-video render`
+            : `${formatBytes(sourceVideoBytes)} over ${formatDurationSeconds(durationSeconds)}`;
+        throw new Error(`Remote-video render workload (${sourceDescriptor}) exceeds the current Vidfarm Lambda render envelope. The platform would need about ${requiredLambdasByDuration} chunks to keep per-chunk runtime safe, but remote media download policy caps this workload at ${maxLambdasByDownloadBudget} chunk${maxLambdasByDownloadBudget === 1 ? "" : "s"}. Trim, shorten, or pre-compress the source video before rendering.`);
+    }
+    const parallelLambdaTarget = inferParallelLambdaTarget({
+        sourceVideoBytes,
+        totalRemoteVideoBytes,
+        outputPixels,
+        preferredLambdasByRequestedFrames
+    });
+    const targetLambdas = Math.max(requiredLambdasByDuration, Math.min(preferredLambdasByRequestedFrames, maxLambdasByDownloadBudget, parallelLambdaTarget));
+    const strategy = targetLambdas <= 1 ? "single" : targetLambdas <= 3 ? "few" : "parallel";
+    const reason = describeLambdaPolicyReason({
+        targetLambdas,
+        preferredLambdasByRequestedFrames,
+        maxSafeSegmentDurationSeconds,
+        sourceVideoBytes,
+        totalRemoteVideoBytes,
+        durationSeconds
+    });
+    const adaptiveFramesPerLambda = Math.max(input.requestedFramesPerLambda, Math.ceil(input.durationInFrames / targetLambdas));
+    return {
+        framesPerLambda: Math.max(1, adaptiveFramesPerLambda),
+        estimatedLambdaCount: Math.max(1, Math.ceil(input.durationInFrames / Math.max(1, adaptiveFramesPerLambda))),
+        strategy,
+        reason,
+        sourceVideoUrl: sourceVideo?.url ?? null,
+        sourceVideoBytes,
+        totalRemoteVideoBytes,
+        remoteVideoCount: remoteVideoAssets.assets.length,
+        durationSeconds,
+        outputWidth: outputDimensions.width,
+        outputHeight: outputDimensions.height,
+        outputPixels
+    };
+}
+function collectRemoteVideoAssets(inputProps, assets) {
+    const prioritizedLabels = new Set(collectRemoteVideoLabels(inputProps));
+    const prioritized = assets.filter((asset) => prioritizedLabels.has(asset.label ?? ""));
+    const candidates = prioritized.length ? prioritized : assets;
+    const videoAssets = candidates.filter((asset) => isLikelyVideoAsset(asset));
+    const totalBytes = videoAssets.reduce((sum, asset) => (sum == null || asset.contentLengthBytes == null ? null : sum + asset.contentLengthBytes), 0);
+    return {
+        primary: videoAssets[0] ?? null,
+        assets: videoAssets,
+        totalBytes
+    };
+}
+function collectRemoteVideoLabels(value, path = "inputProps") {
+    if (typeof value === "string") {
+        return isRemoteVideoLabel(path) && isRemoteHttpUrl(value) ? [path] : [];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((item, index) => collectRemoteVideoLabels(item, `${path}[${index}]`));
+    }
+    if (!value || typeof value !== "object") {
+        return [];
+    }
+    return Object.entries(value).flatMap(([key, item]) => (collectRemoteVideoLabels(item, `${path}.${key}`)));
+}
+function isRemoteVideoLabel(label) {
+    return /(source_video_url|backgroundVideoUrl|background_video_url|video_url)$/u.test(label);
+}
+function isLikelyVideoAsset(asset) {
+    if (asset.contentType?.toLowerCase().startsWith("video/")) {
+        return true;
+    }
+    return /\.(mp4|mov|m4v|webm)(?:$|[?#])/iu.test(asset.url);
+}
+function inferMaxSafeSegmentDurationSeconds(input) {
+    let maxSafeDurationSeconds = inferBaselineMaxSafeSegmentDurationSeconds({
+        sourceVideoBytes: input.sourceVideoBytes,
+        durationSeconds: input.durationSeconds
+    });
+    const outputPixels = input.outputPixels;
+    if (outputPixels != null) {
+        if (outputPixels >= 1920 * 1080) {
+            maxSafeDurationSeconds = Math.min(maxSafeDurationSeconds, input.durationSeconds <= 30 ? 24 : 20);
+        }
+        else if (outputPixels >= 1280 * 720) {
+            maxSafeDurationSeconds = Math.min(maxSafeDurationSeconds, input.durationSeconds <= 30 ? 36 : 30);
+        }
+        else if (outputPixels >= 854 * 480) {
+            maxSafeDurationSeconds = Math.min(maxSafeDurationSeconds, 45);
+        }
+    }
+    return maxSafeDurationSeconds;
+}
+function inferBaselineMaxSafeSegmentDurationSeconds(input) {
+    const bytes = input.sourceVideoBytes;
+    if (bytes == null) {
+        return input.durationSeconds <= 30 ? 45 : 60;
+    }
+    if (bytes >= 400 * 1024 * 1024) {
+        return 30;
+    }
+    if (bytes >= 250 * 1024 * 1024) {
+        return input.durationSeconds <= 30 ? 30 : 25;
+    }
+    if (bytes >= 200 * 1024 * 1024) {
+        return input.durationSeconds <= 30 ? 35 : 25;
+    }
+    if (bytes >= 150 * 1024 * 1024) {
+        return input.durationSeconds <= 45 ? 45 : 30;
+    }
+    if (bytes >= 75 * 1024 * 1024) {
+        return 90;
+    }
+    return 120;
+}
+function inferOutputDimensions(inputProps) {
+    return {
+        width: parsePositiveInteger(inputProps.output_width),
+        height: parsePositiveInteger(inputProps.output_height)
+    };
+}
+function parsePositiveInteger(value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return null;
+    }
+    const normalized = Math.floor(value);
+    return normalized > 0 ? normalized : null;
+}
+function inferMaxLambdasByDownloadBudget(totalRemoteVideoBytes) {
+    if (totalRemoteVideoBytes == null || totalRemoteVideoBytes <= 0) {
+        return DEFAULT_PARALLEL_LAMBDA_TARGET;
+    }
+    return Math.max(1, Math.min(MAX_PARALLEL_LAMBDA_TARGET, Math.floor(REMOTE_VIDEO_DOWNLOAD_BUDGET_BYTES / totalRemoteVideoBytes)));
+}
+function inferParallelLambdaTarget(input) {
+    const requestedTarget = Math.max(1, input.preferredLambdasByRequestedFrames);
+    const totalRemoteBytes = input.totalRemoteVideoBytes ?? input.sourceVideoBytes;
+    const outputPixels = input.outputPixels ?? 0;
+    if (totalRemoteBytes != null && totalRemoteBytes <= SMALL_REMOTE_VIDEO_BYTES) {
+        return Math.min(MAX_PARALLEL_LAMBDA_TARGET, Math.max(DEFAULT_PARALLEL_LAMBDA_TARGET, requestedTarget));
+    }
+    if (totalRemoteBytes != null
+        && totalRemoteBytes <= MEDIUM_REMOTE_VIDEO_BYTES
+        && outputPixels <= 1080 * 1920) {
+        return Math.min(18, Math.max(DEFAULT_PARALLEL_LAMBDA_TARGET, requestedTarget));
+    }
+    if (totalRemoteBytes != null
+        && totalRemoteBytes <= ABSOLUTE_MAX_DIRECT_REMOTE_VIDEO_BYTES
+        && outputPixels <= 1080 * 1920) {
+        return Math.min(12, Math.max(DEFAULT_PARALLEL_LAMBDA_TARGET, requestedTarget));
+    }
+    return DEFAULT_PARALLEL_LAMBDA_TARGET;
+}
+function describeLambdaPolicyReason(input) {
+    const sourcePart = input.sourceVideoBytes == null ? "unknown source size" : `${formatBytes(input.sourceVideoBytes)} source`;
+    const totalPart = input.totalRemoteVideoBytes == null ? "unknown total remote bytes" : `${formatBytes(input.totalRemoteVideoBytes)} total remote video`;
+    return `${sourcePart}, ${formatDurationSeconds(input.durationSeconds)} duration, requested ~${input.preferredLambdasByRequestedFrames} chunk${input.preferredLambdasByRequestedFrames === 1 ? "" : "s"}, target <=${formatDurationSeconds(input.maxSafeSegmentDurationSeconds)} per chunk, ${totalPart}`;
+}
+function formatBytes(bytes) {
+    if (bytes >= 1024 * 1024) {
+        return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+    }
+    if (bytes >= 1024) {
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    }
+    return `${bytes}B`;
+}
+function formatDurationSeconds(seconds) {
+    return `${seconds.toFixed(seconds >= 10 ? 0 : 1)}s`;
+}
+function summarizeFatalRenderError(progress) {
+    if (!progress || typeof progress !== "object") {
+        return null;
+    }
+    const maybeProgress = progress;
+    if (maybeProgress.fatalErrorEncountered !== true) {
+        return null;
+    }
+    const errors = Array.isArray(maybeProgress.errors) ? maybeProgress.errors : [];
+    const messages = errors
+        .map((error) => summarizeRenderError(error))
+        .filter(Boolean)
+        .slice(0, 3);
+    return messages.length ? messages.join(" | ") : "Remotion reported a fatal render error.";
+}
+function summarizeRenderError(error) {
+    if (!error || typeof error !== "object") {
+        return typeof error === "string" ? error : null;
+    }
+    const record = error;
+    const message = firstString(record.message, record.name, record.stack, record.explanation)
+        ?? firstString(record.error?.message);
+    const chunk = typeof record.chunk === "number" || typeof record.chunk === "string"
+        ? `chunk ${record.chunk}: `
+        : "";
+    return message ? `${chunk}${message}` : JSON.stringify(record).slice(0, 500);
+}
+function firstString(...values) {
+    return values.find((value) => typeof value === "string" && value.trim().length > 0)?.trim() ?? null;
 }
 function nonBlank(value) {
     const trimmed = value?.trim();
@@ -283,3 +685,4 @@ function inferHostedServeUrl(compositionId) {
     const encodedSiteName = siteName.split("/").map(encodeURIComponent).join("/");
     return `https://${bucketName}.s3.${config.REMOTION_REGION}.amazonaws.com/sites/${encodedSiteName}/index.html`;
 }
+//# sourceMappingURL=remotion.js.map