@remotion/promo-pages 4.0.461 → 4.0.463

package/dist/Homepage.js

@@ -1,26 +1,15 @@
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -941,8 +930,21 @@ import * as React6 from "react";
 import React7, { useMemo as useMemo6, useRef as useRef2 } from "react";
 import { useContext as useContext8, useMemo as useMemo7 } from "react";
 import { jsx as jsx7 } from "react/jsx-runtime";
-import { useEffect as useEffect4, useMemo as useMemo11, useState as useState3 } from "react";
-import { useContext as useContext11 } from "react";
+import {
+  forwardRef as forwardRef4,
+  useCallback as useCallback6,
+  useEffect as useEffect5,
+  useMemo as useMemo16,
+  useState as useState6
+} from "react";
+import {
+  forwardRef as forwardRef3,
+  useContext as useContext17,
+  useEffect as useEffect3,
+  useMemo as useMemo14,
+  useState as useState5
+} from "react";
+import { useContext as useContext14, useMemo as useMemo11 } from "react";
 import { createContext as createContext12 } from "react";
 import { useContext as useContext10, useMemo as useMemo9 } from "react";
 import {
@@ -953,52 +955,45 @@ import {
   useState as useState2
 } from "react";
 import { jsx as jsx8 } from "react/jsx-runtime";
-import { useEffect as useEffect3, useMemo as useMemo10, useRef as useRef4 } from "react";
-import { useRef as useRef5 } from "react";
-import { jsx as jsx9 } from "react/jsx-runtime";
-import {
-  forwardRef as forwardRef3,
-  useContext as useContext16,
-  useEffect as useEffect5,
-  useMemo as useMemo16,
-  useState as useState6
-} from "react";
-import { useContext as useContext14, useMemo as useMemo13 } from "react";
+import { useContext as useContext11 } from "react";
 import { useContext as useContext13 } from "react";
-import { useContext as useContext12, useMemo as useMemo12 } from "react";
-import { jsx as jsx10 } from "react/jsx-runtime";
+import { useContext as useContext12, useMemo as useMemo10 } from "react";
+import { jsx as jsx9 } from "react/jsx-runtime";
 import { createContext as createContext14 } from "react";
-import React12, { useCallback as useCallback5, useMemo as useMemo14, useRef as useRef6, useState as useState4 } from "react";
-import { jsx as jsx11 } from "react/jsx-runtime";
-import React13, { forwardRef as forwardRef2, useState as useState5, useContext as useContext15, useMemo as useMemo15 } from "react";
+import React11, { useCallback as useCallback5, useMemo as useMemo12, useRef as useRef4, useState as useState3 } from "react";
+import { jsx as jsx10 } from "react/jsx-runtime";
+import React12, { forwardRef as forwardRef2, useState as useState4, useContext as useContext16, useMemo as useMemo13 } from "react";
+import { useContext as useContext15, useRef as useRef5 } from "react";
 import { createContext as createContext15 } from "react";
+import { jsx as jsx11 } from "react/jsx-runtime";
+import { useEffect as useEffect4, useMemo as useMemo15, useRef as useRef6 } from "react";
 import { jsx as jsx12 } from "react/jsx-runtime";
 import {
-  forwardRef as forwardRef4,
+  forwardRef as forwardRef5,
   useEffect as useEffect6,
   useImperativeHandle as useImperativeHandle2,
   useLayoutEffect as useLayoutEffect2,
   useRef as useRef8,
   useState as useState7
 } from "react";
-import React15, { useCallback as useCallback6, useImperativeHandle, useRef as useRef7 } from "react";
+import React15, { useCallback as useCallback7, useImperativeHandle, useRef as useRef7 } from "react";
 import { jsx as jsx13 } from "react/jsx-runtime";
 import { jsx as jsx14 } from "react/jsx-runtime";
 import {
   createContext as createContext16,
-  forwardRef as forwardRef5,
-  useCallback as useCallback7,
-  useContext as useContext17,
+  forwardRef as forwardRef6,
+  useCallback as useCallback8,
+  useContext as useContext18,
   useLayoutEffect as useLayoutEffect3,
   useMemo as useMemo17,
   useRef as useRef9,
   useState as useState8
 } from "react";
 import { jsx as jsx15 } from "react/jsx-runtime";
-import { useContext as useContext18, useLayoutEffect as useLayoutEffect5, useState as useState10 } from "react";
+import { useContext as useContext19, useLayoutEffect as useLayoutEffect5, useState as useState10 } from "react";
 import {
   createContext as createContext17,
-  useCallback as useCallback8,
+  useCallback as useCallback9,
   useImperativeHandle as useImperativeHandle3,
   useLayoutEffect as useLayoutEffect4,
   useMemo as useMemo18,
@@ -1006,29 +1001,29 @@ import {
   useState as useState9
 } from "react";
 import { jsx as jsx16 } from "react/jsx-runtime";
-import { forwardRef as forwardRef8, useCallback as useCallback13, useContext as useContext30 } from "react";
+import { forwardRef as forwardRef9, useCallback as useCallback14, useContext as useContext31 } from "react";
 import React17, { createContext as createContext18, useMemo as useMemo19 } from "react";
 import { jsx as jsx17 } from "react/jsx-runtime";
-import { useContext as useContext19 } from "react";
+import { useContext as useContext20 } from "react";
 import { createContext as createContext19, useEffect as useEffect7, useState as useState11 } from "react";
 import { jsx as jsx18 } from "react/jsx-runtime";
 import { createContext as createContext20, useMemo as useMemo20, useReducer } from "react";
 import { jsx as jsx19 } from "react/jsx-runtime";
 import React23, {
-  forwardRef as forwardRef6,
-  useContext as useContext28,
+  forwardRef as forwardRef7,
+  useContext as useContext29,
   useEffect as useEffect14,
   useImperativeHandle as useImperativeHandle4,
   useMemo as useMemo28,
   useRef as useRef18,
   useState as useState16
 } from "react";
-import { useContext as useContext21, useLayoutEffect as useLayoutEffect6, useRef as useRef13 } from "react";
+import { useContext as useContext22, useLayoutEffect as useLayoutEffect6, useRef as useRef13 } from "react";
 import React20, {
   createContext as createContext21,
   createRef as createRef2,
-  useCallback as useCallback9,
-  useContext as useContext20,
+  useCallback as useCallback10,
+  useContext as useContext21,
   useMemo as useMemo22,
   useRef as useRef11,
   useState as useState12
@@ -1036,20 +1031,20 @@ import React20, {
 import { useMemo as useMemo21 } from "react";
 import { jsx as jsx20, jsxs as jsxs22 } from "react/jsx-runtime";
 import { useRef as useRef12 } from "react";
-import { useContext as useContext23, useEffect as useEffect8, useMemo as useMemo23, useState as useState13 } from "react";
-import { useContext as useContext22 } from "react";
+import { useContext as useContext24, useEffect as useEffect8, useMemo as useMemo23, useState as useState13 } from "react";
+import { useContext as useContext23 } from "react";
 import {
-  useCallback as useCallback12,
-  useContext as useContext26,
+  useCallback as useCallback13,
+  useContext as useContext27,
   useEffect as useEffect12,
   useLayoutEffect as useLayoutEffect8,
   useRef as useRef17
 } from "react";
-import { useCallback as useCallback11, useMemo as useMemo26, useRef as useRef15 } from "react";
-import { useContext as useContext25, useMemo as useMemo25 } from "react";
+import { useCallback as useCallback12, useMemo as useMemo26, useRef as useRef15 } from "react";
+import { useContext as useContext26, useMemo as useMemo25 } from "react";
 import React21, {
-  useCallback as useCallback10,
-  useContext as useContext24,
+  useCallback as useCallback11,
+  useContext as useContext25,
   useEffect as useEffect9,
   useLayoutEffect as useLayoutEffect7,
   useMemo as useMemo24,
@@ -1061,11 +1056,11 @@ import React22 from "react";
 import { useEffect as useEffect10, useState as useState15 } from "react";
 import { useEffect as useEffect11, useRef as useRef16 } from "react";
 import { useEffect as useEffect13 } from "react";
-import { createContext as createContext22, useContext as useContext27, useMemo as useMemo27 } from "react";
+import { createContext as createContext22, useContext as useContext28, useMemo as useMemo27 } from "react";
 import { jsx as jsx222 } from "react/jsx-runtime";
 import {
-  forwardRef as forwardRef7,
-  useContext as useContext29,
+  forwardRef as forwardRef8,
+  useContext as useContext30,
   useEffect as useEffect15,
   useImperativeHandle as useImperativeHandle5,
   useLayoutEffect as useLayoutEffect9,
@@ -1074,11 +1069,11 @@ import {
 } from "react";
 import { jsx as jsx23 } from "react/jsx-runtime";
 import { jsx as jsx24 } from "react/jsx-runtime";
-import { forwardRef as forwardRef9, useCallback as useCallback14, useState as useState17 } from "react";
+import { forwardRef as forwardRef10, useCallback as useCallback15, useState as useState17 } from "react";
 import { jsx as jsx25 } from "react/jsx-runtime";
 import {
-  useCallback as useCallback15,
-  useContext as useContext31,
+  useCallback as useCallback16,
+  useContext as useContext32,
   useImperativeHandle as useImperativeHandle6,
   useLayoutEffect as useLayoutEffect10,
   useRef as useRef20,
@@ -1088,7 +1083,7 @@ import { jsx as jsx26 } from "react/jsx-runtime";
 import { createRef as createRef3 } from "react";
 import React28 from "react";
 import {
-  useCallback as useCallback16,
+  useCallback as useCallback17,
   useImperativeHandle as useImperativeHandle7,
   useMemo as useMemo30,
   useRef as useRef21,
@@ -1097,15 +1092,15 @@ import {
 import { jsx as jsx27 } from "react/jsx-runtime";
 import React29 from "react";
 import { useMemo as useMemo32 } from "react";
-import { createContext as createContext23, useContext as useContext32, useMemo as useMemo31 } from "react";
+import { createContext as createContext23, useContext as useContext33, useMemo as useMemo31 } from "react";
 import { jsx as jsx28 } from "react/jsx-runtime";
 import { jsx as jsx29 } from "react/jsx-runtime";
 import React31 from "react";
 import React32, { createContext as createContext24 } from "react";
-import { useCallback as useCallback18 } from "react";
+import { useCallback as useCallback19 } from "react";
 import {
-  useCallback as useCallback17,
-  useContext as useContext33,
+  useCallback as useCallback18,
+  useContext as useContext34,
   useEffect as useEffect16,
   useLayoutEffect as useLayoutEffect11,
   useMemo as useMemo33,
@@ -1113,8 +1108,8 @@ import {
 } from "react";
 import { jsx as jsx30 } from "react/jsx-runtime";
 import React34, {
-  forwardRef as forwardRef10,
-  useContext as useContext34,
+  forwardRef as forwardRef11,
+  useContext as useContext35,
   useEffect as useEffect18,
   useImperativeHandle as useImperativeHandle8,
   useMemo as useMemo34,
@@ -1126,16 +1121,16 @@ import { jsx as jsx31 } from "react/jsx-runtime";
 import { jsx as jsx32 } from "react/jsx-runtime";
 import React36, { useMemo as useMemo35 } from "react";
 import { jsx as jsx33 } from "react/jsx-runtime";
-import { Children, forwardRef as forwardRef11, useMemo as useMemo36 } from "react";
+import { Children, forwardRef as forwardRef12, useMemo as useMemo36 } from "react";
 import React37 from "react";
 import React38, { createContext as createContext25 } from "react";
 import { jsx as jsx34 } from "react/jsx-runtime";
 import { jsx as jsx35 } from "react/jsx-runtime";
 import React40 from "react";
-import { forwardRef as forwardRef13, useCallback as useCallback19, useContext as useContext36 } from "react";
+import { forwardRef as forwardRef14, useCallback as useCallback20, useContext as useContext37 } from "react";
 import {
-  forwardRef as forwardRef12,
-  useContext as useContext35,
+  forwardRef as forwardRef13,
+  useContext as useContext36,
   useEffect as useEffect19,
   useImperativeHandle as useImperativeHandle9,
   useLayoutEffect as useLayoutEffect12,
@@ -1145,13 +1140,17 @@ import {
 import { jsx as jsx36 } from "react/jsx-runtime";
 import { jsx as jsx37 } from "react/jsx-runtime";
 var __defProp2 = Object.defineProperty;
+var __returnValue2 = (v) => v;
+function __exportSetter2(name, newValue) {
+  this[name] = __returnValue2.bind(null, newValue);
+}
 var __export2 = (target, all) => {
   for (var name in all)
     __defProp2(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter2.bind(all, name)
     });
 };
 if (typeof createContext !== "function") {
@@ -2211,6 +2210,81 @@ var Composition = (props) => {
     ...props
   });
 };
+var componentsToAddStacksTo = [];
+var getComponentsToAddStacksTo = () => componentsToAddStacksTo;
+var addSequenceStackTraces = (component) => {
+  componentsToAddStacksTo.push(component);
+};
+var sequenceStyleSchema = {
+  "style.translate": {
+    type: "translate",
+    step: 1,
+    default: "0px 0px",
+    description: "Offset"
+  },
+  "style.scale": {
+    type: "number",
+    min: 0.05,
+    max: 100,
+    step: 0.01,
+    default: 1,
+    description: "Scale"
+  },
+  "style.rotate": {
+    type: "rotation",
+    step: 1,
+    default: "0deg",
+    description: "Rotation"
+  },
+  "style.opacity": {
+    type: "number",
+    min: 0,
+    max: 1,
+    step: 0.01,
+    default: 1,
+    description: "Opacity"
+  },
+  premountFor: {
+    type: "number",
+    default: 0,
+    description: "Premount For",
+    min: 0,
+    step: 1
+  },
+  postmountFor: {
+    type: "hidden"
+  },
+  styleWhilePremounted: {
+    type: "hidden"
+  },
+  styleWhilePostmounted: {
+    type: "hidden"
+  }
+};
+var hiddenField = {
+  type: "boolean",
+  default: false,
+  description: "Hidden"
+};
+var sequenceSchema = {
+  hidden: hiddenField,
+  layout: {
+    type: "enum",
+    default: "absolute-fill",
+    description: "Layout",
+    variants: {
+      "absolute-fill": sequenceStyleSchema,
+      none: {}
+    }
+  }
+};
+var sequenceSchemaDefaultLayoutNone = {
+  ...sequenceSchema,
+  layout: {
+    ...sequenceSchema.layout,
+    default: "none"
+  }
+};
 var SequenceContext = createContext12(null);
 var exports_timeline_position_state = {};
 __export2(exports_timeline_position_state, {
@@ -2416,314 +2490,13 @@ var useCurrentFrame = () => {
   const contextOffset = context ? context.cumulatedFrom + context.relativeFrom : 0;
   return frame - contextOffset;
 };
-var flattenEffects = (effects) => {
-  const out = [];
-  for (const item of effects) {
-    if (Array.isArray(item)) {
-      for (const inner of item) {
-        out.push(inner);
-      }
-    } else {
-      out.push(item);
-    }
-  }
-  return out;
-};
-var groupByBackend = (effects) => {
-  const runs = [];
-  let current = [];
-  let currentBackend = null;
-  for (const eff of effects) {
-    const { backend } = eff.definition;
-    if (currentBackend === null || backend === currentBackend) {
-      current.push(eff);
-      currentBackend = backend;
-    } else {
-      runs.push({ backend: currentBackend, effects: current });
-      current = [eff];
-      currentBackend = backend;
-    }
-  }
-  if (currentBackend !== null && current.length > 0) {
-    runs.push({ backend: currentBackend, effects: current });
-  }
-  return runs;
-};
-
-class CanvasPool {
-  width;
-  height;
-  pairs = new Map;
-  lostContexts = new Set;
-  constructor(width, height) {
-    this.width = width;
-    this.height = height;
-  }
-  getPair(backend) {
-    const existing = this.pairs.get(backend);
-    if (existing) {
-      return existing;
-    }
-    const pair = [
-      this.allocateCanvas(backend),
-      this.allocateCanvas(backend)
-    ];
-    this.pairs.set(backend, pair);
-    return pair;
-  }
-  assertContextNotLost(canvas) {
-    if (this.lostContexts.has(canvas)) {
-      throw new Error("WebGL context was lost during canvas effect rendering. " + "This typically happens in headless or memory-constrained environments (e.g. Remotion Lambda). " + "Try reducing concurrency or increasing the Lambda function memory.");
-    }
-  }
-  allocateCanvas(backend) {
-    const canvas = document.createElement("canvas");
-    canvas.width = this.width;
-    canvas.height = this.height;
-    switch (backend) {
-      case "2d": {
-        const ctx = canvas.getContext("2d", {
-          colorSpace: "srgb"
-        });
-        if (!ctx) {
-          throw new Error("Failed to acquire 2D context for canvas effect");
-        }
-        return canvas;
-      }
-      case "webgl2": {
-        const ctx = canvas.getContext("webgl2", {
-          premultipliedAlpha: true,
-          alpha: true,
-          preserveDrawingBuffer: true
-        });
-        if (!ctx) {
-          throw new Error("Failed to acquire WebGL2 context for canvas effect");
-        }
-        canvas.addEventListener("webglcontextlost", (e) => {
-          e.preventDefault();
-          this.lostContexts.add(canvas);
-        });
-        canvas.addEventListener("webglcontextrestored", () => {
-          this.lostContexts.delete(canvas);
-        });
-        ctx.pixelStorei(ctx.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
-        return canvas;
-      }
-      case "webgpu": {
-        if (typeof navigator === "undefined" || !("gpu" in navigator)) {
-          throw new Error("WebGPU is not available in this environment for canvas effect");
-        }
-        return canvas;
-      }
-      default: {
-        const exhaustive = backend;
-        throw new Error(`Unknown effect backend: ${exhaustive}`);
-      }
-    }
-  }
-}
-var devicePromise = null;
-var getGpuDevice = () => {
-  if (devicePromise) {
-    return devicePromise;
-  }
-  devicePromise = (async () => {
-    if (typeof navigator === "undefined" || !("gpu" in navigator)) {
-      throw new Error("WebGPU is not available in this environment");
-    }
-    const { gpu } = navigator;
-    const adapter = await gpu.requestAdapter();
-    if (!adapter) {
-      throw new Error("No WebGPU adapter available");
-    }
-    return adapter.requestDevice();
-  })();
-  return devicePromise;
-};
-var createEffectChainState = (width, height) => ({
-  pool: new CanvasPool(width, height),
-  setupCache: new WeakMap,
-  cleanupRegistry: [],
-  currentRunId: 0
-});
-var cleanupEffectChainState = (state) => {
-  state.currentRunId++;
-  for (const entry of state.cleanupRegistry) {
-    entry.definition.cleanup(entry.state);
-  }
-};
-var ensureSetup = (state, def, target) => {
-  const widened = def;
-  if (state.setupCache.has(widened)) {
-    return state.setupCache.get(widened);
-  }
-  const setupState = def.setup(target);
-  state.setupCache.set(widened, setupState);
-  state.cleanupRegistry.push({ definition: widened, state: setupState });
-  return setupState;
-};
-var runEffectChain = async ({
-  state,
-  source,
-  effects,
-  output,
-  frame,
-  width,
-  height
-}) => {
-  const runId = ++state.currentRunId;
-  const isCancelled = () => state.currentRunId !== runId;
-  const runs = groupByBackend(effects);
-  let currentImage = source;
-  let lastTarget = null;
-  if (runs.length === 0) {
-    if (source === output) {
-      return true;
-    }
-    const ctx = output.getContext("2d");
-    if (!ctx) {
-      throw new Error("Failed to acquire 2D context for output canvas");
-    }
-    ctx.clearRect(0, 0, width, height);
-    ctx.drawImage(currentImage, 0, 0, width, height);
-    return true;
-  }
-  let needsGpuDevice = false;
-  for (const run of runs) {
-    if (run.backend === "webgpu") {
-      needsGpuDevice = true;
-      break;
-    }
-  }
-  const gpuDevice = needsGpuDevice ? await getGpuDevice() : null;
-  if (isCancelled()) {
-    return false;
-  }
-  for (let runIndex = 0;runIndex < runs.length; runIndex++) {
-    const run = runs[runIndex];
-    const [a, b] = state.pool.getPair(run.backend);
-    let dst = a;
-    for (const eff of run.effects) {
-      const def = eff.definition;
-      const setupState = ensureSetup(state, def, dst);
-      def.apply({
-        source: currentImage,
-        target: dst,
-        state: setupState,
-        params: eff.params,
-        frame,
-        width,
-        height,
-        gpuDevice
-      });
-      if (run.backend === "webgl2") {
-        state.pool.assertContextNotLost(dst);
-      }
-      currentImage = dst;
-      dst = dst === a ? b : a;
-    }
-    lastTarget = currentImage ?? lastTarget;
-    const nextRun = runs[runIndex + 1];
-    if (nextRun && nextRun.backend !== run.backend && lastTarget) {
-      const bitmap = await createImageBitmap(lastTarget);
-      if (isCancelled()) {
-        bitmap.close();
-        return false;
-      }
-      currentImage = bitmap;
-    }
-  }
-  if (!lastTarget) {
-    return true;
-  }
-  const outCtx = output.getContext("2d");
-  if (!outCtx) {
-    throw new Error("Failed to acquire 2D context for output canvas");
-  }
-  outCtx.clearRect(0, 0, width, height);
-  outCtx.drawImage(lastTarget, 0, 0, width, height);
-  return true;
-};
-var useEffectChainState = () => {
-  const chainStateRef = useRef4(null);
-  const sizeRef = useRef4(null);
-  useEffect3(() => {
-    return () => {
-      if (chainStateRef.current) {
-        cleanupEffectChainState(chainStateRef.current);
-      }
-    };
-  }, []);
-  return useMemo10(() => ({
-    get: (width, height) => {
-      if (!sizeRef.current || sizeRef.current.width !== width || sizeRef.current.height !== height) {
-        if (chainStateRef.current) {
-          cleanupEffectChainState(chainStateRef.current);
-        }
-        chainStateRef.current = createEffectChainState(width, height);
-        sizeRef.current = { width, height };
-      }
-      return chainStateRef.current;
-    }
-  }), []);
-};
-var useMemoizedEffects = (effects) => {
-  const previousRef = useRef5(null);
-  const previous = previousRef.current;
-  const isSame = previous !== null && previous.length === effects.length && previous.every((p, i) => p.definition === effects[i].definition && p.effectKey === effects[i].effectKey);
-  if (isSame) {
-    return previous;
-  }
-  const next = effects.map((e) => ({
-    definition: e.definition,
-    stack: e.stack,
-    effectKey: e.effectKey,
-    params: e.params,
-    memoized: true
-  }));
-  previousRef.current = next;
-  return next;
-};
-var componentsToAddStacksTo = [];
-var getComponentsToAddStacksTo = () => componentsToAddStacksTo;
-var addSequenceStackTraces = (component) => {
-  componentsToAddStacksTo.push(component);
-};
-var VERSION = "4.0.461";
-var checkMultipleRemotionVersions = () => {
-  if (typeof globalThis === "undefined") {
-    return;
-  }
-  const set = () => {
-    globalThis.remotion_imported = VERSION;
-    if (typeof window !== "undefined") {
-      window.remotion_imported = VERSION;
-    }
-  };
-  const alreadyImported = globalThis.remotion_imported || typeof window !== "undefined" && window.remotion_imported;
-  if (alreadyImported) {
-    if (alreadyImported === VERSION) {
-      return;
-    }
-    if (typeof alreadyImported === "string" && alreadyImported.includes("webcodecs")) {
-      set();
-      return;
-    }
-    throw new TypeError(`\uD83D\uDEA8 Multiple versions of Remotion detected: ${[
-      VERSION,
-      typeof alreadyImported === "string" ? alreadyImported : "an older version"
-    ].filter(truthy).join(" and ")}. This will cause things to break in an unexpected way.
-Check that all your Remotion packages are on the same version. If your dependencies depend on Remotion, make them peer dependencies. You can also run \`npx remotion versions\` from your terminal to see which versions are mismatching.`);
-  }
-  set();
-};
 var useUnsafeVideoConfig = () => {
   const context = useContext12(SequenceContext);
   const ctxWidth = context?.width ?? null;
   const ctxHeight = context?.height ?? null;
   const ctxDuration = context?.durationInFrames ?? null;
   const video = useVideo();
-  return useMemo12(() => {
+  return useMemo10(() => {
     if (!video) {
       return null;
     }
@@ -2797,7 +2570,7 @@ var Freeze = ({
   if (!Number.isFinite(frameToFreeze)) {
     throw new Error(`The 'frame' prop of <Freeze /> must be a finite number, but it is ${frameToFreeze}.`);
   }
-  const isActive = useMemo13(() => {
+  const isActive = useMemo11(() => {
     if (typeof active === "boolean") {
       return active;
     }
@@ -2808,7 +2581,7 @@ var Freeze = ({
   const timelineContext = useTimelineContext();
   const sequenceContext = useContext14(SequenceContext);
   const relativeFrom = sequenceContext?.relativeFrom ?? 0;
-  const timelineValue = useMemo13(() => {
+  const timelineValue = useMemo11(() => {
     if (!isActive) {
       return timelineContext;
     }
@@ -2823,7 +2596,7 @@ var Freeze = ({
       }
     };
   }, [isActive, timelineContext, videoConfig.id, frameToFreeze, relativeFrom]);
-  const newSequenceContext = useMemo13(() => {
+  const newSequenceContext = useMemo11(() => {
     if (!sequenceContext) {
       return null;
     }
@@ -2835,9 +2608,9 @@ var Freeze = ({
       cumulatedFrom: 0
     };
   }, [sequenceContext, isActive]);
-  return /* @__PURE__ */ jsx10(TimelineContext.Provider, {
+  return /* @__PURE__ */ jsx9(TimelineContext.Provider, {
     value: timelineValue,
-    children: /* @__PURE__ */ jsx10(SequenceContext.Provider, {
+    children: /* @__PURE__ */ jsx9(SequenceContext.Provider, {
       value: newSequenceContext,
       children
     })
@@ -2846,74 +2619,7 @@ var Freeze = ({
 var PremountContext = createContext14({
   premountFramesRemaining: 0
 });
-var sequenceStyleSchema = {
-  "style.translate": {
-    type: "translate",
-    step: 1,
-    default: "0px 0px",
-    description: "Offset"
-  },
-  "style.scale": {
-    type: "number",
-    min: 0.05,
-    max: 100,
-    step: 0.01,
-    default: 1,
-    description: "Scale"
-  },
-  "style.rotate": {
-    type: "rotation",
-    step: 1,
-    default: "0deg",
-    description: "Rotation"
-  },
-  "style.opacity": {
-    type: "number",
-    min: 0,
-    max: 1,
-    step: 0.01,
-    default: 1,
-    description: "Opacity"
-  },
-  premountFor: {
-    type: "number",
-    default: 0,
-    description: "Premount For",
-    min: 0,
-    step: 1
-  },
-  postmountFor: {
-    type: "hidden"
-  },
-  styleWhilePremounted: {
-    type: "hidden"
-  },
-  styleWhilePostmounted: {
-    type: "hidden"
-  }
-};
-var sequenceSchema = {
-  layout: {
-    type: "enum",
-    default: "absolute-fill",
-    description: "Layout",
-    variants: {
-      "absolute-fill": sequenceStyleSchema,
-      none: {}
-    }
-  }
-};
-var sequenceSchemaDefaultLayoutNone = {
-  ...sequenceSchema,
-  layout: {
-    ...sequenceSchema.layout,
-    default: "none"
-  }
-};
-var nodePathToString = (nodePath) => {
-  return nodePath.join(".");
-};
-var SequenceManager = React12.createContext({
+var SequenceManager = React11.createContext({
   registerSequence: () => {
     throw new Error("SequenceManagerContext not initialized");
   },
@@ -2922,62 +2628,57 @@ var SequenceManager = React12.createContext({
   },
   sequences: []
 });
-var SequenceVisibilityToggleContext = React12.createContext({
-  hidden: {},
-  setHidden: () => {
-    throw new Error("SequenceVisibilityToggle not initialized");
-  }
-});
-var getCodeValuesCtx = (codeValues, nodePath) => {
-  const status = codeValues[nodePathToString(nodePath)];
-  if (!status) {
-    return;
-  }
-  if (!status.canUpdate) {
-    return;
-  }
-  return status.props;
+var makeSequencePropsSubscriptionKey = (key) => {
+  return `${key.nodePath.join(".")}.${key.sequenceKeys.join(".")}.${key.effectKeys.map((keys) => keys.join(".")).join(".")}`;
 };
-var VisualModeCodeValuesContext = React12.createContext({
-  getCodeValues: () => {
-    throw new Error("VisualModeCodeValuesContext not initialized");
-  }
+var VisualModeCodeValuesContext = React11.createContext({
+  codeValues: {}
 });
-var VisualModeDragOverridesContext = React12.createContext({
+var VisualModeDragOverridesContext = React11.createContext({
   getDragOverrides: () => {
     throw new Error("VisualModeDragOverridesContext not initialized");
+  },
+  getEffectDragOverrides: () => {
+    throw new Error("VisualModeDragOverridesContext not initialized");
   }
 });
-var VisualModeSettersContext = React12.createContext({
+var VisualModeSettersContext = React11.createContext({
   setDragOverrides: () => {
     throw new Error("VisualModeSettersContext not initialized");
   },
   clearDragOverrides: () => {
     throw new Error("VisualModeSettersContext not initialized");
   },
+  setEffectDragOverrides: () => {
+    throw new Error("VisualModeSettersContext not initialized");
+  },
+  clearEffectDragOverrides: () => {
+    throw new Error("VisualModeSettersContext not initialized");
+  },
   setCodeValues: () => {
     throw new Error("VisualModeSettersContext not initialized");
   }
 });
+var effectDragOverridesKey = (nodePath, effectIndex) => `${makeSequencePropsSubscriptionKey(nodePath)}.effects.${effectIndex}`;
 var SequenceManagerProvider = ({ children }) => {
-  const [sequences, setSequences] = useState4([]);
-  const [hidden, setHidden] = useState4({});
-  const [dragOverrides, setControlOverrides] = useState4({});
-  const controlOverridesRef = useRef6(dragOverrides);
+  const [sequences, setSequences] = useState3([]);
+  const [dragOverrides, setControlOverrides] = useState3({});
+  const controlOverridesRef = useRef4(dragOverrides);
   controlOverridesRef.current = dragOverrides;
-  const [codeValues, setCodeValuesMapState] = useState4({});
+  const [effectDragOverridesState, setEffectDragOverridesState] = useState3({});
+  const [codeValues, setCodeValuesMapState] = useState3({});
   const setDragOverrides = useCallback5((nodePath, key, value) => {
     setControlOverrides((prev) => ({
       ...prev,
-      [nodePathToString(nodePath)]: {
-        ...prev[nodePathToString(nodePath)],
+      [makeSequencePropsSubscriptionKey(nodePath)]: {
+        ...prev[makeSequencePropsSubscriptionKey(nodePath)],
         [key]: value
       }
     }));
   }, []);
   const clearDragOverrides = useCallback5((nodePath) => {
     setControlOverrides((prev) => {
-      const key = nodePathToString(nodePath);
+      const key = makeSequencePropsSubscriptionKey(nodePath);
       if (!prev[key]) {
         return prev;
       }
@@ -2986,9 +2687,32 @@ var SequenceManagerProvider = ({ children }) => {
       return next;
     });
   }, []);
+  const setEffectDragOverrides = useCallback5((nodePath, effectIndex, key, value) => {
+    setEffectDragOverridesState((prev) => {
+      const mapKey = effectDragOverridesKey(nodePath, effectIndex);
+      return {
+        ...prev,
+        [mapKey]: {
+          ...prev[mapKey],
+          [key]: value
+        }
+      };
+    });
+  }, []);
+  const clearEffectDragOverrides = useCallback5((nodePath, effectIndex) => {
+    setEffectDragOverridesState((prev) => {
+      const mapKey = effectDragOverridesKey(nodePath, effectIndex);
+      if (!prev[mapKey]) {
+        return prev;
+      }
+      const next = { ...prev };
+      delete next[mapKey];
+      return next;
+    });
+  }, []);
   const setCodeValues = useCallback5((nodePath, values) => {
     setCodeValuesMapState((prev) => {
-      const key = nodePathToString(nodePath);
+      const key = makeSequencePropsSubscriptionKey(nodePath);
       const prevKey = prev[key];
       const newKey = values(prevKey);
       if (prevKey === newKey) {
@@ -3005,54 +2729,54 @@ var SequenceManagerProvider = ({ children }) => {
   const unregisterSequence = useCallback5((seq) => {
     setSequences((seqs) => seqs.filter((s) => s.id !== seq));
   }, []);
-  const sequenceContext = useMemo14(() => {
+  const sequenceContext = useMemo12(() => {
     return {
       registerSequence,
       sequences,
       unregisterSequence
     };
   }, [registerSequence, sequences, unregisterSequence]);
-  const hiddenContext = useMemo14(() => {
-    return {
-      hidden,
-      setHidden
-    };
-  }, [hidden]);
   const getDragOverrides = useCallback5((nodePath) => {
-    return dragOverrides[nodePathToString(nodePath)] ?? {};
+    return dragOverrides[makeSequencePropsSubscriptionKey(nodePath)] ?? {};
   }, [dragOverrides]);
-  const getCodeValues = useCallback5((nodePath) => {
-    return getCodeValuesCtx(codeValues, nodePath);
-  }, [codeValues]);
-  const codeValuesContext = useMemo14(() => {
+  const getEffectDragOverrides = useCallback5((nodePath, effectIndex) => {
+    return effectDragOverridesState[effectDragOverridesKey(nodePath, effectIndex)] ?? {};
+  }, [effectDragOverridesState]);
+  const codeValuesContext = useMemo12(() => {
     return {
-      getCodeValues
+      codeValues
     };
-  }, [getCodeValues]);
-  const dragOverridesContext = useMemo14(() => {
+  }, [codeValues]);
+  const dragOverridesContext = useMemo12(() => {
     return {
-      getDragOverrides
+      getDragOverrides,
+      getEffectDragOverrides
     };
-  }, [getDragOverrides]);
-  const settersContext = useMemo14(() => {
+  }, [getDragOverrides, getEffectDragOverrides]);
+  const settersContext = useMemo12(() => {
     return {
       setDragOverrides,
       clearDragOverrides,
+      setEffectDragOverrides,
+      clearEffectDragOverrides,
       setCodeValues
     };
-  }, [setDragOverrides, clearDragOverrides, setCodeValues]);
-  return /* @__PURE__ */ jsx11(SequenceManager.Provider, {
+  }, [
+    setDragOverrides,
+    clearDragOverrides,
+    setEffectDragOverrides,
+    clearEffectDragOverrides,
+    setCodeValues
+  ]);
+  return /* @__PURE__ */ jsx10(SequenceManager.Provider, {
     value: sequenceContext,
-    children: /* @__PURE__ */ jsx11(SequenceVisibilityToggleContext.Provider, {
-      value: hiddenContext,
-      children: /* @__PURE__ */ jsx11(VisualModeCodeValuesContext.Provider, {
-        value: codeValuesContext,
-        children: /* @__PURE__ */ jsx11(VisualModeDragOverridesContext.Provider, {
-          value: dragOverridesContext,
-          children: /* @__PURE__ */ jsx11(VisualModeSettersContext.Provider, {
-            value: settersContext,
-            children
-          })
+    children: /* @__PURE__ */ jsx10(VisualModeCodeValuesContext.Provider, {
+      value: codeValuesContext,
+      children: /* @__PURE__ */ jsx10(VisualModeDragOverridesContext.Provider, {
+        value: dragOverridesContext,
+        children: /* @__PURE__ */ jsx10(VisualModeSettersContext.Provider, {
+          value: settersContext,
+          children
         })
       })
     })
@@ -3090,6 +2814,144 @@ var deleteNestedKey = (obj, keysToRemove) => {
   }
   return obj;
 };
+var OverrideIdsToNodePathsGettersContext = createContext15({
+  overrideIdToNodePathMappings: {}
+});
+var OverrideIdsToNodePathsSettersContext = createContext15({
+  setOverrideIdToNodePath: () => {
+    throw new Error("OverrideIdsToNodePathsSettersContext not initialized");
+  }
+});
+var mergeOverrides = ({
+  descriptor,
+  codeOverrides,
+  dragOverrides
+}) => {
+  if (!codeOverrides && !dragOverrides) {
+    return { params: descriptor.params, effectKey: descriptor.effectKey };
+  }
+  const merged = {
+    ...descriptor.params
+  };
+  if (codeOverrides) {
+    for (const [key, value] of Object.entries(codeOverrides)) {
+      if (value !== undefined) {
+        merged[key] = value;
+      }
+    }
+  }
+  if (dragOverrides) {
+    for (const [key, value] of Object.entries(dragOverrides)) {
+      merged[key] = value;
+    }
+  }
+  return {
+    params: merged,
+    effectKey: descriptor.definition.calculateKey(merged)
+  };
+};
+var extractCodeOverrides = (propStatus) => {
+  if (!propStatus) {
+    return null;
+  }
+  const out = {};
+  let hasAny = false;
+  for (const [key, status] of Object.entries(propStatus)) {
+    if (status.canUpdate) {
+      out[key] = status.codeValue;
+      hasAny = true;
+    }
+  }
+  return hasAny ? out : null;
+};
+var useMemoizedEffectDefinitions = (effects) => {
+  const previousRef = useRef5(null);
+  const definitions = effects.map((descriptor) => descriptor.definition);
+  const previous = previousRef.current;
+  const isSame = previous !== null && previous.length === definitions.length && previous.every((def, i) => def === definitions[i]);
+  if (isSame) {
+    return previous;
+  }
+  previousRef.current = definitions;
+  return definitions;
+};
+var getEffectCodeValuesCtx = ({
+  codeValues,
+  nodePath,
+  effectIndex
+}) => {
+  const status = codeValues[makeSequencePropsSubscriptionKey(nodePath)];
+  if (!status) {
+    return { type: "cannot-update-sequence", reason: "not-found" };
+  }
+  if (!status.canUpdate) {
+    return { type: "cannot-update-sequence", reason: status.reason };
+  }
+  const effect = status.effects.find((e) => e.effectIndex === effectIndex);
+  if (!effect) {
+    return { type: "cannot-update-effect", reason: "not-found" };
+  }
+  if (!effect.canUpdate) {
+    return { type: "cannot-update-effect", reason: effect.reason };
+  }
+  return { type: "can-update-effect", props: effect.props };
+};
+var getCodeValuesCtx = (codeValues, nodePath) => {
+  const status = codeValues[makeSequencePropsSubscriptionKey(nodePath)];
+  if (!status) {
+    return;
+  }
+  if (!status.canUpdate) {
+    return;
+  }
+  return status.props;
+};
+var useMemoizedEffects = ({
+  effects,
+  overrideId
+}) => {
+  const previousRef = useRef5(null);
+  const { codeValues } = useContext15(VisualModeCodeValuesContext);
+  const { getEffectDragOverrides } = useContext15(VisualModeDragOverridesContext);
+  const { overrideIdToNodePathMappings } = useContext15(OverrideIdsToNodePathsGettersContext);
+  const previous = previousRef.current;
+  const nodePath = overrideId ? overrideIdToNodePathMappings[overrideId] ?? null : null;
+  const resolved = effects.map((descriptor, index) => {
+    if (nodePath === null) {
+      return {
+        descriptor,
+        params: descriptor.params,
+        effectKey: descriptor.effectKey
+      };
+    }
+    const effectStatus = getEffectCodeValuesCtx({
+      codeValues,
+      nodePath,
+      effectIndex: index
+    });
+    const codeOverrides = effectStatus.type === "can-update-effect" ? extractCodeOverrides(effectStatus.props) : null;
+    const dragOverridesMap = getEffectDragOverrides(nodePath, index);
+    const dragOverrides = Object.keys(dragOverridesMap).length === 0 ? null : dragOverridesMap;
+    const { params, effectKey } = mergeOverrides({
+      descriptor,
+      codeOverrides,
+      dragOverrides
+    });
+    return { descriptor, params, effectKey };
+  });
+  const isSame = previous !== null && previous.length === resolved.length && previous.every((p, i) => p.definition === resolved[i].descriptor.definition && p.effectKey === resolved[i].effectKey);
+  if (isSame) {
+    return previous;
+  }
+  const next = resolved.map(({ descriptor, params, effectKey }) => ({
+    definition: descriptor.definition,
+    effectKey,
+    params,
+    memoized: true
+  }));
+  previousRef.current = next;
+  return next;
+};
 var flattenActiveSchema = (schema, resolve) => {
   const out = {};
   for (const key of Object.keys(schema)) {
@@ -3131,14 +2993,6 @@ var getFlatSchemaWithAllKeys = (schema) => {
   }
   return out;
 };
-var OverrideIdsToNodePathsGettersContext = createContext15({
-  overrideIdToNodePathMappings: {}
-});
-var OverrideIdsToNodePathsSettersContext = createContext15({
-  setOverrideIdToNodePath: () => {
-    throw new Error("OverrideIdsToNodePathsSettersContext not initialized");
-  }
-});
 var findPropsToDelete = ({
   schema,
   key,
@@ -3171,7 +3025,6 @@ var findPropsToDelete = ({
 };
 var getEffectiveVisualModeValue = ({
   codeValue,
-  runtimeValue,
   dragOverrideValue,
   defaultValue,
   shouldResortToDefaultValueIfUndefined = false
@@ -3179,12 +3032,6 @@ var getEffectiveVisualModeValue = ({
   if (dragOverrideValue !== undefined) {
     return dragOverrideValue;
   }
-  if (!codeValue) {
-    return runtimeValue;
-  }
-  if (!codeValue.canUpdate) {
-    return runtimeValue;
-  }
   if (codeValue.codeValue === undefined && shouldResortToDefaultValueIfUndefined) {
     return defaultValue;
   }
@@ -3221,9 +3068,8 @@ var computeEffectiveSchemaValuesDotNotation = ({
     if (field?.type === "hidden") {
       continue;
     }
-    const value = getEffectiveVisualModeValue({
+    const value = codeValueStatus === null || codeValueStatus.canUpdate === false ? currentValue[key] : getEffectiveVisualModeValue({
       codeValue: codeValueStatus,
-      runtimeValue: currentValue[key],
       dragOverrideValue: overrideValues[key],
       defaultValue: field?.default,
       shouldResortToDefaultValueIfUndefined: false
@@ -3303,22 +3149,22 @@ var wrapInSchema = (Component, schema) => {
   const Wrapped = forwardRef2((props, ref) => {
     const env = useRemotionEnvironment();
     if (!env.isStudio || env.isReadOnlyStudio || env.isRendering) {
-      return React13.createElement(Component, {
+      return React12.createElement(Component, {
         ...props,
         _experimentalControls: null,
         ref
       });
     }
-    const { getCodeValues } = useContext15(VisualModeCodeValuesContext);
-    const { getDragOverrides } = useContext15(VisualModeDragOverridesContext);
-    const nodePathMapping = useContext15(OverrideIdsToNodePathsGettersContext);
+    const { codeValues } = useContext16(VisualModeCodeValuesContext);
+    const { getDragOverrides } = useContext16(VisualModeDragOverridesContext);
+    const nodePathMapping = useContext16(OverrideIdsToNodePathsGettersContext);
     if (props._experimentalControls) {
-      return React13.createElement(Component, {
+      return React12.createElement(Component, {
         ...props,
         ref
       });
     }
-    const [overrideId] = useState5(() => {
+    const [overrideId] = useState4(() => {
       const { stack } = props;
       if (!stack) {
         return String(Math.random());
@@ -3333,26 +3179,26 @@ var wrapInSchema = (Component, schema) => {
     });
     const nodePath = nodePathMapping.overrideIdToNodePathMappings[overrideId] ?? null;
     const runtimeValues = flatKeys.map((k) => getNestedValue(props, k));
-    const currentRuntimeValueDotNotation = useMemo15(() => readValuesFromProps(props, flatKeys), runtimeValues);
-    const controls = useMemo15(() => {
+    const currentRuntimeValueDotNotation = useMemo13(() => readValuesFromProps(props, flatKeys), runtimeValues);
+    const controls = useMemo13(() => {
       return {
         schema,
         currentRuntimeValueDotNotation,
         overrideId
       };
     }, [currentRuntimeValueDotNotation, overrideId]);
-    const { merged: valuesDotNotation, propsToDelete } = useMemo15(() => {
+    const { merged: valuesDotNotation, propsToDelete } = useMemo13(() => {
       return computeEffectiveSchemaValuesDotNotation({
         schema,
         currentValue: currentRuntimeValueDotNotation,
         overrideValues: nodePath === null ? {} : getDragOverrides(nodePath),
-        propStatus: nodePath === null ? undefined : getCodeValues(nodePath)
+        propStatus: nodePath === null ? undefined : getCodeValuesCtx(codeValues, nodePath)
       });
     }, [
       currentRuntimeValueDotNotation,
       getDragOverrides,
       nodePath,
-      getCodeValues
+      codeValues
     ]);
     const activeKeys = selectActiveKeys(schema, valuesDotNotation);
     const mergedProps = mergeValues({
@@ -3361,7 +3207,7 @@ var wrapInSchema = (Component, schema) => {
       schemaKeys: activeKeys,
       propsToDelete
     });
-    return React13.createElement(Component, {
+    return React12.createElement(Component, {
       ...mergedProps,
       _experimentalControls: controls,
       ref
@@ -3378,6 +3224,7 @@ var RegularSequenceRefForwardingFunction = ({
   height,
   width,
   showInTimeline = true,
+  hidden = false,
   _experimentalControls: controls,
   _experimentalEffects,
   _remotionInternalLoopDisplay: loopDisplay,
@@ -3388,8 +3235,8 @@ var RegularSequenceRefForwardingFunction = ({
   ...other
 }, ref) => {
   const { layout = "absolute-fill" } = other;
-  const [id] = useState6(() => String(Math.random()));
-  const parentSequence = useContext16(SequenceContext);
+  const [id] = useState5(() => String(Math.random()));
+  const parentSequence = useContext17(SequenceContext);
   const { rootId } = useTimelineContext();
   const cumulatedFrom = parentSequence ? parentSequence.cumulatedFrom + parentSequence.relativeFrom : 0;
   const nonce = useNonce();
@@ -3415,15 +3262,14 @@ var RegularSequenceRefForwardingFunction = ({
   const videoConfig = useVideoConfig();
   const parentSequenceDuration = parentSequence ? Math.min(parentSequence.durationInFrames - from, durationInFrames) : durationInFrames;
   const actualDurationInFrames = Math.max(0, Math.min(videoConfig.durationInFrames - from, parentSequenceDuration));
-  const { registerSequence, unregisterSequence } = useContext16(SequenceManager);
-  const { hidden } = useContext16(SequenceVisibilityToggleContext);
-  const premounting = useMemo16(() => {
+  const { registerSequence, unregisterSequence } = useContext17(SequenceManager);
+  const premounting = useMemo14(() => {
     return parentSequence?.premounting || Boolean(other._remotionInternalIsPremounting);
   }, [other._remotionInternalIsPremounting, parentSequence?.premounting]);
-  const postmounting = useMemo16(() => {
+  const postmounting = useMemo14(() => {
     return parentSequence?.postmounting || Boolean(other._remotionInternalIsPostmounting);
   }, [other._remotionInternalIsPostmounting, parentSequence?.postmounting]);
-  const contextValue = useMemo16(() => {
+  const contextValue = useMemo14(() => {
     return {
       cumulatedFrom,
       relativeFrom: from,
@@ -3450,12 +3296,13 @@ var RegularSequenceRefForwardingFunction = ({
     premountDisplay,
     postmountDisplay
   ]);
-  const timelineClipName = useMemo16(() => {
+  const timelineClipName = useMemo14(() => {
     return name ?? "";
   }, [name]);
   const env = useRemotionEnvironment();
   const inheritedStack = other?.stack ?? null;
-  useEffect5(() => {
+  const [stackDoesntChange] = useState5(() => stack ?? inheritedStack);
+  useEffect3(() => {
     if (!env.isStudio) {
       return;
     }
@@ -3478,7 +3325,7 @@ var RegularSequenceRefForwardingFunction = ({
         rootId,
         showInTimeline,
         src: isMedia.data.src,
-        stack: stack ?? inheritedStack,
+        stack: stackDoesntChange,
         startMediaFrom: isMedia.data.startMediaFrom,
         volume: isMedia.data.volumes
       });
@@ -3497,7 +3344,7 @@ var RegularSequenceRefForwardingFunction = ({
       showInTimeline,
       nonce: nonce.get(),
       loopDisplay,
-      stack: stack ?? inheritedStack,
+      stack: stackDoesntChange,
       premountDisplay: premountDisplay ?? null,
       postmountDisplay: postmountDisplay ?? null,
       controls: controls ?? null,
@@ -3520,11 +3367,10 @@ var RegularSequenceRefForwardingFunction = ({
     showInTimeline,
     nonce,
     loopDisplay,
-    stack,
+    stackDoesntChange,
     premountDisplay,
     postmountDisplay,
     env.isStudio,
-    inheritedStack,
     controls,
     _experimentalEffects,
     isMedia
@@ -3532,7 +3378,7 @@ var RegularSequenceRefForwardingFunction = ({
   const endThreshold = Math.ceil(cumulatedFrom + from + durationInFrames - 1);
   const content = absoluteFrame < cumulatedFrom + from ? null : absoluteFrame > endThreshold ? null : children;
   const styleIfThere = other.layout === "none" ? undefined : other.style;
-  const defaultStyle = useMemo16(() => {
+  const defaultStyle = useMemo14(() => {
     return {
       flexDirection: undefined,
       ...width ? { width } : {},
@@ -3543,13 +3389,12 @@ var RegularSequenceRefForwardingFunction = ({
   if (ref !== null && layout === "none") {
     throw new TypeError('It is not supported to pass both a `ref` and `layout="none"` to <Sequence />.');
   }
-  const isSequenceHidden = hidden[id] ?? false;
-  if (isSequenceHidden) {
+  if (hidden) {
     return null;
   }
-  return /* @__PURE__ */ jsx12(SequenceContext.Provider, {
+  return /* @__PURE__ */ jsx11(SequenceContext.Provider, {
     value: contextValue,
-    children: content === null ? null : other.layout === "none" ? content : /* @__PURE__ */ jsx12(AbsoluteFill, {
+    children: content === null ? null : other.layout === "none" ? content : /* @__PURE__ */ jsx11(AbsoluteFill, {
       ref,
       style: defaultStyle,
       className: other.className,
@@ -3559,7 +3404,7 @@ var RegularSequenceRefForwardingFunction = ({
 };
 var RegularSequence = forwardRef3(RegularSequenceRefForwardingFunction);
 var PremountedPostmountedSequenceRefForwardingFunction = (props, ref) => {
-  const parentPremountContext = useContext16(PremountContext);
+  const parentPremountContext = useContext17(PremountContext);
   const frame = useCurrentFrame() - parentPremountContext.premountFramesRemaining;
   if (props.layout === "none") {
     throw new Error('`<Sequence>` with `premountFor` and `postmountFor` props does not support layout="none"');
@@ -3579,7 +3424,7 @@ var PremountedPostmountedSequenceRefForwardingFunction = (props, ref) => {
   const postmountingActive = frame > endThreshold && frame <= endThreshold + postmountFor;
   const freezeFrame = premountingActive ? from : postmountingActive ? from + durationInFrames - 1 : 0;
   const isFreezingActive = premountingActive || postmountingActive;
-  const style = useMemo16(() => {
+  const style = useMemo14(() => {
     return {
       ...passedStyle,
       opacity: premountingActive || postmountingActive ? 0 : 1,
@@ -3594,10 +3439,10 @@ var PremountedPostmountedSequenceRefForwardingFunction = (props, ref) => {
     styleWhilePremounted,
     styleWhilePostmounted
   ]);
-  return /* @__PURE__ */ jsx12(Freeze, {
+  return /* @__PURE__ */ jsx11(Freeze, {
     frame: freezeFrame,
     active: isFreezingActive,
-    children: /* @__PURE__ */ jsx12(SequenceInner, {
+    children: /* @__PURE__ */ jsx11(SequenceInner, {
       ref,
       from,
       durationInFrames,
@@ -3617,20 +3462,437 @@ var SequenceRefForwardingFunction = (props, ref) => {
   if (props.layout !== "none" && !env.isRendering) {
     const effectivePremountFor = ENABLE_V5_BREAKING_CHANGES ? props.premountFor ?? fps : props.premountFor;
     if (effectivePremountFor || props.postmountFor) {
-      return /* @__PURE__ */ jsx12(PremountedPostmountedSequence, {
+      return /* @__PURE__ */ jsx11(PremountedPostmountedSequence, {
         ref,
         ...props,
         premountFor: effectivePremountFor
       });
     }
   }
-  return /* @__PURE__ */ jsx12(RegularSequence, {
+  return /* @__PURE__ */ jsx11(RegularSequence, {
     ...props,
     ref
   });
 };
 var SequenceInner = forwardRef3(SequenceRefForwardingFunction);
 var Sequence = wrapInSchema(SequenceInner, sequenceSchema);
+
+class CanvasPool {
+  width;
+  height;
+  pairs = new Map;
+  lostContexts = new Set;
+  constructor(width, height) {
+    this.width = width;
+    this.height = height;
+  }
+  getPair(backend) {
+    const existing = this.pairs.get(backend);
+    if (existing) {
+      return existing;
+    }
+    const pair = [
+      this.allocateCanvas(backend),
+      this.allocateCanvas(backend)
+    ];
+    this.pairs.set(backend, pair);
+    return pair;
+  }
+  assertContextNotLost(canvas) {
+    if (this.lostContexts.has(canvas)) {
+      throw new Error("WebGL context was lost during canvas effect rendering. " + "This typically happens in headless or memory-constrained environments (e.g. Remotion Lambda). " + "Try reducing concurrency or increasing the Lambda function memory.");
+    }
+  }
+  allocateCanvas(backend) {
+    const canvas = document.createElement("canvas");
+    canvas.width = this.width;
+    canvas.height = this.height;
+    switch (backend) {
+      case "2d": {
+        const ctx = canvas.getContext("2d", {
+          colorSpace: "srgb"
+        });
+        if (!ctx) {
+          throw new Error("Failed to acquire 2D context for canvas effect");
+        }
+        return canvas;
+      }
+      case "webgl2": {
+        const ctx = canvas.getContext("webgl2", {
+          premultipliedAlpha: true,
+          alpha: true,
+          preserveDrawingBuffer: true
+        });
+        if (!ctx) {
+          throw new Error("Failed to acquire WebGL2 context for canvas effect");
+        }
+        canvas.addEventListener("webglcontextlost", (e) => {
+          e.preventDefault();
+          this.lostContexts.add(canvas);
+        });
+        canvas.addEventListener("webglcontextrestored", () => {
+          this.lostContexts.delete(canvas);
+        });
+        ctx.pixelStorei(ctx.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
+        return canvas;
+      }
+      case "webgpu": {
+        if (typeof navigator === "undefined" || !("gpu" in navigator)) {
+          throw new Error("WebGPU is not available in this environment for canvas effect");
+        }
+        return canvas;
+      }
+      default: {
+        const exhaustive = backend;
+        throw new Error(`Unknown effect backend: ${exhaustive}`);
+      }
+    }
+  }
+}
+var groupByBackend = (effects) => {
+  const runs = [];
+  let current = [];
+  let currentBackend = null;
+  for (const eff of effects) {
+    const { backend } = eff.definition;
+    if (currentBackend === null || backend === currentBackend) {
+      current.push(eff);
+      currentBackend = backend;
+    } else {
+      runs.push({ backend: currentBackend, effects: current });
+      current = [eff];
+      currentBackend = backend;
+    }
+  }
+  if (currentBackend !== null && current.length > 0) {
+    runs.push({ backend: currentBackend, effects: current });
+  }
+  return runs;
+};
+var devicePromise = null;
+var getGpuDevice = () => {
+  if (devicePromise) {
+    return devicePromise;
+  }
+  devicePromise = (async () => {
+    if (typeof navigator === "undefined" || !("gpu" in navigator)) {
+      throw new Error("WebGPU is not available in this environment");
+    }
+    const { gpu } = navigator;
+    const adapter = await gpu.requestAdapter();
+    if (!adapter) {
+      throw new Error("No WebGPU adapter available");
+    }
+    return adapter.requestDevice();
+  })();
+  return devicePromise;
+};
+var createEffectChainState = (width, height) => ({
+  pool: new CanvasPool(width, height),
+  setupCache: new WeakMap,
+  cleanupRegistry: [],
+  currentRunId: 0
+});
+var cleanupEffectChainState = (state) => {
+  state.currentRunId++;
+  for (const entry of state.cleanupRegistry) {
+    entry.definition.cleanup(entry.state);
+  }
+};
+var ensureSetup = (state, def, target) => {
+  const widened = def;
+  if (state.setupCache.has(widened)) {
+    return state.setupCache.get(widened);
+  }
+  const setupState = def.setup(target);
+  state.setupCache.set(widened, setupState);
+  state.cleanupRegistry.push({ definition: widened, state: setupState });
+  return setupState;
+};
+var runEffectChain = async ({
+  state,
+  source,
+  effects,
+  output,
+  width,
+  height
+}) => {
+  const runId = ++state.currentRunId;
+  const isCancelled = () => state.currentRunId !== runId;
+  const enabledEffects = effects.filter((e) => !e.params.disabled);
+  const runs = groupByBackend(enabledEffects);
+  let currentImage = source;
+  let lastTarget = null;
+  if (runs.length === 0) {
+    if (source === output) {
+      return true;
+    }
+    const ctx = output.getContext("2d");
+    if (!ctx) {
+      throw new Error("Failed to acquire 2D context for output canvas");
+    }
+    ctx.clearRect(0, 0, width, height);
+    ctx.drawImage(currentImage, 0, 0, width, height);
+    return true;
+  }
+  let needsGpuDevice = false;
+  for (const run of runs) {
+    if (run.backend === "webgpu") {
+      needsGpuDevice = true;
+      break;
+    }
+  }
+  const gpuDevice = needsGpuDevice ? await getGpuDevice() : null;
+  if (isCancelled()) {
+    return false;
+  }
+  for (let runIndex = 0;runIndex < runs.length; runIndex++) {
+    const run = runs[runIndex];
+    const [a, b] = state.pool.getPair(run.backend);
+    let dst = a;
+    for (const eff of run.effects) {
+      const def = eff.definition;
+      const setupState = ensureSetup(state, def, dst);
+      def.apply({
+        source: currentImage,
+        target: dst,
+        state: setupState,
+        params: eff.params,
+        width,
+        height,
+        gpuDevice
+      });
+      if (run.backend === "webgl2") {
+        state.pool.assertContextNotLost(dst);
+      }
+      currentImage = dst;
+      dst = dst === a ? b : a;
+    }
+    lastTarget = currentImage ?? lastTarget;
+    const nextRun = runs[runIndex + 1];
+    if (nextRun && nextRun.backend !== run.backend && lastTarget) {
+      const bitmap = await createImageBitmap(lastTarget);
+      if (isCancelled()) {
+        bitmap.close();
+        return false;
+      }
+      currentImage = bitmap;
+    }
+  }
+  if (!lastTarget) {
+    return true;
+  }
+  const outCtx = output.getContext("2d");
+  if (!outCtx) {
+    throw new Error("Failed to acquire 2D context for output canvas");
+  }
+  outCtx.clearRect(0, 0, width, height);
+  outCtx.drawImage(lastTarget, 0, 0, width, height);
+  return true;
+};
+var useEffectChainState = () => {
+  const chainStateRef = useRef6(null);
+  const sizeRef = useRef6(null);
+  useEffect4(() => {
+    return () => {
+      if (chainStateRef.current) {
+        cleanupEffectChainState(chainStateRef.current);
+      }
+    };
+  }, []);
+  return useMemo15(() => ({
+    get: (width, height) => {
+      if (!sizeRef.current || sizeRef.current.width !== width || sizeRef.current.height !== height) {
+        if (chainStateRef.current) {
+          cleanupEffectChainState(chainStateRef.current);
+        }
+        chainStateRef.current = createEffectChainState(width, height);
+        sizeRef.current = { width, height };
+      }
+      return chainStateRef.current;
+    }
+  }), []);
+};
+var solidSchema = {
+  color: {
+    type: "color",
+    default: "#ffffff",
+    description: "Color"
+  },
+  width: {
+    type: "number",
+    min: 1,
+    step: 1,
+    default: 1920,
+    description: "Width"
+  },
+  height: {
+    type: "number",
+    min: 1,
+    step: 1,
+    default: 1080,
+    description: "Height"
+  },
+  ...sequenceStyleSchema
+};
+var SolidInner = ({
+  color,
+  width,
+  height,
+  _experimentalEffects: experimentalEffects = [],
+  className,
+  style,
+  overrideId,
+  ref
+}) => {
+  const { delayRender: delayRender2, continueRender: continueRender2, cancelRender: cancelRender2 } = useDelayRender();
+  const [outputCanvas, setOutputCanvas] = useState6(null);
+  const memoizedEffects = useMemoizedEffects({
+    effects: experimentalEffects,
+    overrideId: overrideId ?? null
+  });
+  const sourceCanvas = useMemo16(() => {
+    if (typeof document === "undefined") {
+      return null;
+    }
+    const canvas = document.createElement("canvas");
+    canvas.width = 1;
+    canvas.height = 1;
+    return canvas;
+  }, []);
+  const chainState = useEffectChainState();
+  const canvasRef = useCallback6((canvas) => {
+    setOutputCanvas(canvas);
+    if (typeof ref === "function") {
+      ref(canvas);
+    } else if (ref) {
+      ref.current = canvas;
+    }
+  }, [ref]);
+  useEffect5(() => {
+    if (!outputCanvas || !sourceCanvas) {
+      return;
+    }
+    const handle = delayRender2("Solid effect chain");
+    if (!chainState) {
+      continueRender2(handle);
+      return () => {
+        continueRender2(handle);
+      };
+    }
+    const ctx = sourceCanvas.getContext("2d", { colorSpace: "srgb" });
+    if (!ctx) {
+      cancelRender2(new Error("Failed to acquire 2D context for <Solid> source"));
+      return;
+    }
+    ctx.fillStyle = color;
+    ctx.fillRect(0, 0, 1, 1);
+    runEffectChain({
+      state: chainState.get(width, height),
+      source: sourceCanvas,
+      effects: memoizedEffects,
+      output: outputCanvas,
+      width,
+      height
+    }).then((completed) => {
+      if (completed) {
+        continueRender2(handle);
+      }
+    }).catch((err) => {
+      cancelRender2(err);
+    });
+    return () => {
+      continueRender2(handle);
+    };
+  }, [
+    color,
+    outputCanvas,
+    sourceCanvas,
+    chainState,
+    width,
+    height,
+    delayRender2,
+    continueRender2,
+    cancelRender2,
+    memoizedEffects
+  ]);
+  return /* @__PURE__ */ jsx12("canvas", {
+    ref: canvasRef,
+    width,
+    height,
+    className,
+    style
+  });
+};
+var SolidOuter = forwardRef4(({
+  _experimentalEffects = [],
+  _experimentalControls: controls,
+  color,
+  height,
+  width,
+  className,
+  durationInFrames,
+  style,
+  name,
+  from,
+  hidden,
+  showInTimeline,
+  ...props
+}, ref) => {
+  const memoizedEffectDefinitions = useMemoizedEffectDefinitions(_experimentalEffects);
+  return /* @__PURE__ */ jsx12(Sequence, {
+    layout: "none",
+    from,
+    hidden,
+    showInTimeline,
+    _experimentalControls: controls,
+    _experimentalEffects: memoizedEffectDefinitions,
+    durationInFrames,
+    name: name ?? "<Solid>",
+    ...props,
+    children: /* @__PURE__ */ jsx12(SolidInner, {
+      ref,
+      overrideId: controls?.overrideId ?? null,
+      color,
+      height,
+      width,
+      className,
+      style,
+      _experimentalEffects
+    })
+  });
+});
+var Solid = wrapInSchema(SolidOuter, solidSchema);
+Solid.displayName = "Solid";
+addSequenceStackTraces(Solid);
+var VERSION = "4.0.463";
+var checkMultipleRemotionVersions = () => {
+  if (typeof globalThis === "undefined") {
+    return;
+  }
+  const set = () => {
+    globalThis.remotion_imported = VERSION;
+    if (typeof window !== "undefined") {
+      window.remotion_imported = VERSION;
+    }
+  };
+  const alreadyImported = globalThis.remotion_imported || typeof window !== "undefined" && window.remotion_imported;
+  if (alreadyImported) {
+    if (alreadyImported === VERSION) {
+      return;
+    }
+    if (typeof alreadyImported === "string" && alreadyImported.includes("webcodecs")) {
+      set();
+      return;
+    }
+    throw new TypeError(`\uD83D\uDEA8 Multiple versions of Remotion detected: ${[
+      VERSION,
+      typeof alreadyImported === "string" ? alreadyImported : "an older version"
+    ].filter(truthy).join(" and ")}. This will cause things to break in an unexpected way.
+Check that all your Remotion packages are on the same version. If your dependencies depend on Remotion, make them peer dependencies. You can also run \`npx remotion versions\` from your terminal to see which versions are mismatching.`);
+  }
+  set();
+};
 var calcArgs = (fit, frameSize, canvasSize) => {
   switch (fit) {
     case "fill": {
@@ -3681,7 +3943,7 @@ var calcArgs = (fit, frameSize, canvasSize) => {
 };
 var CanvasRefForwardingFunction = ({ width, height, fit, className, style }, ref) => {
   const canvasRef = useRef7(null);
-  const draw = useCallback6((imageData) => {
+  const draw = useCallback7((imageData) => {
     const canvas = canvasRef.current;
     const canvasWidth = width ?? imageData.displayWidth;
     const canvasHeight = height ?? imageData.displayHeight;
@@ -3873,7 +4135,19 @@ var resolveAnimatedImageSource = (src) => {
   }
   return new URL(src, window.origin).href;
 };
-var AnimatedImage = forwardRef4(({
+var animatedImageSchema = {
+  playbackRate: {
+    type: "number",
+    min: 0,
+    max: 10,
+    step: 0.1,
+    default: 1,
+    description: "Playback Rate"
+  },
+  ...sequenceStyleSchema,
+  hidden: hiddenField
+};
+var AnimatedImageContent = forwardRef5(({
   src,
   width,
   height,
@@ -3980,6 +4254,52 @@ var AnimatedImage = forwardRef4(({
     ...props
   });
 });
+AnimatedImageContent.displayName = "AnimatedImageContent";
+var AnimatedImageInner = ({
+  src,
+  width,
+  height,
+  onError,
+  fit,
+  playbackRate,
+  loopBehavior,
+  id,
+  className,
+  style,
+  durationInFrames,
+  _experimentalControls: controls,
+  ref,
+  ...sequenceProps
+}) => {
+  const { durationInFrames: videoDuration } = useVideoConfig();
+  const resolvedDuration = durationInFrames ?? videoDuration;
+  const animatedImageProps = {
+    src,
+    width,
+    height,
+    onError,
+    fit,
+    playbackRate,
+    loopBehavior,
+    id,
+    className,
+    style
+  };
+  return /* @__PURE__ */ jsx14(Sequence, {
+    layout: "none",
+    durationInFrames: resolvedDuration,
+    name: "<AnimatedImage>",
+    _experimentalControls: controls,
+    ...sequenceProps,
+    children: /* @__PURE__ */ jsx14(AnimatedImageContent, {
+      ...animatedImageProps,
+      ref
+    })
+  });
+};
+var AnimatedImage = wrapInSchema(AnimatedImageInner, animatedImageSchema);
+AnimatedImage.displayName = "AnimatedImage";
+addSequenceStackTraces(AnimatedImage);
 var cachedSupport = null;
 var isHtmlInCanvasSupported = () => {
   if (cachedSupport !== null) {
@@ -3993,6 +4313,7 @@ var isHtmlInCanvasSupported = () => {
   cachedSupport = typeof ctx?.drawElementImage === "function" && typeof canvas.requestPaint === "function" && typeof canvas.captureElementImage === "function";
   return cachedSupport;
 };
+var HTML_IN_CANVAS_UNSUPPORTED_MESSAGE = "HTML in Canvas is not supported. Two common causes: Chrome is older than version 148 (update Chrome), or the HTML-in-Canvas flag is disabled at chrome://flags/#canvas-draw-element (enable it and restart Chrome).";
 function assertHtmlInCanvasDimensions(width, height) {
   if (typeof width !== "number" || typeof height !== "number") {
     throw new Error(`HtmlInCanvas: \`width\` and \`height\` must be numbers. Received width=${String(width)}, height=${String(height)}.`);
@@ -4018,30 +4339,16 @@ var defaultOnPaint = ({
   element.style.transform = transform.toString();
 };
 var HtmlInCanvasAncestorContext = createContext16(false);
-var HtmlInCanvasInner = forwardRef5(({
-  width,
-  height,
-  _experimentalEffects: effects = [],
-  children,
-  onPaint,
-  onInit,
-  _experimentalControls: controls,
-  style,
-  durationInFrames,
-  ...sequenceProps
-}, ref) => {
-  const isInsideAncestorHtmlInCanvas = useContext17(HtmlInCanvasAncestorContext);
+var HtmlInCanvasContent = forwardRef6(({ width, height, effects, children, onPaint, onInit, controls, style }, ref) => {
+  const isInsideAncestorHtmlInCanvas = useContext18(HtmlInCanvasAncestorContext);
   assertHtmlInCanvasDimensions(width, height);
   const { continueRender: continueRender2, cancelRender: cancelRender2 } = useDelayRender();
   if (!isHtmlInCanvasSupported()) {
-    cancelRender2(new Error("HTML in Canvas is not supported. Open this page in Chrome Canary with chrome://flags/#canvas-draw-element enabled."));
+    cancelRender2(new Error(HTML_IN_CANVAS_UNSUPPORTED_MESSAGE));
   }
-  const { durationInFrames: videoDuration } = useVideoConfig();
-  const resolvedDuration = durationInFrames ?? videoDuration;
-  const frame = useCurrentFrame();
   const canvas2dRef = useRef9(null);
   const divRef = useRef9(null);
-  const setLayoutCanvasRef = useCallback7((node) => {
+  const setLayoutCanvasRef = useCallback8((node) => {
     canvas2dRef.current = node;
     if (typeof ref === "function") {
       ref(node);
@@ -4051,11 +4358,12 @@ var HtmlInCanvasInner = forwardRef5(({
   }, [ref]);
   const [offscreenCanvas] = useState8(() => new OffscreenCanvas(1, 1));
   const chainState = useEffectChainState();
-  const memoizedEffects = useMemoizedEffects(flattenEffects(effects));
+  const memoizedEffects = useMemoizedEffects({
+    effects,
+    overrideId: controls?.overrideId ?? null
+  });
   const effectsRef = useRef9(memoizedEffects);
   effectsRef.current = memoizedEffects;
-  const frameRef = useRef9(frame);
-  frameRef.current = frame;
   const onPaintRef = useRef9(onPaint);
   onPaintRef.current = onPaint;
   const onInitRef = useRef9(onInit);
@@ -4063,7 +4371,7 @@ var HtmlInCanvasInner = forwardRef5(({
   const initializedRef = useRef9(false);
   const onInitCleanupRef = useRef9(null);
   const unmountedRef = useRef9(false);
-  const onPaintCb = useCallback7(async () => {
+  const onPaintCb = useCallback8(async () => {
     const element = divRef.current;
     if (!element) {
       throw new Error("Canvas or scene element not found");
@@ -4112,7 +4420,6 @@ var HtmlInCanvasInner = forwardRef5(({
         source: offscreenCanvas,
         effects: effectsRef.current,
         output: canvas2dRef.current,
-        frame: frameRef.current,
         width,
         height
       });
@@ -4176,31 +4483,64 @@ var HtmlInCanvasInner = forwardRef5(({
   if (isInsideAncestorHtmlInCanvas) {
     throw new Error("<HtmlInCanvas> effects cannot be nested together. Chrome will only display the outer effect. Consider merging the effects into one if you can.");
   }
+  return /* @__PURE__ */ jsx15(HtmlInCanvasAncestorContext.Provider, {
+    value: true,
+    children: /* @__PURE__ */ jsx15("canvas", {
+      ref: setLayoutCanvasRef,
+      width,
+      height,
+      style,
+      children: /* @__PURE__ */ jsx15("div", {
+        ref: divRef,
+        style: innerStyle,
+        children
+      })
+    })
+  });
+});
+HtmlInCanvasContent.displayName = "HtmlInCanvasContent";
+var HtmlInCanvasInner = forwardRef6(({
+  width,
+  height,
+  _experimentalEffects: effects = [],
+  children,
+  onPaint,
+  onInit,
+  _experimentalControls: controls,
+  style,
+  durationInFrames,
+  name,
+  ...sequenceProps
+}, ref) => {
+  const { durationInFrames: videoDuration } = useVideoConfig();
+  const resolvedDuration = durationInFrames ?? videoDuration;
+  const memoizedEffectDefinitions = useMemoizedEffectDefinitions(effects);
   return /* @__PURE__ */ jsx15(Sequence, {
     durationInFrames: resolvedDuration,
-    name: "<HtmlInCanvas>",
+    name: name ?? "<HtmlInCanvas>",
     _experimentalControls: controls,
-    _experimentalEffects: memoizedEffects,
+    _experimentalEffects: memoizedEffectDefinitions,
     layout: "none",
     ...sequenceProps,
-    children: /* @__PURE__ */ jsx15(HtmlInCanvasAncestorContext.Provider, {
-      value: true,
-      children: /* @__PURE__ */ jsx15("canvas", {
-        ref: setLayoutCanvasRef,
-        width,
-        height,
-        style,
-        children: /* @__PURE__ */ jsx15("div", {
-          ref: divRef,
-          style: innerStyle,
-          children
-        })
-      })
+    children: /* @__PURE__ */ jsx15(HtmlInCanvasContent, {
+      ref,
+      width,
+      height,
+      effects,
+      onPaint,
+      onInit,
+      controls,
+      style,
+      children
     })
   });
 });
 HtmlInCanvasInner.displayName = "HtmlInCanvas";
-var HtmlInCanvasWrapped = wrapInSchema(HtmlInCanvasInner, sequenceStyleSchema);
+var htmlInCanvasSchema = {
+  ...sequenceStyleSchema,
+  hidden: hiddenField
+};
+var HtmlInCanvasWrapped = wrapInSchema(HtmlInCanvasInner, htmlInCanvasSchema);
 var HtmlInCanvas = Object.assign(HtmlInCanvasWrapped, {
   isSupported: isHtmlInCanvasSupported
 });
@@ -4247,7 +4587,7 @@ var RenderAssetManager = createContext17({
 var RenderAssetManagerProvider = ({ children, collectAssets }) => {
   const [renderAssets, setRenderAssets] = useState9([]);
   const renderAssetsRef = useRef10([]);
-  const registerRenderAsset = useCallback8((renderAsset) => {
+  const registerRenderAsset = useCallback9((renderAsset) => {
     validateRenderAsset(renderAsset);
     renderAssetsRef.current = [...renderAssetsRef.current, renderAsset];
     setRenderAssets(renderAssetsRef.current);
@@ -4264,7 +4604,7 @@ var RenderAssetManagerProvider = ({ children, collectAssets }) => {
       };
     }, []);
   }
-  const unregisterRenderAsset = useCallback8((id) => {
+  const unregisterRenderAsset = useCallback9((id) => {
     renderAssetsRef.current = renderAssetsRef.current.filter((a) => a.id !== id);
     setRenderAssets(renderAssetsRef.current);
   }, []);
@@ -4292,7 +4632,7 @@ var RenderAssetManagerProvider = ({ children, collectAssets }) => {
 };
 var ArtifactThumbnail = Symbol("Thumbnail");
 var Artifact = ({ filename, content, downloadBehavior }) => {
-  const { registerRenderAsset, unregisterRenderAsset } = useContext18(RenderAssetManager);
+  const { registerRenderAsset, unregisterRenderAsset } = useContext19(RenderAssetManager);
   const env = useRemotionEnvironment();
   const frame = useCurrentFrame();
   const [id] = useState10(() => {
@@ -4482,7 +4822,7 @@ var getSrcWithoutHash = (src) => {
   return src.slice(0, hashIndex);
 };
 var usePreload = (src) => {
-  const preloads2 = useContext19(PreloadContext);
+  const preloads2 = useContext20(PreloadContext);
   const hashFragmentIndex = removeAndGetHashFragment(src);
   const withoutHashFragment = getSrcWithoutHash(src);
   if (!preloads2[withoutHashFragment]) {
@@ -4664,6 +5004,9 @@ var validateMediaProps = (props, component) => {
   if (typeof props.playbackRate === "number" && (isNaN(props.playbackRate) || !Number.isFinite(props.playbackRate) || props.playbackRate <= 0)) {
     throw new TypeError(`You have passed a playbackRate of ${props.playbackRate} to your <${component} /> component. Playback rate must be a real number above 0.`);
   }
+  if (typeof props.preservePitch !== "boolean" && typeof props.preservePitch !== "undefined") {
+    throw new TypeError(`'preservePitch' must be a boolean or undefined but got '${typeof props.preservePitch}' instead`);
+  }
 };
 var validateStartFromProps = (startFrom, endAt) => {
   if (typeof startFrom !== "undefined") {
@@ -5009,7 +5352,7 @@ var SharedAudioContextProvider = ({ children, audioLatencyHint, audioEnabled })
   }, []);
   const prevEndTimes = useRef11({ scheduledEndTime: null, mediaEndTime: null });
   const nodesToResume = useRef11(new Map);
-  const unscheduleAudioNode = useCallback9((node) => {
+  const unscheduleAudioNode = useCallback10((node) => {
     nodesToResume.current.delete(node);
   }, []);
   const scheduleAudioNode = useMemo22(() => {
@@ -5057,7 +5400,7 @@ var SharedAudioContextProvider = ({ children, audioLatencyHint, audioEnabled })
       };
     };
   }, [ctxAndGain, logLevel]);
-  const resume = useCallback9(() => {
+  const resume = useCallback10(() => {
     if (!ctxAndGain) {
       return Promise.resolve();
     }
@@ -5084,10 +5427,10 @@ var SharedAudioContextProvider = ({ children, audioLatencyHint, audioEnabled })
     });
     return resumePromise.catch(() => {});
   }, [ctxAndGain, logLevel]);
-  const getIsResumingAudioContext = useCallback9(() => {
+  const getIsResumingAudioContext = useCallback10(() => {
     return isResuming.current;
   }, []);
-  const suspend = useCallback9(() => {
+  const suspend = useCallback10(() => {
     if (!ctxAndGain) {
       return;
     }
@@ -5133,7 +5476,7 @@ var SharedAudioTagsContextProvider = ({ children, numberOfAudioTags }) => {
   const logLevel = useLogLevel();
   const mountTime = useMountTime();
   const env = useRemotionEnvironment();
-  const audioCtx = useContext20(SharedAudioContext);
+  const audioCtx = useContext21(SharedAudioContext);
   const audioContext = audioCtx?.audioContext ?? null;
   const resume = audioCtx?.resume;
   const refs = useMemo22(() => {
@@ -5160,7 +5503,7 @@ var SharedAudioTagsContextProvider = ({ children, numberOfAudioTags }) => {
     };
   }, [refs]);
   const takenAudios = useRef11(new Array(numberOfAudioTags).fill(false));
-  const rerenderAudios = useCallback9(() => {
+  const rerenderAudios = useCallback10(() => {
     refs.forEach(({ ref, id }) => {
       const data = audios.current?.find((a) => a.id === id);
       const { current } = ref;
@@ -5181,7 +5524,7 @@ var SharedAudioTagsContextProvider = ({ children, numberOfAudioTags }) => {
       });
     });
   }, [refs]);
-  const registerAudio = useCallback9((options) => {
+  const registerAudio = useCallback10((options) => {
     const { aud, audioId, premounting, postmounting } = options;
     const found = audios.current?.find((a) => a.audioId === audioId);
     if (found) {
@@ -5210,7 +5553,7 @@ var SharedAudioTagsContextProvider = ({ children, numberOfAudioTags }) => {
     rerenderAudios();
     return newElem;
   }, [numberOfAudioTags, refs, rerenderAudios]);
-  const unregisterAudio = useCallback9((id) => {
+  const unregisterAudio = useCallback10((id) => {
     const cloned = [...takenAudios.current];
     const index = refs.findIndex((r) => r.id === id);
     if (index === -1) {
@@ -5221,7 +5564,7 @@ var SharedAudioTagsContextProvider = ({ children, numberOfAudioTags }) => {
     audios.current = audios.current?.filter((a) => a.id !== id);
     rerenderAudios();
   }, [refs, rerenderAudios]);
-  const updateAudio = useCallback9(({
+  const updateAudio = useCallback10(({
     aud,
     audioId,
     id,
@@ -5255,7 +5598,7 @@ var SharedAudioTagsContextProvider = ({ children, numberOfAudioTags }) => {
       rerenderAudios();
     }
   }, [rerenderAudios]);
-  const playAllAudios = useCallback9(() => {
+  const playAllAudios = useCallback10(() => {
     refs.forEach((ref) => {
       const audio = audios.current.find((a) => a.el === ref.ref);
       if (audio?.premounting) {
@@ -5308,8 +5651,8 @@ var useSharedAudio = ({
   premounting,
   postmounting
 }) => {
-  const audioCtx = useContext20(SharedAudioContext);
-  const tagsCtx = useContext20(SharedAudioTagsContext);
+  const audioCtx = useContext21(SharedAudioContext);
+  const tagsCtx = useContext21(SharedAudioTagsContext);
   const [elem] = useState12(() => {
     if (tagsCtx && tagsCtx.numberOfAudioTags > 0) {
       return tagsCtx.registerAudio({ aud, audioId, premounting, postmounting });
@@ -5488,7 +5831,7 @@ var useVolume = ({
   const audioStuffRef = useRef13(null);
   const currentVolumeRef = useRef13(volume);
   currentVolumeRef.current = volume;
-  const sharedAudioContext = useContext21(SharedAudioContext);
+  const sharedAudioContext = useContext22(SharedAudioContext);
   if (!sharedAudioContext) {
     throw new Error("useAmplification must be used within a SharedAudioContext");
   }
@@ -5553,7 +5896,7 @@ var useVolume = ({
   return audioStuffRef;
 };
 var useMediaStartsAt = () => {
-  const parentSequence = useContext22(SequenceContext);
+  const parentSequence = useContext23(SequenceContext);
   const startsAt = Math.min(0, parentSequence?.relativeFrom ?? 0);
   return startsAt;
 };
@@ -5642,7 +5985,7 @@ var useBasicMediaInTimeline = ({
   if (!src) {
     throw new Error("No src passed");
   }
-  const parentSequence = useContext23(SequenceContext);
+  const parentSequence = useContext24(SequenceContext);
   const [initialVolume] = useState13(() => volume);
   const duration = getTimelineDuration({
     compositionDurationInFrames: sequenceDurationInFrames,
@@ -5709,8 +6052,8 @@ var useImageInTimeline = ({
   loopDisplay,
   controls
 }) => {
-  const parentSequence = useContext23(SequenceContext);
-  const { registerSequence, unregisterSequence } = useContext23(SequenceManager);
+  const parentSequence = useContext24(SequenceContext);
+  const { registerSequence, unregisterSequence } = useContext24(SequenceManager);
   const { durationInFrames } = useVideoConfig();
   const mediaStartsAt = useMediaStartsAt();
   const { duration, nonce, rootId, finalDisplayName } = useBasicMediaInTimeline({
@@ -5791,9 +6134,9 @@ var useMediaInTimeline = ({
   postmountDisplay,
   loopDisplay
 }) => {
-  const parentSequence = useContext23(SequenceContext);
+  const parentSequence = useContext24(SequenceContext);
   const startsAt = useMediaStartsAt();
-  const { registerSequence, unregisterSequence } = useContext23(SequenceManager);
+  const { registerSequence, unregisterSequence } = useContext24(SequenceManager);
   const { durationInFrames } = useVideoConfig();
   const mediaStartsAt = useMediaStartsAt();
   const { volumes, duration, doesVolumeChange, nonce, rootId, finalDisplayName } = useBasicMediaInTimeline({
@@ -5875,7 +6218,7 @@ var useBufferManager = (logLevel, mountTime) => {
   const env = useRemotionEnvironment();
   const rendering = env.isRendering;
   const buffering = useRef14(false);
-  const addBlock = useCallback10((block) => {
+  const addBlock = useCallback11((block) => {
     if (rendering) {
       return {
         unblock: () => {
@@ -5901,7 +6244,7 @@ var useBufferManager = (logLevel, mountTime) => {
       }
     };
   }, [rendering]);
-  const listenForBuffering = useCallback10((callback) => {
+  const listenForBuffering = useCallback11((callback) => {
     setOnBufferingCallbacks((c) => [...c, callback]);
     return {
       remove: () => {
@@ -5909,7 +6252,7 @@ var useBufferManager = (logLevel, mountTime) => {
       }
     };
   }, []);
-  const listenForResume = useCallback10((callback) => {
+  const listenForResume = useCallback11((callback) => {
     setOnResumeCallbacks((c) => [...c, callback]);
     return {
       remove: () => {
@@ -5953,7 +6296,7 @@ var useBufferManager = (logLevel, mountTime) => {
 };
 var BufferingContextReact = React21.createContext(null);
 var BufferingProvider = ({ children }) => {
-  const { logLevel, mountTime } = useContext24(LogLevelContext);
+  const { logLevel, mountTime } = useContext25(LogLevelContext);
   const bufferManager = useBufferManager(logLevel ?? "info", mountTime);
   return /* @__PURE__ */ jsx21(BufferingContextReact.Provider, {
     value: bufferManager,
@@ -5983,7 +6326,7 @@ var useIsPlayerBuffering = (bufferManager) => {
   return isBuffering;
 };
 var useBufferState = () => {
-  const buffer = useContext25(BufferingContextReact);
+  const buffer = useContext26(BufferingContextReact);
   const logLevel = useLogLevel();
   const addBlock = buffer ? buffer.addBlock : null;
   return useMemo25(() => ({
@@ -6023,7 +6366,7 @@ var useBufferUntilFirstFrame = ({
 }) => {
   const bufferingRef = useRef15(false);
   const { delayPlayback } = useBufferState();
-  const bufferUntilFirstFrame = useCallback11((requestedTime) => {
+  const bufferUntilFirstFrame = useCallback12((requestedTime) => {
     if (mediaType !== "video") {
       return;
     }
@@ -6394,6 +6737,23 @@ function checkInfiniteRange(name, arr) {
     }
   }
 }
+function assertValidInterpolateEasingOption(easing, inputRangeLength) {
+  if (easing === undefined) {
+    return;
+  }
+  if (typeof easing === "function") {
+    return;
+  }
+  const expectedLength = inputRangeLength - 1;
+  if (easing.length !== expectedLength) {
+    throw new Error(`When easing is an array, it must have one entry per segment between keyframes (length inputRange.length - 1 = ${expectedLength}), but got length ${easing.length}`);
+  }
+  for (let i = 0;i < easing.length; i++) {
+    if (typeof easing[i] !== "function") {
+      throw new Error(`easing[${i}] must be a function`);
+    }
+  }
+}
 function interpolate(input, inputRange, outputRange, options) {
   if (typeof input === "undefined") {
     throw new Error("input can not be undefined");
@@ -6410,7 +6770,18 @@ function interpolate(input, inputRange, outputRange, options) {
   checkInfiniteRange("inputRange", inputRange);
   checkInfiniteRange("outputRange", outputRange);
   checkValidInputRange(inputRange);
-  const easing = options?.easing ?? ((num) => num);
+  assertValidInterpolateEasingOption(options?.easing, inputRange.length);
+  const easingOption = options?.easing;
+  const defaultEasing = (num) => num;
+  const resolveEasingForSegment = (segmentIndex) => {
+    if (easingOption === undefined) {
+      return defaultEasing;
+    }
+    if (typeof easingOption === "function") {
+      return easingOption;
+    }
+    return easingOption[segmentIndex];
+  };
   let extrapolateLeft = "extend";
   if (options?.extrapolateLeft !== undefined) {
     extrapolateLeft = options.extrapolateLeft;
@@ -6424,7 +6795,7 @@ function interpolate(input, inputRange, outputRange, options) {
   }
   const range = findRange(input, inputRange);
   return interpolateFunction(input, [inputRange[range], inputRange[range + 1]], [outputRange[range], outputRange[range + 1]], {
-    easing,
+    easing: resolveEasingForSegment(range),
     extrapolateLeft,
     extrapolateRight
   });
@@ -6489,6 +6860,7 @@ var useMediaPlayback = ({
   src,
   mediaType,
   playbackRate: localPlaybackRate,
+  preservePitch = true,
   onlyWarnForMediaSeekingError,
   acceptableTimeshift,
   pauseWhenBuffering,
@@ -6500,7 +6872,7 @@ var useMediaPlayback = ({
   const frame = useCurrentFrame();
   const absoluteFrame = useTimelinePosition();
   const [playing] = usePlayingState();
-  const buffering = useContext26(BufferingContextReact);
+  const buffering = useContext27(BufferingContextReact);
   const { fps } = useVideoConfig();
   const mediaStartsAt = useMediaStartsAt();
   const lastSeekDueToShift = useRef17(null);
@@ -6511,7 +6883,7 @@ var useMediaPlayback = ({
     throw new Error("useMediaPlayback must be used inside a <BufferingContext>");
   }
   const isVariableFpsVideoMap = useRef17({});
-  const onVariableFpsVideoDetected = useCallback12(() => {
+  const onVariableFpsVideoDetected = useCallback13(() => {
     if (!src) {
       return;
     }
@@ -6606,7 +6978,10 @@ var useMediaPlayback = ({
     if (mediaRef.current && mediaRef.current.playbackRate !== playbackRateToSet) {
       mediaRef.current.playbackRate = playbackRateToSet;
     }
-  }, [mediaRef, playbackRate]);
+    if (mediaRef.current && mediaRef.current.preservesPitch !== preservePitch) {
+      mediaRef.current.preservesPitch = preservePitch;
+    }
+  }, [mediaRef, playbackRate, preservePitch]);
   useEffect12(() => {
     const tagName = mediaType === "audio" ? "<Html5Audio>" : "<Html5Video>";
     if (!mediaRef.current) {
@@ -6788,15 +7163,15 @@ var SetMediaVolumeContext = createContext22({
   }
 });
 var useMediaVolumeState = () => {
-  const { mediaVolume } = useContext27(MediaVolumeContext);
-  const { setMediaVolume } = useContext27(SetMediaVolumeContext);
+  const { mediaVolume } = useContext28(MediaVolumeContext);
+  const { setMediaVolume } = useContext28(SetMediaVolumeContext);
   return useMemo27(() => {
     return [mediaVolume, setMediaVolume];
   }, [mediaVolume, setMediaVolume]);
 };
 var useMediaMutedState = () => {
-  const { mediaMuted } = useContext27(MediaVolumeContext);
-  const { setMediaMuted } = useContext27(SetMediaVolumeContext);
+  const { mediaMuted } = useContext28(MediaVolumeContext);
+  const { setMediaMuted } = useContext28(SetMediaVolumeContext);
   return useMemo27(() => {
     return [mediaMuted, setMediaMuted];
   }, [mediaMuted, setMediaMuted]);
@@ -6816,6 +7191,7 @@ var AudioForDevelopmentForwardRefFunction = (props, ref) => {
     volume,
     muted,
     playbackRate,
+    preservePitch,
     shouldPreMountAudioTags,
     src,
     onDuration,
@@ -6846,14 +7222,12 @@ var AudioForDevelopmentForwardRefFunction = (props, ref) => {
   const [mediaVolume] = useMediaVolumeState();
   const [mediaMuted] = useMediaMutedState();
   const volumePropFrame = useFrameForVolumeProp(loopVolumeCurveBehavior ?? "repeat");
-  const { hidden } = useContext28(SequenceVisibilityToggleContext);
   if (!src) {
     throw new TypeError("No 'src' was passed to <Html5Audio>.");
   }
   const preloadedSrc = usePreload(src);
-  const sequenceContext = useContext28(SequenceContext);
+  const sequenceContext = useContext29(SequenceContext);
   const [timelineId] = useState16(() => String(Math.random()));
-  const isSequenceHidden = hidden[timelineId] ?? false;
   const userPreferredVolume = evaluateVolume({
     frame: volumePropFrame,
     volume,
@@ -6867,7 +7241,7 @@ var AudioForDevelopmentForwardRefFunction = (props, ref) => {
   });
   const propsToPass = useMemo28(() => {
     return {
-      muted: muted || mediaMuted || isSequenceHidden || userPreferredVolume <= 0,
+      muted: muted || mediaMuted || userPreferredVolume <= 0,
       src: preloadedSrc,
       loop: _remotionInternalNativeLoopPassed,
       crossOrigin: crossOriginValue,
@@ -6875,7 +7249,6 @@ var AudioForDevelopmentForwardRefFunction = (props, ref) => {
     };
   }, [
     _remotionInternalNativeLoopPassed,
-    isSequenceHidden,
     mediaMuted,
     muted,
     nativeProps,
@@ -6920,6 +7293,7 @@ var AudioForDevelopmentForwardRefFunction = (props, ref) => {
     src,
     mediaType: "audio",
     playbackRate: playbackRate ?? 1,
+    preservePitch,
     onlyWarnForMediaSeekingError: false,
     acceptableTimeshift: acceptableTimeShiftInSeconds ?? null,
     isPremounting: Boolean(sequenceContext?.premounting),
@@ -6982,7 +7356,7 @@ var AudioForDevelopmentForwardRefFunction = (props, ref) => {
     ...propsToPass
   });
 };
-var AudioForPreview = forwardRef6(AudioForDevelopmentForwardRefFunction);
+var AudioForPreview = forwardRef7(AudioForDevelopmentForwardRefFunction);
 var AudioForRenderingRefForwardingFunction = (props, ref) => {
   const audioRef = useRef19(null);
   const {
@@ -7001,13 +7375,14 @@ var AudioForRenderingRefForwardingFunction = (props, ref) => {
     loopVolumeCurveBehavior,
     pauseWhenBuffering,
     audioStreamIndex,
+    preservePitch: _preservePitch,
     ...nativeProps
   } = props;
   const absoluteFrame = useTimelinePosition();
   const volumePropFrame = useFrameForVolumeProp(loopVolumeCurveBehavior ?? "repeat");
   const frame = useCurrentFrame();
-  const sequenceContext = useContext29(SequenceContext);
-  const { registerRenderAsset, unregisterRenderAsset } = useContext29(RenderAssetManager);
+  const sequenceContext = useContext30(SequenceContext);
+  const { registerRenderAsset, unregisterRenderAsset } = useContext30(RenderAssetManager);
   const { delayRender: delayRender2, continueRender: continueRender2 } = useDelayRender();
   const id = useMemo29(() => `audio-${random(props.src ?? "")}-${sequenceContext?.relativeFrom}-${sequenceContext?.cumulatedFrom}-${sequenceContext?.durationInFrames}`, [
     props.src,
@@ -7114,9 +7489,9 @@ var AudioForRenderingRefForwardingFunction = (props, ref) => {
     onError: onNativeError
   });
 };
-var AudioForRendering = forwardRef7(AudioForRenderingRefForwardingFunction);
+var AudioForRendering = forwardRef8(AudioForRenderingRefForwardingFunction);
 var AudioRefForwardingFunction = (props, ref) => {
-  const audioTagsContext = useContext30(SharedAudioTagsContext);
+  const audioTagsContext = useContext31(SharedAudioTagsContext);
   const {
     startFrom,
     endAt,
@@ -7135,12 +7510,12 @@ var AudioRefForwardingFunction = (props, ref) => {
   if (environment.isClientSideRendering) {
     throw new Error("<Html5Audio> is not supported in @remotion/web-renderer. Use <Audio> from @remotion/media instead. See https://remotion.dev/docs/client-side-rendering/limitations");
   }
-  const { durations, setDurations } = useContext30(DurationsContext);
+  const { durations, setDurations } = useContext31(DurationsContext);
   if (typeof props.src !== "string") {
     throw new TypeError(`The \`<Html5Audio>\` tag requires a string for \`src\`, but got ${JSON.stringify(props.src)} instead.`);
   }
   const preloadedSrc = usePreload(props.src);
-  const onError = useCallback13((e) => {
+  const onError = useCallback14((e) => {
     console.log(e.currentTarget.error);
     const errMessage = `Could not play audio with src ${preloadedSrc}: ${e.currentTarget.error}. See https://remotion.dev/docs/media-playback-error for help.`;
     if (loop) {
@@ -7154,7 +7529,7 @@ var AudioRefForwardingFunction = (props, ref) => {
       console.warn(errMessage);
     }
   }, [loop, onRemotionError, preloadedSrc]);
-  const onDuration = useCallback13((src, durationInSeconds) => {
+  const onDuration = useCallback14((src, durationInSeconds) => {
     setDurations({ type: "got-duration", durationInSeconds, src });
   }, [setDurations]);
   const durationFetched = durations[getAbsoluteSrc(preloadedSrc)] ?? durations[getAbsoluteSrc(props.src)];
@@ -7204,7 +7579,11 @@ var AudioRefForwardingFunction = (props, ref) => {
       })
     });
   }
-  validateMediaProps({ playbackRate: props.playbackRate, volume: props.volume }, "Html5Audio");
+  validateMediaProps({
+    playbackRate: props.playbackRate,
+    preservePitch: props.preservePitch,
+    volume: props.volume
+  }, "Html5Audio");
   if (environment.isRendering) {
     return /* @__PURE__ */ jsx24(AudioForRendering, {
       onDuration,
@@ -7227,7 +7606,7 @@ var AudioRefForwardingFunction = (props, ref) => {
     showInTimeline: showInTimeline ?? true
   });
 };
-var Html5Audio = forwardRef8(AudioRefForwardingFunction);
+var Html5Audio = forwardRef9(AudioRefForwardingFunction);
 addSequenceStackTraces(Html5Audio);
 var Audio = Html5Audio;
 var kSplineTableSize = 11;
@@ -7244,11 +7623,11 @@ var IFrameRefForwarding = ({
     retries: delayRenderRetries ?? undefined,
     timeoutInMilliseconds: delayRenderTimeoutInMilliseconds ?? undefined
   }));
-  const didLoad = useCallback14((e) => {
+  const didLoad = useCallback15((e) => {
     continueRender2(handle);
     onLoad?.(e);
   }, [handle, onLoad, continueRender2]);
-  const didGetError = useCallback14((e) => {
+  const didGetError = useCallback15((e) => {
     continueRender2(handle);
     if (onError) {
       onError(e);
@@ -7264,7 +7643,7 @@ var IFrameRefForwarding = ({
     onLoad: didLoad
   });
 };
-var IFrame = forwardRef9(IFrameRefForwarding);
+var IFrame = forwardRef10(IFrameRefForwarding);
 function exponentialBackoff(errorCount) {
   return 1000 * 2 ** (errorCount - 1);
 }
@@ -7274,7 +7653,7 @@ function truncateSrcForLabel(src) {
   }
   return src;
 }
-var ImgInner = ({
+var ImgContent = ({
   onError,
   maxRetries = 2,
   src,
@@ -7283,21 +7662,13 @@ var ImgInner = ({
   delayRenderTimeoutInMilliseconds,
   onImageFrame,
   crossOrigin,
-  showInTimeline,
-  name,
-  stack,
   ref,
-  _experimentalControls: controls,
   ...props2
 }) => {
   const imageRef = useRef20(null);
   const errors = useRef20({});
   const { delayPlayback } = useBufferState();
-  const sequenceContext = useContext31(SequenceContext);
-  const [timelineId] = useState18(() => String(Math.random()));
-  if (!src) {
-    throw new Error('No "src" prop was passed to <Img>.');
-  }
+  const sequenceContext = useContext32(SequenceContext);
   const _propsValid = true;
   if (!_propsValid) {
     throw new Error("typecheck error");
@@ -7305,19 +7676,8 @@ var ImgInner = ({
   useImperativeHandle6(ref, () => {
     return imageRef.current;
   }, []);
-  useImageInTimeline({
-    src,
-    displayName: name ?? null,
-    id: timelineId,
-    stack: stack ?? null,
-    showInTimeline: showInTimeline ?? true,
-    premountDisplay: sequenceContext?.premountDisplay ?? null,
-    postmountDisplay: sequenceContext?.postmountDisplay ?? null,
-    loopDisplay: undefined,
-    controls: controls ?? null
-  });
   const actualSrc = usePreload(src);
-  const retryIn = useCallback15((timeout) => {
+  const retryIn = useCallback16((timeout) => {
     if (!imageRef.current) {
       return;
     }
@@ -7335,7 +7695,7 @@ var ImgInner = ({
     }, timeout);
   }, []);
   const { delayRender: delayRender2, continueRender: continueRender2, cancelRender: cancelRender2 } = useDelayRender();
-  const didGetError = useCallback15((e) => {
+  const didGetError = useCallback16((e) => {
     if (!errors.current) {
       return;
     }
@@ -7437,7 +7797,44 @@ var ImgInner = ({
     decoding: "sync"
   });
 };
-var Img = wrapInSchema(ImgInner, sequenceStyleSchema);
+var ImgInner = ({
+  hidden,
+  name,
+  stack,
+  showInTimeline,
+  src,
+  _experimentalControls: controls,
+  ...props2
+}) => {
+  const sequenceContext = useContext32(SequenceContext);
+  const [timelineId] = useState18(() => String(Math.random()));
+  if (!src) {
+    throw new Error('No "src" prop was passed to <Img>.');
+  }
+  useImageInTimeline({
+    src,
+    displayName: name ?? null,
+    id: timelineId,
+    stack: stack ?? null,
+    showInTimeline: showInTimeline ?? true,
+    premountDisplay: sequenceContext?.premountDisplay ?? null,
+    postmountDisplay: sequenceContext?.postmountDisplay ?? null,
+    loopDisplay: undefined,
+    controls: controls ?? null
+  });
+  if (hidden) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx26(ImgContent, {
+    src,
+    ...props2
+  });
+};
+var imgSchema = {
+  ...sequenceStyleSchema,
+  hidden: hiddenField
+};
+var Img = wrapInSchema(ImgInner, imgSchema);
 addSequenceStackTraces(Img);
 var compositionsRef = React28.createRef();
 var CompositionManagerProvider = ({
@@ -7451,14 +7848,14 @@ var CompositionManagerProvider = ({
   const [canvasContent, setCanvasContent] = useState19(initialCanvasContent);
   const [compositions, setCompositions] = useState19(initialCompositions);
   const currentcompositionsRef = useRef21(compositions);
-  const updateCompositions = useCallback16((updateComps) => {
+  const updateCompositions = useCallback17((updateComps) => {
     setCompositions((comps) => {
       const updated = updateComps(comps);
       currentcompositionsRef.current = updated;
       return updated;
     });
   }, []);
-  const registerComposition = useCallback16((comp) => {
+  const registerComposition = useCallback17((comp) => {
     updateCompositions((comps) => {
       if (comps.find((c2) => c2.id === comp.id)) {
         throw new Error(`Multiple composition with id ${comp.id} are registered.`);
@@ -7466,12 +7863,12 @@ var CompositionManagerProvider = ({
       return [...comps, comp];
     });
   }, [updateCompositions]);
-  const unregisterComposition = useCallback16((id) => {
+  const unregisterComposition = useCallback17((id) => {
     setCompositions((comps) => {
       return comps.filter((c2) => c2.id !== id);
     });
   }, []);
-  const registerFolder = useCallback16((name, parent, nonce) => {
+  const registerFolder = useCallback17((name, parent, nonce) => {
     setFolders((prevFolders) => {
       return [
         ...prevFolders,
@@ -7483,7 +7880,7 @@ var CompositionManagerProvider = ({
       ];
     });
   }, []);
-  const unregisterFolder = useCallback16((name, parent) => {
+  const unregisterFolder = useCallback17((name, parent) => {
     setFolders((prevFolders) => {
       return prevFolders.filter((p) => !(p.name === name && p.parent === parent));
     });
@@ -7583,16 +7980,31 @@ var makeDefaultPreviewCSS = (scope, backgroundColor) => {
     }
   `;
 };
-var defineEffect = (definition) => definition;
-var createDescriptor = (definition, params) => {
-  const widened = definition;
-  return {
+var disabledEffectField = {
+  type: "boolean",
+  default: false,
+  description: "Disabled"
+};
+var createEffect = (definition) => {
+  const userCalculateKey = definition.calculateKey;
+  const widened = {
+    ...definition,
+    calculateKey: (params) => {
+      const disabled = params.disabled ?? false;
+      return `${userCalculateKey(params)}-disabled-${disabled}`;
+    },
+    schema: {
+      disabled: disabledEffectField,
+      ...definition.schema
+    }
+  };
+  const factory = (params = {}) => ({
     definition: widened,
     params,
-    stack: new Error().stack,
     effectKey: widened.calculateKey(params),
     memoized: false
-  };
+  });
+  return factory;
 };
 var REMOTION_STUDIO_CONTAINER_ELEMENT = "__remotion-studio-container";
 var getPreviewDomElement = () => {
@@ -7618,7 +8030,7 @@ var waitForRoot = (fn) => {
 };
 var MediaEnabledContext = createContext23(null);
 var useVideoEnabled = () => {
-  const context = useContext32(MediaEnabledContext);
+  const context = useContext33(MediaEnabledContext);
   if (!context) {
     return window.remotion_videoEnabled;
   }
@@ -7628,7 +8040,7 @@ var useVideoEnabled = () => {
   return context.videoEnabled;
 };
 var useAudioEnabled = () => {
-  const context = useContext32(MediaEnabledContext);
+  const context = useContext33(MediaEnabledContext);
   if (!context) {
     return window.remotion_audioEnabled;
   }
@@ -7944,15 +8356,16 @@ var OffthreadVideoForRendering = ({
   onVideoFrame,
   crossOrigin,
   audioStreamIndex,
+  preservePitch: _preservePitch,
   ...props2
 }) => {
   const absoluteFrame = useTimelinePosition();
   const frame = useCurrentFrame();
   const volumePropsFrame = useFrameForVolumeProp(loopVolumeCurveBehavior);
   const videoConfig = useUnsafeVideoConfig();
-  const sequenceContext = useContext33(SequenceContext);
+  const sequenceContext = useContext34(SequenceContext);
   const mediaStartsAt = useMediaStartsAt();
-  const { registerRenderAsset, unregisterRenderAsset } = useContext33(RenderAssetManager);
+  const { registerRenderAsset, unregisterRenderAsset } = useContext34(RenderAssetManager);
   if (!src) {
     throw new TypeError("No `src` was passed to <OffthreadVideo>.");
   }
@@ -8099,7 +8512,7 @@ var OffthreadVideoForRendering = ({
     continueRender2,
     delayRender2
   ]);
-  const onErr = useCallback17(() => {
+  const onErr = useCallback18(() => {
     if (onError) {
       onError?.(new Error("Failed to load image with src " + imageSrc));
     } else {
@@ -8109,7 +8522,7 @@ var OffthreadVideoForRendering = ({
   const className = useMemo33(() => {
     return [OBJECTFIT_CONTAIN_CLASS_NAME, props2.className].filter(truthy).join(" ");
   }, [props2.className]);
-  const onImageFrame = useCallback17((img) => {
+  const onImageFrame = useCallback18((img) => {
     if (onVideoFrame) {
       onVideoFrame(img);
     }
@@ -8164,7 +8577,7 @@ class MediaPlaybackError extends Error {
   }
 }
 var VideoForDevelopmentRefForwardingFunction = (props2, ref) => {
-  const context = useContext34(SharedAudioContext);
+  const context = useContext35(SharedAudioContext);
   if (!context) {
     throw new Error("SharedAudioContext not found");
   }
@@ -8190,6 +8603,7 @@ var VideoForDevelopmentRefForwardingFunction = (props2, ref) => {
     volume,
     muted,
     playbackRate,
+    preservePitch,
     onlyWarnForMediaSeekingError,
     src,
     onDuration,
@@ -8220,12 +8634,10 @@ var VideoForDevelopmentRefForwardingFunction = (props2, ref) => {
   }
   const volumePropFrame = useFrameForVolumeProp(loopVolumeCurveBehavior ?? "repeat");
   const { fps, durationInFrames } = useVideoConfig();
-  const parentSequence = useContext34(SequenceContext);
-  const { hidden } = useContext34(SequenceVisibilityToggleContext);
+  const parentSequence = useContext35(SequenceContext);
   const logLevel = useLogLevel();
   const mountTime = useMountTime();
   const [timelineId] = useState21(() => String(Math.random()));
-  const isSequenceHidden = hidden[timelineId] ?? false;
   if (typeof acceptableTimeShift !== "undefined") {
     throw new Error("acceptableTimeShift has been removed. Use acceptableTimeShiftInSeconds instead.");
   }
@@ -8256,6 +8668,7 @@ var VideoForDevelopmentRefForwardingFunction = (props2, ref) => {
     src,
     mediaType: "video",
     playbackRate: props2.playbackRate ?? 1,
+    preservePitch,
     onlyWarnForMediaSeekingError,
     acceptableTimeshift: acceptableTimeShiftInSeconds ?? null,
     isPremounting: Boolean(parentSequence?.premounting),
@@ -8369,10 +8782,9 @@ var VideoForDevelopmentRefForwardingFunction = (props2, ref) => {
   }, []);
   const actualStyle = useMemo34(() => {
     return {
-      ...style,
-      opacity: isSequenceHidden ? 0 : style?.opacity ?? 1
+      ...style
     };
-  }, [isSequenceHidden, style]);
+  }, [style]);
   const crossOriginValue = getCrossOriginValue({
     crossOrigin,
     requestsVideoFrame: Boolean(onVideoFrame),
@@ -8380,7 +8792,7 @@ var VideoForDevelopmentRefForwardingFunction = (props2, ref) => {
   });
   return /* @__PURE__ */ jsx31("video", {
     ref: videoRef,
-    muted: muted || mediaMuted || isSequenceHidden || userPreferredVolume <= 0,
+    muted: muted || mediaMuted || userPreferredVolume <= 0,
     playsInline: true,
     src: actualSrc,
     loop: _remotionInternalNativeLoopPassed,
@@ -8390,7 +8802,7 @@ var VideoForDevelopmentRefForwardingFunction = (props2, ref) => {
     ...nativeProps
   });
 };
-var VideoForPreview = forwardRef10(VideoForDevelopmentRefForwardingFunction);
+var VideoForPreview = forwardRef11(VideoForDevelopmentRefForwardingFunction);
 var InnerOffthreadVideo = (props2) => {
   const {
     startFrom,
@@ -8407,7 +8819,7 @@ var InnerOffthreadVideo = (props2) => {
   if (environment.isClientSideRendering) {
     throw new Error("<OffthreadVideo> is not supported in @remotion/web-renderer. Use <Video> from @remotion/media instead. See https://remotion.dev/docs/client-side-rendering/limitations");
   }
-  const onDuration = useCallback18(() => {
+  const onDuration = useCallback19(() => {
     return;
   }, []);
   if (typeof props2.src !== "string") {
@@ -8495,6 +8907,7 @@ var OffthreadVideo = ({
   onVideoFrame,
   pauseWhenBuffering,
   playbackRate,
+  preservePitch,
   showInTimeline,
   style,
   toneFrequency,
@@ -8530,6 +8943,7 @@ var OffthreadVideo = ({
     onVideoFrame,
     pauseWhenBuffering: pauseWhenBuffering ?? true,
     playbackRate: playbackRate ?? 1,
+    preservePitch,
     toneFrequency: toneFrequency ?? 1,
     showInTimeline: showInTimeline ?? true,
     src,
@@ -8650,7 +9064,6 @@ var Internals = {
   VisualModeSettersContext,
   SequenceManager,
   SequenceStackTracesUpdateContext,
-  SequenceVisibilityToggleContext,
   wrapInSchema,
   sequenceSchema,
   sequenceStyleSchema,
@@ -8746,13 +9159,16 @@ var Internals = {
   useEffectChainState,
   runEffectChain,
   useMemoizedEffects,
-  defineEffect,
-  createDescriptor,
+  useMemoizedEffectDefinitions,
+  createEffect,
   computeEffectiveSchemaValuesDotNotation,
   OverrideIdsToNodePathsGettersContext,
   OverrideIdsToNodePathsSettersContext,
   findPropsToDelete,
-  flattenEffects
+  makeSequencePropsSubscriptionKey,
+  getCodeValuesCtx,
+  getEffectCodeValuesCtx,
+  hiddenField
 };
 var NUMBER = "[-+]?\\d*\\.?\\d+";
 var PERCENTAGE = NUMBER + "%";
@@ -8815,7 +9231,7 @@ var SeriesSequenceRefForwardingFunction = ({ children }, _ref) => {
     children
   });
 };
-var SeriesSequence = forwardRef11(SeriesSequenceRefForwardingFunction);
+var SeriesSequence = forwardRef12(SeriesSequenceRefForwardingFunction);
 var SeriesInner = (props2) => {
   const childrenValue = useMemo36(() => {
     let startFrame = 0;
@@ -9340,6 +9756,7 @@ var VideoForRenderingForwardFunction = ({
   loopVolumeCurveBehavior,
   audioStreamIndex,
   onVideoFrame,
+  preservePitch: _preservePitch,
   ...props2
 }, ref) => {
   const absoluteFrame = useTimelinePosition();
@@ -9347,13 +9764,13 @@ var VideoForRenderingForwardFunction = ({
   const volumePropsFrame = useFrameForVolumeProp(loopVolumeCurveBehavior ?? "repeat");
   const videoConfig = useUnsafeVideoConfig();
   const videoRef = useRef23(null);
-  const sequenceContext = useContext35(SequenceContext);
+  const sequenceContext = useContext36(SequenceContext);
   const mediaStartsAt = useMediaStartsAt();
   const environment = useRemotionEnvironment();
   const logLevel = useLogLevel();
   const mountTime = useMountTime();
   const { delayRender: delayRender2, continueRender: continueRender2 } = useDelayRender();
-  const { registerRenderAsset, unregisterRenderAsset } = useContext35(RenderAssetManager);
+  const { registerRenderAsset, unregisterRenderAsset } = useContext36(RenderAssetManager);
   const id = useMemo37(() => `video-${random(props2.src ?? "")}-${sequenceContext?.cumulatedFrom}-${sequenceContext?.relativeFrom}-${sequenceContext?.durationInFrames}`, [
     props2.src,
     sequenceContext?.cumulatedFrom,
@@ -9542,7 +9959,7 @@ var VideoForRenderingForwardFunction = ({
     ...props2
   });
 };
-var VideoForRendering = forwardRef12(VideoForRenderingForwardFunction);
+var VideoForRendering = forwardRef13(VideoForRenderingForwardFunction);
 var VideoForwardingFunction = (props2, ref) => {
   const {
     startFrom,
@@ -9563,7 +9980,7 @@ var VideoForwardingFunction = (props2, ref) => {
   if (environment.isClientSideRendering) {
     throw new Error("<Html5Video> is not supported in @remotion/web-renderer. Use <Video> from @remotion/media instead. See https://remotion.dev/docs/client-side-rendering/limitations");
   }
-  const { durations, setDurations } = useContext36(DurationsContext);
+  const { durations, setDurations } = useContext37(DurationsContext);
   if (typeof ref === "string") {
     throw new Error("string refs are not supported");
   }
@@ -9571,10 +9988,10 @@ var VideoForwardingFunction = (props2, ref) => {
     throw new TypeError(`The \`<Html5Video>\` tag requires a string for \`src\`, but got ${JSON.stringify(props2.src)} instead.`);
   }
   const preloadedSrc = usePreload(props2.src);
-  const onDuration = useCallback19((src, durationInSeconds) => {
+  const onDuration = useCallback20((src, durationInSeconds) => {
     setDurations({ type: "got-duration", durationInSeconds, src });
   }, [setDurations]);
-  const onVideoFrame = useCallback19(() => {}, []);
+  const onVideoFrame = useCallback20(() => {}, []);
   const durationFetched = durations[getAbsoluteSrc(preloadedSrc)] ?? durations[getAbsoluteSrc(props2.src)];
   validateMediaTrimProps({ startFrom, endAt, trimBefore, trimAfter });
   const { trimBeforeValue, trimAfterValue } = resolveTrimProps({
@@ -9626,7 +10043,11 @@ var VideoForwardingFunction = (props2, ref) => {
       })
     });
   }
-  validateMediaProps({ playbackRate: props2.playbackRate, volume: props2.volume }, "Html5Video");
+  validateMediaProps({
+    playbackRate: props2.playbackRate,
+    preservePitch: props2.preservePitch,
+    volume: props2.volume
+  }, "Html5Video");
   if (environment.isRendering) {
     return /* @__PURE__ */ jsx37(VideoForRendering, {
       onDuration,
@@ -9648,7 +10069,7 @@ var VideoForwardingFunction = (props2, ref) => {
     onAutoPlayError: onAutoPlayError ?? undefined
   });
 };
-var Html5Video = forwardRef13(VideoForwardingFunction);
+var Html5Video = forwardRef14(VideoForwardingFunction);
 addSequenceStackTraces(Html5Video);
 checkMultipleRemotionVersions();
 var proxyObj = {};
@@ -15810,7 +16231,7 @@ import { jsx as jsx112 } from "react/jsx-runtime";
 import { jsx as jsx122 } from "react/jsx-runtime";
 import * as React362 from "react";
 import * as ReactDOM4 from "react-dom";
-import React11 from "react";
+import React112 from "react";
 import * as React82 from "react";
 import { jsx as jsx132 } from "react/jsx-runtime";
 import * as React9 from "react";
@@ -15820,7 +16241,7 @@ import { jsx as jsx152 } from "react/jsx-runtime";
 import * as React122 from "react";
 import { jsx as jsx162 } from "react/jsx-runtime";
 import * as React16 from "react";
-import * as React132 from "react";
+import * as React13 from "react";
 import * as ReactDOM from "react-dom";
 import { jsx as jsx172 } from "react/jsx-runtime";
 import * as React14 from "react";
@@ -15848,8 +16269,8 @@ import * as React282 from "react";
 import { jsx as jsx232 } from "react/jsx-runtime";
 import * as React35 from "react";
 import * as React312 from "react";
-import { useState as useState112 } from "react";
 import * as React292 from "react";
+import { useState as useState112 } from "react";
 import * as React30 from "react";
 import * as React342 from "react";
 import * as React332 from "react";
@@ -16792,13 +17213,13 @@ function createCollection(name) {
   const [CollectionProviderImpl, useCollectionContext] = createCollectionContext(PROVIDER_NAME, { collectionRef: { current: null }, itemMap: /* @__PURE__ */ new Map });
   const CollectionProvider = (props) => {
     const { scope, children } = props;
-    const ref = React11.useRef(null);
-    const itemMap = React11.useRef(/* @__PURE__ */ new Map).current;
+    const ref = React112.useRef(null);
+    const itemMap = React112.useRef(/* @__PURE__ */ new Map).current;
     return /* @__PURE__ */ jsx152(CollectionProviderImpl, { scope, itemMap, collectionRef: ref, children });
   };
   CollectionProvider.displayName = PROVIDER_NAME;
   const COLLECTION_SLOT_NAME = name + "CollectionSlot";
-  const CollectionSlot = React11.forwardRef((props, forwardedRef) => {
+  const CollectionSlot = React112.forwardRef((props, forwardedRef) => {
     const { scope, children } = props;
     const context = useCollectionContext(COLLECTION_SLOT_NAME, scope);
     const composedRefs = useComposedRefs2(forwardedRef, context.collectionRef);
@@ -16807,12 +17228,12 @@ function createCollection(name) {
   CollectionSlot.displayName = COLLECTION_SLOT_NAME;
   const ITEM_SLOT_NAME = name + "CollectionItemSlot";
   const ITEM_DATA_ATTR = "data-radix-collection-item";
-  const CollectionItemSlot = React11.forwardRef((props, forwardedRef) => {
+  const CollectionItemSlot = React112.forwardRef((props, forwardedRef) => {
     const { scope, children, ...itemData } = props;
-    const ref = React11.useRef(null);
+    const ref = React112.useRef(null);
     const composedRefs = useComposedRefs2(forwardedRef, ref);
     const context = useCollectionContext(ITEM_SLOT_NAME, scope);
-    React11.useEffect(() => {
+    React112.useEffect(() => {
       context.itemMap.set(ref, { ref, ...itemData });
       return () => void context.itemMap.delete(ref);
     });
@@ -16821,7 +17242,7 @@ function createCollection(name) {
   CollectionItemSlot.displayName = ITEM_SLOT_NAME;
   function useCollection(scope) {
     const context = useCollectionContext(name + "CollectionConsumer", scope);
-    const getItems = React11.useCallback(() => {
+    const getItems = React112.useCallback(() => {
       const collectionNode = context.collectionRef.current;
       if (!collectionNode)
         return [];
@@ -16862,7 +17283,7 @@ var NODES = [
   "ul"
 ];
 var Primitive = NODES.reduce((primitive, node) => {
-  const Node2 = React132.forwardRef((props, forwardedRef) => {
+  const Node2 = React13.forwardRef((props, forwardedRef) => {
     const { asChild, ...primitiveProps } = props;
     const Comp = asChild ? Slot2 : node;
     if (typeof window !== "undefined") {
@@ -19604,7 +20025,7 @@ var hideOthers = function(originalTarget, parentNode, markerName) {
   return applyAttributeToOthers(targets, activeParentNode, markerName, "aria-hidden");
 };
 var __assign = function() {
-  __assign = Object.assign || function __assign(t) {
+  __assign = Object.assign || function __assign2(t) {
     for (var s, i = 1, n = arguments.length;i < n; i++) {
       s = arguments[i];
       for (var p in s)
@@ -21391,17 +21812,17 @@ function createContextScope2(scopeName, createContextScopeDeps = []) {
   let defaultContexts = [];
   function createContext32(rootComponentName, defaultContext) {
     const BaseContext = React382.createContext(defaultContext);
-    const index2 = defaultContexts.length;
+    const index3 = defaultContexts.length;
     defaultContexts = [...defaultContexts, defaultContext];
     const Provider = (props) => {
       const { scope, children, ...context } = props;
-      const Context = scope?.[scopeName]?.[index2] || BaseContext;
+      const Context = scope?.[scopeName]?.[index3] || BaseContext;
       const value = React382.useMemo(() => context, Object.values(context));
       return /* @__PURE__ */ jsx272(Context.Provider, { value, children });
     };
     Provider.displayName = rootComponentName + "Provider";
     function useContext222(consumerName, scope) {
-      const Context = scope?.[scopeName]?.[index2] || BaseContext;
+      const Context = scope?.[scopeName]?.[index3] || BaseContext;
       const context = React382.useContext(Context);
       if (context)
         return context;
@@ -21598,10 +22019,10 @@ var OrderedDict = class _OrderedDict extends Map {
     super.set(key, value);
     return this;
   }
-  insert(index2, key, value) {
+  insert(index3, key, value) {
     const has = this.has(key);
     const length2 = this.#keys.length;
-    const relativeIndex = toSafeInteger(index2);
+    const relativeIndex = toSafeInteger(index3);
     let actualIndex = relativeIndex >= 0 ? relativeIndex : length2 + relativeIndex;
     const safeIndex = actualIndex < 0 || actualIndex >= length2 ? -1 : actualIndex;
     if (safeIndex === this.size || has && safeIndex === this.size - 1 || safeIndex === -1) {
@@ -21639,39 +22060,39 @@ var OrderedDict = class _OrderedDict extends Map {
     }
     return this;
   }
-  with(index2, key, value) {
+  with(index3, key, value) {
     const copy = new _OrderedDict(this);
-    copy.insert(index2, key, value);
+    copy.insert(index3, key, value);
     return copy;
   }
   before(key) {
-    const index2 = this.#keys.indexOf(key) - 1;
-    if (index2 < 0) {
+    const index3 = this.#keys.indexOf(key) - 1;
+    if (index3 < 0) {
       return;
     }
-    return this.entryAt(index2);
+    return this.entryAt(index3);
   }
   setBefore(key, newKey, value) {
-    const index2 = this.#keys.indexOf(key);
-    if (index2 === -1) {
+    const index3 = this.#keys.indexOf(key);
+    if (index3 === -1) {
       return this;
     }
-    return this.insert(index2, newKey, value);
+    return this.insert(index3, newKey, value);
   }
   after(key) {
-    let index2 = this.#keys.indexOf(key);
-    index2 = index2 === -1 || index2 === this.size - 1 ? -1 : index2 + 1;
-    if (index2 === -1) {
+    let index3 = this.#keys.indexOf(key);
+    index3 = index3 === -1 || index3 === this.size - 1 ? -1 : index3 + 1;
+    if (index3 === -1) {
       return;
     }
-    return this.entryAt(index2);
+    return this.entryAt(index3);
   }
   setAfter(key, newKey, value) {
-    const index2 = this.#keys.indexOf(key);
-    if (index2 === -1) {
+    const index3 = this.#keys.indexOf(key);
+    if (index3 === -1) {
       return this;
     }
-    return this.insert(index2 + 1, newKey, value);
+    return this.insert(index3 + 1, newKey, value);
   }
   first() {
     return this.entryAt(0);
@@ -21690,21 +22111,21 @@ var OrderedDict = class _OrderedDict extends Map {
     }
     return deleted;
   }
-  deleteAt(index2) {
-    const key = this.keyAt(index2);
+  deleteAt(index3) {
+    const key = this.keyAt(index3);
     if (key !== undefined) {
       return this.delete(key);
     }
     return false;
   }
-  at(index2) {
-    const key = at(this.#keys, index2);
+  at(index3) {
+    const key = at(this.#keys, index3);
     if (key !== undefined) {
       return this.get(key);
     }
   }
-  entryAt(index2) {
-    const key = at(this.#keys, index2);
+  entryAt(index3) {
+    const key = at(this.#keys, index3);
     if (key !== undefined) {
       return [key, this.get(key)];
     }
@@ -21712,15 +22133,15 @@ var OrderedDict = class _OrderedDict extends Map {
   indexOf(key) {
     return this.#keys.indexOf(key);
   }
-  keyAt(index2) {
-    return at(this.#keys, index2);
+  keyAt(index3) {
+    return at(this.#keys, index3);
   }
   from(key, offset4) {
-    const index2 = this.indexOf(key);
-    if (index2 === -1) {
+    const index3 = this.indexOf(key);
+    if (index3 === -1) {
       return;
     }
-    let dest = index2 + offset4;
+    let dest = index3 + offset4;
     if (dest < 0)
       dest = 0;
     if (dest >= this.size)
@@ -21728,11 +22149,11 @@ var OrderedDict = class _OrderedDict extends Map {
     return this.at(dest);
   }
   keyFrom(key, offset4) {
-    const index2 = this.indexOf(key);
-    if (index2 === -1) {
+    const index3 = this.indexOf(key);
+    if (index3 === -1) {
       return;
     }
-    let dest = index2 + offset4;
+    let dest = index3 + offset4;
     if (dest < 0)
       dest = 0;
     if (dest >= this.size)
@@ -21740,68 +22161,68 @@ var OrderedDict = class _OrderedDict extends Map {
     return this.keyAt(dest);
   }
   find(predicate, thisArg) {
-    let index2 = 0;
+    let index3 = 0;
     for (const entry of this) {
-      if (Reflect.apply(predicate, thisArg, [entry, index2, this])) {
+      if (Reflect.apply(predicate, thisArg, [entry, index3, this])) {
         return entry;
       }
-      index2++;
+      index3++;
     }
     return;
   }
   findIndex(predicate, thisArg) {
-    let index2 = 0;
+    let index3 = 0;
     for (const entry of this) {
-      if (Reflect.apply(predicate, thisArg, [entry, index2, this])) {
-        return index2;
+      if (Reflect.apply(predicate, thisArg, [entry, index3, this])) {
+        return index3;
       }
-      index2++;
+      index3++;
     }
     return -1;
   }
   filter(predicate, thisArg) {
     const entries = [];
-    let index2 = 0;
+    let index3 = 0;
     for (const entry of this) {
-      if (Reflect.apply(predicate, thisArg, [entry, index2, this])) {
+      if (Reflect.apply(predicate, thisArg, [entry, index3, this])) {
         entries.push(entry);
       }
-      index2++;
+      index3++;
     }
     return new _OrderedDict(entries);
   }
   map(callbackfn, thisArg) {
     const entries = [];
-    let index2 = 0;
+    let index3 = 0;
     for (const entry of this) {
-      entries.push([entry[0], Reflect.apply(callbackfn, thisArg, [entry, index2, this])]);
-      index2++;
+      entries.push([entry[0], Reflect.apply(callbackfn, thisArg, [entry, index3, this])]);
+      index3++;
     }
     return new _OrderedDict(entries);
   }
   reduce(...args) {
     const [callbackfn, initialValue] = args;
-    let index2 = 0;
+    let index3 = 0;
     let accumulator = initialValue ?? this.at(0);
     for (const entry of this) {
-      if (index2 === 0 && args.length === 1) {
+      if (index3 === 0 && args.length === 1) {
         accumulator = entry;
       } else {
-        accumulator = Reflect.apply(callbackfn, this, [accumulator, entry, index2, this]);
+        accumulator = Reflect.apply(callbackfn, this, [accumulator, entry, index3, this]);
       }
-      index2++;
+      index3++;
     }
     return accumulator;
   }
   reduceRight(...args) {
     const [callbackfn, initialValue] = args;
     let accumulator = initialValue ?? this.at(-1);
-    for (let index2 = this.size - 1;index2 >= 0; index2--) {
-      const entry = this.at(index2);
-      if (index2 === this.size - 1 && args.length === 1) {
+    for (let index3 = this.size - 1;index3 >= 0; index3--) {
+      const entry = this.at(index3);
+      if (index3 === this.size - 1 && args.length === 1) {
         accumulator = entry;
       } else {
-        accumulator = Reflect.apply(callbackfn, this, [accumulator, entry, index2, this]);
+        accumulator = Reflect.apply(callbackfn, this, [accumulator, entry, index3, this]);
       }
     }
     return accumulator;
@@ -21812,8 +22233,8 @@ var OrderedDict = class _OrderedDict extends Map {
   }
   toReversed() {
     const reversed = new _OrderedDict;
-    for (let index2 = this.size - 1;index2 >= 0; index2--) {
-      const key = this.keyAt(index2);
+    for (let index3 = this.size - 1;index3 >= 0; index3--) {
+      const key = this.keyAt(index3);
       const element = this.get(key);
       reversed.set(key, element);
     }
@@ -21836,44 +22257,44 @@ var OrderedDict = class _OrderedDict extends Map {
     if (end !== undefined && end > 0) {
       stop = end - 1;
     }
-    for (let index2 = start;index2 <= stop; index2++) {
-      const key = this.keyAt(index2);
+    for (let index3 = start;index3 <= stop; index3++) {
+      const key = this.keyAt(index3);
       const element = this.get(key);
       result.set(key, element);
     }
     return result;
   }
   every(predicate, thisArg) {
-    let index2 = 0;
+    let index3 = 0;
     for (const entry of this) {
-      if (!Reflect.apply(predicate, thisArg, [entry, index2, this])) {
+      if (!Reflect.apply(predicate, thisArg, [entry, index3, this])) {
         return false;
       }
-      index2++;
+      index3++;
     }
     return true;
   }
   some(predicate, thisArg) {
-    let index2 = 0;
+    let index3 = 0;
     for (const entry of this) {
-      if (Reflect.apply(predicate, thisArg, [entry, index2, this])) {
+      if (Reflect.apply(predicate, thisArg, [entry, index3, this])) {
         return true;
       }
-      index2++;
+      index3++;
     }
     return false;
   }
 };
-function at(array, index2) {
+function at(array, index3) {
   if ("at" in Array.prototype) {
-    return Array.prototype.at.call(array, index2);
+    return Array.prototype.at.call(array, index3);
   }
-  const actualIndex = toSafeIndex(array, index2);
+  const actualIndex = toSafeIndex(array, index3);
   return actualIndex === -1 ? undefined : array[actualIndex];
 }
-function toSafeIndex(array, index2) {
+function toSafeIndex(array, index3) {
   const length2 = array.length;
-  const relativeIndex = toSafeInteger(index2);
+  const relativeIndex = toSafeInteger(index3);
   const actualIndex = relativeIndex >= 0 ? relativeIndex : length2 + relativeIndex;
   return actualIndex < 0 || actualIndex >= length2 ? -1 : actualIndex;
 }
@@ -21925,7 +22346,7 @@ var Primitive2 = NODES2.reduce((primitive, node) => {
   Node2.displayName = `Primitive.${node}`;
   return { ...primitive, [node]: Node2 };
 }, {});
-function useCallbackRef3(callback) {
+function useCallbackRef4(callback) {
   const callbackRef = React44.useRef(callback);
   React44.useEffect(() => {
     callbackRef.current = callback;
@@ -22029,7 +22450,7 @@ var RovingFocusGroupImpl = React47.forwardRef((props, forwardedRef) => {
     caller: GROUP_NAME2
   });
   const [isTabbingBackOut, setIsTabbingBackOut] = React47.useState(false);
-  const handleEntryFocus = useCallbackRef3(onEntryFocus);
+  const handleEntryFocus = useCallbackRef4(onEntryFocus);
   const getItems = useCollection2(__scopeRovingFocusGroup);
   const isClickFocusRef = React47.useRef(false);
   const [focusableItemsCount, setFocusableItemsCount] = React47.useState(0);
@@ -22182,7 +22603,7 @@ function focusFirst2(candidates, preventScroll = false) {
   }
 }
 function wrapArray2(array, startIndex) {
-  return array.map((_, index2) => array[(startIndex + index2) % array.length]);
+  return array.map((_, index3) => array[(startIndex + index3) % array.length]);
 }
 var Root3 = RovingFocusGroup;
 var Item2 = RovingFocusGroupItem;
@@ -22497,7 +22918,7 @@ var Triangle2 = (props) => {
 };
 
 // src/components/homepage/FreePricing.tsx
-import React53, { useCallback as useCallback33, useMemo as useMemo50 } from "react";
+import React53, { useCallback as useCallback32, useMemo as useMemo50 } from "react";
 
 // ../../node_modules/.bun/tailwind-merge@2.5.2/node_modules/tailwind-merge/dist/bundle-mjs.mjs
 var CLASS_PART_SEPARATOR2 = "-";
@@ -24144,7 +24565,7 @@ var CompanyPricing = () => {
   const [automatorsSelected, setAutomatorsSelected] = React53.useState(true);
   const [devSeatCount, setDevSeatCount] = React53.useState(3);
   const [cloudRenders, setCloudRenders] = React53.useState(1e4);
-  const formatPrice = useCallback33((price) => {
+  const formatPrice = useCallback32((price) => {
     const formatter = new Intl.NumberFormat("en-US", {
       style: "currency",
       currency: "USD",
@@ -24198,23 +24619,23 @@ var CompanyPricing = () => {
         style: { height: 30 }
       }),
       /* @__PURE__ */ jsx47(SectionCheckbox, {
-        checked: creatorsSelected,
-        onChange: setCreatorsSelected,
-        title: "Remotion for Creators",
-        subtitle: "Create videos for yourself - $25/mo per seat"
+        checked: automatorsSelected,
+        onChange: setAutomatorsSelected,
+        title: "Remotion for Automators",
+        subtitle: "Build video creation tools - $0.01 per render, $100/mo minimum"
       }),
       /* @__PURE__ */ jsx47("div", {
-        className: cn2("grid ease-out", creatorsSelected ? "grid-rows-[1fr] opacity-100" : "grid-rows-[0fr] opacity-0"),
+        className: cn2("grid ease-out", automatorsSelected ? "grid-rows-[1fr] opacity-100" : "grid-rows-[0fr] opacity-0"),
         style: {
-          transition: creatorsSelected ? "grid-template-rows 150ms ease-out, opacity 150ms ease-out 75ms" : "opacity 150ms ease-out, grid-template-rows 150ms ease-out 75ms"
+          transition: automatorsSelected ? "grid-template-rows 150ms ease-out, opacity 150ms ease-out 75ms" : "opacity 150ms ease-out, grid-template-rows 150ms ease-out 75ms"
         },
-        inert: !creatorsSelected,
+        inert: !automatorsSelected,
         children: /* @__PURE__ */ jsxs8("div", {
           className: "overflow-hidden",
           children: [
             /* @__PURE__ */ jsx47("p", {
               className: "text-sm text-muted fontbrand pt-3 pb-1",
-              children: "Intended for low volume video creations through coding and prompting, and building motion design systems in a local environment. Get 1 Seat per user."
+              children: "Intended for companies launching applications and systems; such as video editors, prompt-to-video apps, embedding the Remotion Player, or any other automated video creation. A $100/mo Minimum Spend applies. Developers working on automation projects do not require a Seat."
             }),
             /* @__PURE__ */ jsxs8("div", {
               className: "flex flex-row items-center gap-3 sm:gap-4 w-full pt-3 pb-1",
@@ -24222,19 +24643,19 @@ var CompanyPricing = () => {
                 /* @__PURE__ */ jsx47("div", {
                   className: "flex-1 min-w-0",
                   children: /* @__PURE__ */ jsx47(PricingSlider, {
-                    value: devSeatCount,
-                    onChange: setDevSeatCount,
-                    min: 1,
-                    max: 50,
-                    "aria-label": "Number of seats"
+                    value: cloudRenders,
+                    onChange: setCloudRenders,
+                    min: 1000,
+                    max: 1e5,
+                    step: 1000,
+                    "aria-label": "Number of renders"
                   })
                 }),
                 /* @__PURE__ */ jsxs8("div", {
-                  className: "fontbrand shrink-0 whitespace-nowrap w-[135px] sm:w-[150px] text-center tabular-nums",
+                  className: "fontbrand shrink-0 whitespace-nowrap w-[135px] sm:w-[150px] text-right tabular-nums",
                   children: [
-                    devSeatCount,
-                    " ",
-                    devSeatCount === 1 ? "Seat" : "Seats"
+                    new Intl.NumberFormat("en-US").format(cloudRenders),
+                    " Renders"
                   ]
                 }),
                 /* @__PURE__ */ jsxs8("div", {
@@ -24243,7 +24664,7 @@ var CompanyPricing = () => {
                     "$",
                     new Intl.NumberFormat("en-US", {
                       maximumFractionDigits: 0
-                    }).format(SEAT_PRICE * devSeatCount)
+                    }).format(Math.ceil(cloudRenders / 1000) * RENDER_UNIT_PRICE)
                   ]
                 })
               ]
@@ -24255,23 +24676,23 @@ var CompanyPricing = () => {
         className: "h-6"
       }),
       /* @__PURE__ */ jsx47(SectionCheckbox, {
-        checked: automatorsSelected,
-        onChange: setAutomatorsSelected,
-        title: "Remotion for Automators",
-        subtitle: "Build video creation tools - $0.01 per render, $100/mo minimum"
+        checked: creatorsSelected,
+        onChange: setCreatorsSelected,
+        title: "Remotion for Creators",
+        subtitle: "Create videos for yourself - $25/mo per seat"
       }),
       /* @__PURE__ */ jsx47("div", {
-        className: cn2("grid ease-out", automatorsSelected ? "grid-rows-[1fr] opacity-100" : "grid-rows-[0fr] opacity-0"),
+        className: cn2("grid ease-out", creatorsSelected ? "grid-rows-[1fr] opacity-100" : "grid-rows-[0fr] opacity-0"),
         style: {
-          transition: automatorsSelected ? "grid-template-rows 150ms ease-out, opacity 150ms ease-out 75ms" : "opacity 150ms ease-out, grid-template-rows 150ms ease-out 75ms"
+          transition: creatorsSelected ? "grid-template-rows 150ms ease-out, opacity 150ms ease-out 75ms" : "opacity 150ms ease-out, grid-template-rows 150ms ease-out 75ms"
         },
-        inert: !automatorsSelected,
+        inert: !creatorsSelected,
         children: /* @__PURE__ */ jsxs8("div", {
           className: "overflow-hidden",
           children: [
             /* @__PURE__ */ jsx47("p", {
               className: "text-sm text-muted fontbrand pt-3 pb-1",
-              children: "Intended for companies launching SaaS applications; such as video editors and prompt-to-video apps, and automated high-volume video creation. A $100/mo Minimum Spend applies. Developers working on automation projects do not require a Seat."
+              children: "Intended for low volume video creations through coding and prompting, and building motion design systems in a local environment. Get 1 Seat per user."
             }),
             /* @__PURE__ */ jsxs8("div", {
               className: "flex flex-row items-center gap-3 sm:gap-4 w-full pt-3 pb-1",
@@ -24279,19 +24700,19 @@ var CompanyPricing = () => {
                 /* @__PURE__ */ jsx47("div", {
                   className: "flex-1 min-w-0",
                   children: /* @__PURE__ */ jsx47(PricingSlider, {
-                    value: cloudRenders,
-                    onChange: setCloudRenders,
-                    min: 1000,
-                    max: 1e5,
-                    step: 1000,
-                    "aria-label": "Number of renders"
+                    value: devSeatCount,
+                    onChange: setDevSeatCount,
+                    min: 1,
+                    max: 50,
+                    "aria-label": "Number of seats"
                   })
                 }),
                 /* @__PURE__ */ jsxs8("div", {
-                  className: "fontbrand shrink-0 whitespace-nowrap w-[135px] sm:w-[150px] text-right tabular-nums",
+                  className: "fontbrand shrink-0 whitespace-nowrap w-[135px] sm:w-[150px] text-center tabular-nums",
                   children: [
-                    new Intl.NumberFormat("en-US").format(cloudRenders),
-                    " Renders"
+                    devSeatCount,
+                    " ",
+                    devSeatCount === 1 ? "Seat" : "Seats"
                   ]
                 }),
                 /* @__PURE__ */ jsxs8("div", {
@@ -24300,7 +24721,7 @@ var CompanyPricing = () => {
                     "$",
                     new Intl.NumberFormat("en-US", {
                       maximumFractionDigits: 0
-                    }).format(Math.ceil(cloudRenders / 1000) * RENDER_UNIT_PRICE)
+                    }).format(SEAT_PRICE * devSeatCount)
                   ]
                 })
               ]
@@ -24674,7 +25095,7 @@ var GitHubStars = () => {
             width: "45px"
           }),
           /* @__PURE__ */ jsx50(StatItemContent, {
-            content: "46k",
+            content: "47k",
             width: "80px",
             fontSize: "2.5rem",
             fontWeight: "bold"
@@ -24863,19 +25284,20 @@ var CommunityStats = () => /* @__PURE__ */ jsxs12("div", {
 var CommunityStats_default = CommunityStats;
 
 // ../player/dist/esm/index.mjs
+import { createContext as createContext32 } from "react";
 import { jsx as jsx56, jsxs as jsxs13 } from "react/jsx-runtime";
 import { jsx as jsx214, jsxs as jsxs24, Fragment as Fragment11 } from "react/jsx-runtime";
 import React56 from "react";
 import { useContext as useContext210, useEffect as useEffect42, useState as useState40 } from "react";
-import { useContext as useContext43, useLayoutEffect as useLayoutEffect17 } from "react";
+import { useContext as useContext44, useLayoutEffect as useLayoutEffect17 } from "react";
 import { jsx as jsx313 } from "react/jsx-runtime";
 import { useEffect as useEffect24, useState as useState24 } from "react";
 import { useLayoutEffect as useLayoutEffect23 } from "react";
-import { useContext as useContext44, useEffect as useEffect52, useRef as useRef42 } from "react";
+import { useContext as useContext45, useEffect as useEffect52, useRef as useRef42 } from "react";
 import { useEffect as useEffect310, useRef as useRef26 } from "react";
-import { useCallback as useCallback34, useContext as useContext38, useMemo as useMemo51, useRef as useRef43, useState as useState310 } from "react";
+import { useCallback as useCallback33, useContext as useContext39, useMemo as useMemo51, useRef as useRef43, useState as useState310 } from "react";
 import { useEffect as useEffect43, useRef as useRef310 } from "react";
-import { useCallback as useCallback24, useEffect as useEffect62, useMemo as useMemo212, useState as useState42 } from "react";
+import { useCallback as useCallback210, useEffect as useEffect62, useMemo as useMemo212, useState as useState42 } from "react";
 import {
   forwardRef as forwardRef210,
   useEffect as useEffect132,
@@ -24887,7 +25309,7 @@ import {
 } from "react";
 import React102, {
   Suspense as Suspense2,
-  forwardRef as forwardRef33,
+  forwardRef as forwardRef34,
   useCallback as useCallback102,
   useContext as useContext52,
   useEffect as useEffect122,
@@ -24903,7 +25325,7 @@ import { jsx as jsx55 } from "react/jsx-runtime";
 import { useCallback as useCallback72, useEffect as useEffect112, useMemo as useMemo92, useRef as useRef82, useState as useState102 } from "react";
 import { jsx as jsx64 } from "react/jsx-runtime";
 import { useCallback as useCallback42, useMemo as useMemo410, useRef as useRef52, useState as useState62 } from "react";
-import React54, { useCallback as useCallback35, useMemo as useMemo39, useState as useState52 } from "react";
+import React54, { useCallback as useCallback34, useMemo as useMemo39, useState as useState52 } from "react";
 import { jsx as jsx74, jsxs as jsxs33 } from "react/jsx-runtime";
 import { jsx as jsx84, jsxs as jsxs43 } from "react/jsx-runtime";
 import { useCallback as useCallback52, useEffect as useEffect92, useMemo as useMemo52, useState as useState82 } from "react";
@@ -24986,6 +25408,23 @@ function checkInfiniteRange2(name, arr) {
     }
   }
 }
+function assertValidInterpolateEasingOption2(easing, inputRangeLength) {
+  if (easing === undefined) {
+    return;
+  }
+  if (typeof easing === "function") {
+    return;
+  }
+  const expectedLength = inputRangeLength - 1;
+  if (easing.length !== expectedLength) {
+    throw new Error(`When easing is an array, it must have one entry per segment between keyframes (length inputRange.length - 1 = ${expectedLength}), but got length ${easing.length}`);
+  }
+  for (let i = 0;i < easing.length; i++) {
+    if (typeof easing[i] !== "function") {
+      throw new Error(`easing[${i}] must be a function`);
+    }
+  }
+}
 function interpolate3(input, inputRange, outputRange, options2) {
   if (typeof input === "undefined") {
     throw new Error("input can not be undefined");
@@ -25002,7 +25441,18 @@ function interpolate3(input, inputRange, outputRange, options2) {
   checkInfiniteRange2("inputRange", inputRange);
   checkInfiniteRange2("outputRange", outputRange);
   checkValidInputRange2(inputRange);
-  const easing = options2?.easing ?? ((num) => num);
+  assertValidInterpolateEasingOption2(options2?.easing, inputRange.length);
+  const easingOption = options2?.easing;
+  const defaultEasing = (num) => num;
+  const resolveEasingForSegment = (segmentIndex) => {
+    if (easingOption === undefined) {
+      return defaultEasing;
+    }
+    if (typeof easingOption === "function") {
+      return easingOption;
+    }
+    return easingOption[segmentIndex];
+  };
   let extrapolateLeft = "extend";
   if (options2?.extrapolateLeft !== undefined) {
     extrapolateLeft = options2.extrapolateLeft;
@@ -25016,7 +25466,7 @@ function interpolate3(input, inputRange, outputRange, options2) {
   }
   const range = findRange2(input, inputRange);
   return interpolateFunction2(input, [inputRange[range], inputRange[range + 1]], [outputRange[range], outputRange[range + 1]], {
-    easing,
+    easing: resolveEasingForSegment(range),
     extrapolateLeft,
     extrapolateRight
   });
@@ -25570,6 +26020,76 @@ var proResProfileOptions = [
   "light",
   "proxy"
 ];
+var sequenceStyleSchema2 = {
+  "style.translate": {
+    type: "translate",
+    step: 1,
+    default: "0px 0px",
+    description: "Offset"
+  },
+  "style.scale": {
+    type: "number",
+    min: 0.05,
+    max: 100,
+    step: 0.01,
+    default: 1,
+    description: "Scale"
+  },
+  "style.rotate": {
+    type: "rotation",
+    step: 1,
+    default: "0deg",
+    description: "Rotation"
+  },
+  "style.opacity": {
+    type: "number",
+    min: 0,
+    max: 1,
+    step: 0.01,
+    default: 1,
+    description: "Opacity"
+  },
+  premountFor: {
+    type: "number",
+    default: 0,
+    description: "Premount For",
+    min: 0,
+    step: 1
+  },
+  postmountFor: {
+    type: "hidden"
+  },
+  styleWhilePremounted: {
+    type: "hidden"
+  },
+  styleWhilePostmounted: {
+    type: "hidden"
+  }
+};
+var hiddenField2 = {
+  type: "boolean",
+  default: false,
+  description: "Hidden"
+};
+var sequenceSchema2 = {
+  hidden: hiddenField2,
+  layout: {
+    type: "enum",
+    default: "absolute-fill",
+    description: "Layout",
+    variants: {
+      "absolute-fill": sequenceStyleSchema2,
+      none: {}
+    }
+  }
+};
+var sequenceSchemaDefaultLayoutNone2 = {
+  ...sequenceSchema2,
+  layout: {
+    ...sequenceSchema2.layout,
+    default: "none"
+  }
+};
 var ENABLE_V5_BREAKING_CHANGES2 = false;
 var validateFrame2 = ({
   allowFloats,
@@ -25733,7 +26253,8 @@ var NoReactInternals = {
   FILE_TOKEN: FILE_TOKEN2,
   validateCodec: validateCodec2,
   proResProfileOptions,
-  findPropsToDelete: findPropsToDelete2
+  findPropsToDelete: findPropsToDelete2,
+  sequenceSchema: sequenceSchema2
 };
 
 // ../player/dist/esm/index.mjs
@@ -25746,8 +26267,8 @@ import {
   useRef as useRef132,
   useState as useState142
 } from "react";
-import React133, {
-  forwardRef as forwardRef34,
+import React132, {
+  forwardRef as forwardRef35,
   Suspense as Suspense22,
   useCallback as useCallback122,
   useImperativeHandle as useImperativeHandle32,
@@ -25758,6 +26279,21 @@ import { useContext as useContext62, useMemo as useMemo152 } from "react";
 import { jsx as jsx153 } from "react/jsx-runtime";
 import { jsx as jsx163 } from "react/jsx-runtime";
 "use client";
+if (typeof createContext32 !== "function") {
+  const err = [
+    'Remotion requires React.createContext, but it is "undefined".',
+    'If you are in a React Server Component, turn it into a client component by adding "use client" at the top of the file.',
+    "",
+    "Before:",
+    '  import {Player} from "@remotion/player";',
+    "",
+    "After:",
+    '  "use client";',
+    '  import {Player} from "@remotion/player";'
+  ];
+  throw new Error(err.join(`
+`));
+}
 var ICON_SIZE2 = 25;
 var fullscreenIconSize = 16;
 var PlayIcon = () => {
@@ -26190,7 +26726,7 @@ class ThumbnailEmitter {
   };
 }
 var useBufferStateEmitter = (emitter) => {
-  const bufferManager = useContext43(Internals.BufferingContextReact);
+  const bufferManager = useContext44(Internals.BufferingContextReact);
   if (!bufferManager) {
     throw new Error("BufferingContextReact not found");
   }
@@ -26273,33 +26809,33 @@ var usePlayer = () => {
   const playStart = useRef43(frame);
   const setFrame = Internals.Timeline.useTimelineSetFrame();
   const setTimelinePosition = Internals.Timeline.useTimelineSetFrame();
-  const audioContext = useContext38(Internals.SharedAudioContext);
-  const audioTagsContext = useContext38(Internals.SharedAudioTagsContext);
+  const audioContext = useContext39(Internals.SharedAudioContext);
+  const audioTagsContext = useContext39(Internals.SharedAudioTagsContext);
   const { audioAndVideoTags } = Internals.useTimelineContext();
   const frameRef = useRef43(frame);
   frameRef.current = frame;
   const video = Internals.useVideo();
   const config = Internals.useUnsafeVideoConfig();
-  const emitter = useContext38(PlayerEventEmitterContext);
+  const emitter = useContext39(PlayerEventEmitterContext);
   const lastFrame = (config?.durationInFrames ?? 1) - 1;
   const isLastFrame = frame === lastFrame;
   const isFirstFrame = frame === 0;
   if (!emitter) {
     throw new TypeError("Expected Player event emitter context");
   }
-  const bufferingContext = useContext38(Internals.BufferingContextReact);
+  const bufferingContext = useContext39(Internals.BufferingContextReact);
   if (!bufferingContext) {
     throw new Error("Missing the buffering context. Most likely you have a Remotion version mismatch.");
   }
   const { buffering } = bufferingContext;
-  const seek2 = useCallback34((newFrame) => {
+  const seek2 = useCallback33((newFrame) => {
     if (video?.id) {
       setTimelinePosition((c) => ({ ...c, [video.id]: newFrame }));
     }
     frameRef.current = newFrame;
     emitter.dispatchSeek(newFrame);
   }, [emitter, setTimelinePosition, video?.id]);
-  const play = useCallback34((e) => {
+  const play = useCallback33((e) => {
     if (imperativePlaying.current) {
       return;
     }
@@ -26326,7 +26862,7 @@ var usePlayer = () => {
     seek2,
     audioAndVideoTags
   ]);
-  const pause = useCallback34(() => {
+  const pause = useCallback33(() => {
     if (imperativePlaying.current) {
       imperativePlaying.current = false;
       setPlaying(false);
@@ -26334,7 +26870,7 @@ var usePlayer = () => {
       audioContext?.suspend();
     }
   }, [emitter, imperativePlaying, setPlaying, audioContext]);
-  const pauseAndReturnToPlayStart = useCallback34(() => {
+  const pauseAndReturnToPlayStart = useCallback33(() => {
     if (imperativePlaying.current) {
       imperativePlaying.current = false;
       frameRef.current = playStart.current;
@@ -26349,7 +26885,7 @@ var usePlayer = () => {
     }
   }, [config, emitter, imperativePlaying, setPlaying, setTimelinePosition]);
   const videoId = video?.id;
-  const frameBack = useCallback34((frames) => {
+  const frameBack = useCallback33((frames) => {
     if (!videoId) {
       return null;
     }
@@ -26368,7 +26904,7 @@ var usePlayer = () => {
       };
     });
   }, [imperativePlaying, setFrame, videoId]);
-  const frameForward = useCallback34((frames) => {
+  const frameForward = useCallback33((frames) => {
     if (!videoId) {
       return null;
     }
@@ -26387,20 +26923,20 @@ var usePlayer = () => {
       };
     });
   }, [videoId, imperativePlaying, lastFrame, setFrame]);
-  const toggle = useCallback34((e) => {
+  const toggle = useCallback33((e) => {
     if (imperativePlaying.current) {
       pause();
     } else {
       play(e);
     }
   }, [imperativePlaying, pause, play]);
-  const isPlaying = useCallback34(() => {
+  const isPlaying = useCallback33(() => {
     return imperativePlaying.current;
   }, [imperativePlaying]);
-  const getCurrentFrame = useCallback34(() => {
+  const getCurrentFrame = useCallback33(() => {
     return frameRef.current;
   }, [frameRef]);
-  const isBuffering = useCallback34(() => {
+  const isBuffering = useCallback33(() => {
     return buffering.current;
   }, [buffering]);
   const returnValue = useMemo51(() => {
@@ -26635,11 +27171,11 @@ var usePlayback = ({
   const frame = Internals.Timeline.useTimelinePosition();
   const { playing, pause, emitter, isPlaying } = usePlayer();
   const setFrame = Internals.Timeline.useTimelineSetFrame();
-  const sharedAudioContext = useContext44(Internals.SharedAudioContext);
+  const sharedAudioContext = useContext45(Internals.SharedAudioContext);
   const logLevel = Internals.useLogLevel();
   const isBackgroundedRef = useIsBackgrounded();
   const lastTimeUpdateTimestamp = useRef42(0);
-  const context = useContext44(Internals.BufferingContextReact);
+  const context = useContext45(Internals.BufferingContextReact);
   if (!context) {
     throw new Error("Missing the buffering context. Most likely you have a Remotion version mismatch.");
   }
@@ -26905,7 +27441,7 @@ var useElementSize = (ref, options2) => {
       });
     });
   }, [options2.shouldApplyCssTransforms]);
-  const updateSize = useCallback24(() => {
+  const updateSize = useCallback210(() => {
     if (!ref.current) {
       return;
     }
@@ -27126,7 +27662,7 @@ var DefaultVolumeSlider = ({
   }, [isVertical]);
   const randomId = typeof React54.useId === "undefined" ? "volume-slider" : React54.useId();
   const [randomClass] = useState52(() => `__remotion-volume-slider-${random(randomId)}`.replace(".", ""));
-  const onVolumeChange = useCallback35((e) => {
+  const onVolumeChange = useCallback34((e) => {
     setVolume(parseFloat(e.target.value));
   }, [setVolume]);
   const inputStyle = useMemo39(() => {
@@ -28564,7 +29100,7 @@ var PlayerUI = ({
     })
   });
 };
-var PlayerUI_default = forwardRef33(PlayerUI);
+var PlayerUI_default = forwardRef34(PlayerUI);
 var DEFAULT_VOLUME_PERSISTENCE_KEY = "remotion.volumePreference";
 var persistVolume = (volume, logLevel, volumePersistenceKey) => {
   if (typeof window === "undefined") {
@@ -29091,7 +29627,7 @@ var useThumbnail = () => {
   }, [emitter]);
   return returnValue;
 };
-var reactVersion2 = React133.version.split(".")[0];
+var reactVersion2 = React132.version.split(".")[0];
 if (reactVersion2 === "0") {
   throw new Error(`Version ${reactVersion2} of "react" is not supported by Remotion`);
 }
@@ -29210,7 +29746,7 @@ var ThumbnailUI = ({
     })
   });
 };
-var ThumbnailUI_default = forwardRef34(ThumbnailUI);
+var ThumbnailUI_default = forwardRef35(ThumbnailUI);
 var ThumbnailFn = ({
   frameToDisplay,
   style: style2,
@@ -29304,7 +29840,7 @@ var Thumbnail = forward2(ThumbnailFn);
 
 // src/components/homepage/Demo/index.tsx
 import {
-  useCallback as useCallback49,
+  useCallback as useCallback48,
   useEffect as useEffect58,
   useMemo as useMemo64,
   useRef as useRef53,
@@ -29363,7 +29899,7 @@ function _isNativeReflectConstruct() {
   try {
     var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
   } catch (t2) {}
-  return (_isNativeReflectConstruct = function _isNativeReflectConstruct() {
+  return (_isNativeReflectConstruct = function _isNativeReflectConstruct2() {
     return !!t;
   })();
 }
@@ -29381,7 +29917,7 @@ function _construct(t, e, r2) {
 // ../../node_modules/.bun/@babel+runtime@7.27.1/node_modules/@babel/runtime/helpers/esm/wrapNativeSuper.js
 function _wrapNativeSuper(t) {
   var r2 = typeof Map == "function" ? new Map : undefined;
-  return _wrapNativeSuper = function _wrapNativeSuper(t2) {
+  return _wrapNativeSuper = function _wrapNativeSuper2(t2) {
     if (t2 === null || !_isNativeFunction(t2))
       return t2;
     if (typeof t2 != "function")
@@ -30057,7 +30593,7 @@ var UNDERLAY_RED = curriedTransparentize$1(0.9, RED);
 var BLUE_TEXT = curriedDarken$1(0.3, "#42e9f5");
 
 // src/components/homepage/layout/use-color-mode.tsx
-import React57, { useContext as useContext45, useMemo as useMemo53 } from "react";
+import React57, { useContext as useContext46, useMemo as useMemo53 } from "react";
 import { jsx as jsx57 } from "react/jsx-runtime";
 var Context = React57.createContext(undefined);
 var ColorModeProvider = ({
@@ -30074,7 +30610,7 @@ var ColorModeProvider = ({
   });
 };
 function useColorMode() {
-  const context = useContext45(Context);
+  const context = useContext46(Context);
   if (context === null || context === undefined) {
     throw new Error("ColorModeProvider");
   }
@@ -30088,9 +30624,9 @@ import { useContext as useContext212, useEffect as useEffect44, useMemo as useMe
 import { ALL_FORMATS, Input as Input2, UrlSource } from "mediabunny";
 import { AudioBufferSink, InputDisposedError } from "mediabunny";
 import { CanvasSink } from "mediabunny";
-import { useContext as useContext47, useLayoutEffect as useLayoutEffect18 } from "react";
+import { useContext as useContext48, useLayoutEffect as useLayoutEffect18 } from "react";
 import { jsx as jsx58 } from "react/jsx-runtime";
-import { useContext as useContext310, useLayoutEffect as useLayoutEffect24, useMemo as useMemo213, useState as useState210 } from "react";
+import { useContext as useContext311, useLayoutEffect as useLayoutEffect24, useMemo as useMemo213, useState as useState210 } from "react";
 import React211 from "react";
 import {
   ALL_FORMATS as ALL_FORMATS2,
@@ -30106,7 +30642,7 @@ import { jsx as jsx216 } from "react/jsx-runtime";
 import { jsx as jsx315 } from "react/jsx-runtime";
 import { useMemo as useMemo63, useState as useState63 } from "react";
 import {
-  useContext as useContext46,
+  useContext as useContext47,
   useEffect as useEffect210,
   useLayoutEffect as useLayoutEffect34,
   useMemo as useMemo412,
@@ -31180,8 +31716,7 @@ var videoIteratorManager = async ({
   getStartTime,
   getIsLooping,
   getEffects,
-  getEffectChainState,
-  getCurrentFrame
+  getEffectChainState
 }) => {
   let videoIteratorsCreated = 0;
   let videoFrameIterator = null;
@@ -31211,7 +31746,6 @@ var videoIteratorManager = async ({
           source: frame.canvas,
           effects,
           output: canvas,
-          frame: getCurrentFrame(),
           width: canvas.width,
           height: canvas.height
         });
@@ -31324,7 +31858,6 @@ class MediaPlayer {
   onVideoFrameCallback = null;
   getEffects;
   getEffectChainState;
-  getCurrentFrame;
   initializationPromise = null;
   bufferState;
   isPremounting;
@@ -31353,8 +31886,7 @@ class MediaPlayer {
     credentials,
     tagType,
     getEffects,
-    getEffectChainState,
-    getCurrentFrame
+    getEffectChainState
   }) {
     this.canvas = canvas ?? null;
     this.src = src;
@@ -31385,7 +31917,6 @@ class MediaPlayer {
     this.tagType = tagType;
     this.getEffects = getEffects;
     this.getEffectChainState = getEffectChainState;
-    this.getCurrentFrame = getCurrentFrame;
     if (canvas) {
       const context = canvas.getContext("2d", {
         alpha: true,
@@ -31495,8 +32026,7 @@ class MediaPlayer {
             getStartTime: () => this.getStartTime(),
             getIsLooping: () => this.loop,
             getEffects: this.getEffects,
-            getEffectChainState: this.getEffectChainState,
-            getCurrentFrame: this.getCurrentFrame
+            getEffectChainState: this.getEffectChainState
           });
         }
         const startTime = this.getTrimmedTime(startTimeUnresolved);
@@ -31873,7 +32403,7 @@ var useCommonEffects = ({
   logLevel,
   label: label3
 }) => {
-  const sharedAudioContext = useContext47(Internals.SharedAudioContext);
+  const sharedAudioContext = useContext48(Internals.SharedAudioContext);
   useLayoutEffect18(() => {
     const mediaPlayer = mediaPlayerRef.current;
     if (!mediaPlayer)
@@ -32143,8 +32673,7 @@ var AudioForPreviewAssertedShowing = ({
         credentials,
         tagType: "audio",
         getEffects: () => [],
-        getEffectChainState: () => null,
-        getCurrentFrame: () => 0
+        getEffectChainState: () => null
       });
       mediaPlayerRef.current = player;
       player.initialize(currentTimeRef.current, initialMuted.current).then((result) => {
@@ -34149,7 +34678,7 @@ var AudioForRendering2 = ({
   const frame = useCurrentFrame();
   const absoluteFrame = Internals.useTimelinePosition();
   const videoConfig = Internals.useUnsafeVideoConfig();
-  const { registerRenderAsset, unregisterRenderAsset } = useContext310(Internals.RenderAssetManager);
+  const { registerRenderAsset, unregisterRenderAsset } = useContext311(Internals.RenderAssetManager);
   const startsAt = Internals.useMediaStartsAt();
   const environment = useRemotionEnvironment();
   if (!videoConfig) {
@@ -34161,7 +34690,7 @@ var AudioForRendering2 = ({
   const { fps } = videoConfig;
   const { delayRender: delayRender2, continueRender } = useDelayRender();
   const [replaceWithHtml5Audio, setReplaceWithHtml5Audio] = useState210(false);
-  const sequenceContext = useContext310(Internals.SequenceContext);
+  const sequenceContext = useContext311(Internals.SequenceContext);
   const id = useMemo213(() => `media-audio-${random(src)}-${sequenceContext?.cumulatedFrom}-${sequenceContext?.relativeFrom}-${sequenceContext?.durationInFrames}`, [
     src,
     sequenceContext?.cumulatedFrom,
@@ -34320,6 +34849,7 @@ var AudioForRendering2 = ({
       onError: fallbackHtml5AudioProps?.onError,
       toneFrequency,
       acceptableTimeShiftInSeconds: fallbackHtml5AudioProps?.acceptableTimeShiftInSeconds,
+      preservePitch: fallbackHtml5AudioProps?.preservePitch ?? true,
       name,
       showInTimeline
     });
@@ -34343,7 +34873,8 @@ var audioSchema = {
     default: 1,
     description: "Playback Rate"
   },
-  loop: { type: "boolean", default: false, description: "Loop" }
+  loop: { type: "boolean", default: false, description: "Loop" },
+  hidden: Internals.hiddenField
 };
 var AudioInner = (props) => {
   const {
@@ -34353,6 +34884,7 @@ var AudioInner = (props) => {
     _experimentalControls: controls,
     from,
     durationInFrames,
+    hidden,
     ...otherProps
   } = props;
   const environment = useRemotionEnvironment();
@@ -34412,6 +34944,7 @@ var AudioInner = (props) => {
     _experimentalControls: controls,
     _remotionInternalLoopDisplay: loopDisplay,
     showInTimeline: showInTimeline ?? true,
+    hidden,
     children: environment.isRendering ? /* @__PURE__ */ jsx315(AudioForRendering2, {
       ...otherProps
     }) : /* @__PURE__ */ jsx315(AudioForPreview2, {
@@ -34514,7 +35047,7 @@ var VideoForPreviewAssertedShowing = ({
   const [shouldFallbackToNativeVideo, setShouldFallbackToNativeVideo] = useState43(false);
   const [playing] = Timeline2.usePlayingState();
   const { playbackRate: globalPlaybackRate } = Internals.usePlaybackRate();
-  const sharedAudioContext = useContext46(SharedAudioContext22);
+  const sharedAudioContext = useContext47(SharedAudioContext22);
   const buffer = useBufferState();
   const [mediaMuted] = useMediaMutedState22();
   const [mediaVolume] = useMediaVolumeState22();
@@ -34533,9 +35066,7 @@ var VideoForPreviewAssertedShowing = ({
   experimentalEffectsRef.current = _experimentalEffects;
   const effectChainStateRef = useRef210(effectChainState);
   effectChainStateRef.current = effectChainState;
-  const frameRef = useRef210(frame);
-  frameRef.current = frame;
-  const parentSequence = useContext46(SequenceContext22);
+  const parentSequence = useContext47(SequenceContext22);
   const isPremounting = Boolean(parentSequence?.premounting);
   const isPostmounting = Boolean(parentSequence?.postmounting);
   const sequenceOffset = ((parentSequence?.cumulatedFrom ?? 0) + (parentSequence?.relativeFrom ?? 0)) / videoConfig.fps;
@@ -34543,7 +35074,7 @@ var VideoForPreviewAssertedShowing = ({
   const currentTimeRef = useRef210(currentTime);
   currentTimeRef.current = currentTime;
   const preloadedSrc = usePreload22(src);
-  const buffering = useContext46(Internals.BufferingContextReact);
+  const buffering = useContext47(Internals.BufferingContextReact);
   if (!buffering) {
     throw new Error("useMediaPlayback must be used inside a <BufferingContext>");
   }
@@ -34640,8 +35171,7 @@ var VideoForPreviewAssertedShowing = ({
         credentials,
         tagType: "video",
         getEffects: () => experimentalEffectsRef.current,
-        getEffectChainState: (width, height) => effectChainStateRef.current?.get(width, height),
-        getCurrentFrame: () => frameRef.current
+        getEffectChainState: (width, height) => effectChainStateRef.current?.get(width, height)
       });
       mediaPlayerRef.current = player;
       player.initialize(currentTimeRef.current, initialMuted.current).then((result) => {
@@ -35105,6 +35635,7 @@ var VideoForRendering2 = ({
       trimAfter: trimAfterValue,
       trimBefore: trimBeforeValue,
       useWebAudioApi: fallbackOffthreadVideoProps?.useWebAudioApi ?? false,
+      preservePitch: fallbackOffthreadVideoProps?.preservePitch ?? true,
       startFrom: undefined,
       endAt: undefined,
       stack,
@@ -35155,6 +35686,11 @@ var videoSchema = {
     default: 1,
     description: "Playback Rate"
   },
+  hidden: {
+    type: "boolean",
+    default: false,
+    description: "Hidden"
+  },
   loop: { type: "boolean", default: false, description: "Loop" },
   ...Internals.sequenceStyleSchema
 };
@@ -35293,7 +35829,8 @@ var VideoInner = ({
   _experimentalInitiallyDrawCachedFrame,
   _experimentalEffects,
   durationInFrames,
-  from
+  from,
+  hidden
 }) => {
   const fallbackLogLevel = Internals.useLogLevel();
   const [mediaVolume] = Internals.useMediaVolumeState();
@@ -35335,7 +35872,11 @@ var VideoInner = ({
     type: "video",
     data: basicInfo
   }), [basicInfo]);
-  const memoizedEffects = Internals.useMemoizedEffects(Internals.flattenEffects(_experimentalEffects ?? []));
+  const memoizedEffects = Internals.useMemoizedEffects({
+    effects: _experimentalEffects ?? [],
+    overrideId: controls?.overrideId ?? null
+  });
+  const memoizedEffectDefinitions = Internals.useMemoizedEffectDefinitions(_experimentalEffects ?? []);
   if (sequenceDurationInFrames === 0) {
     return null;
   }
@@ -35348,8 +35889,9 @@ var VideoInner = ({
     name: name ?? "<Video>",
     _experimentalControls: controls,
     _remotionInternalLoopDisplay: loopDisplay,
-    _experimentalEffects: memoizedEffects,
+    _experimentalEffects: memoizedEffectDefinitions,
     showInTimeline: showInTimeline ?? true,
+    hidden,
     children: /* @__PURE__ */ jsx65(InnerVideo, {
       audioStreamIndex: audioStreamIndex ?? 0,
       className: className2,
@@ -35387,19 +35929,19 @@ var Video = Internals.wrapInSchema(VideoInner, videoSchema);
 Internals.addSequenceStackTraces(Video);
 
 // src/components/homepage/Demo/Comp.tsx
-import { useCallback as useCallback41, useEffect as useEffect50, useMemo as useMemo58, useState as useState48 } from "react";
+import { useCallback as useCallback40, useEffect as useEffect50, useMemo as useMemo58, useState as useState48 } from "react";
 
 // src/components/homepage/Demo/Cards.tsx
 import {
   createRef as createRef4,
-  useCallback as useCallback40,
+  useCallback as useCallback39,
   useEffect as useEffect49,
   useRef as useRef49,
   useState as useState47
 } from "react";
 
 // src/components/homepage/Demo/Card.tsx
-import { useCallback as useCallback38, useRef as useRef46 } from "react";
+import { useCallback as useCallback37, useRef as useRef46 } from "react";
 
 // src/components/homepage/Demo/math.ts
 var paddingAndMargin = 20;
@@ -35433,10 +35975,10 @@ var getIndexFromPosition = (clientX, clientY) => {
 };
 
 // src/components/homepage/Demo/Switcher.tsx
-import { useCallback as useCallback36 } from "react";
+import { useCallback as useCallback35 } from "react";
 import { jsx as jsx60, jsxs as jsxs14 } from "react/jsx-runtime";
 var Switcher = ({ type, theme, onTap }) => {
-  const onPointerDown = useCallback36((e) => {
+  const onPointerDown = useCallback35((e) => {
     e.stopPropagation();
     onTap();
   }, [onTap]);
@@ -35499,7 +36041,7 @@ var Card2 = ({
   const refToUse = refsToUse[index2];
   const stopPrevious = useRef46([]);
   let newIndices = [...indices];
-  const applyPositions = useCallback38((except) => {
+  const applyPositions = useCallback37((except) => {
     let stopped = false;
     stopPrevious.current.forEach((s) => {
       s();
@@ -35572,7 +36114,7 @@ var Card2 = ({
       update();
     });
   }, [newIndices, onUpdate, positions, refsToUse, shouldBePositions]);
-  const onPointerDown = useCallback38((e) => {
+  const onPointerDown = useCallback37((e) => {
     e.currentTarget.setPointerCapture(e.pointerId);
     const cardLeft = refToUse.current.offsetLeft;
     const cardTop = refToUse.current.offsetTop;
@@ -35633,7 +36175,7 @@ var Card2 = ({
     }, { once: true });
     refToUse.current.addEventListener("pointermove", onMove);
   }, [applyPositions, index2, positions, refToUse, shouldBePositions]);
-  const onPointerUp = useCallback38((e) => {
+  const onPointerUp = useCallback37((e) => {
     e.currentTarget.releasePointerCapture(e.pointerId);
   }, []);
   const { x, y } = getPositionForIndex(index2);
@@ -35759,8 +36301,8 @@ var CurrentCountry = ({ theme, countryPaths, countryLabel }) => {
 
 // src/components/homepage/Demo/EmojiCard.tsx
 import {
-  forwardRef as forwardRef35,
-  useCallback as useCallback39,
+  forwardRef as forwardRef36,
+  useCallback as useCallback38,
   useEffect as useEffect48,
   useImperativeHandle as useImperativeHandle12,
   useRef as useRef48
@@ -36044,7 +36586,7 @@ var EmojiCardRefFn = ({ emojiIndex }, ref) => {
   const ref2 = useRef48(null);
   const ref3 = useRef48(null);
   const transforms = useRef48([-100, 0, 100]);
-  const onLeft = useCallback39(() => {
+  const onLeft = useCallback38(() => {
     if (!ref1.current || !ref2.current || !ref3.current) {
       return;
     }
@@ -36055,7 +36597,7 @@ var EmojiCardRefFn = ({ emojiIndex }, ref) => {
       transforms: transforms.current
     });
   }, []);
-  const onRight = useCallback39(() => {
+  const onRight = useCallback38(() => {
     if (!ref1.current || !ref2.current || !ref3.current) {
       return;
     }
@@ -36156,7 +36698,7 @@ var EmojiCardRefFn = ({ emojiIndex }, ref) => {
     ]
   });
 };
-var EmojiCard = forwardRef35(EmojiCardRefFn);
+var EmojiCard = forwardRef36(EmojiCardRefFn);
 
 // src/components/homepage/Demo/Minus.tsx
 import { jsx as jsx75 } from "react/jsx-runtime";
@@ -36515,11 +37057,11 @@ var Cards = ({
     };
   }, [onToggle]);
   const ref = useRef49(null);
-  const onLeft = useCallback40(() => {
+  const onLeft = useCallback39(() => {
     ref.current?.onRight();
     onRightPress();
   }, [onRightPress]);
-  const onRight = useCallback40(() => {
+  const onRight = useCallback39(() => {
     ref.current?.onLeft();
     onLeftPress();
   }, [onLeftPress]);
@@ -36589,7 +37131,7 @@ var HomepageVideoComp = ({
   onClickRight
 }) => {
   const [rerenders, setRerenders] = useState48(0);
-  const onUpdate = useCallback41((newIndices) => {
+  const onUpdate = useCallback40((newIndices) => {
     setRerenders(rerenders + 1);
     updateCardOrder(newIndices);
   }, [rerenders, updateCardOrder]);
@@ -36687,7 +37229,7 @@ import {
 import { BufferTarget, StreamTarget } from "mediabunny";
 
 // ../core/dist/esm/version.mjs
-var VERSION2 = "4.0.461";
+var VERSION2 = "4.0.463";
 
 // ../web-renderer/dist/esm/index.mjs
 import { AudioSample, VideoSample } from "mediabunny";
@@ -41316,7 +41858,7 @@ var renderMediaOnWeb = (options2) => {
 };
 
 // src/components/homepage/Demo/DemoRender.tsx
-import React68, { useCallback as useCallback43 } from "react";
+import React68, { useCallback as useCallback41 } from "react";
 import { z } from "zod";
 
 // src/components/homepage/Demo/DemoErrorIcon.tsx
@@ -41517,7 +42059,7 @@ var RenderButton = ({ renderData, onError, playerRef }) => {
   const [state, setState] = React68.useState({
     type: "idle"
   });
-  const triggerRender = useCallback43(async () => {
+  const triggerRender = useCallback41(async () => {
     if (renderData === null) {
       return;
     }
@@ -41692,10 +42234,10 @@ var DragAndDropNudge = () => {
 };
 
 // src/components/homepage/Demo/PlayerSeekBar.tsx
-import { useCallback as useCallback46, useEffect as useEffect53, useMemo as useMemo61, useRef as useRef50, useState as useState51 } from "react";
+import { useCallback as useCallback45, useEffect as useEffect53, useMemo as useMemo61, useRef as useRef50, useState as useState51 } from "react";
 
 // src/components/homepage/layout/use-el-size.ts
-import { useCallback as useCallback45, useEffect as useEffect51, useMemo as useMemo60, useState as useState50 } from "react";
+import { useCallback as useCallback43, useEffect as useEffect51, useMemo as useMemo60, useState as useState50 } from "react";
 var useElementSize2 = (ref) => {
   const [size4, setSize] = useState50(null);
   const observer = useMemo60(() => {
@@ -41709,7 +42251,7 @@ var useElementSize2 = (ref) => {
       });
     });
   }, []);
-  const updateSize = useCallback45(() => {
+  const updateSize = useCallback43(() => {
     if (ref === null) {
       return;
     }
@@ -41861,7 +42403,7 @@ var PlayerSeekBar2 = ({
     dragging: false
   });
   const width2 = size4?.width ?? 0;
-  const onPointerDown = useCallback46((e) => {
+  const onPointerDown = useCallback45((e) => {
     if (e.button !== 0) {
       return;
     }
@@ -41875,7 +42417,7 @@ var PlayerSeekBar2 = ({
     });
     onSeekStart();
   }, [durationInFrames, width2, playerRef, playing, onSeekStart]);
-  const onPointerMove = useCallback46((e) => {
+  const onPointerMove = useCallback45((e) => {
     if (!size4) {
       throw new Error("Player has no size");
     }
@@ -41886,7 +42428,7 @@ var PlayerSeekBar2 = ({
     const _frame = getFrameFromX2(e.clientX - posLeft, durationInFrames, size4.width);
     playerRef.current.seekTo(_frame);
   }, [dragging.dragging, durationInFrames, playerRef, size4]);
-  const onPointerUp = useCallback46(() => {
+  const onPointerUp = useCallback45(() => {
     setDragging({
       dragging: false
     });
@@ -41970,7 +42512,7 @@ var PlayerSeekBar2 = ({
 };
 
 // src/components/homepage/Demo/PlayerVolume.tsx
-import { useCallback as useCallback47, useEffect as useEffect55, useRef as useRef51, useState as useState54 } from "react";
+import { useCallback as useCallback46, useEffect as useEffect55, useRef as useRef51, useState as useState54 } from "react";
 
 // src/components/homepage/Demo/icons.tsx
 import { jsx as jsx101 } from "react/jsx-runtime";
@@ -42051,7 +42593,7 @@ var PlayerVolume = ({ playerRef }) => {
       document.body.style.userSelect = "auto";
     }
   }, [isHovered]);
-  const onClick = useCallback47(() => {
+  const onClick = useCallback46(() => {
     if (timerRef.current !== null) {
       clearTimeout(timerRef.current);
       timerRef.current = null;
@@ -42089,7 +42631,7 @@ var PlayerVolume = ({ playerRef }) => {
 };
 
 // src/components/homepage/Demo/PlayPauseButton.tsx
-import React71, { useCallback as useCallback48, useEffect as useEffect56 } from "react";
+import React71, { useCallback as useCallback47, useEffect as useEffect56 } from "react";
 import { jsx as jsx107 } from "react/jsx-runtime";
 var playerButtonStyle2 = {
   appearance: "none",
@@ -42125,7 +42667,7 @@ var PlayPauseButton = ({ playerRef }) => {
       current.removeEventListener("pause", onPause);
     };
   }, [playerRef]);
-  const onToggle = useCallback48(() => {
+  const onToggle = useCallback47(() => {
     playerRef.current?.toggle();
   }, [playerRef]);
   const playPauseIconStyle = {
@@ -42345,7 +42887,7 @@ var Demo = () => {
       playerRef.removeEventListener("fullscreenchange", onFullscreenChange);
     };
   }, [data2]);
-  const updateCardOrder = useCallback49((newCardOrder) => {
+  const updateCardOrder = useCallback48((newCardOrder) => {
     setCardOrder(newCardOrder);
   }, []);
   const props = useMemo64(() => {
@@ -42367,7 +42909,7 @@ var Demo = () => {
       emojiIndex
     };
   }, [cardOrder, emojiIndex, colorMode, data2, updateCardOrder]);
-  const onError = useCallback49(() => {
+  const onError = useCallback48(() => {
     setError(true);
   }, []);
   return /* @__PURE__ */ jsxs38("div", {
@@ -42477,12 +43019,12 @@ var ClearButton = (props) => {
 
 // src/components/homepage/MuxVideo.tsx
 import Hls2 from "hls.js";
-import { forwardRef as forwardRef38, useEffect as useEffect60, useImperativeHandle as useImperativeHandle14, useRef as useRef56 } from "react";
+import { forwardRef as forwardRef39, useEffect as useEffect60, useImperativeHandle as useImperativeHandle14, useRef as useRef56 } from "react";
 
 // src/components/homepage/VideoPlayerWithControls.tsx
 import Hls from "hls.js";
 import"plyr/dist/plyr.css";
-import { forwardRef as forwardRef37, useCallback as useCallback50, useEffect as useEffect59, useRef as useRef55, useState as useState57 } from "react";
+import { forwardRef as forwardRef38, useCallback as useCallback49, useEffect as useEffect59, useRef as useRef55, useState as useState57 } from "react";
 import { jsx as jsx116 } from "react/jsx-runtime";
 var useCombinedRefs = function(...refs) {
   const targetRef = useRef55(null);
@@ -42499,13 +43041,13 @@ var useCombinedRefs = function(...refs) {
   }, [refs]);
   return targetRef;
 };
-var VideoPlayerWithControls = forwardRef37(({ playbackId, poster, currentTime, onLoaded, onError, onSize, autoPlay }, ref) => {
+var VideoPlayerWithControls = forwardRef38(({ playbackId, poster, currentTime, onLoaded, onError, onSize, autoPlay }, ref) => {
   const videoRef = useRef55(null);
   const metaRef = useCombinedRefs(ref, videoRef);
   const playerRef = useRef55(null);
   const [playerInitTime] = useState57(Date.now());
-  const videoError = useCallback50((event) => onError(event), [onError]);
-  const onImageLoad = useCallback50((event) => {
+  const videoError = useCallback49((event) => onError(event), [onError]);
+  const onImageLoad = useCallback49((event) => {
     const [w, h] = [event.target.width, event.target.height];
     if (w && h) {
       onSize({ width: w, height: h });
@@ -42615,7 +43157,7 @@ var MuxVideoForward = ({ muxId, ...props }, ref) => {
     ...props
   });
 };
-var MuxVideo = forwardRef38(MuxVideoForward);
+var MuxVideo = forwardRef39(MuxVideoForward);
 
 // src/components/homepage/EditorStarterSection.tsx
 import { jsx as jsx118, jsxs as jsxs39 } from "react/jsx-runtime";
@@ -42879,13 +43421,13 @@ var IfYouKnowReact = () => {
 };
 
 // src/components/homepage/NewsletterButton.tsx
-import { useCallback as useCallback51, useState as useState60 } from "react";
+import { useCallback as useCallback50, useState as useState60 } from "react";
 import { jsx as jsx121, jsxs as jsxs44 } from "react/jsx-runtime";
 var NewsletterButton = () => {
   const [email, setEmail] = useState60("");
   const [submitting, setSubmitting] = useState60(false);
   const [subscribed, setSubscribed] = useState60(false);
-  const handleSubmit = useCallback51(async (e) => {
+  const handleSubmit = useCallback50(async (e) => {
     try {
       setSubmitting(true);
       e.preventDefault();
@@ -43669,6 +44211,7 @@ var listOfRemotionPackages = [
   "@remotion/serverless",
   "@remotion/serverless-client",
   "@remotion/skills",
+  "@remotion/skills-evals",
   "@remotion/studio-server",
   "@remotion/studio-shared",
   "@remotion/studio",
@@ -44951,7 +45494,7 @@ var GithubButton = () => {
       " ",
       /* @__PURE__ */ jsx164("div", {
         className: "text-xs inline-block ml-2 leading-none mt-[3px] self-center",
-        children: "46k"
+        children: "47k"
       })
     ]
   });