@run-cloud/sdk 0.20.0 → 0.22.0

package/dist/remotion.js

@@ -0,0 +1,1050 @@
+import { Buffer } from "node:buffer";
+import { createHash } from "node:crypto";
+export const REMOTION_IMAGE_REGISTRY = "us-docker.pkg.dev/remotion-dev/production/render";
+const REMOTION_DIR = "/tmp/runcloud-remotion";
+const RUNNER_PATH = `${REMOTION_DIR}/runner.mjs`;
+const PLANNER_PATH = `${REMOTION_DIR}/planner.mjs`;
+const PLAN_PATH = `${REMOTION_DIR}/plan.json`;
+const MANIFEST_PATH = `${REMOTION_DIR}/manifest.json`;
+const PROGRESS_PATH = `${REMOTION_DIR}/progress.json`;
+const STARTED_PATH = `${REMOTION_DIR}/started`;
+const LOG_PATH = `${REMOTION_DIR}/render.log`;
+export class RemotionClient {
+    sandboxes;
+    constructor(sandboxes) {
+        this.sandboxes = sandboxes;
+    }
+    /**
+     * Start a detached render. The caller owns every returned sandbox until it
+     * calls cancel(), or until the finite sandbox timeouts expire.
+     */
+    async start(options) {
+        return this.startWithSignal(options);
+    }
+    async startWithSignal(options, signal) {
+        const job = renderJob(options);
+        const image = resolveRemotionImage(options);
+        throwIfAborted(signal);
+        if (options.distributed) {
+            return this.startDistributed(options, job, image, signal);
+        }
+        const created = [];
+        try {
+            const sandbox = await this.createSandbox(options, image);
+            created.push(sandbox);
+            throwIfAborted(signal);
+            const handle = handleForSandboxes([sandbox.id]);
+            await prepareSandbox(this.sandboxes, sandbox, options.startupTimeoutSeconds ?? 15 * 60, signal);
+            await startGuestJob(this.sandboxes, sandbox.id, job, REMOTION_RUNNER_SOURCE, signal);
+            return handle;
+        }
+        catch (error) {
+            return destroyAfterFailure(this.sandboxes, created.map((sandbox) => sandbox.id), error, "Remotion render setup");
+        }
+    }
+    createSandbox(options, image, index) {
+        const suffix = index === undefined ? undefined : `chunk-${index}`;
+        return this.sandboxes.create({
+            image,
+            cpu: options.cpu ?? 8,
+            memory: options.memory ?? 16_384,
+            disk: options.disk ?? 40,
+            idlePauseSeconds: 0,
+            timeoutSeconds: options.timeoutSeconds ?? 3_600,
+            region: options.region,
+            name: options.name && suffix ? `${options.name}-${suffix}` : options.name,
+            idempotencyKey: options.idempotencyKey && suffix
+                ? `${options.idempotencyKey}:${suffix}`
+                : options.idempotencyKey,
+        });
+    }
+    async startDistributed(options, baseJob, image, signal) {
+        const distributed = validateDistributedOptions(options.distributed);
+        const created = [];
+        try {
+            throwIfAborted(signal);
+            const coordinator = await this.createSandbox(options, image, 0);
+            created.push(coordinator);
+            throwIfAborted(signal);
+            await prepareSandbox(this.sandboxes, coordinator, options.startupTimeoutSeconds ?? 15 * 60, signal);
+            const plan = await planComposition(this.sandboxes, coordinator.id, baseJob, signal);
+            const chunkRanges = distributeFrames(plan.durationInFrames, distributed);
+            for (let index = 1; index < chunkRanges.length; index += 1) {
+                throwIfAborted(signal);
+                created.push(await this.createSandbox(options, image, index));
+                throwIfAborted(signal);
+            }
+            await Promise.all(created.slice(1).map((sandbox) => prepareSandbox(this.sandboxes, sandbox, options.startupTimeoutSeconds ?? 15 * 60, signal)));
+            const handle = handleForSandboxes(created.map((sandbox) => sandbox.id));
+            const chunkOutputs = await Promise.all(chunkRanges.map(async (frameRange, index) => {
+                throwIfAborted(signal);
+                const output = await distributed.createChunkOutput({
+                    renderId: handle.renderId,
+                    index,
+                    frameRange,
+                    sandboxCount: chunkRanges.length,
+                });
+                throwIfAborted(signal);
+                validateChunkOutput(output, baseJob.codec, baseJob.renderOptions.muted === true, index);
+                return output;
+            }));
+            throwIfAborted(signal);
+            await this.sandboxes.writeFile(coordinator.id, MANIFEST_PATH, new TextEncoder().encode(JSON.stringify({ sandboxIds: handle.sandboxIds })), { mode: 0o600 });
+            throwIfAborted(signal);
+            const framesPerChunk = chunkRanges[0][1] - chunkRanges[0][0] + 1;
+            const chunkJobs = chunkRanges.map((frameRange, index) => {
+                const media = chunkMediaPlan(baseJob.codec, baseJob.renderOptions.audioCodec, baseJob.renderOptions.muted === true, framesPerChunk);
+                return {
+                    ...baseJob,
+                    mode: "distributed",
+                    coordinator: index === 0,
+                    sandboxCount: chunkRanges.length,
+                    downloadTimeoutSeconds: distributed.downloadTimeoutSeconds ?? options.timeoutSeconds ?? 3_600,
+                    chunk: {
+                        index,
+                        frameRange,
+                        framesPerChunk,
+                        compositionDurationInFrames: plan.durationInFrames,
+                        fps: plan.fps,
+                        videoFile: media.hasVideo ? `${REMOTION_DIR}/chunk-${index}.${extensionForChunkCodec(media.codec)}` : null,
+                        audioFile: media.hasAudio ? `${REMOTION_DIR}/chunk-${index}.${extensionForAudioCodec(media.audioCodec)}` : null,
+                        codec: media.codec,
+                        audioCodec: media.audioCodec,
+                        forSeamlessAacConcatenation: media.forSeamlessAacConcatenation,
+                        output: chunkOutputs[index],
+                    },
+                    ...(index === 0 ? {
+                        chunks: chunkRanges.map((_range, chunkIndex) => ({
+                            index: chunkIndex,
+                            videoFile: media.hasVideo
+                                ? `${REMOTION_DIR}/chunk-${chunkIndex}.${extensionForChunkCodec(media.codec)}`
+                                : null,
+                            audioFile: media.hasAudio
+                                ? `${REMOTION_DIR}/chunk-${chunkIndex}.${extensionForAudioCodec(media.audioCodec)}`
+                                : null,
+                            output: chunkOutputs[chunkIndex],
+                        })),
+                    } : {}),
+                };
+            });
+            await Promise.all(created.map((sandbox, index) => writeGuestJob(this.sandboxes, sandbox.id, chunkJobs[index], REMOTION_DISTRIBUTED_RUNNER_SOURCE, signal)));
+            await Promise.all(created.slice(1).map((sandbox, offset) => launchGuestJob(this.sandboxes, sandbox.id, chunkJobs[offset + 1], signal)));
+            await launchGuestJob(this.sandboxes, coordinator.id, chunkJobs[0], signal);
+            return handle;
+        }
+        catch (error) {
+            return destroyAfterFailure(this.sandboxes, created.map((sandbox) => sandbox.id), error, "Distributed Remotion render setup");
+        }
+    }
+    async getProgress(render) {
+        const handle = await resolveRenderHandle(this.sandboxes, render);
+        let bytes;
+        try {
+            bytes = await this.sandboxes.readFile(handle.sandboxId, PROGRESS_PATH);
+        }
+        catch (error) {
+            const sandbox = await this.sandboxes.get(handle.sandboxId);
+            if (["destroyed", "destroying", "stopped", "interrupted"].includes(sandbox.state)) {
+                return {
+                    ...handle,
+                    stage: "expired",
+                    progress: 0,
+                    done: true,
+                    outputFile: null,
+                    outputSizeInBytes: null,
+                    errors: [{ message: `render sandbox is ${sandbox.state}` }],
+                    fatalErrorEncountered: true,
+                    updatedAt: new Date().toISOString(),
+                };
+            }
+            // The runner creates progress.json immediately. Before that, a live
+            // sandbox is simply still starting; transport errors from get() are not
+            // swallowed and remain visible to the caller.
+            return startingProgress(handle);
+        }
+        const progress = progressPayload(handle, JSON.parse(new TextDecoder().decode(bytes)));
+        if (progress.done || handle.sandboxIds.length === 1)
+            return progress;
+        const workerErrors = (await Promise.all(handle.sandboxIds.slice(1).map(async (sandboxId) => {
+            try {
+                const workerBytes = await this.sandboxes.readFile(sandboxId, PROGRESS_PATH);
+                const worker = progressPayload(handleForSandboxes([sandboxId]), JSON.parse(new TextDecoder().decode(workerBytes)));
+                return worker.fatalErrorEncountered ? worker.errors : [];
+            }
+            catch {
+                return [];
+            }
+        }))).flat();
+        if (workerErrors.length === 0)
+            return progress;
+        return {
+            ...progress,
+            stage: "error",
+            done: true,
+            errors: workerErrors,
+            fatalErrorEncountered: true,
+            updatedAt: new Date().toISOString(),
+        };
+    }
+    /** Wait for a render and always stop billing when it reaches a terminal state. */
+    async render(options, waitOptions = {}) {
+        const handle = await this.startWithSignal(options, waitOptions.signal);
+        let renderError;
+        try {
+            for (;;) {
+                if (waitOptions.signal?.aborted)
+                    throw waitOptions.signal.reason ?? new Error("render aborted");
+                const progress = await this.getProgress(handle);
+                if (progress.done) {
+                    if (progress.fatalErrorEncountered) {
+                        throw new RemotionRenderFailedError(progress);
+                    }
+                    return progress;
+                }
+                await abortableDelay(waitOptions.pollIntervalMs ?? 1_000, waitOptions.signal);
+            }
+        }
+        catch (error) {
+            renderError = error;
+            throw error;
+        }
+        finally {
+            try {
+                await this.cancel(handle);
+            }
+            catch (cleanupError) {
+                if (renderError) {
+                    throw new AggregateError([renderError, cleanupError], `Remotion render failed and sandbox ${handle.sandboxId} could not be destroyed`);
+                }
+                throw cleanupError;
+            }
+        }
+    }
+    async cancel(render) {
+        const handle = await resolveRenderHandle(this.sandboxes, render);
+        const results = await Promise.allSettled([...new Set(handle.sandboxIds)].map((sandboxId) => this.sandboxes.destroy(sandboxId)));
+        const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+        if (failures.length > 0) {
+            throw new AggregateError(failures, `failed to destroy ${failures.length} Remotion sandbox(es)`);
+        }
+    }
+}
+export function remotionImageForVersion(version) {
+    if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version)) {
+        throw new TypeError("remotionVersion must be an exact semantic version");
+    }
+    return `${REMOTION_IMAGE_REGISTRY}:${version}`;
+}
+function resolveRemotionImage(options) {
+    if (options.image)
+        return options.image;
+    if (!options.remotionVersion) {
+        throw new TypeError("remotionVersion is required unless a custom image is supplied");
+    }
+    return remotionImageForVersion(options.remotionVersion);
+}
+async function prepareSandbox(sandboxes, sandbox, startupTimeoutSeconds, signal) {
+    await waitForSandboxReady(sandboxes, sandbox, startupTimeoutSeconds, signal);
+    throwIfAborted(signal);
+    const prepare = await sandboxes.exec(sandbox.id, ["/bin/mkdir", "-p", REMOTION_DIR], { signal });
+    throwIfAborted(signal);
+    if (prepare.exitCode !== 0) {
+        throw new Error(`failed to prepare Remotion render: ${prepare.stderr || `exit ${prepare.exitCode}`}`);
+    }
+}
+async function writeGuestJob(sandboxes, sandboxId, job, runnerSource, signal) {
+    throwIfAborted(signal);
+    const encodedJob = new TextEncoder().encode(JSON.stringify(job));
+    const jobHash = createHash("sha256").update(encodedJob).digest("hex");
+    const jobPath = `${REMOTION_DIR}/job-${jobHash}.json`;
+    await sandboxes.writeFile(sandboxId, RUNNER_PATH, new TextEncoder().encode(runnerSource), { mode: 0o700 });
+    throwIfAborted(signal);
+    await sandboxes.writeFile(sandboxId, jobPath, encodedJob, { mode: 0o600 });
+    throwIfAborted(signal);
+    return jobPath;
+}
+async function launchGuestJob(sandboxes, sandboxId, job, signal) {
+    throwIfAborted(signal);
+    const encodedJob = new TextEncoder().encode(JSON.stringify(job));
+    const jobHash = createHash("sha256").update(encodedJob).digest("hex");
+    const jobPath = `${REMOTION_DIR}/job-${jobHash}.json`;
+    const start = await sandboxes.exec(sandboxId, [
+        "/bin/sh",
+        "-c",
+        `mkdir -p ${REMOTION_DIR} && if (set -C; : > ${STARTED_PATH}) 2>/dev/null; then nohup node ${RUNNER_PATH} ${jobPath} >${LOG_PATH} 2>&1 </dev/null & fi`,
+    ], { signal });
+    throwIfAborted(signal);
+    if (start.exitCode !== 0) {
+        throw new Error(`failed to start Remotion render: ${start.stderr || `exit ${start.exitCode}`}`);
+    }
+}
+async function startGuestJob(sandboxes, sandboxId, job, runnerSource, signal) {
+    await writeGuestJob(sandboxes, sandboxId, job, runnerSource, signal);
+    await launchGuestJob(sandboxes, sandboxId, job, signal);
+}
+async function planComposition(sandboxes, sandboxId, job, signal) {
+    throwIfAborted(signal);
+    await sandboxes.writeFile(sandboxId, PLANNER_PATH, new TextEncoder().encode(REMOTION_PLANNER_SOURCE), { mode: 0o700 });
+    throwIfAborted(signal);
+    const planJob = new TextEncoder().encode(JSON.stringify({
+        serveUrl: job.serveUrl,
+        composition: job.composition,
+        inputProps: job.inputProps,
+        envVariables: job.renderOptions.envVariables,
+        planPath: PLAN_PATH,
+    }));
+    await sandboxes.writeFile(sandboxId, `${REMOTION_DIR}/plan-job.json`, planJob, { mode: 0o600 });
+    throwIfAborted(signal);
+    const result = await sandboxes.exec(sandboxId, ["node", PLANNER_PATH, `${REMOTION_DIR}/plan-job.json`], { signal });
+    if (result.exitCode !== 0) {
+        throw new Error(`failed to plan Remotion render: ${result.stderr || `exit ${result.exitCode}`}`);
+    }
+    throwIfAborted(signal);
+    const raw = JSON.parse(new TextDecoder().decode(await sandboxes.readFile(sandboxId, PLAN_PATH)));
+    throwIfAborted(signal);
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new Error("Remotion composition plan is invalid");
+    }
+    const plan = raw;
+    for (const key of ["durationInFrames", "fps", "width", "height"]) {
+        if (typeof plan[key] !== "number" || !Number.isFinite(plan[key]) || plan[key] <= 0) {
+            throw new Error(`Remotion composition plan has invalid ${key}`);
+        }
+    }
+    return plan;
+}
+function validateDistributedOptions(options) {
+    if (typeof options.createChunkOutput !== "function") {
+        throw new TypeError("distributed.createChunkOutput must be a function");
+    }
+    if (options.sandboxCount !== undefined && options.framesPerSandbox !== undefined) {
+        throw new TypeError("set either distributed.sandboxCount or framesPerSandbox, not both");
+    }
+    if (options.sandboxCount === undefined && options.framesPerSandbox === undefined) {
+        throw new TypeError("distributed.sandboxCount or framesPerSandbox is required");
+    }
+    if (options.sandboxCount !== undefined) {
+        assertIntegerInRange(options.sandboxCount, 2, 200, "distributed.sandboxCount");
+    }
+    if (options.framesPerSandbox !== undefined) {
+        assertIntegerInRange(options.framesPerSandbox, 1, Number.MAX_SAFE_INTEGER, "distributed.framesPerSandbox");
+    }
+    if (options.downloadTimeoutSeconds !== undefined &&
+        (!Number.isFinite(options.downloadTimeoutSeconds) || options.downloadTimeoutSeconds <= 0)) {
+        throw new RangeError("distributed.downloadTimeoutSeconds must be a positive number");
+    }
+    return options;
+}
+function assertIntegerInRange(value, minimum, maximum, name) {
+    if (!Number.isInteger(value) || value < minimum || value > maximum) {
+        throw new RangeError(`${name} must be an integer between ${minimum} and ${maximum}`);
+    }
+}
+export function distributeFrames(durationInFrames, options) {
+    assertIntegerInRange(durationInFrames, 1, Number.MAX_SAFE_INTEGER, "durationInFrames");
+    let framesPerChunk;
+    if (options.sandboxCount !== undefined) {
+        assertIntegerInRange(options.sandboxCount, 2, 200, "distributed.sandboxCount");
+        framesPerChunk = Math.ceil(durationInFrames / options.sandboxCount);
+    }
+    else {
+        assertIntegerInRange(options.framesPerSandbox, 1, Number.MAX_SAFE_INTEGER, "distributed.framesPerSandbox");
+        framesPerChunk = options.framesPerSandbox;
+    }
+    const sandboxCount = Math.ceil(durationInFrames / framesPerChunk);
+    if (sandboxCount > 200) {
+        throw new RangeError(`distributed render would create ${sandboxCount} sandboxes; maximum is 200`);
+    }
+    if (sandboxCount < 2) {
+        throw new RangeError("distributed render needs at least 2 sandboxes for this composition");
+    }
+    return Array.from({ length: sandboxCount }, (_, index) => [
+        index * framesPerChunk,
+        Math.min(durationInFrames - 1, (index + 1) * framesPerChunk - 1),
+    ]);
+}
+function validateChunkOutput(output, codec, muted, index) {
+    const hasVideo = !isAudioCodec(codec);
+    const hasAudio = hasAudioOutput(codec, muted);
+    if (hasVideo)
+        validateChunkLocation(output?.video, `distributed chunk ${index} video`);
+    if (hasAudio)
+        validateChunkLocation(output?.audio, `distributed chunk ${index} audio`);
+}
+function validateChunkLocation(output, name) {
+    assertHttpUrl(output?.uploadUrl, `${name}.uploadUrl`);
+    assertHttpUrl(output?.downloadUrl, `${name}.downloadUrl`);
+    validateHeaders(output?.headers ?? {});
+    validateHeaders(output?.downloadHeaders ?? {});
+}
+function isAudioCodec(codec) {
+    return codec === "mp3" || codec === "aac" || codec === "wav";
+}
+function hasAudioOutput(codec, muted) {
+    return isAudioCodec(codec) || (!muted && codec !== "gif");
+}
+function chunkMediaPlan(codec, requestedAudioCodec, muted, framesPerChunk) {
+    const hasVideo = !isAudioCodec(codec);
+    const hasAudio = hasAudioOutput(codec, muted);
+    if (!hasVideo) {
+        return {
+            hasVideo: false,
+            hasAudio: true,
+            codec,
+            audioCodec: codec,
+            forSeamlessAacConcatenation: codec === "aac",
+        };
+    }
+    const finalAudioCodec = requestedAudioCodec ?? defaultAudioCodec(codec);
+    const usePcmChunks = hasAudio && framesPerChunk >= 4 && finalAudioCodec !== "aac";
+    return {
+        hasVideo,
+        hasAudio,
+        codec: codec === "h264" || codec === "gif" ? "h264-ts" : codec,
+        audioCodec: hasAudio ? (usePcmChunks ? "pcm-16" : finalAudioCodec) : null,
+        forSeamlessAacConcatenation: hasAudio && !usePcmChunks,
+    };
+}
+function defaultAudioCodec(codec) {
+    if (codec === "vp8" || codec === "vp9")
+        return "opus";
+    if (codec === "prores")
+        return "pcm-16";
+    return "aac";
+}
+function extensionForChunkCodec(codec) {
+    if (codec === "h264-ts")
+        return "ts";
+    if (codec === "vp8" || codec === "vp9")
+        return "webm";
+    if (codec === "prores")
+        return "mov";
+    return "mp4";
+}
+function extensionForAudioCodec(codec) {
+    if (codec === "pcm-16")
+        return "wav";
+    return codec ?? "aac";
+}
+async function destroyAfterFailure(sandboxes, sandboxIds, error, context) {
+    const cleanup = await Promise.allSettled([...new Set(sandboxIds)].map((sandboxId) => sandboxes.destroy(sandboxId)));
+    const failures = cleanup.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+    if (failures.length > 0) {
+        throw new AggregateError([error, ...failures], `${context} failed and ${failures.length} sandbox(es) could not be destroyed`);
+    }
+    throw error;
+}
+async function waitForSandboxReady(sandboxes, initial, timeoutSeconds, signal) {
+    if (!Number.isFinite(timeoutSeconds) || timeoutSeconds <= 0) {
+        throw new RangeError("startupTimeoutSeconds must be a positive number");
+    }
+    const deadline = Date.now() + timeoutSeconds * 1_000;
+    let sandbox = initial;
+    let hasPolled = false;
+    for (;;) {
+        throwIfAborted(signal);
+        if (sandbox.state === "running")
+            return;
+        if (["interrupted", "destroying", "destroyed", "stopped"].includes(sandbox.state)) {
+            throw new Error(`Remotion sandbox entered terminal state ${sandbox.state}`);
+        }
+        if (!["building_image", "pending", "starting"].includes(sandbox.state)) {
+            throw new Error(`Remotion sandbox entered unexpected state ${sandbox.state}`);
+        }
+        if (Date.now() >= deadline) {
+            throw new Error(`Remotion sandbox did not become ready within ${timeoutSeconds} seconds`);
+        }
+        if (hasPolled)
+            await abortableDelay(1_000, signal);
+        sandbox = await sandboxes.get(sandbox.id);
+        throwIfAborted(signal);
+        hasPolled = true;
+    }
+}
+export class RemotionRenderFailedError extends Error {
+    progress;
+    constructor(progress) {
+        super(progress.errors[0]?.message ?? "Remotion render failed");
+        this.progress = progress;
+        this.name = "RemotionRenderFailedError";
+    }
+}
+function renderJob(options) {
+    assertHttpUrl(options.serveUrl, "serveUrl");
+    assertHttpUrl(options.output?.uploadUrl, "output.uploadUrl");
+    if (options.output.downloadUrl)
+        assertHttpUrl(options.output.downloadUrl, "output.downloadUrl");
+    if (!options.composition?.trim())
+        throw new TypeError("composition must not be empty");
+    assertJson(options.inputProps ?? {}, "inputProps");
+    assertJson(options.envVariables ?? {}, "envVariables");
+    validateHeaders(options.output.headers ?? {});
+    const codec = options.codec ?? "h264";
+    if (isAudioCodec(codec) && options.muted === true) {
+        throw new TypeError("muted cannot be true for audio-only codecs");
+    }
+    const contentType = options.output.contentType ?? contentTypeForCodec(codec);
+    return {
+        serveUrl: options.serveUrl,
+        composition: options.composition,
+        inputProps: options.inputProps ?? {},
+        codec,
+        outputFile: `${REMOTION_DIR}/output.${extensionForCodec(codec)}`,
+        output: {
+            uploadUrl: options.output.uploadUrl,
+            downloadUrl: options.output.downloadUrl ?? null,
+            headers: options.output.headers ?? {},
+            contentType,
+        },
+        renderOptions: compact({
+            concurrency: options.concurrency,
+            envVariables: options.envVariables,
+            crf: options.crf,
+            imageFormat: options.imageFormat,
+            pixelFormat: options.pixelFormat,
+            scale: options.scale,
+            muted: options.muted,
+            audioCodec: options.audioCodec,
+            metadata: options.metadata,
+        }),
+    };
+}
+function compact(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}
+function assertHttpUrl(raw, name) {
+    if (!raw)
+        throw new TypeError(`${name} is required`);
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new TypeError(`${name} must be an HTTP(S) URL`);
+    }
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) {
+        throw new TypeError(`${name} must be an HTTP(S) URL without embedded credentials`);
+    }
+}
+function assertJson(value, name) {
+    try {
+        JSON.stringify(value);
+    }
+    catch {
+        throw new TypeError(`${name} must be JSON serializable`);
+    }
+}
+function validateHeaders(headers) {
+    for (const [name, value] of Object.entries(headers)) {
+        if (!name || /[\r\n]/.test(name) || /[\r\n]/.test(value)) {
+            throw new TypeError("output headers must not contain newlines");
+        }
+    }
+}
+function extensionForCodec(codec) {
+    if (codec === "vp8" || codec === "vp9")
+        return "webm";
+    if (codec === "gif" || codec === "mp3" || codec === "aac" || codec === "wav")
+        return codec;
+    if (codec === "prores")
+        return "mov";
+    return "mp4";
+}
+function contentTypeForCodec(codec) {
+    if (codec === "vp8" || codec === "vp9")
+        return "video/webm";
+    if (codec === "gif")
+        return "image/gif";
+    if (codec === "prores")
+        return "video/quicktime";
+    if (codec === "mp3")
+        return "audio/mpeg";
+    if (codec === "aac")
+        return "audio/aac";
+    if (codec === "wav")
+        return "audio/wav";
+    return "video/mp4";
+}
+function handleForSandboxes(sandboxIds) {
+    const sandboxId = sandboxIds[0];
+    if (!sandboxId)
+        throw new TypeError("at least one Remotion sandbox is required");
+    return {
+        renderId: sandboxIds.length === 1
+            ? `render_${sandboxId}`
+            : `render_group_${Buffer.from(JSON.stringify(sandboxIds)).toString("base64url")}`,
+        sandboxId,
+        sandboxIds,
+        sandboxCount: sandboxIds.length,
+    };
+}
+function handleForRenderId(renderId) {
+    if (renderId.startsWith("render_group_")) {
+        try {
+            const encoded = renderId.slice("render_group_".length);
+            const sandboxIds = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+            if (!Array.isArray(sandboxIds) ||
+                sandboxIds.length < 2 ||
+                sandboxIds.length > 200 ||
+                sandboxIds.some((id) => typeof id !== "string" || id.length === 0) ||
+                new Set(sandboxIds).size !== sandboxIds.length) {
+                throw new TypeError("invalid run.cloud distributed Remotion renderId");
+            }
+            return handleForSandboxes(sandboxIds);
+        }
+        catch (error) {
+            if (error instanceof TypeError && error.message.startsWith("invalid run.cloud"))
+                throw error;
+            throw new TypeError("invalid run.cloud distributed Remotion renderId");
+        }
+    }
+    if (!renderId.startsWith("render_") || renderId.length === "render_".length) {
+        throw new TypeError("invalid run.cloud Remotion renderId");
+    }
+    return handleForSandboxes([renderId.slice("render_".length)]);
+}
+async function resolveRenderHandle(sandboxes, render) {
+    if (typeof render !== "string" && render.sandboxIds?.length > 1)
+        return render;
+    const handle = typeof render === "string"
+        ? handleForRenderId(render)
+        : {
+            ...render,
+            sandboxIds: render.sandboxIds ?? [render.sandboxId],
+            sandboxCount: render.sandboxCount ?? render.sandboxIds?.length ?? 1,
+        };
+    if (handle.sandboxIds.length > 1)
+        return handle;
+    try {
+        const raw = JSON.parse(new TextDecoder().decode(await sandboxes.readFile(handle.sandboxId, MANIFEST_PATH)));
+        if (!raw || typeof raw !== "object" || Array.isArray(raw))
+            return handle;
+        const sandboxIds = raw["sandboxIds"];
+        if (!Array.isArray(sandboxIds) ||
+            sandboxIds.length === 0 ||
+            sandboxIds.some((id) => typeof id !== "string" || id.length === 0)) {
+            return handle;
+        }
+        return {
+            ...handle,
+            sandboxIds: sandboxIds,
+            sandboxCount: sandboxIds.length,
+        };
+    }
+    catch {
+        return handle;
+    }
+}
+function startingProgress(handle) {
+    return {
+        ...handle,
+        stage: "starting",
+        progress: 0,
+        done: false,
+        outputFile: null,
+        outputSizeInBytes: null,
+        errors: [],
+        fatalErrorEncountered: false,
+        updatedAt: new Date().toISOString(),
+    };
+}
+function progressPayload(handle, raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new Error("render progress file is invalid");
+    }
+    const value = raw;
+    const stage = value["stage"];
+    const validStages = [
+        "starting",
+        "selecting-composition",
+        "rendering",
+        "downloading",
+        "combining",
+        "uploading",
+        "done",
+        "error",
+    ];
+    if (typeof stage !== "string" || !validStages.includes(stage)) {
+        throw new Error("render progress stage is invalid");
+    }
+    const progress = typeof value["progress"] === "number"
+        ? Math.max(0, Math.min(1, value["progress"]))
+        : 0;
+    const errors = Array.isArray(value["errors"])
+        ? value["errors"].flatMap((entry) => {
+            if (!entry || typeof entry !== "object")
+                return [];
+            const error = entry;
+            return typeof error["message"] === "string"
+                ? [{
+                        message: error["message"],
+                        ...(typeof error["name"] === "string" ? { name: error["name"] } : {}),
+                        ...(typeof error["stack"] === "string" ? { stack: error["stack"] } : {}),
+                    }]
+                : [];
+        })
+        : [];
+    const terminal = stage === "done" || stage === "error";
+    return {
+        ...handle,
+        sandboxCount: typeof value["sandboxCount"] === "number"
+            ? value["sandboxCount"]
+            : handle.sandboxCount,
+        stage: stage,
+        progress,
+        done: terminal,
+        outputFile: typeof value["outputFile"] === "string" ? value["outputFile"] : null,
+        outputSizeInBytes: typeof value["outputSizeInBytes"] === "number"
+            ? value["outputSizeInBytes"]
+            : null,
+        errors,
+        fatalErrorEncountered: stage === "error",
+        updatedAt: typeof value["updatedAt"] === "string" ? value["updatedAt"] : new Date().toISOString(),
+    };
+}
+async function abortableDelay(milliseconds, signal) {
+    throwIfAborted(signal);
+    await new Promise((resolve, reject) => {
+        const onAbort = () => {
+            clearTimeout(timeout);
+            reject(signal?.reason ?? new Error("render aborted"));
+        };
+        const timeout = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, milliseconds);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw signal.reason ?? new Error("render aborted");
+}
+/**
+ * Self-contained guest runner written into the sandbox by the SDK. The image
+ * supplies @remotion/renderer and its native browser/FFmpeg dependencies.
+ */
+export const REMOTION_PLANNER_SOURCE = String.raw `
+import {readFile, writeFile} from 'node:fs/promises';
+import {createRequire} from 'node:module';
+
+const loadRenderer = async () => {
+  try {
+    return await import('@remotion/renderer');
+  } catch (initialError) {
+    for (const root of ['/usr/app', '/app', '/workspace']) {
+      try {
+        return createRequire(root + '/package.json')('@remotion/renderer');
+      } catch {}
+    }
+    throw initialError;
+  }
+};
+
+const {selectComposition} = await loadRenderer();
+const jobPath = process.argv[2];
+if (!jobPath) throw new Error('render plan job path is required');
+const job = JSON.parse(await readFile(jobPath, 'utf8'));
+const composition = await selectComposition({
+  serveUrl: job.serveUrl,
+  id: job.composition,
+  inputProps: job.inputProps,
+  envVariables: job.envVariables,
+  logLevel: 'error',
+});
+await writeFile(job.planPath, JSON.stringify({
+  durationInFrames: composition.durationInFrames,
+  fps: composition.fps,
+  width: composition.width,
+  height: composition.height,
+}), {mode: 0o600});
+`.trimStart();
+export const REMOTION_RUNNER_SOURCE = String.raw `
+import {createReadStream} from 'node:fs';
+import {readFile, rename, stat, writeFile} from 'node:fs/promises';
+import {dirname, join} from 'node:path';
+import {createRequire} from 'node:module';
+
+const loadRenderer = async () => {
+  try {
+    return await import('@remotion/renderer');
+  } catch (initialError) {
+    for (const root of ['/usr/app', '/app', '/workspace']) {
+      try {
+        return createRequire(root + '/package.json')('@remotion/renderer');
+      } catch {}
+    }
+    throw initialError;
+  }
+};
+
+const jobPath = process.argv[2];
+if (!jobPath) throw new Error('render job path is required');
+const job = JSON.parse(await readFile(jobPath, 'utf8'));
+const progressPath = join(dirname(jobPath), 'progress.json');
+let state = {
+  stage: 'starting',
+  progress: 0,
+  outputFile: null,
+  outputSizeInBytes: null,
+  errors: [],
+  updatedAt: new Date().toISOString(),
+};
+let writes = Promise.resolve();
+
+const persist = async (patch) => {
+  state = {...state, ...patch, updatedAt: new Date().toISOString()};
+  const snapshot = JSON.stringify(state);
+  writes = writes.then(async () => {
+    const temporary = progressPath + '.tmp';
+    await writeFile(temporary, snapshot, {mode: 0o600});
+    await rename(temporary, progressPath);
+  });
+  await writes;
+};
+
+try {
+  await persist({stage: 'selecting-composition'});
+  const {selectComposition, renderMedia} = await loadRenderer();
+  const composition = await selectComposition({
+    serveUrl: job.serveUrl,
+    id: job.composition,
+    inputProps: job.inputProps,
+    envVariables: job.renderOptions.envVariables,
+  });
+
+  await persist({stage: 'rendering'});
+  await renderMedia({
+    ...job.renderOptions,
+    serveUrl: job.serveUrl,
+    composition,
+    codec: job.codec,
+    inputProps: job.inputProps,
+    outputLocation: job.outputFile,
+    onProgress: ({progress}) => void persist({stage: 'rendering', progress}),
+  });
+  await writes;
+
+  const output = await stat(job.outputFile);
+  await persist({stage: 'uploading', progress: 1, outputSizeInBytes: output.size});
+  const response = await fetch(job.output.uploadUrl, {
+    method: 'PUT',
+    headers: {
+      'content-type': job.output.contentType,
+      'content-length': String(output.size),
+      ...job.output.headers,
+    },
+    body: createReadStream(job.outputFile),
+    duplex: 'half',
+  });
+  if (!response.ok) {
+    const body = (await response.text()).slice(0, 500);
+    throw new Error('S3-compatible upload failed with HTTP ' + response.status + (body ? ': ' + body : ''));
+  }
+  await persist({
+    stage: 'done',
+    progress: 1,
+    outputFile: job.output.downloadUrl,
+    outputSizeInBytes: output.size,
+  });
+} catch (error) {
+  await persist({
+    stage: 'error',
+    errors: [{
+      message: error instanceof Error ? error.message : String(error),
+      name: error instanceof Error ? error.name : undefined,
+      stack: error instanceof Error ? error.stack : undefined,
+    }],
+  });
+  process.exitCode = 1;
+}
+`.trimStart();
+export const REMOTION_DISTRIBUTED_RUNNER_SOURCE = String.raw `
+import {createReadStream, createWriteStream} from 'node:fs';
+import {readFile, rename, stat, writeFile} from 'node:fs/promises';
+import {dirname, join} from 'node:path';
+import {createRequire} from 'node:module';
+import {pipeline} from 'node:stream/promises';
+import {Readable} from 'node:stream';
+
+const loadRenderer = async () => {
+  try {
+    return await import('@remotion/renderer');
+  } catch (initialError) {
+    for (const root of ['/usr/app', '/app', '/workspace']) {
+      try {
+        return createRequire(root + '/package.json')('@remotion/renderer');
+      } catch {}
+    }
+    throw initialError;
+  }
+};
+
+const jobPath = process.argv[2];
+if (!jobPath) throw new Error('distributed render job path is required');
+const job = JSON.parse(await readFile(jobPath, 'utf8'));
+const progressPath = join(dirname(jobPath), 'progress.json');
+let state = {
+  stage: 'starting',
+  progress: 0,
+  sandboxCount: job.sandboxCount,
+  chunkIndex: job.chunk.index,
+  outputFile: null,
+  outputSizeInBytes: null,
+  errors: [],
+  updatedAt: new Date().toISOString(),
+};
+let writes = Promise.resolve();
+
+const persist = async (patch) => {
+  state = {...state, ...patch, updatedAt: new Date().toISOString()};
+  const snapshot = JSON.stringify(state);
+  writes = writes.then(async () => {
+    const temporary = progressPath + '.tmp';
+    await writeFile(temporary, snapshot, {mode: 0o600});
+    await rename(temporary, progressPath);
+  });
+  await writes;
+};
+
+const upload = async (file, destination) => {
+  if (!file || !destination) return 0;
+  const info = await stat(file);
+  const response = await fetch(destination.uploadUrl, {
+    method: 'PUT',
+    headers: {
+      'content-type': destination.contentType || 'application/octet-stream',
+      'content-length': String(info.size),
+      ...destination.headers,
+    },
+    body: createReadStream(file),
+    duplex: 'half',
+  });
+  if (!response.ok) {
+    const body = (await response.text()).slice(0, 500);
+    throw new Error('chunk upload failed with HTTP ' + response.status + (body ? ': ' + body : ''));
+  }
+  return info.size;
+};
+
+const download = async (source, destination, deadline) => {
+  let lastStatus = null;
+  while (Date.now() < deadline) {
+    const response = await fetch(source.downloadUrl, {headers: source.downloadHeaders || {}});
+    lastStatus = response.status;
+    if (response.ok && response.body) {
+      await pipeline(Readable.fromWeb(response.body), createWriteStream(destination, {mode: 0o600}));
+      return;
+    }
+    await response.body?.cancel();
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+  }
+  throw new Error('chunk did not become readable before timeout' + (lastStatus ? ' (last HTTP ' + lastStatus + ')' : ''));
+};
+
+try {
+  await persist({stage: 'selecting-composition'});
+  const {selectComposition, renderMedia, combineChunks} = await loadRenderer();
+  const composition = await selectComposition({
+    serveUrl: job.serveUrl,
+    id: job.composition,
+    inputProps: job.inputProps,
+    envVariables: job.renderOptions.envVariables,
+  });
+  if (composition.durationInFrames !== job.chunk.compositionDurationInFrames ||
+      composition.fps !== job.chunk.fps) {
+    throw new Error('composition metadata changed after the distributed render was planned');
+  }
+
+  const {metadata, muted, ...chunkRenderOptions} = job.renderOptions;
+  await persist({stage: 'rendering'});
+  await renderMedia({
+    ...chunkRenderOptions,
+    serveUrl: job.serveUrl,
+    composition,
+    codec: job.chunk.codec,
+    inputProps: job.inputProps,
+    outputLocation: job.chunk.videoFile || job.chunk.audioFile,
+    separateAudioTo: job.chunk.videoFile && job.chunk.audioFile ? job.chunk.audioFile : undefined,
+    frameRange: job.chunk.frameRange,
+    compositionStart: 0,
+    enforceAudioTrack: Boolean(job.chunk.audioFile),
+    muted: muted === true,
+    audioCodec: job.chunk.audioCodec,
+    forSeamlessAacConcatenation: job.chunk.forSeamlessAacConcatenation,
+    numberOfGifLoops: null,
+    preferLossless: false,
+    onProgress: ({progress}) => void persist({
+      stage: 'rendering',
+      progress: job.coordinator ? progress * 0.8 / job.sandboxCount : progress,
+    }),
+  });
+  await writes;
+
+  await persist({stage: 'uploading'});
+  await Promise.all([
+    upload(job.chunk.videoFile, job.chunk.output.video),
+    upload(job.chunk.audioFile, job.chunk.output.audio),
+  ]);
+
+  if (!job.coordinator) {
+    await persist({stage: 'done', progress: 1});
+  } else {
+    const chunks = job.chunks;
+    if (!Array.isArray(chunks) || chunks.length !== job.sandboxCount) {
+      throw new Error('coordinator chunk manifest is invalid');
+    }
+    const deadline = Date.now() + job.downloadTimeoutSeconds * 1000;
+    let downloaded = 1;
+    await persist({stage: 'downloading', progress: 0.8 * downloaded / job.sandboxCount});
+    for (const chunk of chunks.slice(1)) {
+      await Promise.all([
+        chunk.videoFile ? download(chunk.output.video, chunk.videoFile, deadline) : undefined,
+        chunk.audioFile ? download(chunk.output.audio, chunk.audioFile, deadline) : undefined,
+      ]);
+      downloaded += 1;
+      await persist({stage: 'downloading', progress: 0.8 * downloaded / job.sandboxCount});
+    }
+
+    await persist({stage: 'combining', progress: 0.8});
+    await combineChunks({
+      outputLocation: job.outputFile,
+      videoFiles: chunks.flatMap((chunk) => chunk.videoFile ? [chunk.videoFile] : []),
+      audioFiles: chunks.flatMap((chunk) => chunk.audioFile ? [chunk.audioFile] : []),
+      codec: job.codec,
+      fps: job.chunk.fps,
+      framesPerChunk: job.chunk.framesPerChunk,
+      preferLossless: false,
+      compositionDurationInFrames: job.chunk.compositionDurationInFrames,
+      audioCodec: job.renderOptions.audioCodec ?? null,
+      metadata: job.renderOptions.metadata ?? null,
+      onProgress: ({totalProgress}) => void persist({
+        stage: 'combining',
+        progress: 0.8 + totalProgress * 0.15,
+      }),
+    });
+    await writes;
+
+    const output = await stat(job.outputFile);
+    await persist({stage: 'uploading', progress: 0.95, outputSizeInBytes: output.size});
+    await upload(job.outputFile, job.output);
+    await persist({
+      stage: 'done',
+      progress: 1,
+      outputFile: job.output.downloadUrl,
+      outputSizeInBytes: output.size,
+    });
+  }
+} catch (error) {
+  await persist({
+    stage: 'error',
+    errors: [{
+      message: error instanceof Error ? error.message : String(error),
+      name: error instanceof Error ? error.name : undefined,
+      stack: error instanceof Error ? error.stack : undefined,
+    }],
+  });
+  process.exitCode = 1;
+}
+`.trimStart();
+//# sourceMappingURL=remotion.js.map