@remotion/promo-pages 4.0.461 → 4.0.463

package/dist/experts.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,1014 +2490,786 @@ 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);
+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 useMemo10(() => {
+    if (!video) {
+      return null;
     }
-  }
-  return out;
+    const {
+      id,
+      durationInFrames,
+      fps,
+      height,
+      width,
+      defaultProps,
+      props,
+      defaultCodec,
+      defaultOutName,
+      defaultVideoImageFormat,
+      defaultPixelFormat,
+      defaultProResProfile,
+      defaultSampleRate
+    } = video;
+    return {
+      id,
+      width: ctxWidth ?? width,
+      height: ctxHeight ?? height,
+      fps,
+      durationInFrames: ctxDuration ?? durationInFrames,
+      defaultProps,
+      props,
+      defaultCodec,
+      defaultOutName,
+      defaultVideoImageFormat,
+      defaultPixelFormat,
+      defaultProResProfile,
+      defaultSampleRate
+    };
+  }, [ctxDuration, ctxHeight, ctxWidth, video]);
 };
-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;
+var useVideoConfig = () => {
+  const videoConfig = useUnsafeVideoConfig();
+  const context = useContext13(CanUseRemotionHooks);
+  const isPlayer = useIsPlayer();
+  if (!videoConfig) {
+    if (typeof window !== "undefined" && window.remotion_isPlayer || isPlayer) {
+      throw new Error([
+        "No video config found. Likely reasons:",
+        "- You are probably calling useVideoConfig() from outside the component passed to <Player />. See https://www.remotion.dev/docs/player/examples for how to set up the Player correctly.",
+        "- You have multiple versions of Remotion installed which causes the React context to get lost."
+      ].join("-"));
     }
+    throw new Error("No video config found. You are probably calling useVideoConfig() from a component which has not been registered as a <Composition />. See https://www.remotion.dev/docs/the-fundamentals#defining-compositions for more information.");
   }
-  if (currentBackend !== null && current.length > 0) {
-    runs.push({ backend: currentBackend, effects: current });
+  if (!context) {
+    throw new Error("Called useVideoConfig() outside a Remotion composition.");
   }
-  return runs;
+  return videoConfig;
 };
-
-class CanvasPool {
-  width;
-  height;
-  pairs = new Map;
-  lostContexts = new Set;
-  constructor(width, height) {
-    this.width = width;
-    this.height = height;
+var Freeze = ({
+  frame: frameToFreeze,
+  children,
+  active = true
+}) => {
+  const frame = useCurrentFrame();
+  const videoConfig = useVideoConfig();
+  if (typeof frameToFreeze === "undefined") {
+    throw new Error(`The <Freeze /> component requires a 'frame' prop, but none was passed.`);
   }
-  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;
+  if (typeof frameToFreeze !== "number") {
+    throw new Error(`The 'frame' prop of <Freeze /> must be a number, but is of type ${typeof frameToFreeze}`);
   }
-  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.");
-    }
+  if (Number.isNaN(frameToFreeze)) {
+    throw new Error(`The 'frame' prop of <Freeze /> must be a real number, but it is NaN.`);
   }
-  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;
+  if (!Number.isFinite(frameToFreeze)) {
+    throw new Error(`The 'frame' prop of <Freeze /> must be a finite number, but it is ${frameToFreeze}.`);
+  }
+  const isActive = useMemo11(() => {
+    if (typeof active === "boolean") {
+      return active;
+    }
+    if (typeof active === "function") {
+      return active(frame);
+    }
+  }, [active, frame]);
+  const timelineContext = useTimelineContext();
+  const sequenceContext = useContext14(SequenceContext);
+  const relativeFrom = sequenceContext?.relativeFrom ?? 0;
+  const timelineValue = useMemo11(() => {
+    if (!isActive) {
+      return timelineContext;
+    }
+    return {
+      ...timelineContext,
+      playing: false,
+      imperativePlaying: {
+        current: false
+      },
+      frame: {
+        [videoConfig.id]: frameToFreeze + relativeFrom
       }
-      case "webgpu": {
-        if (typeof navigator === "undefined" || !("gpu" in navigator)) {
-          throw new Error("WebGPU is not available in this environment for canvas effect");
+    };
+  }, [isActive, timelineContext, videoConfig.id, frameToFreeze, relativeFrom]);
+  const newSequenceContext = useMemo11(() => {
+    if (!sequenceContext) {
+      return null;
+    }
+    if (!isActive) {
+      return sequenceContext;
+    }
+    return {
+      ...sequenceContext,
+      cumulatedFrom: 0
+    };
+  }, [sequenceContext, isActive]);
+  return /* @__PURE__ */ jsx9(TimelineContext.Provider, {
+    value: timelineValue,
+    children: /* @__PURE__ */ jsx9(SequenceContext.Provider, {
+      value: newSequenceContext,
+      children
+    })
+  });
+};
+var PremountContext = createContext14({
+  premountFramesRemaining: 0
+});
+var SequenceManager = React11.createContext({
+  registerSequence: () => {
+    throw new Error("SequenceManagerContext not initialized");
+  },
+  unregisterSequence: () => {
+    throw new Error("SequenceManagerContext not initialized");
+  },
+  sequences: []
+});
+var makeSequencePropsSubscriptionKey = (key) => {
+  return `${key.nodePath.join(".")}.${key.sequenceKeys.join(".")}.${key.effectKeys.map((keys) => keys.join(".")).join(".")}`;
+};
+var VisualModeCodeValuesContext = React11.createContext({
+  codeValues: {}
+});
+var VisualModeDragOverridesContext = React11.createContext({
+  getDragOverrides: () => {
+    throw new Error("VisualModeDragOverridesContext not initialized");
+  },
+  getEffectDragOverrides: () => {
+    throw new Error("VisualModeDragOverridesContext not initialized");
+  }
+});
+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] = useState3([]);
+  const [dragOverrides, setControlOverrides] = useState3({});
+  const controlOverridesRef = useRef4(dragOverrides);
+  controlOverridesRef.current = dragOverrides;
+  const [effectDragOverridesState, setEffectDragOverridesState] = useState3({});
+  const [codeValues, setCodeValuesMapState] = useState3({});
+  const setDragOverrides = useCallback5((nodePath, key, value) => {
+    setControlOverrides((prev) => ({
+      ...prev,
+      [makeSequencePropsSubscriptionKey(nodePath)]: {
+        ...prev[makeSequencePropsSubscriptionKey(nodePath)],
+        [key]: value
+      }
+    }));
+  }, []);
+  const clearDragOverrides = useCallback5((nodePath) => {
+    setControlOverrides((prev) => {
+      const key = makeSequencePropsSubscriptionKey(nodePath);
+      if (!prev[key]) {
+        return prev;
+      }
+      const next = { ...prev };
+      delete next[key];
+      return next;
+    });
+  }, []);
+  const setEffectDragOverrides = useCallback5((nodePath, effectIndex, key, value) => {
+    setEffectDragOverridesState((prev) => {
+      const mapKey = effectDragOverridesKey(nodePath, effectIndex);
+      return {
+        ...prev,
+        [mapKey]: {
+          ...prev[mapKey],
+          [key]: value
         }
-        return canvas;
+      };
+    });
+  }, []);
+  const clearEffectDragOverrides = useCallback5((nodePath, effectIndex) => {
+    setEffectDragOverridesState((prev) => {
+      const mapKey = effectDragOverridesKey(nodePath, effectIndex);
+      if (!prev[mapKey]) {
+        return prev;
       }
-      default: {
-        const exhaustive = backend;
-        throw new Error(`Unknown effect backend: ${exhaustive}`);
+      const next = { ...prev };
+      delete next[mapKey];
+      return next;
+    });
+  }, []);
+  const setCodeValues = useCallback5((nodePath, values) => {
+    setCodeValuesMapState((prev) => {
+      const key = makeSequencePropsSubscriptionKey(nodePath);
+      const prevKey = prev[key];
+      const newKey = values(prevKey);
+      if (prevKey === newKey) {
+        return prev;
+      }
+      return { ...prev, [key]: newKey };
+    });
+  }, []);
+  const registerSequence = useCallback5((seq) => {
+    setSequences((seqs) => {
+      return [...seqs, seq];
+    });
+  }, []);
+  const unregisterSequence = useCallback5((seq) => {
+    setSequences((seqs) => seqs.filter((s) => s.id !== seq));
+  }, []);
+  const sequenceContext = useMemo12(() => {
+    return {
+      registerSequence,
+      sequences,
+      unregisterSequence
+    };
+  }, [registerSequence, sequences, unregisterSequence]);
+  const getDragOverrides = useCallback5((nodePath) => {
+    return dragOverrides[makeSequencePropsSubscriptionKey(nodePath)] ?? {};
+  }, [dragOverrides]);
+  const getEffectDragOverrides = useCallback5((nodePath, effectIndex) => {
+    return effectDragOverridesState[effectDragOverridesKey(nodePath, effectIndex)] ?? {};
+  }, [effectDragOverridesState]);
+  const codeValuesContext = useMemo12(() => {
+    return {
+      codeValues
+    };
+  }, [codeValues]);
+  const dragOverridesContext = useMemo12(() => {
+    return {
+      getDragOverrides,
+      getEffectDragOverrides
+    };
+  }, [getDragOverrides, getEffectDragOverrides]);
+  const settersContext = useMemo12(() => {
+    return {
+      setDragOverrides,
+      clearDragOverrides,
+      setEffectDragOverrides,
+      clearEffectDragOverrides,
+      setCodeValues
+    };
+  }, [
+    setDragOverrides,
+    clearDragOverrides,
+    setEffectDragOverrides,
+    clearEffectDragOverrides,
+    setCodeValues
+  ]);
+  return /* @__PURE__ */ jsx10(SequenceManager.Provider, {
+    value: sequenceContext,
+    children: /* @__PURE__ */ jsx10(VisualModeCodeValuesContext.Provider, {
+      value: codeValuesContext,
+      children: /* @__PURE__ */ jsx10(VisualModeDragOverridesContext.Provider, {
+        value: dragOverridesContext,
+        children: /* @__PURE__ */ jsx10(VisualModeSettersContext.Provider, {
+          value: settersContext,
+          children
+        })
+      })
+    })
+  });
+};
+var ENABLE_V5_BREAKING_CHANGES = false;
+var deleteNestedKey = (obj, keysToRemove) => {
+  for (const key of keysToRemove) {
+    const parts = key.split(".");
+    const parents = [obj];
+    let current = obj;
+    for (let i = 0;i < parts.length - 1; i++) {
+      const part = parts[i];
+      const next = current[part];
+      if (next === undefined || next === null) {
+        current = null;
+        break;
+      }
+      current = next;
+      parents.push(current);
+    }
+    if (current === null) {
+      continue;
+    }
+    delete current[parts[parts.length - 1]];
+    for (let i = parents.length - 1;i > 0; i--) {
+      const parent = parents[i];
+      if (Object.keys(parent).length === 0) {
+        const parentKey = parts[i - 1];
+        delete parents[i - 1][parentKey];
+      } else {
+        break;
       }
     }
   }
-}
-var devicePromise = null;
-var getGpuDevice = () => {
-  if (devicePromise) {
-    return devicePromise;
+  return obj;
+};
+var OverrideIdsToNodePathsGettersContext = createContext15({
+  overrideIdToNodePathMappings: {}
+});
+var OverrideIdsToNodePathsSettersContext = createContext15({
+  setOverrideIdToNodePath: () => {
+    throw new Error("OverrideIdsToNodePathsSettersContext not initialized");
   }
-  devicePromise = (async () => {
-    if (typeof navigator === "undefined" || !("gpu" in navigator)) {
-      throw new Error("WebGPU is not available in this environment");
+});
+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;
+      }
     }
-    const { gpu } = navigator;
-    const adapter = await gpu.requestAdapter();
-    if (!adapter) {
-      throw new Error("No WebGPU adapter available");
+  }
+  if (dragOverrides) {
+    for (const [key, value] of Object.entries(dragOverrides)) {
+      merged[key] = value;
     }
-    return adapter.requestDevice();
-  })();
-  return devicePromise;
+  }
+  return {
+    params: merged,
+    effectKey: descriptor.definition.calculateKey(merged)
+  };
 };
-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 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 ensureSetup = (state, def, target) => {
-  const widened = def;
-  if (state.setupCache.has(widened)) {
-    return state.setupCache.get(widened);
+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;
   }
-  const setupState = def.setup(target);
-  state.setupCache.set(widened, setupState);
-  state.cleanupRegistry.push({ definition: widened, state: setupState });
-  return setupState;
+  previousRef.current = definitions;
+  return definitions;
 };
-var runEffectChain = async ({
-  state,
-  source,
-  effects,
-  output,
-  frame,
-  width,
-  height
+var getEffectCodeValuesCtx = ({
+  codeValues,
+  nodePath,
+  effectIndex
 }) => {
-  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;
+  const status = codeValues[makeSequencePropsSubscriptionKey(nodePath)];
+  if (!status) {
+    return { type: "cannot-update-sequence", reason: "not-found" };
   }
-  let needsGpuDevice = false;
-  for (const run of runs) {
-    if (run.backend === "webgpu") {
-      needsGpuDevice = true;
-      break;
-    }
+  if (!status.canUpdate) {
+    return { type: "cannot-update-sequence", reason: status.reason };
   }
-  const gpuDevice = needsGpuDevice ? await getGpuDevice() : null;
-  if (isCancelled()) {
-    return false;
+  const effect = status.effects.find((e) => e.effectIndex === effectIndex);
+  if (!effect) {
+    return { type: "cannot-update-effect", reason: "not-found" };
   }
-  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 (!effect.canUpdate) {
+    return { type: "cannot-update-effect", reason: effect.reason };
   }
-  if (!lastTarget) {
-    return true;
+  return { type: "can-update-effect", props: effect.props };
+};
+var getCodeValuesCtx = (codeValues, nodePath) => {
+  const status = codeValues[makeSequencePropsSubscriptionKey(nodePath)];
+  if (!status) {
+    return;
   }
-  const outCtx = output.getContext("2d");
-  if (!outCtx) {
-    throw new Error("Failed to acquire 2D context for output canvas");
+  if (!status.canUpdate) {
+    return;
   }
-  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;
-    }
-  }), []);
+  return status.props;
 };
-var useMemoizedEffects = (effects) => {
+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 isSame = previous !== null && previous.length === effects.length && previous.every((p, i) => p.definition === effects[i].definition && p.effectKey === effects[i].effectKey);
+  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 = effects.map((e) => ({
-    definition: e.definition,
-    stack: e.stack,
-    effectKey: e.effectKey,
-    params: e.params,
+  const next = resolved.map(({ descriptor, params, effectKey }) => ({
+    definition: descriptor.definition,
+    effectKey,
+    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;
+var flattenActiveSchema = (schema, resolve) => {
+  const out = {};
+  for (const key of Object.keys(schema)) {
+    const field = schema[key];
+    if (field.type === "hidden") {
+      continue;
+    } else if (field.type === "enum") {
+      out[key] = field;
+      const current = resolve(key) ?? field.default;
+      const variant = field.variants[current];
+      if (variant) {
+        Object.assign(out, flattenActiveSchema(variant, resolve));
+      }
+    } else {
+      out[key] = field;
     }
-    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();
+  return out;
 };
-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(() => {
-    if (!video) {
-      return null;
+var getFlatSchemaWithAllKeys = (schema) => {
+  const out = {};
+  const addKey = (key, field) => {
+    if (key in out) {
+      throw new Error(`Duplicate key "${key}" in schema: discriminated union variants must not share keys`);
     }
-    const {
-      id,
-      durationInFrames,
-      fps,
-      height,
-      width,
-      defaultProps,
-      props,
-      defaultCodec,
-      defaultOutName,
-      defaultVideoImageFormat,
-      defaultPixelFormat,
-      defaultProResProfile,
-      defaultSampleRate
-    } = video;
-    return {
-      id,
-      width: ctxWidth ?? width,
-      height: ctxHeight ?? height,
-      fps,
-      durationInFrames: ctxDuration ?? durationInFrames,
-      defaultProps,
-      props,
-      defaultCodec,
-      defaultOutName,
-      defaultVideoImageFormat,
-      defaultPixelFormat,
-      defaultProResProfile,
-      defaultSampleRate
-    };
-  }, [ctxDuration, ctxHeight, ctxWidth, video]);
-};
-var useVideoConfig = () => {
-  const videoConfig = useUnsafeVideoConfig();
-  const context = useContext13(CanUseRemotionHooks);
-  const isPlayer = useIsPlayer();
-  if (!videoConfig) {
-    if (typeof window !== "undefined" && window.remotion_isPlayer || isPlayer) {
-      throw new Error([
-        "No video config found. Likely reasons:",
-        "- You are probably calling useVideoConfig() from outside the component passed to <Player />. See https://www.remotion.dev/docs/player/examples for how to set up the Player correctly.",
-        "- You have multiple versions of Remotion installed which causes the React context to get lost."
-      ].join("-"));
+    out[key] = field;
+  };
+  for (const key of Object.keys(schema)) {
+    const field = schema[key];
+    addKey(key, field);
+    if (field.type === "enum") {
+      for (const variant of Object.values(field.variants)) {
+        const flatVariant = getFlatSchemaWithAllKeys(variant);
+        for (const variantKey of Object.keys(flatVariant)) {
+          addKey(variantKey, flatVariant[variantKey]);
+        }
+      }
     }
-    throw new Error("No video config found. You are probably calling useVideoConfig() from a component which has not been registered as a <Composition />. See https://www.remotion.dev/docs/the-fundamentals#defining-compositions for more information.");
-  }
-  if (!context) {
-    throw new Error("Called useVideoConfig() outside a Remotion composition.");
   }
-  return videoConfig;
+  return out;
 };
-var Freeze = ({
-  frame: frameToFreeze,
-  children,
-  active = true
+var findPropsToDelete = ({
+  schema,
+  key,
+  value
 }) => {
-  const frame = useCurrentFrame();
-  const videoConfig = useVideoConfig();
-  if (typeof frameToFreeze === "undefined") {
-    throw new Error(`The <Freeze /> component requires a 'frame' prop, but none was passed.`);
+  const fieldSchema = schema[key];
+  if (!fieldSchema) {
+    throw new Error("Key " + JSON.stringify(key) + " not found in schema");
   }
-  if (typeof frameToFreeze !== "number") {
-    throw new Error(`The 'frame' prop of <Freeze /> must be a number, but is of type ${typeof frameToFreeze}`);
+  if (typeof value !== "string") {
+    throw new Error("Value must be a string, but is " + JSON.stringify(value));
   }
-  if (Number.isNaN(frameToFreeze)) {
-    throw new Error(`The 'frame' prop of <Freeze /> must be a real number, but it is NaN.`);
+  if (fieldSchema.type !== "enum") {
+    throw new Error("Key " + JSON.stringify(key) + " is not an enum");
   }
-  if (!Number.isFinite(frameToFreeze)) {
-    throw new Error(`The 'frame' prop of <Freeze /> must be a finite number, but it is ${frameToFreeze}.`);
+  const currentVariant = fieldSchema.variants[value];
+  if (!currentVariant) {
+    throw new Error("Value for " + JSON.stringify(key) + " must be one of " + Object.keys(fieldSchema.variants).map((v) => JSON.stringify(v)).join(", ") + ", got " + JSON.stringify(value));
   }
-  const isActive = useMemo13(() => {
-    if (typeof active === "boolean") {
-      return active;
-    }
-    if (typeof active === "function") {
-      return active(frame);
+  const otherVariants = Object.keys(fieldSchema.variants).filter((v) => v !== value);
+  const otherKeys = new Set;
+  for (const variant of otherVariants) {
+    const otherVariant = fieldSchema.variants[variant];
+    const keys = Object.keys(otherVariant);
+    for (const k of keys) {
+      otherKeys.add(k);
     }
-  }, [active, frame]);
-  const timelineContext = useTimelineContext();
-  const sequenceContext = useContext14(SequenceContext);
-  const relativeFrom = sequenceContext?.relativeFrom ?? 0;
-  const timelineValue = useMemo13(() => {
-    if (!isActive) {
-      return timelineContext;
+  }
+  return [...otherKeys];
+};
+var getEffectiveVisualModeValue = ({
+  codeValue,
+  dragOverrideValue,
+  defaultValue,
+  shouldResortToDefaultValueIfUndefined = false
+}) => {
+  if (dragOverrideValue !== undefined) {
+    return dragOverrideValue;
+  }
+  if (codeValue.codeValue === undefined && shouldResortToDefaultValueIfUndefined) {
+    return defaultValue;
+  }
+  return codeValue.codeValue;
+};
+var findFieldInSchema = (schema, key) => {
+  if (key in schema) {
+    return schema[key];
+  }
+  for (const field of Object.values(schema)) {
+    if (field.type !== "enum") {
+      continue;
     }
-    return {
-      ...timelineContext,
-      playing: false,
-      imperativePlaying: {
-        current: false
-      },
-      frame: {
-        [videoConfig.id]: frameToFreeze + relativeFrom
+    for (const variant of Object.values(field.variants)) {
+      const found = findFieldInSchema(variant, key);
+      if (found) {
+        return found;
       }
-    };
-  }, [isActive, timelineContext, videoConfig.id, frameToFreeze, relativeFrom]);
-  const newSequenceContext = useMemo13(() => {
-    if (!sequenceContext) {
-      return null;
-    }
-    if (!isActive) {
-      return sequenceContext;
     }
-    return {
-      ...sequenceContext,
-      cumulatedFrom: 0
-    };
-  }, [sequenceContext, isActive]);
-  return /* @__PURE__ */ jsx10(TimelineContext.Provider, {
-    value: timelineValue,
-    children: /* @__PURE__ */ jsx10(SequenceContext.Provider, {
-      value: newSequenceContext,
-      children
-    })
-  });
-};
-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"
   }
+  return;
 };
-var sequenceSchema = {
-  layout: {
-    type: "enum",
-    default: "absolute-fill",
-    description: "Layout",
-    variants: {
-      "absolute-fill": sequenceStyleSchema,
-      none: {}
+var computeEffectiveSchemaValuesDotNotation = ({
+  schema,
+  currentValue,
+  overrideValues,
+  propStatus
+}) => {
+  const merged = {};
+  const propsToDelete = new Set;
+  for (const key of Object.keys(currentValue)) {
+    const codeValueStatus = propStatus?.[key] ?? null;
+    const field = findFieldInSchema(schema, key);
+    if (field?.type === "hidden") {
+      continue;
+    }
+    const value = codeValueStatus === null || codeValueStatus.canUpdate === false ? currentValue[key] : getEffectiveVisualModeValue({
+      codeValue: codeValueStatus,
+      dragOverrideValue: overrideValues[key],
+      defaultValue: field?.default,
+      shouldResortToDefaultValueIfUndefined: false
+    });
+    if (value === undefined) {
+      propsToDelete.add(key);
     }
+    merged[key] = value;
   }
-};
-var sequenceSchemaDefaultLayoutNone = {
-  ...sequenceSchema,
-  layout: {
-    ...sequenceSchema.layout,
-    default: "none"
+  for (const key of Object.keys(overrideValues)) {
+    if (schema[key]?.type === "enum") {
+      const propsToDeleteForKey = findPropsToDelete({
+        schema,
+        key,
+        value: merged[key]
+      });
+      for (const propToDelete of propsToDeleteForKey) {
+        propsToDelete.add(propToDelete);
+      }
+    }
   }
+  return { merged, propsToDelete };
 };
-var nodePathToString = (nodePath) => {
-  return nodePath.join(".");
-};
-var SequenceManager = React12.createContext({
-  registerSequence: () => {
-    throw new Error("SequenceManagerContext not initialized");
-  },
-  unregisterSequence: () => {
-    throw new Error("SequenceManagerContext not initialized");
-  },
-  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;
+var getNestedValue = (obj, key) => {
+  const parts = key.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === undefined || typeof current !== "object")
+      return;
+    current = current[part];
   }
-  return status.props;
+  return current;
 };
-var VisualModeCodeValuesContext = React12.createContext({
-  getCodeValues: () => {
-    throw new Error("VisualModeCodeValuesContext not initialized");
-  }
-});
-var VisualModeDragOverridesContext = React12.createContext({
-  getDragOverrides: () => {
-    throw new Error("VisualModeDragOverridesContext not initialized");
-  }
-});
-var VisualModeSettersContext = React12.createContext({
-  setDragOverrides: () => {
-    throw new Error("VisualModeSettersContext not initialized");
-  },
-  clearDragOverrides: () => {
-    throw new Error("VisualModeSettersContext not initialized");
-  },
-  setCodeValues: () => {
-    throw new Error("VisualModeSettersContext not initialized");
+var readValuesFromProps = (props, keys) => {
+  const out = {};
+  for (const key of keys) {
+    out[key] = getNestedValue(props, key);
   }
-});
-var SequenceManagerProvider = ({ children }) => {
-  const [sequences, setSequences] = useState4([]);
-  const [hidden, setHidden] = useState4({});
-  const [dragOverrides, setControlOverrides] = useState4({});
-  const controlOverridesRef = useRef6(dragOverrides);
-  controlOverridesRef.current = dragOverrides;
-  const [codeValues, setCodeValuesMapState] = useState4({});
-  const setDragOverrides = useCallback5((nodePath, key, value) => {
-    setControlOverrides((prev) => ({
-      ...prev,
-      [nodePathToString(nodePath)]: {
-        ...prev[nodePathToString(nodePath)],
-        [key]: value
-      }
-    }));
-  }, []);
-  const clearDragOverrides = useCallback5((nodePath) => {
-    setControlOverrides((prev) => {
-      const key = nodePathToString(nodePath);
-      if (!prev[key]) {
-        return prev;
-      }
-      const next = { ...prev };
-      delete next[key];
-      return next;
-    });
-  }, []);
-  const setCodeValues = useCallback5((nodePath, values) => {
-    setCodeValuesMapState((prev) => {
-      const key = nodePathToString(nodePath);
-      const prevKey = prev[key];
-      const newKey = values(prevKey);
-      if (prevKey === newKey) {
-        return prev;
-      }
-      return { ...prev, [key]: newKey };
-    });
-  }, []);
-  const registerSequence = useCallback5((seq) => {
-    setSequences((seqs) => {
-      return [...seqs, seq];
-    });
-  }, []);
-  const unregisterSequence = useCallback5((seq) => {
-    setSequences((seqs) => seqs.filter((s) => s.id !== seq));
-  }, []);
-  const sequenceContext = useMemo14(() => {
-    return {
-      registerSequence,
-      sequences,
-      unregisterSequence
-    };
-  }, [registerSequence, sequences, unregisterSequence]);
-  const hiddenContext = useMemo14(() => {
-    return {
-      hidden,
-      setHidden
-    };
-  }, [hidden]);
-  const getDragOverrides = useCallback5((nodePath) => {
-    return dragOverrides[nodePathToString(nodePath)] ?? {};
-  }, [dragOverrides]);
-  const getCodeValues = useCallback5((nodePath) => {
-    return getCodeValuesCtx(codeValues, nodePath);
-  }, [codeValues]);
-  const codeValuesContext = useMemo14(() => {
-    return {
-      getCodeValues
-    };
-  }, [getCodeValues]);
-  const dragOverridesContext = useMemo14(() => {
-    return {
-      getDragOverrides
-    };
-  }, [getDragOverrides]);
-  const settersContext = useMemo14(() => {
-    return {
-      setDragOverrides,
-      clearDragOverrides,
-      setCodeValues
-    };
-  }, [setDragOverrides, clearDragOverrides, setCodeValues]);
-  return /* @__PURE__ */ jsx11(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
-          })
-        })
-      })
-    })
-  });
-};
-var ENABLE_V5_BREAKING_CHANGES = false;
-var deleteNestedKey = (obj, keysToRemove) => {
-  for (const key of keysToRemove) {
-    const parts = key.split(".");
-    const parents = [obj];
-    let current = obj;
-    for (let i = 0;i < parts.length - 1; i++) {
-      const part = parts[i];
-      const next = current[part];
-      if (next === undefined || next === null) {
-        current = null;
-        break;
-      }
-      current = next;
-      parents.push(current);
-    }
-    if (current === null) {
-      continue;
-    }
-    delete current[parts[parts.length - 1]];
-    for (let i = parents.length - 1;i > 0; i--) {
-      const parent = parents[i];
-      if (Object.keys(parent).length === 0) {
-        const parentKey = parts[i - 1];
-        delete parents[i - 1][parentKey];
-      } else {
-        break;
+  return out;
+};
+var selectActiveKeys = (schema, values) => {
+  return Object.keys(flattenActiveSchema(schema, (key) => values[key]));
+};
+var mergeValues = ({
+  props,
+  valuesDotNotation,
+  schemaKeys,
+  propsToDelete
+}) => {
+  const merged = { ...props };
+  for (const key of schemaKeys) {
+    const value = valuesDotNotation[key];
+    const parts = key.split(".");
+    if (parts.length === 1) {
+      merged[key] = value;
+      continue;
+    }
+    let current = merged;
+    for (let i = 0;i < parts.length - 1; i++) {
+      const part = parts[i];
+      if (typeof current[part] === "object" && current[part] !== null) {
+        current[part] = { ...current[part] };
+      } else {
+        current[part] = {};
       }
+      current = current[part];
     }
+    current[parts[parts.length - 1]] = value;
   }
-  return obj;
+  deleteNestedKey(merged, propsToDelete);
+  return merged;
 };
-var flattenActiveSchema = (schema, resolve) => {
-  const out = {};
-  for (const key of Object.keys(schema)) {
-    const field = schema[key];
-    if (field.type === "hidden") {
-      continue;
-    } else if (field.type === "enum") {
-      out[key] = field;
-      const current = resolve(key) ?? field.default;
-      const variant = field.variants[current];
-      if (variant) {
-        Object.assign(out, flattenActiveSchema(variant, resolve));
-      }
-    } else {
-      out[key] = field;
+var stackToOverrideMap = {};
+var wrapInSchema = (Component, schema) => {
+  const flatSchema = getFlatSchemaWithAllKeys(schema);
+  const flatKeys = Object.keys(flatSchema);
+  const Wrapped = forwardRef2((props, ref) => {
+    const env = useRemotionEnvironment();
+    if (!env.isStudio || env.isReadOnlyStudio || env.isRendering) {
+      return React12.createElement(Component, {
+        ...props,
+        _experimentalControls: null,
+        ref
+      });
     }
-  }
-  return out;
-};
-var getFlatSchemaWithAllKeys = (schema) => {
-  const out = {};
-  const addKey = (key, field) => {
-    if (key in out) {
-      throw new Error(`Duplicate key "${key}" in schema: discriminated union variants must not share keys`);
+    const { codeValues } = useContext16(VisualModeCodeValuesContext);
+    const { getDragOverrides } = useContext16(VisualModeDragOverridesContext);
+    const nodePathMapping = useContext16(OverrideIdsToNodePathsGettersContext);
+    if (props._experimentalControls) {
+      return React12.createElement(Component, {
+        ...props,
+        ref
+      });
     }
-    out[key] = field;
-  };
-  for (const key of Object.keys(schema)) {
-    const field = schema[key];
-    addKey(key, field);
-    if (field.type === "enum") {
-      for (const variant of Object.values(field.variants)) {
-        const flatVariant = getFlatSchemaWithAllKeys(variant);
-        for (const variantKey of Object.keys(flatVariant)) {
-          addKey(variantKey, flatVariant[variantKey]);
-        }
+    const [overrideId] = useState4(() => {
+      const { stack } = props;
+      if (!stack) {
+        return String(Math.random());
       }
-    }
-  }
-  return out;
+      const existingOverrideId = stackToOverrideMap[stack];
+      if (existingOverrideId) {
+        return existingOverrideId;
+      }
+      const newOverrideId = String(Math.random());
+      stackToOverrideMap[stack] = newOverrideId;
+      return newOverrideId;
+    });
+    const nodePath = nodePathMapping.overrideIdToNodePathMappings[overrideId] ?? null;
+    const runtimeValues = flatKeys.map((k) => getNestedValue(props, k));
+    const currentRuntimeValueDotNotation = useMemo13(() => readValuesFromProps(props, flatKeys), runtimeValues);
+    const controls = useMemo13(() => {
+      return {
+        schema,
+        currentRuntimeValueDotNotation,
+        overrideId
+      };
+    }, [currentRuntimeValueDotNotation, overrideId]);
+    const { merged: valuesDotNotation, propsToDelete } = useMemo13(() => {
+      return computeEffectiveSchemaValuesDotNotation({
+        schema,
+        currentValue: currentRuntimeValueDotNotation,
+        overrideValues: nodePath === null ? {} : getDragOverrides(nodePath),
+        propStatus: nodePath === null ? undefined : getCodeValuesCtx(codeValues, nodePath)
+      });
+    }, [
+      currentRuntimeValueDotNotation,
+      getDragOverrides,
+      nodePath,
+      codeValues
+    ]);
+    const activeKeys = selectActiveKeys(schema, valuesDotNotation);
+    const mergedProps = mergeValues({
+      props,
+      valuesDotNotation,
+      schemaKeys: activeKeys,
+      propsToDelete
+    });
+    return React12.createElement(Component, {
+      ...mergedProps,
+      _experimentalControls: controls,
+      ref
+    });
+  });
+  Wrapped.displayName = `wrapInSchema(${Component.displayName || Component.name || "Component"})`;
+  return Wrapped;
 };
-var OverrideIdsToNodePathsGettersContext = createContext15({
-  overrideIdToNodePathMappings: {}
-});
-var OverrideIdsToNodePathsSettersContext = createContext15({
-  setOverrideIdToNodePath: () => {
-    throw new Error("OverrideIdsToNodePathsSettersContext not initialized");
-  }
-});
-var findPropsToDelete = ({
-  schema,
-  key,
-  value
-}) => {
-  const fieldSchema = schema[key];
-  if (!fieldSchema) {
-    throw new Error("Key " + JSON.stringify(key) + " not found in schema");
-  }
-  if (typeof value !== "string") {
-    throw new Error("Value must be a string, but is " + JSON.stringify(value));
-  }
-  if (fieldSchema.type !== "enum") {
-    throw new Error("Key " + JSON.stringify(key) + " is not an enum");
-  }
-  const currentVariant = fieldSchema.variants[value];
-  if (!currentVariant) {
-    throw new Error("Value for " + JSON.stringify(key) + " must be one of " + Object.keys(fieldSchema.variants).map((v) => JSON.stringify(v)).join(", ") + ", got " + JSON.stringify(value));
+var RegularSequenceRefForwardingFunction = ({
+  from = 0,
+  durationInFrames = Infinity,
+  children,
+  name,
+  height,
+  width,
+  showInTimeline = true,
+  hidden = false,
+  _experimentalControls: controls,
+  _experimentalEffects,
+  _remotionInternalLoopDisplay: loopDisplay,
+  _remotionInternalStack: stack,
+  _remotionInternalPremountDisplay: premountDisplay,
+  _remotionInternalPostmountDisplay: postmountDisplay,
+  _remotionInternalIsMedia: isMedia,
+  ...other
+}, ref) => {
+  const { layout = "absolute-fill" } = other;
+  const [id] = useState5(() => String(Math.random()));
+  const parentSequence = useContext17(SequenceContext);
+  const { rootId } = useTimelineContext();
+  const cumulatedFrom = parentSequence ? parentSequence.cumulatedFrom + parentSequence.relativeFrom : 0;
+  const nonce = useNonce();
+  if (layout !== "absolute-fill" && layout !== "none") {
+    throw new TypeError(`The layout prop of <Sequence /> expects either "absolute-fill" or "none", but you passed: ${layout}`);
   }
-  const otherVariants = Object.keys(fieldSchema.variants).filter((v) => v !== value);
-  const otherKeys = new Set;
-  for (const variant of otherVariants) {
-    const otherVariant = fieldSchema.variants[variant];
-    const keys = Object.keys(otherVariant);
-    for (const k of keys) {
-      otherKeys.add(k);
-    }
+  if (layout === "none" && typeof other.style !== "undefined") {
+    throw new TypeError('If layout="none", you may not pass a style. Passed: ' + JSON.stringify(other.style));
   }
-  return [...otherKeys];
-};
-var getEffectiveVisualModeValue = ({
-  codeValue,
-  runtimeValue,
-  dragOverrideValue,
-  defaultValue,
-  shouldResortToDefaultValueIfUndefined = false
-}) => {
-  if (dragOverrideValue !== undefined) {
-    return dragOverrideValue;
+  if (typeof durationInFrames !== "number") {
+    throw new TypeError(`You passed to durationInFrames an argument of type ${typeof durationInFrames}, but it must be a number.`);
   }
-  if (!codeValue) {
-    return runtimeValue;
+  if (durationInFrames <= 0) {
+    throw new TypeError(`durationInFrames must be positive, but got ${durationInFrames}`);
   }
-  if (!codeValue.canUpdate) {
-    return runtimeValue;
+  if (typeof from !== "number") {
+    throw new TypeError(`You passed to the "from" props of your <Sequence> an argument of type ${typeof from}, but it must be a number.`);
   }
-  if (codeValue.codeValue === undefined && shouldResortToDefaultValueIfUndefined) {
-    return defaultValue;
-  }
-  return codeValue.codeValue;
-};
-var findFieldInSchema = (schema, key) => {
-  if (key in schema) {
-    return schema[key];
-  }
-  for (const field of Object.values(schema)) {
-    if (field.type !== "enum") {
-      continue;
-    }
-    for (const variant of Object.values(field.variants)) {
-      const found = findFieldInSchema(variant, key);
-      if (found) {
-        return found;
-      }
-    }
-  }
-  return;
-};
-var computeEffectiveSchemaValuesDotNotation = ({
-  schema,
-  currentValue,
-  overrideValues,
-  propStatus
-}) => {
-  const merged = {};
-  const propsToDelete = new Set;
-  for (const key of Object.keys(currentValue)) {
-    const codeValueStatus = propStatus?.[key] ?? null;
-    const field = findFieldInSchema(schema, key);
-    if (field?.type === "hidden") {
-      continue;
-    }
-    const value = getEffectiveVisualModeValue({
-      codeValue: codeValueStatus,
-      runtimeValue: currentValue[key],
-      dragOverrideValue: overrideValues[key],
-      defaultValue: field?.default,
-      shouldResortToDefaultValueIfUndefined: false
-    });
-    if (value === undefined) {
-      propsToDelete.add(key);
-    }
-    merged[key] = value;
-  }
-  for (const key of Object.keys(overrideValues)) {
-    if (schema[key]?.type === "enum") {
-      const propsToDeleteForKey = findPropsToDelete({
-        schema,
-        key,
-        value: merged[key]
-      });
-      for (const propToDelete of propsToDeleteForKey) {
-        propsToDelete.add(propToDelete);
-      }
-    }
-  }
-  return { merged, propsToDelete };
-};
-var getNestedValue = (obj, key) => {
-  const parts = key.split(".");
-  let current = obj;
-  for (const part of parts) {
-    if (current === null || current === undefined || typeof current !== "object")
-      return;
-    current = current[part];
-  }
-  return current;
-};
-var readValuesFromProps = (props, keys) => {
-  const out = {};
-  for (const key of keys) {
-    out[key] = getNestedValue(props, key);
-  }
-  return out;
-};
-var selectActiveKeys = (schema, values) => {
-  return Object.keys(flattenActiveSchema(schema, (key) => values[key]));
-};
-var mergeValues = ({
-  props,
-  valuesDotNotation,
-  schemaKeys,
-  propsToDelete
-}) => {
-  const merged = { ...props };
-  for (const key of schemaKeys) {
-    const value = valuesDotNotation[key];
-    const parts = key.split(".");
-    if (parts.length === 1) {
-      merged[key] = value;
-      continue;
-    }
-    let current = merged;
-    for (let i = 0;i < parts.length - 1; i++) {
-      const part = parts[i];
-      if (typeof current[part] === "object" && current[part] !== null) {
-        current[part] = { ...current[part] };
-      } else {
-        current[part] = {};
-      }
-      current = current[part];
-    }
-    current[parts[parts.length - 1]] = value;
-  }
-  deleteNestedKey(merged, propsToDelete);
-  return merged;
-};
-var stackToOverrideMap = {};
-var wrapInSchema = (Component, schema) => {
-  const flatSchema = getFlatSchemaWithAllKeys(schema);
-  const flatKeys = Object.keys(flatSchema);
-  const Wrapped = forwardRef2((props, ref) => {
-    const env = useRemotionEnvironment();
-    if (!env.isStudio || env.isReadOnlyStudio || env.isRendering) {
-      return React13.createElement(Component, {
-        ...props,
-        _experimentalControls: null,
-        ref
-      });
-    }
-    const { getCodeValues } = useContext15(VisualModeCodeValuesContext);
-    const { getDragOverrides } = useContext15(VisualModeDragOverridesContext);
-    const nodePathMapping = useContext15(OverrideIdsToNodePathsGettersContext);
-    if (props._experimentalControls) {
-      return React13.createElement(Component, {
-        ...props,
-        ref
-      });
-    }
-    const [overrideId] = useState5(() => {
-      const { stack } = props;
-      if (!stack) {
-        return String(Math.random());
-      }
-      const existingOverrideId = stackToOverrideMap[stack];
-      if (existingOverrideId) {
-        return existingOverrideId;
-      }
-      const newOverrideId = String(Math.random());
-      stackToOverrideMap[stack] = newOverrideId;
-      return newOverrideId;
-    });
-    const nodePath = nodePathMapping.overrideIdToNodePathMappings[overrideId] ?? null;
-    const runtimeValues = flatKeys.map((k) => getNestedValue(props, k));
-    const currentRuntimeValueDotNotation = useMemo15(() => readValuesFromProps(props, flatKeys), runtimeValues);
-    const controls = useMemo15(() => {
-      return {
-        schema,
-        currentRuntimeValueDotNotation,
-        overrideId
-      };
-    }, [currentRuntimeValueDotNotation, overrideId]);
-    const { merged: valuesDotNotation, propsToDelete } = useMemo15(() => {
-      return computeEffectiveSchemaValuesDotNotation({
-        schema,
-        currentValue: currentRuntimeValueDotNotation,
-        overrideValues: nodePath === null ? {} : getDragOverrides(nodePath),
-        propStatus: nodePath === null ? undefined : getCodeValues(nodePath)
-      });
-    }, [
-      currentRuntimeValueDotNotation,
-      getDragOverrides,
-      nodePath,
-      getCodeValues
-    ]);
-    const activeKeys = selectActiveKeys(schema, valuesDotNotation);
-    const mergedProps = mergeValues({
-      props,
-      valuesDotNotation,
-      schemaKeys: activeKeys,
-      propsToDelete
-    });
-    return React13.createElement(Component, {
-      ...mergedProps,
-      _experimentalControls: controls,
-      ref
-    });
-  });
-  Wrapped.displayName = `wrapInSchema(${Component.displayName || Component.name || "Component"})`;
-  return Wrapped;
-};
-var RegularSequenceRefForwardingFunction = ({
-  from = 0,
-  durationInFrames = Infinity,
-  children,
-  name,
-  height,
-  width,
-  showInTimeline = true,
-  _experimentalControls: controls,
-  _experimentalEffects,
-  _remotionInternalLoopDisplay: loopDisplay,
-  _remotionInternalStack: stack,
-  _remotionInternalPremountDisplay: premountDisplay,
-  _remotionInternalPostmountDisplay: postmountDisplay,
-  _remotionInternalIsMedia: isMedia,
-  ...other
-}, ref) => {
-  const { layout = "absolute-fill" } = other;
-  const [id] = useState6(() => String(Math.random()));
-  const parentSequence = useContext16(SequenceContext);
-  const { rootId } = useTimelineContext();
-  const cumulatedFrom = parentSequence ? parentSequence.cumulatedFrom + parentSequence.relativeFrom : 0;
-  const nonce = useNonce();
-  if (layout !== "absolute-fill" && layout !== "none") {
-    throw new TypeError(`The layout prop of <Sequence /> expects either "absolute-fill" or "none", but you passed: ${layout}`);
-  }
-  if (layout === "none" && typeof other.style !== "undefined") {
-    throw new TypeError('If layout="none", you may not pass a style. Passed: ' + JSON.stringify(other.style));
-  }
-  if (typeof durationInFrames !== "number") {
-    throw new TypeError(`You passed to durationInFrames an argument of type ${typeof durationInFrames}, but it must be a number.`);
-  }
-  if (durationInFrames <= 0) {
-    throw new TypeError(`durationInFrames must be positive, but got ${durationInFrames}`);
-  }
-  if (typeof from !== "number") {
-    throw new TypeError(`You passed to the "from" props of your <Sequence> an argument of type ${typeof from}, but it must be a number.`);
-  }
-  if (!Number.isFinite(from)) {
-    throw new TypeError(`The "from" prop of a sequence must be finite, but got ${from}.`);
+  if (!Number.isFinite(from)) {
+    throw new TypeError(`The "from" prop of a sequence must be finite, but got ${from}.`);
   }
   const absoluteFrame = useTimelinePosition();
   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,
@@ -3588,49 +3433,466 @@ var PremountedPostmountedSequenceRefForwardingFunction = (props, ref) => {
       ...postmountingActive ? styleWhilePostmounted : {}
     };
   }, [
-    passedStyle,
-    premountingActive,
-    postmountingActive,
-    styleWhilePremounted,
-    styleWhilePostmounted
+    passedStyle,
+    premountingActive,
+    postmountingActive,
+    styleWhilePremounted,
+    styleWhilePostmounted
+  ]);
+  return /* @__PURE__ */ jsx11(Freeze, {
+    frame: freezeFrame,
+    active: isFreezingActive,
+    children: /* @__PURE__ */ jsx11(SequenceInner, {
+      ref,
+      from,
+      durationInFrames,
+      style,
+      _remotionInternalPremountDisplay: premountFor,
+      _remotionInternalPostmountDisplay: postmountFor,
+      _remotionInternalIsPremounting: premountingActive,
+      _remotionInternalIsPostmounting: postmountingActive,
+      ...otherProps
+    })
+  });
+};
+var PremountedPostmountedSequence = forwardRef3(PremountedPostmountedSequenceRefForwardingFunction);
+var SequenceRefForwardingFunction = (props, ref) => {
+  const env = useRemotionEnvironment();
+  const { fps } = useVideoConfig();
+  if (props.layout !== "none" && !env.isRendering) {
+    const effectivePremountFor = ENABLE_V5_BREAKING_CHANGES ? props.premountFor ?? fps : props.premountFor;
+    if (effectivePremountFor || props.postmountFor) {
+      return /* @__PURE__ */ jsx11(PremountedPostmountedSequence, {
+        ref,
+        ...props,
+        premountFor: effectivePremountFor
+      });
+    }
+  }
+  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(Freeze, {
-    frame: freezeFrame,
-    active: isFreezingActive,
-    children: /* @__PURE__ */ jsx12(SequenceInner, {
+  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,
-      from,
-      durationInFrames,
+      overrideId: controls?.overrideId ?? null,
+      color,
+      height,
+      width,
+      className,
       style,
-      _remotionInternalPremountDisplay: premountFor,
-      _remotionInternalPostmountDisplay: postmountFor,
-      _remotionInternalIsPremounting: premountingActive,
-      _remotionInternalIsPostmounting: postmountingActive,
-      ...otherProps
+      _experimentalEffects
     })
   });
-};
-var PremountedPostmountedSequence = forwardRef3(PremountedPostmountedSequenceRefForwardingFunction);
-var SequenceRefForwardingFunction = (props, ref) => {
-  const env = useRemotionEnvironment();
-  const { fps } = useVideoConfig();
-  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, {
-        ref,
-        ...props,
-        premountFor: effectivePremountFor
-      });
+});
+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.`);
   }
-  return /* @__PURE__ */ jsx12(RegularSequence, {
-    ...props,
-    ref
-  });
+  set();
 };
-var SequenceInner = forwardRef3(SequenceRefForwardingFunction);
-var Sequence = wrapInSchema(SequenceInner, sequenceSchema);
 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 = {};