@mevdragon/vidfarm-devcli 0.2.14 → 0.3.1

package/dist/src/services/remotion.js

@@ -1,688 +0,0 @@
-import { mkdirSync } from "node:fs";
-import path from "node:path";
-import { bundle } from "@remotion/bundler";
-import { getRenderProgress, renderMediaOnLambda } from "@remotion/lambda";
-import { getCompositions, renderMedia, renderStill } from "@remotion/renderer";
-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);
-        const hasHostedLambdaConfig = Boolean(nonBlank(config.REMOTION_FUNCTION_NAME) && serveUrl && nonBlank(config.REMOTION_BUCKET_NAME));
-        if (config.isProduction && config.REMOTION_MODE !== "lambda") {
-            throw new Error("Production video rendering must use lambda mode.");
-        }
-        if (input.entryPoint
-            && (config.REMOTION_MODE === "local"
-                || (config.REMOTION_MODE === "auto" && !hasHostedLambdaConfig)
-                || (!config.isProduction && config.REMOTION_MODE === "auto"))) {
-            if (config.isProduction) {
-                throw new Error("Production video rendering cannot fall back to local mode.");
-            }
-            return this.renderLocal({
-                compositionId: input.compositionId,
-                entryPoint: input.entryPoint,
-                outputKey: input.outputKey,
-                fps,
-                inputProps: input.inputProps
-            });
-        }
-        if (config.REMOTION_MODE === "mock") {
-            if (config.isProduction) {
-                throw new Error("Production video rendering cannot use mock mode.");
-            }
-            return {
-                renderId: createId("render"),
-                outputUrl: null,
-                metadata: {
-                    mode: "mock",
-                    compositionId: input.compositionId,
-                    fps,
-                    inputProps: input.inputProps
-                }
-            };
-        }
-        if (!hasHostedLambdaConfig) {
-            throw new Error(config.isProduction
-                ? "Cloud render is not configured."
-                : "Cloud render is not configured. Set REMOTION_FUNCTION_NAME, REMOTION_SERVE_URL, and REMOTION_BUCKET_NAME, or provide a local entryPoint.");
-        }
-        const hostedServeUrl = serveUrl;
-        const hostedFunctionName = nonBlank(config.REMOTION_FUNCTION_NAME);
-        const hostedBucketName = nonBlank(config.REMOTION_BUCKET_NAME);
-        const requestedFramesPerLambda = Number.isFinite(input.framesPerLambda)
-            ? Math.max(1, Math.floor(input.framesPerLambda))
-            : 40;
-        const composition = await this.resolveComposition({
-            compositionId: input.compositionId,
-            source: hostedServeUrl,
-            inputProps: input.inputProps,
-        });
-        this.assertExpectedFps({
-            compositionId: input.compositionId,
-            actualFps: composition.fps,
-            expectedFps: fps
-        });
-        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,
-                bucketName: hostedBucketName,
-                renderId: render.renderId
-            });
-            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.`);
-                }
-                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");
-        const bundled = await getOrCreateBundle(input.entryPoint);
-        const composition = await this.resolveComposition({
-            source: bundled,
-            compositionId: input.compositionId,
-            inputProps: input.inputProps
-        });
-        this.assertExpectedFps({
-            compositionId: input.compositionId,
-            actualFps: composition.fps,
-            expectedFps: input.fps
-        });
-        const outputKey = input.outputKey ?? `renders/${renderId}.mp4`;
-        const outputLocation = path.join(config.VIDFARM_DATA_DIR, "storage", outputKey);
-        mkdirSync(path.dirname(outputLocation), { recursive: true });
-        await renderMedia({
-            serveUrl: bundled,
-            composition,
-            codec: "h264",
-            inputProps: input.inputProps,
-            outputLocation,
-            overwrite: true
-        });
-        return {
-            renderId,
-            outputUrl: `${config.PUBLIC_BASE_URL}/storage/${encodeURIComponent(outputKey)}`,
-            metadata: {
-                mode: "local",
-                compositionId: input.compositionId,
-                entryPoint: input.entryPoint,
-                fps: input.fps,
-                outputKey
-            }
-        };
-    }
-    async renderStill(input) {
-        const renderId = createId("render");
-        const bundled = await getOrCreateBundle(input.entryPoint);
-        const composition = await this.resolveComposition({
-            source: bundled,
-            compositionId: input.compositionId,
-            inputProps: input.inputProps
-        });
-        const format = input.imageFormat ?? "png";
-        const extension = format === "jpeg" ? "jpg" : format;
-        const outputKey = input.outputKey ?? `renders/${renderId}.${extension}`;
-        const outputLocation = path.join(config.VIDFARM_DATA_DIR, "storage", outputKey);
-        mkdirSync(path.dirname(outputLocation), { recursive: true });
-        await renderStill({
-            serveUrl: bundled,
-            composition,
-            inputProps: input.inputProps,
-            output: outputLocation,
-            imageFormat: format,
-            overwrite: true
-        });
-        return {
-            renderId,
-            outputUrl: `${config.PUBLIC_BASE_URL}/storage/${encodeURIComponent(outputKey)}`,
-            metadata: {
-                mode: "local_still",
-                compositionId: input.compositionId,
-                entryPoint: input.entryPoint,
-                outputKey,
-                imageFormat: format
-            }
-        };
-    }
-    async resolveComposition(input) {
-        const compositions = await getCompositions(input.source, {
-            inputProps: input.inputProps
-        });
-        const composition = compositions.find((item) => item.id === input.compositionId);
-        if (!composition) {
-            throw new Error(`Composition ${input.compositionId} not found in ${input.source}`);
-        }
-        return composition;
-    }
-    assertExpectedFps(input) {
-        if (input.actualFps !== input.expectedFps) {
-            throw new Error(`Composition ${input.compositionId} is ${input.actualFps}fps, but Vidfarm requires ${input.expectedFps}fps output.`);
-        }
-    }
-}
-const bundleCache = new Map();
-function getOrCreateBundle(entryPoint) {
-    const existing = bundleCache.get(entryPoint);
-    if (existing) {
-        return existing;
-    }
-    const created = bundle({
-        entryPoint,
-        onProgress: () => undefined
-    });
-    bundleCache.set(entryPoint, created);
-    return created;
-}
-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 (Array.isArray(value)) {
-        return value.flatMap((item, index) => collectPreflightUrls(item, `${path}[${index}]`));
-    }
-    if (!value || typeof value !== "object") {
-        return [];
-    }
-    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("; ")}`);
-        }
-    }
-    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 (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;
-        }
-        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 (attempt < maxAttempts - 1) {
-            await sleep(preflightRetryDelayMs(attempt));
-        }
-    }
-    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 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();
-    return trimmed ? trimmed : undefined;
-}
-function inferHostedServeUrl(compositionId) {
-    const bucketName = nonBlank(config.REMOTION_BUCKET_NAME);
-    if (!bucketName) {
-        return undefined;
-    }
-    const siteName = nonBlank(config.REMOTION_SITE_NAME) ?? 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