@remotion/lambda-client 4.0.508 → 4.0.510

package/dist/esm/index.mjs

@@ -69200,6 +69200,498 @@ var import_client_sts = __toESM(require_dist_cjs81(), 1);
 
 // ../serverless-client/dist/esm/index.mjs
 import * as tty from "tty";
+var NEWTON_ITERATIONS = 4;
+var NEWTON_MIN_SLOPE = 0.001;
+var SUBDIVISION_PRECISION = 0.0000001;
+var SUBDIVISION_MAX_ITERATIONS = 10;
+var kSplineTableSize = 11;
+var kSampleStepSize = 1 / (kSplineTableSize - 1);
+var float32ArraySupported = typeof Float32Array === "function";
+function a(aA1, aA2) {
+  return 1 - 3 * aA2 + 3 * aA1;
+}
+function b(aA1, aA2) {
+  return 3 * aA2 - 6 * aA1;
+}
+function c(aA1) {
+  return 3 * aA1;
+}
+function calcBezier(aT, aA1, aA2) {
+  return ((a(aA1, aA2) * aT + b(aA1, aA2)) * aT + c(aA1)) * aT;
+}
+function getSlope(aT, aA1, aA2) {
+  return 3 * a(aA1, aA2) * aT * aT + 2 * b(aA1, aA2) * aT + c(aA1);
+}
+function binarySubdivide({
+  aX,
+  _aA,
+  _aB,
+  mX1,
+  mX2
+}) {
+  let currentX;
+  let currentT;
+  let i = 0;
+  let aA = _aA;
+  let aB = _aB;
+  do {
+    currentT = aA + (aB - aA) / 2;
+    currentX = calcBezier(currentT, mX1, mX2) - aX;
+    if (currentX > 0) {
+      aB = currentT;
+    } else {
+      aA = currentT;
+    }
+  } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);
+  return currentT;
+}
+function newtonRaphsonIterate(aX, _aGuessT, mX1, mX2) {
+  let aGuessT = _aGuessT;
+  for (let i = 0;i < NEWTON_ITERATIONS; ++i) {
+    const currentSlope = getSlope(aGuessT, mX1, mX2);
+    if (currentSlope === 0) {
+      return aGuessT;
+    }
+    const currentX = calcBezier(aGuessT, mX1, mX2) - aX;
+    aGuessT -= currentX / currentSlope;
+  }
+  return aGuessT;
+}
+function bezier(mX1, mY1, mX2, mY2) {
+  if (!(mX1 >= 0 && mX1 <= 1 && mX2 >= 0 && mX2 <= 1)) {
+    throw new Error("bezier x values must be in [0, 1] range");
+  }
+  const sampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);
+  if (mX1 !== mY1 || mX2 !== mY2) {
+    for (let i = 0;i < kSplineTableSize; ++i) {
+      sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
+    }
+  }
+  function getTForX(aX) {
+    let intervalStart = 0;
+    let currentSample = 1;
+    const lastSample = kSplineTableSize - 1;
+    for (;currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {
+      intervalStart += kSampleStepSize;
+    }
+    --currentSample;
+    const dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);
+    const guessForT = intervalStart + dist * kSampleStepSize;
+    const initialSlope = getSlope(guessForT, mX1, mX2);
+    if (initialSlope >= NEWTON_MIN_SLOPE) {
+      return newtonRaphsonIterate(aX, guessForT, mX1, mX2);
+    }
+    if (initialSlope === 0) {
+      return guessForT;
+    }
+    return binarySubdivide({
+      aX,
+      _aA: intervalStart,
+      _aB: intervalStart + kSampleStepSize,
+      mX1,
+      mX2
+    });
+  }
+  return function(x) {
+    const clampedX = Math.min(1, Math.max(0, x));
+    if (mX1 === mY1 && mX2 === mY2) {
+      return clampedX;
+    }
+    if (clampedX === 0) {
+      return 0;
+    }
+    if (clampedX === 1) {
+      return 1;
+    }
+    return calcBezier(getTForX(clampedX), mY1, mY2);
+  };
+}
+var validateFrame = ({
+  allowFloats,
+  durationInFrames,
+  frame
+}) => {
+  if (typeof frame === "undefined") {
+    throw new TypeError(`Argument missing for parameter "frame"`);
+  }
+  if (typeof frame !== "number") {
+    throw new TypeError(`Argument passed for "frame" is not a number: ${frame}`);
+  }
+  if (!Number.isFinite(frame)) {
+    throw new RangeError(`Frame ${frame} is not finite`);
+  }
+  if (frame % 1 !== 0 && !allowFloats) {
+    throw new RangeError(`Argument for frame must be an integer, but got ${frame}`);
+  }
+  if (frame < 0 && frame < -durationInFrames) {
+    throw new RangeError(`Cannot use frame ${frame}: Duration of composition is ${durationInFrames}, therefore the lowest frame that can be rendered is ${-durationInFrames}`);
+  }
+  if (frame > durationInFrames - 1) {
+    throw new RangeError(`Cannot use frame ${frame}: Duration of composition is ${durationInFrames}, therefore the highest frame that can be rendered is ${durationInFrames - 1}`);
+  }
+};
+function validateFps(fps, location, isGif) {
+  if (typeof fps !== "number") {
+    throw new Error(`"fps" must be a number, but you passed a value of type ${typeof fps} ${location}`);
+  }
+  if (!Number.isFinite(fps)) {
+    throw new Error(`"fps" must be a finite, but you passed ${fps} ${location}`);
+  }
+  if (isNaN(fps)) {
+    throw new Error(`"fps" must not be NaN, but got ${fps} ${location}`);
+  }
+  if (fps <= 0) {
+    throw new TypeError(`"fps" must be positive, but got ${fps} ${location}`);
+  }
+  if (isGif && fps > 50) {
+    throw new TypeError(`The FPS for a GIF cannot be higher than 50. Use the --every-nth-frame option to lower the FPS: https://remotion.dev/docs/render-as-gif`);
+  }
+}
+var validateSpringDuration = (dur) => {
+  if (typeof dur === "undefined") {
+    return;
+  }
+  if (typeof dur !== "number") {
+    throw new TypeError(`A "duration" of a spring must be a "number" but is "${typeof dur}"`);
+  }
+  if (Number.isNaN(dur)) {
+    throw new TypeError('A "duration" of a spring is NaN, which it must not be');
+  }
+  if (!Number.isFinite(dur)) {
+    throw new TypeError('A "duration" of a spring must be finite, but is ' + dur);
+  }
+  if (dur <= 0) {
+    throw new TypeError('A "duration" of a spring must be positive, but is ' + dur);
+  }
+};
+var defaultSpringConfig = {
+  damping: 10,
+  mass: 1,
+  stiffness: 100,
+  overshootClamping: false
+};
+var advanceCache = {};
+function advance({
+  animation,
+  now,
+  config
+}) {
+  const { toValue, lastTimestamp, current, velocity } = animation;
+  const deltaTime = Math.min(now - lastTimestamp, 64);
+  if (config.damping <= 0) {
+    throw new Error("Spring damping must be greater than 0, otherwise the spring() animation will never end, causing an infinite loop.");
+  }
+  const c2 = config.damping;
+  const m = config.mass;
+  const k = config.stiffness;
+  const cacheKey = [
+    toValue,
+    lastTimestamp,
+    current,
+    velocity,
+    c2,
+    m,
+    k,
+    now
+  ].join("-");
+  if (advanceCache[cacheKey]) {
+    return advanceCache[cacheKey];
+  }
+  const v0 = -velocity;
+  const x0 = toValue - current;
+  const zeta = c2 / (2 * Math.sqrt(k * m));
+  const omega0 = Math.sqrt(k / m);
+  const omega1 = omega0 * Math.sqrt(1 - zeta ** 2);
+  const t = deltaTime / 1000;
+  const sin1 = Math.sin(omega1 * t);
+  const cos1 = Math.cos(omega1 * t);
+  const underDampedEnvelope = Math.exp(-zeta * omega0 * t);
+  const underDampedFrag1 = underDampedEnvelope * (sin1 * ((v0 + zeta * omega0 * x0) / omega1) + x0 * cos1);
+  const underDampedPosition = toValue - underDampedFrag1;
+  const underDampedVelocity = zeta * omega0 * underDampedFrag1 - underDampedEnvelope * (cos1 * (v0 + zeta * omega0 * x0) - omega1 * x0 * sin1);
+  const criticallyDampedEnvelope = Math.exp(-omega0 * t);
+  const criticallyDampedPosition = toValue - criticallyDampedEnvelope * (x0 + (v0 + omega0 * x0) * t);
+  const criticallyDampedVelocity = criticallyDampedEnvelope * (v0 * (t * omega0 - 1) + t * x0 * omega0 * omega0);
+  const animationNode = {
+    toValue,
+    prevPosition: current,
+    lastTimestamp: now,
+    current: zeta < 1 ? underDampedPosition : criticallyDampedPosition,
+    velocity: zeta < 1 ? underDampedVelocity : criticallyDampedVelocity
+  };
+  advanceCache[cacheKey] = animationNode;
+  return animationNode;
+}
+var calculationCache = {};
+function springCalculation({
+  frame,
+  fps,
+  config = {}
+}) {
+  const from = 0;
+  const to = 1;
+  const cacheKey = [
+    frame,
+    fps,
+    config.damping,
+    config.mass,
+    config.overshootClamping,
+    config.stiffness
+  ].join("-");
+  if (calculationCache[cacheKey]) {
+    return calculationCache[cacheKey];
+  }
+  let animation = {
+    lastTimestamp: 0,
+    current: from,
+    toValue: to,
+    velocity: 0,
+    prevPosition: 0
+  };
+  const frameClamped = Math.max(0, frame);
+  const unevenRest = frameClamped % 1;
+  for (let f = 0;f <= Math.floor(frameClamped); f++) {
+    if (f === Math.floor(frameClamped)) {
+      f += unevenRest;
+    }
+    const time = f / fps * 1000;
+    animation = advance({
+      animation,
+      now: time,
+      config: {
+        ...defaultSpringConfig,
+        ...config
+      }
+    });
+  }
+  calculationCache[cacheKey] = animation;
+  return animation;
+}
+var cache = new Map;
+function measureSpring({
+  fps,
+  config = {},
+  threshold = 0.005
+}) {
+  if (typeof threshold !== "number") {
+    throw new TypeError(`threshold must be a number, got ${threshold} of type ${typeof threshold}`);
+  }
+  if (threshold === 0) {
+    return Infinity;
+  }
+  if (threshold === 1) {
+    return 0;
+  }
+  if (isNaN(threshold)) {
+    throw new TypeError("Threshold is NaN");
+  }
+  if (!Number.isFinite(threshold)) {
+    throw new TypeError("Threshold is not finite");
+  }
+  if (threshold < 0) {
+    throw new TypeError("Threshold is below 0");
+  }
+  const cacheKey = [
+    fps,
+    config.damping,
+    config.mass,
+    config.overshootClamping,
+    config.stiffness,
+    threshold
+  ].join("-");
+  if (cache.has(cacheKey)) {
+    return cache.get(cacheKey);
+  }
+  validateFps(fps, "to the measureSpring() function", false);
+  let frame = 0;
+  let finishedFrame = 0;
+  const calc = () => {
+    return springCalculation({
+      fps,
+      frame,
+      config
+    });
+  };
+  let animation = calc();
+  const calcDifference = () => {
+    return Math.abs(animation.current - animation.toValue);
+  };
+  let difference = calcDifference();
+  while (difference >= threshold) {
+    frame++;
+    animation = calc();
+    difference = calcDifference();
+  }
+  finishedFrame = frame;
+  for (let i = 0;i < 20; i++) {
+    frame++;
+    animation = calc();
+    difference = calcDifference();
+    if (difference >= threshold) {
+      i = 0;
+      finishedFrame = frame + 1;
+    }
+  }
+  cache.set(cacheKey, finishedFrame);
+  return finishedFrame;
+}
+function spring({
+  frame: passedFrame,
+  fps,
+  config = {},
+  from = 0,
+  to = 1,
+  durationInFrames: passedDurationInFrames,
+  durationRestThreshold,
+  delay = 0,
+  reverse = false
+}) {
+  validateSpringDuration(passedDurationInFrames);
+  validateFrame({
+    frame: passedFrame,
+    durationInFrames: Infinity,
+    allowFloats: true
+  });
+  validateFps(fps, "to spring()", false);
+  const needsToCalculateNaturalDuration = reverse || typeof passedDurationInFrames !== "undefined";
+  const naturalDuration = needsToCalculateNaturalDuration ? measureSpring({
+    fps,
+    config,
+    threshold: durationRestThreshold
+  }) : undefined;
+  const naturalDurationGetter = needsToCalculateNaturalDuration ? {
+    get: () => naturalDuration
+  } : {
+    get: () => {
+      throw new Error("did not calculate natural duration, this is an error with Remotion. Please report");
+    }
+  };
+  const reverseProcessed = reverse ? (passedDurationInFrames ?? naturalDurationGetter.get()) - passedFrame : passedFrame;
+  const delayProcessed = reverseProcessed + (reverse ? delay : -delay);
+  const durationProcessed = passedDurationInFrames === undefined ? delayProcessed : delayProcessed / (passedDurationInFrames / naturalDurationGetter.get());
+  if (passedDurationInFrames && delayProcessed > passedDurationInFrames) {
+    return to;
+  }
+  const spr = springCalculation({
+    fps,
+    frame: durationProcessed,
+    config
+  });
+  const inner = config.overshootClamping ? to >= from ? Math.min(spr.current, to) : Math.max(spr.current, to) : spr.current;
+  const interpolated = from === 0 && to === 1 ? inner : interpolate(inner, [0, 1], [from, to]);
+  return interpolated;
+}
+var clampUnit = (t) => Math.min(1, Math.max(0, t));
+var springEasingDurationInFrames = 30;
+
+class Easing {
+  static step0(n) {
+    return n > 0 ? 1 : 0;
+  }
+  static step1(n) {
+    return n >= 1 ? 1 : 0;
+  }
+  static linear(t) {
+    return t;
+  }
+  static ease(t) {
+    return Easing.bezier(0.42, 0, 1, 1)(t);
+  }
+  static quad(t) {
+    return t * t;
+  }
+  static cubic(t) {
+    return t * t * t;
+  }
+  static poly(n) {
+    return (t) => t ** n;
+  }
+  static sin(t) {
+    return 1 - Math.cos(t * Math.PI / 2);
+  }
+  static circle(t) {
+    const u = clampUnit(t);
+    return 1 - Math.sqrt(1 - u * u);
+  }
+  static exp(t) {
+    return 2 ** (10 * (t - 1));
+  }
+  static elastic(bounciness = 1) {
+    const p = bounciness * Math.PI;
+    return (t) => 1 - Math.cos(t * Math.PI / 2) ** 3 * Math.cos(t * p);
+  }
+  static back(s = 1.70158) {
+    return (t) => t * t * ((s + 1) * t - s);
+  }
+  static spring({
+    allowTail = false,
+    durationRestThreshold,
+    ...config
+  } = {}) {
+    const easing = (t) => {
+      if (t <= 0) {
+        return 0;
+      }
+      if (!allowTail && t >= 1) {
+        return 1;
+      }
+      if (allowTail) {
+        return spring({
+          fps: springEasingDurationInFrames,
+          frame: t * measureSpring({
+            fps: springEasingDurationInFrames,
+            config,
+            threshold: durationRestThreshold
+          }),
+          config
+        });
+      }
+      return spring({
+        fps: springEasingDurationInFrames,
+        frame: t * springEasingDurationInFrames,
+        config,
+        durationInFrames: springEasingDurationInFrames,
+        durationRestThreshold
+      });
+    };
+    return Object.assign(easing, {
+      remotionShouldExtendRight: allowTail
+    });
+  }
+  static bounce(t) {
+    const u = clampUnit(t);
+    if (u < 1 / 2.75) {
+      return 7.5625 * u * u;
+    }
+    if (u < 2 / 2.75) {
+      const t2_ = u - 1.5 / 2.75;
+      return 7.5625 * t2_ * t2_ + 0.75;
+    }
+    if (u < 2.5 / 2.75) {
+      const t2_ = u - 2.25 / 2.75;
+      return 7.5625 * t2_ * t2_ + 0.9375;
+    }
+    const t2 = u - 2.625 / 2.75;
+    return 7.5625 * t2 * t2 + 0.984375;
+  }
+  static bezier(x1, y1, x2, y2) {
+    return bezier(x1, y1, x2, y2);
+  }
+  static in(easing) {
+    return easing;
+  }
+  static out(easing) {
+    return (t) => 1 - easing(1 - t);
+  }
+  static inOut(easing) {
+    return (t) => {
+      if (t < 0.5) {
+        return easing(t * 2) / 2;
+      }
+      return 1 - easing((1 - t) * 2) / 2;
+    };
+  }
+}
 var normalizeNumber = (value) => {
   return Math.round(value * 1e6) / 1e6;
 };
@@ -69270,10 +69762,13 @@ var transformOriginCenter = { value: 50, unit: "%" };
 var stringifyNumber = (value) => {
   return String(normalizeNumber(value));
 };
+
+class UnsupportedStringInterpolationValueError extends TypeError {
+}
 var parseStringInterpolationComponent = (component, value) => {
   const match = cssNumberRegex.exec(component);
   if (match === null) {
-    throw new TypeError(`Cannot interpolate "${value}" because "${component}" is not a supported scale, translate, or rotate value`);
+    throw new UnsupportedStringInterpolationValueError(`Cannot interpolate "${value}" because "${component}" is not a supported scale, translate, or rotate value`);
   }
   const unit = match[2] ?? null;
   const numberValue = Number(match[1]);
@@ -69740,6 +70235,52 @@ var interpolateString = ({
     axisRotation: hasAxisRotation
   });
 };
+var interpolateDiscreteString = ({
+  input,
+  inputRange,
+  outputRange,
+  options
+}) => {
+  if (inputRange.length === 1) {
+    return outputRange[0];
+  }
+  for (let segmentIndex = 0;segmentIndex < inputRange.length - 1; segmentIndex++) {
+    if (resolveEasingForSegment({
+      easing: options?.easing,
+      segmentIndex
+    }) !== Easing.step1) {
+      throw new TypeError("Non-numeric strings can only be interpolated using Easing.step1");
+    }
+  }
+  const posterizedInput = options?.posterize === undefined ? input : Math.floor(input / options.posterize) * options.posterize;
+  const inputMin = inputRange[0];
+  const inputMax = inputRange[inputRange.length - 1];
+  let resolvedInput = posterizedInput;
+  if (resolvedInput < inputMin) {
+    if (options?.extrapolateLeft === "identity") {
+      throw new TypeError('extrapolateLeft: "identity" is not supported for non-numeric strings');
+    }
+    if (options?.extrapolateLeft === "wrap") {
+      const wrapRange = inputMax - inputMin;
+      resolvedInput = ((resolvedInput - inputMin) % wrapRange + wrapRange) % wrapRange + inputMin;
+    } else {
+      return outputRange[0];
+    }
+  }
+  if (resolvedInput > inputMax) {
+    if (options?.extrapolateRight === "identity") {
+      throw new TypeError('extrapolateRight: "identity" is not supported for non-numeric strings');
+    }
+    if (options?.extrapolateRight === "wrap") {
+      const wrapRange = inputMax - inputMin;
+      resolvedInput = ((resolvedInput - inputMin) % wrapRange + wrapRange) % wrapRange + inputMin;
+    } else {
+      return outputRange[outputRange.length - 1];
+    }
+  }
+  const range = findRange(resolvedInput, inputRange);
+  return resolvedInput >= inputRange[range + 1] ? outputRange[range + 1] : outputRange[range];
+};
 var validateTupleOutputRange = (outputRange) => {
   const dimensions = outputRange[0]?.length;
   if (dimensions === undefined) {
@@ -69854,7 +70395,30 @@ function interpolate(input, inputRange, outputRange, options) {
     if (!outputRange.every((output) => typeof output === "string" || typeof output === "number")) {
       throw new TypeError("outputRange must contain only numbers, or supported scale, translate, and rotate strings");
     }
-    return interpolateString({ input, inputRange, outputRange, options });
+    try {
+      return interpolateString({ input, inputRange, outputRange, options });
+    } catch (error) {
+      if (!outputRange.every((output) => typeof output === "string")) {
+        throw error;
+      }
+      const hasNonNumericString = outputRange.some((output) => {
+        try {
+          parseStringInterpolationValue(output);
+          return false;
+        } catch (parseError) {
+          return parseError instanceof UnsupportedStringInterpolationValueError;
+        }
+      });
+      if (!hasNonNumericString) {
+        throw error;
+      }
+      return interpolateDiscreteString({
+        input,
+        inputRange,
+        outputRange,
+        options
+      });
+    }
   }
   if (outputRange.every((output) => Array.isArray(output))) {
     return interpolateTuple({ input, inputRange, outputRange, options });
@@ -69865,8 +70429,8 @@ function interpolate(input, inputRange, outputRange, options) {
   checkInfiniteRange("outputRange", outputRange);
   return interpolateNumber({ input, inputRange, outputRange, options });
 }
-function mulberry32(a) {
-  let t = a + 1831565813;
+function mulberry32(a2) {
+  let t = a2 + 1831565813;
   t = Math.imul(t ^ t >>> 15, t | 1);
   t ^= t + Math.imul(t ^ t >>> 7, t | 61);
   return ((t ^ t >>> 14) >>> 0) / 4294967296;
@@ -70355,8 +70919,8 @@ function hslToRgb(h, s, l) {
   const p = 2 * l - q;
   const r = hue2rgb(p, q, h + 1 / 3);
   const g = hue2rgb(p, q, h);
-  const b = hue2rgb(p, q, h - 1 / 3);
-  return Math.round(r * 255) << 24 | Math.round(g * 255) << 16 | Math.round(b * 255) << 8;
+  const b2 = hue2rgb(p, q, h - 1 / 3);
+  return Math.round(r * 255) << 24 | Math.round(g * 255) << 16 | Math.round(b2 * 255) << 8;
 }
 function parse255(str) {
   const int = Number.parseInt(str, 10);
@@ -70420,25 +70984,25 @@ function parseModernAlpha(str) {
   }
   return Math.max(0, Math.min(1, Number.parseFloat(str)));
 }
-function linearToSrgb(c) {
-  if (c <= 0.0031308)
-    return 12.92 * c;
-  return 1.055 * c ** (1 / 2.4) - 0.055;
+function linearToSrgb(c2) {
+  if (c2 <= 0.0031308)
+    return 12.92 * c2;
+  return 1.055 * c2 ** (1 / 2.4) - 0.055;
 }
 function clamp01(v) {
   return Math.max(0, Math.min(1, v));
 }
-function rgbFloatToInt(r, g, b, alpha) {
+function rgbFloatToInt(r, g, b2, alpha) {
   const ri = Math.round(clamp01(r) * 255);
   const gi = Math.round(clamp01(g) * 255);
-  const bi = Math.round(clamp01(b) * 255);
+  const bi = Math.round(clamp01(b2) * 255);
   const ai = Math.round(clamp01(alpha) * 255);
   return (ri << 24 | gi << 16 | bi << 8 | ai) >>> 0;
 }
-function oklabToSrgb(L, a, b) {
-  const l_ = L + 0.3963377774 * a + 0.2158037573 * b;
-  const m_ = L - 0.1055613458 * a - 0.0638541728 * b;
-  const s_ = L - 0.0894841775 * a - 1.291485548 * b;
+function oklabToSrgb(L, a2, b2) {
+  const l_ = L + 0.3963377774 * a2 + 0.2158037573 * b2;
+  const m_ = L - 0.1055613458 * a2 - 0.0638541728 * b2;
+  const s_ = L - 0.0894841775 * a2 - 1.291485548 * b2;
   const l = l_ * l_ * l_;
   const m = m_ * m_ * m_;
   const s = s_ * s_ * s_;
@@ -70447,15 +71011,15 @@ function oklabToSrgb(L, a, b) {
   const bLin = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s;
   return [linearToSrgb(rLin), linearToSrgb(gLin), linearToSrgb(bLin)];
 }
-function labToSrgb(L, a, b) {
+function labToSrgb(L, a2, b2) {
   const epsilon = 216 / 24389;
   const kappa = 24389 / 27;
   const Xn = 0.95047;
   const Yn = 1;
   const Zn = 1.08883;
   const fy = (L + 16) / 116;
-  const fx = a / 500 + fy;
-  const fz = fy - b / 200;
+  const fx = a2 / 500 + fy;
+  const fz = fy - b2 / 200;
   const fx3 = fx * fx * fx;
   const fz3 = fz * fz * fz;
   const xr = fx3 > epsilon ? fx3 : (116 * fx - 16) / kappa;
@@ -70687,27 +71251,27 @@ function normalizeColor(color) {
       const H = parseHueAngle(match[3]);
       const alpha = parseModernAlpha(match[4]);
       const hRad = H * Math.PI / 180;
-      const [r, g, b] = oklabToSrgb(L, C * Math.cos(hRad), C * Math.sin(hRad));
-      return rgbFloatToInt(r, g, b, alpha);
+      const [r, g, b2] = oklabToSrgb(L, C * Math.cos(hRad), C * Math.sin(hRad));
+      return rgbFloatToInt(r, g, b2, alpha);
     }
   }
   if (matchers.oklab) {
     if (match = matchers.oklab.exec(color)) {
       const L = parseModernComponent(match[1], 1);
-      const a = parseModernComponent(match[2], 0.4);
-      const b = parseModernComponent(match[3], 0.4);
+      const a2 = parseModernComponent(match[2], 0.4);
+      const b2 = parseModernComponent(match[3], 0.4);
       const alpha = parseModernAlpha(match[4]);
-      const [r, g, bl] = oklabToSrgb(L, a, b);
+      const [r, g, bl] = oklabToSrgb(L, a2, b2);
       return rgbFloatToInt(r, g, bl, alpha);
     }
   }
   if (matchers.lab) {
     if (match = matchers.lab.exec(color)) {
       const L = parseModernComponent(match[1], 100);
-      const a = parseModernComponent(match[2], 125);
-      const b = parseModernComponent(match[3], 125);
+      const a2 = parseModernComponent(match[2], 125);
+      const b2 = parseModernComponent(match[3], 125);
       const alpha = parseModernAlpha(match[4]);
-      const [r, g, bl] = labToSrgb(L, a, b);
+      const [r, g, bl] = labToSrgb(L, a2, b2);
       return rgbFloatToInt(r, g, bl, alpha);
     }
   }
@@ -70786,30 +71350,6 @@ var serializeScaleValue = ([x, y, z]) => {
   return `${normalizedX} ${normalizedY} ${normalizedZ}`;
 };
 var ENABLE_V5_BREAKING_CHANGES = false;
-var validateFrame = ({
-  allowFloats,
-  durationInFrames,
-  frame
-}) => {
-  if (typeof frame === "undefined") {
-    throw new TypeError(`Argument missing for parameter "frame"`);
-  }
-  if (typeof frame !== "number") {
-    throw new TypeError(`Argument passed for "frame" is not a number: ${frame}`);
-  }
-  if (!Number.isFinite(frame)) {
-    throw new RangeError(`Frame ${frame} is not finite`);
-  }
-  if (frame % 1 !== 0 && !allowFloats) {
-    throw new RangeError(`Argument for frame must be an integer, but got ${frame}`);
-  }
-  if (frame < 0 && frame < -durationInFrames) {
-    throw new RangeError(`Cannot use frame ${frame}: Duration of composition is ${durationInFrames}, therefore the lowest frame that can be rendered is ${-durationInFrames}`);
-  }
-  if (frame > durationInFrames - 1) {
-    throw new RangeError(`Cannot use frame ${frame}: Duration of composition is ${durationInFrames}, therefore the highest frame that can be rendered is ${durationInFrames - 1}`);
-  }
-};
 var validCodecs = [
   "h264",
   "h265",
@@ -70881,23 +71421,6 @@ function validateDurationInFrames(durationInFrames, options) {
     throw new TypeError(`The "durationInFrames" prop ${component} must be finite, but got ${durationInFrames}.`);
   }
 }
-function validateFps(fps, location, isGif) {
-  if (typeof fps !== "number") {
-    throw new Error(`"fps" must be a number, but you passed a value of type ${typeof fps} ${location}`);
-  }
-  if (!Number.isFinite(fps)) {
-    throw new Error(`"fps" must be a finite, but you passed ${fps} ${location}`);
-  }
-  if (isNaN(fps)) {
-    throw new Error(`"fps" must not be NaN, but got ${fps} ${location}`);
-  }
-  if (fps <= 0) {
-    throw new TypeError(`"fps" must be positive, but got ${fps} ${location}`);
-  }
-  if (isGif && fps > 50) {
-    throw new TypeError(`The FPS for a GIF cannot be higher than 50. Use the --every-nth-frame option to lower the FPS: https://remotion.dev/docs/render-as-gif`);
-  }
-}
 var getExpectedMediaFrameUncorrected = ({
   frame,
   playbackRate,
@@ -71018,7 +71541,7 @@ var validateDownloadBehavior = (downloadBehavior) => {
     }
   }
 };
-var VERSION = "4.0.508";
+var VERSION = "4.0.510";
 var isColorSupported = () => {
   const env = process.env || {};
   const isForceDisabled = "NO_COLOR" in env;
@@ -71187,17 +71710,17 @@ var Log = {
     return [
       options.indent ? INDENT_TOKEN : null,
       options.tag ? verboseTag(options.tag) : null
-    ].filter(truthy2).concat(args.map((a) => {
+    ].filter(truthy2).concat(args.map((a2) => {
       if (logLevel === "warn") {
-        return chalk.yellow(a);
+        return chalk.yellow(a2);
       }
       if (logLevel === "error") {
-        return chalk.red(a);
+        return chalk.red(a2);
       }
       if (logLevel === "verbose" || logLevel === "trace") {
-        return chalk.gray(a);
+        return chalk.gray(a2);
       }
-      return a;
+      return a2;
     }));
   },
   trace: (options, ...args) => {
@@ -71485,7 +72008,7 @@ var calculateBillingDuration = ({
   functionsInvoked,
   elapsedTimeOfUnfinishedChunks
 }) => {
-  const completedChunksDuration = timings.map((p) => Math.max(0, p.rendered - p.start) + OVERHEAD_TIME_PER_LAMBDA).reduce((a, b) => a + b, 0);
+  const completedChunksDuration = timings.map((p) => Math.max(0, p.rendered - p.start) + OVERHEAD_TIME_PER_LAMBDA).reduce((a2, b2) => a2 + b2, 0);
   const unfinished = Math.max(0, functionsInvoked - timings.length);
   return completedChunksDuration + unfinished * elapsedTimeOfUnfinishedChunks;
 };
@@ -71532,7 +72055,7 @@ var calculateChunkTimes = ({
   const parsedTimings = timings;
   const absoluteTime = getAbsoluteTime(parsedTimings);
   if (type === "combined-time-for-cost-calculation") {
-    const totalEncodingTimings = parsedTimings.map((p) => Math.max(0, p.rendered - p.start)).reduce((a, b) => a + b, 0);
+    const totalEncodingTimings = parsedTimings.map((p) => Math.max(0, p.rendered - p.start)).reduce((a2, b2) => a2 + b2, 0);
     return totalEncodingTimings + absoluteTime;
   }
   if (type === "absolute-time") {
@@ -71542,10 +72065,11 @@ var calculateChunkTimes = ({
 };
 var checkBucketListing = async ({
   bucketName,
-  region
+  region,
+  dnsSuffix
 }) => {
   try {
-    const res = await fetch(`https://${bucketName}.s3.${region}.amazonaws.com/`);
+    const res = await fetch(`https://${bucketName}.s3.${region}.${dnsSuffix}/`);
     if (res.status === 200) {
       console.warn(`Warning: Your bucket ${bucketName} allows public listing of its contents. See https://remotion.dev/docs/lambda/bucket-security for how to fix this.`);
     }
@@ -71562,7 +72086,7 @@ var internalGetOrCreateBucket = async (params) => {
     requestHandler: params.requestHandler
   });
   if (remotionBuckets.length > 1) {
-    throw new Error(`You have multiple buckets (${remotionBuckets.map((b) => b.name)}) in your S3 region (${params.region}) starting with "${params.providerSpecifics.getBucketPrefix()}". Please see https://remotion.dev/docs/lambda/multiple-buckets.`);
+    throw new Error(`You have multiple buckets (${remotionBuckets.map((b2) => b2.name)}) in your S3 region (${params.region}) starting with "${params.providerSpecifics.getBucketPrefix()}". Please see https://remotion.dev/docs/lambda/multiple-buckets.`);
   }
   const { enableFolderExpiry, region } = params;
   if (remotionBuckets.length === 1) {
@@ -71575,7 +72099,11 @@ var internalGetOrCreateBucket = async (params) => {
       forcePathStyle: params.forcePathStyle,
       requestHandler: params.requestHandler
     });
-    await checkBucketListing({ bucketName: existingBucketName, region });
+    await checkBucketListing({
+      bucketName: existingBucketName,
+      region,
+      dnsSuffix: params.providerSpecifics.getServiceDnsSuffix(region)
+    });
     return { bucketName: remotionBuckets[0].name, alreadyExisted: true };
   }
   const bucketName = makeBucketName(params.region, params.providerSpecifics);
@@ -71651,7 +72179,7 @@ var getNeedsToUpload = ({
 }) => {
   const MARGIN = 5000 + MAX_WEBHOOK_CUSTOM_DATA_SIZE;
   const MAX_INLINE_PAYLOAD_SIZE = (type === "still" ? providerSpecifics.getMaxStillInlinePayloadSize() : providerSpecifics.getMaxNonInlinePayloadSizePerFunction()) - MARGIN;
-  const sizesAlreadyUsed = sizes.reduce((a, b) => a + b);
+  const sizesAlreadyUsed = sizes.reduce((a2, b2) => a2 + b2);
   if (sizesAlreadyUsed > MAX_INLINE_PAYLOAD_SIZE) {
     console.warn(`Warning: The props are over ${Math.round(MAX_INLINE_PAYLOAD_SIZE / 1000)}KB (${Math.ceil(sizesAlreadyUsed / 1024)}KB) in size. Uploading them to ${providerSpecifics.serverStorageProductName()} to circumvent AWS Lambda payload size, which may lead to slowdown.`);
     return true;
@@ -72432,22 +72960,22 @@ var findOutputFileInBucket = async ({
     throw err;
   }
 };
-var display = (accrued) => {
+var display = (accrued, currency) => {
   if (accrued < 0.001) {
-    return "<$0.001";
+    return `<${currency === "CNY" ? "¥" : "$"}0.001`;
   }
   return new Intl.NumberFormat("en-US", {
-    currency: "USD",
+    currency,
     style: "currency",
     currencyDisplay: "narrowSymbol",
     minimumFractionDigits: 3
   }).format(accrued);
 };
-var formatCostsInfo = (accrued) => {
+var formatCostsInfo = (accrued, currency = "USD") => {
   return {
     accruedSoFar: accrued,
-    displayCost: display(accrued),
-    currency: "USD",
+    displayCost: display(accrued, currency),
+    currency,
     disclaimer: "Estimated cost only. Does not include charges for other AWS services."
   };
 };
@@ -72535,7 +73063,7 @@ var getOverallProgress = ({
     Boolean(invokedLambda),
     Boolean(visitedServeUrl),
     Boolean(gotComposition)
-  ].reduce((a, b) => Number(a) + Number(b), 0) / 3;
+  ].reduce((a2, b2) => Number(a2) + Number(b2), 0) / 3;
   return evaluationProgress * weights.evaluating + encoding * weights.encoding + invoking * weights.invoking + frames * weights.frames + combining * weights.combining;
 };
 var MAX_MISSING_CHUNKS = 5;
@@ -72682,6 +73210,7 @@ var getProgress = async ({
   functionName,
   requestHandler
 }) => {
+  const billingCurrency = providerSpecifics.getBillingCurrency(region);
   const overallProgress = await getOverallProgressFromStorage({
     renderId,
     bucketName,
@@ -72777,7 +73306,7 @@ var getProgress = async ({
         timeToCombine: overallProgress.timeToCombine
       },
       timeToRenderFrames: overallProgress.timeToRenderFrames,
-      costs: formatCostsInfo(0),
+      costs: formatCostsInfo(0, billingCurrency),
       renderId,
       renderMetadata,
       bucket: bucketName,
@@ -72833,7 +73362,7 @@ var getProgress = async ({
   const allChunks = (overallProgress.chunks ?? []).length / chunkMultiplier === (renderMetadata.totalChunks ?? Infinity);
   const frameCount = NoReactAPIs.getFramesToRender(renderMetadata.frameRange, renderMetadata.everyNthFrame).length;
   const missingChunks = new Array(renderMetadata.totalChunks).fill(true).map((_, i) => i).filter((index) => {
-    return typeof (overallProgress.chunks ?? []).find((c) => c === index) === "undefined";
+    return typeof (overallProgress.chunks ?? []).find((c2) => c2 === index) === "undefined";
   });
   const isBeyondTimeoutAndMissingChunks = Date.now() > renderMetadata.startedDate + timeoutInMilliseconds + 20000 && missingChunks && missingChunks.length > 0;
   const isBeyondTimeoutAndHasStitchTimeout = Date.now() > renderMetadata.startedDate + timeoutInMilliseconds * 2 + 20000;
@@ -72871,7 +73400,7 @@ var getProgress = async ({
           filesDeleted: 0,
           minFilesToDelete: 0
         },
-        costs: priceFromBucket ? formatCostsInfo(priceFromBucket.accruedSoFar) : formatCostsInfo(0),
+        costs: priceFromBucket ? formatCostsInfo(priceFromBucket.accruedSoFar, billingCurrency) : formatCostsInfo(0, billingCurrency),
         currentTime: now,
         done: true,
         encodingStatus: {
@@ -72929,7 +73458,7 @@ var getProgress = async ({
       timeToCombine: overallProgress.timeToCombine
     },
     timeToRenderFrames: overallProgress.timeToRenderFrames,
-    costs: priceFromBucket ? formatCostsInfo(priceFromBucket.accruedSoFar) : formatCostsInfo(0),
+    costs: priceFromBucket ? formatCostsInfo(priceFromBucket.accruedSoFar, billingCurrency) : formatCostsInfo(0, billingCurrency),
     renderId,
     renderMetadata,
     bucket: bucketName,
@@ -73311,6 +73840,51 @@ function getStsClient(region, requestHandler) {
 // src/aws-provider.ts
 import { EventEmitter } from "node:events";
 
+// src/aws-region-metadata.ts
+var regionPartitions = {
+  "af-south-1": "aws",
+  "ap-east-1": "aws",
+  "ap-northeast-1": "aws",
+  "ap-northeast-2": "aws",
+  "ap-northeast-3": "aws",
+  "ap-south-1": "aws",
+  "ap-southeast-1": "aws",
+  "ap-southeast-2": "aws",
+  "ap-southeast-4": "aws",
+  "ap-southeast-5": "aws",
+  "ca-central-1": "aws",
+  "cn-north-1": "aws-cn",
+  "cn-northwest-1": "aws-cn",
+  "eu-central-1": "aws",
+  "eu-central-2": "aws",
+  "eu-north-1": "aws",
+  "eu-south-1": "aws",
+  "eu-west-1": "aws",
+  "eu-west-2": "aws",
+  "eu-west-3": "aws",
+  "sa-east-1": "aws",
+  "us-east-1": "aws",
+  "us-east-2": "aws",
+  "us-west-1": "aws",
+  "us-west-2": "aws"
+};
+var partitionMetadata = {
+  aws: {
+    partition: "aws",
+    dnsSuffix: "amazonaws.com",
+    consoleDomain: "console.aws.amazon.com",
+    billingCurrency: "USD"
+  },
+  "aws-cn": {
+    partition: "aws-cn",
+    dnsSuffix: "amazonaws.com.cn",
+    consoleDomain: "console.amazonaws.cn",
+    billingCurrency: "CNY"
+  }
+};
+var getAwsPartitionMetadata = (partition) => partitionMetadata[partition];
+var getAwsRegionMetadata = (region) => getAwsPartitionMetadata(regionPartitions[region]);
+
 // src/bucket-exists.ts
 var import_client_s32 = __toESM(require_dist_cjs79(), 1);
 
@@ -73458,7 +74032,8 @@ var callLambdaWithStreamingWithoutRetry = async ({
     }
     if (event.InvokeComplete) {
       if (event.InvokeComplete.ErrorCode) {
-        const logs = `https://${region}.console.aws.amazon.com/cloudwatch/home?region=${region}#logsV2:logs-insights$3FqueryDetail$3D~(end~0~start~-3600~timeType~'RELATIVE~unit~'seconds~editorString~'fields*20*40timestamp*2c*20*40requestId*2c*20*40message*0a*7c*20filter*20*40requestId*20like*20*${res.$metadata.requestId}*22*0a*7c*20sort*20*40timestamp*20asc~source~(~'*2faws*2flambda*2f${functionName}))`;
+        const { consoleDomain } = getAwsRegionMetadata(region);
+        const logs = `https://${region}.${consoleDomain}/cloudwatch/home?region=${region}#logsV2:logs-insights$3FqueryDetail$3D~(end~0~start~-3600~timeType~'RELATIVE~unit~'seconds~editorString~'fields*20*40timestamp*2c*20*40requestId*2c*20*40message*0a*7c*20filter*20*40requestId*20like*20*${res.$metadata.requestId}*22*0a*7c*20sort*20*40timestamp*20asc~source~(~'*2faws*2flambda*2f${functionName}))`;
         if (event.InvokeComplete.ErrorCode === "Unhandled") {
           throw new Error(`Lambda function ${functionName} failed with an unhandled error: ${event.InvokeComplete.ErrorDetails} See ${logs} to see the logs of this invocation.`);
         }
@@ -73555,7 +74130,8 @@ var convertToServeUrlImplementation = ({
   if (urlOrId.startsWith("http://") || urlOrId.startsWith("https://")) {
     return urlOrId;
   }
-  return `https://${bucketName}.s3.${region}.amazonaws.com/sites/${urlOrId}/index.html`;
+  const { dnsSuffix } = getAwsRegionMetadata(region);
+  return `https://${bucketName}.s3.${region}.${dnsSuffix}/sites/${urlOrId}/index.html`;
 };
 
 // src/create-bucket.ts
@@ -73601,6 +74177,7 @@ var createBucket = async ({ region, bucketName, forcePathStyle, requestHandler }
   }
   let usedBucketPolicy = false;
   try {
+    const { partition } = getAwsRegionMetadata(region);
     const policy = JSON.stringify({
       Version: "2012-10-17",
       Statement: [
@@ -73609,7 +74186,7 @@ var createBucket = async ({ region, bucketName, forcePathStyle, requestHandler }
           Effect: "Allow",
           Principal: "*",
           Action: "s3:GetObject",
-          Resource: `arn:aws:s3:::${bucketName}/*`
+          Resource: `arn:${partition}:s3:::${bucketName}/*`
         }
       ]
     });
@@ -73679,6 +74256,16 @@ var deleteFunction = async ({
 
 // src/price-per-1s.ts
 var pricing = {
+  "cn-north-1": {
+    "Lambda Requests": { price: "0.00000136" },
+    "Lambda Duration-ARM": { price: "0.000090800" },
+    "Lambda Storage-Duration-ARM": { price: "0.0000002303" }
+  },
+  "cn-northwest-1": {
+    "Lambda Requests": { price: "0.00000136" },
+    "Lambda Duration-ARM": { price: "0.000090800" },
+    "Lambda Storage-Duration-ARM": { price: "0.0000002049" }
+  },
   "af-south-1": {
     "Lambda Duration-Provisioned": {
       rateCode: "X7CK6KFXNWY9RF6Z.JRTCKXETXF.6YS6EN2CT7",
@@ -74487,6 +75074,8 @@ var AWS_REGIONS = [
   "ap-southeast-4",
   "ap-southeast-5",
   "ca-central-1",
+  "cn-north-1",
+  "cn-northwest-1",
   "sa-east-1"
 ];
 
@@ -74590,7 +75179,8 @@ var cloudWatchUrlWithQuery = ({
   functionNameToUse,
   query
 }) => {
-  return `https://${region}.console.aws.amazon.com/cloudwatch/home?region=${region}#logsV2:log-groups/log-group/$252Faws$252Flambda$252F${functionNameToUse}/log-events$3FfilterPattern$3D${encodeAwsUrlParams(query)}`;
+  const { consoleDomain } = getAwsRegionMetadata(region);
+  return `https://${region}.${consoleDomain}/cloudwatch/home?region=${region}#logsV2:log-groups/log-group/$252Faws$252Flambda$252F${functionNameToUse}/log-events$3FfilterPattern$3D${encodeAwsUrlParams(query)}`;
 };
 var getCloudwatchMethodUrl = ({
   region,
@@ -74607,7 +75197,8 @@ var getLambdaInsightsUrl = ({
   region,
   functionName
 }) => {
-  return `https://${region}.console.aws.amazon.com/cloudwatch/home?region=${region}#lambda-insights:functions/${functionName}`;
+  const { consoleDomain } = getAwsRegionMetadata(region);
+  return `https://${region}.${consoleDomain}/cloudwatch/home?region=${region}#lambda-insights:functions/${functionName}`;
 };
 var getCloudwatchRendererUrl = ({ region, functionName, renderId, rendererFunctionName, chunk }) => {
   const functionNameToUse = rendererFunctionName ?? functionName;
@@ -74619,14 +75210,31 @@ var getS3RenderUrl = ({
   region,
   bucketName
 }) => {
-  return `https://s3.console.aws.amazon.com/s3/buckets/${bucketName}?region=${region}&prefix=renders/${renderId}/`;
+  const { consoleDomain, partition } = getAwsRegionMetadata(region);
+  const consoleHost = partition === "aws" ? `s3.${consoleDomain}` : `${region}.${consoleDomain}`;
+  return `https://${consoleHost}/s3/buckets/${bucketName}?region=${region}&prefix=renders/${renderId}/`;
 };
 var getProgressJsonUrl = ({
   region,
   bucketName,
   renderId
 }) => {
-  return `https://${region}.console.aws.amazon.com/s3/object/${bucketName}?region=${region}&bucketType=general&prefix=renders/${renderId}/progress.json`;
+  const { consoleDomain } = getAwsRegionMetadata(region);
+  return `https://${region}.${consoleDomain}/s3/object/${bucketName}?region=${region}&bucketType=general&prefix=renders/${renderId}/progress.json`;
+};
+var getLambdaFunctionUrl = ({
+  region,
+  functionName
+}) => {
+  const { consoleDomain } = getAwsRegionMetadata(region);
+  return `https://${region}.${consoleDomain}/lambda/home#/functions/${functionName}?tab=code`;
+};
+var getS3BucketUrl = ({
+  region,
+  bucketName
+}) => {
+  const { consoleDomain } = getAwsRegionMetadata(region);
+  return `https://${region}.${consoleDomain}/s3/buckets/${bucketName}/?region=${region}`;
 };
 
 // src/get-buckets.ts
@@ -74659,11 +75267,11 @@ var getRemotionBuckets = async ({
   if (!Buckets) {
     return [];
   }
-  const remotionBuckets = Buckets.filter((b) => {
+  const remotionBuckets = Buckets.filter((b2) => {
     if (forceBucketName) {
-      return b.Name === forceBucketName;
+      return b2.Name === forceBucketName;
     }
-    return b.Name?.startsWith(REMOTION_BUCKET_PREFIX);
+    return b2.Name?.startsWith(REMOTION_BUCKET_PREFIX);
   });
   const locations = await Promise.all(remotionBuckets.map(async (bucket) => {
     const { region: parsedRegion } = parseBucketName(bucket.Name);
@@ -74693,7 +75301,7 @@ var getRemotionBuckets = async ({
       name: bucket.Name,
       region: locations[i]
     };
-  }).filter((b) => b.region);
+  }).filter((b2) => b2.region);
   return bucketsWithLocation.filter((bucket) => {
     return bucket.region === region;
   });
@@ -74816,8 +75424,9 @@ var getOutputUrlFromMetadata = ({
     customCredentials,
     bucketNamePrefix: REMOTION_BUCKET_PREFIX
   });
+  const { dnsSuffix } = getAwsRegionMetadata(currentRegion);
   return {
-    url: `https://s3.${currentRegion}.amazonaws.com/${renderBucketName}/${key}`,
+    url: `https://s3.${currentRegion}.${dnsSuffix}/${renderBucketName}/${key}`,
     key
   };
 };
@@ -75566,7 +76175,7 @@ If this is not correct, provide an override value by setting a number
 to input.params.ContentLength in bytes.
 `);
       }
-      this.uploadedParts.sort((a, b) => a.PartNumber - b.PartNumber);
+      this.uploadedParts.sort((a2, b2) => a2.PartNumber - b2.PartNumber);
       const uploadCompleteParams = {
         ...this.params,
         Body: undefined,
@@ -75801,6 +76410,9 @@ var awsImplementation = {
     return MAX_EPHEMERAL_STORAGE_IN_MB;
   },
   estimatePrice,
+  getBillingCurrency: (region) => getAwsRegionMetadata(region).billingCurrency,
+  getRendererFunctionTransport: (region) => getAwsRegionMetadata(region).partition === "aws-cn" ? "s3" : "response-streaming",
+  getServiceDnsSuffix: (region) => getAwsRegionMetadata(region).dnsSuffix,
   getLoggingUrlForMethod: getCloudwatchMethodUrl,
   getLoggingUrlForRendererFunction: getCloudwatchRendererUrl,
   isFlakyError,
@@ -75936,8 +76548,8 @@ var internalDeleteRender = async (input) => {
   });
   let totalSize = 0;
   while (files.length > 0) {
-    totalSize += files.reduce((a, b) => {
-      return a + (b.Size ?? 0);
+    totalSize += files.reduce((a2, b2) => {
+      return a2 + (b2.Size ?? 0);
     }, 0);
     await cleanItems({
       list: files.map((f) => f.Key),
@@ -75980,7 +76592,8 @@ var makeS3ServeUrl = ({
   subFolder,
   region
 }) => {
-  return `https://${bucketName}.s3.${region}.amazonaws.com/${subFolder}/index.html`;
+  const { dnsSuffix } = getAwsRegionMetadata(region);
+  return `https://${bucketName}.s3.${region}.${dnsSuffix}/${subFolder}/index.html`;
 };
 
 // src/get-sites.ts
@@ -76342,7 +76955,7 @@ var makeLambdaRenderStillPayload = async ({
     offthreadVideoCacheSizeInBytes,
     deleteAfter,
     type: ServerlessRoutines.still,
-    streamed: true,
+    streamed: awsImplementation.getRendererFunctionTransport(region) === "response-streaming",
     forcePathStyle,
     licenseKey: licenseKey ?? null,
     offthreadVideoThreads: offthreadVideoThreads ?? null,
@@ -76480,7 +77093,7 @@ var innerRenderStillOnLambda = async (input) => {
   const { functionName, region, onInit } = input;
   try {
     const payload = await makeLambdaRenderStillPayload(input);
-    const res = await new Promise((resolve, reject) => {
+    const res = payload.streamed ? await new Promise((resolve, reject) => {
       awsImplementation.callFunctionStreaming({
         functionName,
         type: ServerlessRoutines.still,
@@ -76518,7 +77131,27 @@ var innerRenderStillOnLambda = async (input) => {
       }).catch((err) => {
         reject(err);
       });
+    }) : await awsImplementation.callFunctionSync({
+      functionName,
+      type: ServerlessRoutines.still,
+      payload,
+      region,
+      timeoutInTest: 120000,
+      requestHandler: input.requestHandler
     });
+    if (!payload.streamed) {
+      onInit?.({
+        renderId: res.renderId,
+        cloudWatchLogs: getCloudwatchMethodUrl({
+          functionName,
+          method: ServerlessRoutines.still,
+          region,
+          rendererFunctionName: null,
+          renderId: res.renderId
+        }),
+        lambdaInsightsUrl: getLambdaInsightsUrl({ functionName, region })
+      });
+    }
     return {
       estimatedPrice: res.estimatedPrice,
       url: res.output,
@@ -77148,6 +77781,8 @@ var LambdaClientInternals = {
   parseJsonOrThrowSource,
   getCloudwatchMethodUrl,
   getCloudwatchRendererUrl,
+  getLambdaFunctionUrl,
+  getS3BucketUrl,
   MAX_EPHEMERAL_STORAGE_IN_MB,
   parseFunctionName,
   isFlakyError,
@@ -77176,7 +77811,9 @@ var LambdaClientInternals = {
   cleanItems,
   makeLambdaRenderStillPayload,
   getRenderProgressPayload,
-  innerSpeculateFunctionName
+  innerSpeculateFunctionName,
+  getAwsPartitionMetadata,
+  getAwsRegionMetadata
 };
 export {
   validateWebhookSignature,