@remotion/promo-pages 4.0.463 → 4.0.464

package/dist/team.js

@@ -1,15 +1,26 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
+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 __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: __exportSetter.bind(all, name)
+      set: (newValue) => all[name] = () => newValue
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -206,7 +217,7 @@ var TitleTeamCards = () => {
 import * as React24 from "react";
 import * as React3 from "react";
 import { Fragment as Fragment2, jsx as jsx38 } from "react/jsx-runtime";
-import React52, { useCallback as useCallback22, useRef as useRef24, useState as useState22 } from "react";
+import React52, { useCallback as useCallback24, useRef as useRef25, useState as useState22 } from "react";
 
 // ../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs
 function r(e) {
@@ -1548,7 +1559,7 @@ var getDefaultConfig = () => {
 var twMerge = /* @__PURE__ */ createTailwindMerge(getDefaultConfig);
 
 // ../design/dist/esm/index.mjs
-import React33, { useEffect as useEffect20, useMemo as useMemo38, useState as useState23 } from "react";
+import React33, { useEffect as useEffect20, useMemo as useMemo39, useState as useState21 } from "react";
 
 // ../paths/dist/esm/index.mjs
 var cutLInstruction = ({
@@ -5913,13 +5924,6 @@ 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 jsx72 } from "react/jsx-runtime";
-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,
@@ -5927,6 +5931,7 @@ import {
   useMemo as useMemo14,
   useState as useState5
 } from "react";
+import { useRef as useRef6 } 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";
@@ -5949,18 +5954,25 @@ import React12, { forwardRef as forwardRef2, useState as useState4, useContext a
 import { useContext as useContext15, useRef as useRef5 } from "react";
 import { createContext as createContext15 } from "react";
 import { jsx as jsx112 } from "react/jsx-runtime";
-import { useEffect as useEffect4, useMemo as useMemo15, useRef as useRef6 } from "react";
+import {
+  forwardRef as forwardRef4,
+  useEffect as useEffect5,
+  useImperativeHandle as useImperativeHandle2,
+  useLayoutEffect as useLayoutEffect2,
+  useRef as useRef9,
+  useState as useState6
+} from "react";
+import React14, { useCallback as useCallback6, useImperativeHandle, useMemo as useMemo16, useRef as useRef8 } from "react";
+import { useEffect as useEffect4, useMemo as useMemo15, useRef as useRef7 } from "react";
 import { jsx as jsx12 } from "react/jsx-runtime";
+import { jsx as jsx13 } from "react/jsx-runtime";
 import {
   forwardRef as forwardRef5,
+  useCallback as useCallback7,
   useEffect as useEffect6,
-  useImperativeHandle as useImperativeHandle2,
-  useLayoutEffect as useLayoutEffect2,
-  useRef as useRef8,
+  useMemo as useMemo17,
   useState as useState7
 } 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,
@@ -5968,78 +5980,78 @@ import {
   useCallback as useCallback8,
   useContext as useContext18,
   useLayoutEffect as useLayoutEffect3,
-  useMemo as useMemo17,
-  useRef as useRef9,
-  useState as useState8
+  useMemo as useMemo18,
+  useRef as useRef10
 } from "react";
 import { jsx as jsx15 } from "react/jsx-runtime";
-import { useContext as useContext19, useLayoutEffect as useLayoutEffect5, useState as useState10 } from "react";
+import { useContext as useContext19, useLayoutEffect as useLayoutEffect5, useState as useState9 } from "react";
 import {
   createContext as createContext17,
   useCallback as useCallback9,
   useImperativeHandle as useImperativeHandle3,
   useLayoutEffect as useLayoutEffect4,
-  useMemo as useMemo18,
-  useRef as useRef10,
-  useState as useState9
+  useMemo as useMemo19,
+  useRef as useRef11,
+  useState as useState8
 } from "react";
 import { jsx as jsx16 } from "react/jsx-runtime";
-import { forwardRef as forwardRef9, useCallback as useCallback14, useContext as useContext31 } from "react";
-import React17, { createContext as createContext18, useMemo as useMemo19 } from "react";
+import { forwardRef as forwardRef9, useCallback as useCallback15, useContext as useContext31 } from "react";
+import React17, { createContext as createContext18, useMemo as useMemo20 } from "react";
 import { jsx as jsx17 } from "react/jsx-runtime";
 import { useContext as useContext20 } from "react";
-import { createContext as createContext19, useEffect as useEffect7, useState as useState11 } from "react";
+import { createContext as createContext19, useEffect as useEffect7, useState as useState10 } from "react";
 import { jsx as jsx18 } from "react/jsx-runtime";
-import { createContext as createContext20, useMemo as useMemo20, useReducer } from "react";
+import { createContext as createContext20, useMemo as useMemo21, useReducer } from "react";
 import { jsx as jsx19 } from "react/jsx-runtime";
+import { useCallback as useCallback14 } from "react";
 import React23, {
   forwardRef as forwardRef7,
   useContext as useContext29,
   useEffect as useEffect14,
   useImperativeHandle as useImperativeHandle4,
-  useMemo as useMemo28,
-  useRef as useRef18,
-  useState as useState16
+  useMemo as useMemo29,
+  useRef as useRef19,
+  useState as useState15
 } from "react";
-import { useContext as useContext22, useLayoutEffect as useLayoutEffect6, useRef as useRef13 } from "react";
+import { useContext as useContext22, useLayoutEffect as useLayoutEffect6, useRef as useRef14 } from "react";
 import React20, {
   createContext as createContext21,
   createRef as createRef2,
   useCallback as useCallback10,
   useContext as useContext21,
-  useMemo as useMemo22,
-  useRef as useRef11,
-  useState as useState12
+  useMemo as useMemo23,
+  useRef as useRef12,
+  useState as useState11
 } from "react";
-import { useMemo as useMemo21 } from "react";
+import { useMemo as useMemo22 } from "react";
 import { jsx as jsx20, jsxs as jsxs22 } from "react/jsx-runtime";
-import { useRef as useRef12 } from "react";
-import { useContext as useContext24, useEffect as useEffect8, useMemo as useMemo23, useState as useState13 } from "react";
+import { useRef as useRef13 } from "react";
+import { useContext as useContext24, useEffect as useEffect8, useMemo as useMemo24, useState as useState12 } from "react";
 import { useContext as useContext23 } from "react";
 import {
   useCallback as useCallback13,
   useContext as useContext27,
   useEffect as useEffect12,
   useLayoutEffect as useLayoutEffect8,
-  useRef as useRef17
+  useRef as useRef18
 } from "react";
-import { useCallback as useCallback12, useMemo as useMemo26, useRef as useRef15 } from "react";
-import { useContext as useContext26, useMemo as useMemo25 } from "react";
+import { useCallback as useCallback12, useMemo as useMemo27, useRef as useRef16 } from "react";
+import { useContext as useContext26, useMemo as useMemo26 } from "react";
 import React21, {
   useCallback as useCallback11,
   useContext as useContext25,
   useEffect as useEffect9,
   useLayoutEffect as useLayoutEffect7,
-  useMemo as useMemo24,
-  useRef as useRef14,
-  useState as useState14
+  useMemo as useMemo25,
+  useRef as useRef15,
+  useState as useState13
 } from "react";
 import { jsx as jsx21 } from "react/jsx-runtime";
 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 useEffect10, useState as useState14 } from "react";
+import { useEffect as useEffect11, useRef as useRef17 } from "react";
 import { useEffect as useEffect13 } from "react";
-import { createContext as createContext22, useContext as useContext28, useMemo as useMemo27 } from "react";
+import { createContext as createContext22, useContext as useContext28, useMemo as useMemo28 } from "react";
 import { jsx as jsx222 } from "react/jsx-runtime";
 import {
   forwardRef as forwardRef8,
@@ -6047,47 +6059,47 @@ import {
   useEffect as useEffect15,
   useImperativeHandle as useImperativeHandle5,
   useLayoutEffect as useLayoutEffect9,
-  useMemo as useMemo29,
-  useRef as useRef19
+  useMemo as useMemo30,
+  useRef as useRef20
 } from "react";
 import { jsx as jsx232 } from "react/jsx-runtime";
 import { jsx as jsx24 } from "react/jsx-runtime";
-import { forwardRef as forwardRef10, useCallback as useCallback15, useState as useState17 } from "react";
+import { forwardRef as forwardRef10, useCallback as useCallback16, useState as useState16 } from "react";
 import { jsx as jsx25 } from "react/jsx-runtime";
 import {
-  useCallback as useCallback16,
+  useCallback as useCallback17,
   useContext as useContext32,
   useImperativeHandle as useImperativeHandle6,
   useLayoutEffect as useLayoutEffect10,
-  useRef as useRef20,
-  useState as useState18
+  useRef as useRef21,
+  useState as useState17
 } from "react";
 import { jsx as jsx26 } from "react/jsx-runtime";
 import { createRef as createRef3 } from "react";
 import React28 from "react";
 import {
-  useCallback as useCallback17,
+  useCallback as useCallback18,
   useImperativeHandle as useImperativeHandle7,
-  useMemo as useMemo30,
-  useRef as useRef21,
-  useState as useState19
+  useMemo as useMemo31,
+  useRef as useRef22,
+  useState as useState18
 } from "react";
 import { jsx as jsx27 } from "react/jsx-runtime";
 import React29 from "react";
-import { useMemo as useMemo322 } from "react";
-import { createContext as createContext23, useContext as useContext33, useMemo as useMemo31 } from "react";
+import { useMemo as useMemo33 } from "react";
+import { createContext as createContext23, useContext as useContext33, useMemo as useMemo322 } 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 useCallback19 } from "react";
+import { useCallback as useCallback21 } from "react";
 import {
-  useCallback as useCallback18,
+  useCallback as useCallback19,
   useContext as useContext34,
   useEffect as useEffect16,
   useLayoutEffect as useLayoutEffect11,
-  useMemo as useMemo33,
-  useState as useState20
+  useMemo as useMemo34,
+  useState as useState19
 } from "react";
 import { jsx as jsx30 } from "react/jsx-runtime";
 import React34, {
@@ -6095,45 +6107,42 @@ import React34, {
   useContext as useContext35,
   useEffect as useEffect18,
   useImperativeHandle as useImperativeHandle8,
-  useMemo as useMemo34,
-  useRef as useRef22,
-  useState as useState21
+  useMemo as useMemo35,
+  useRef as useRef23,
+  useState as useState20,
+  useCallback as useCallback20
 } from "react";
 import { useEffect as useEffect17 } from "react";
 import { jsx as jsx31 } from "react/jsx-runtime";
 import { jsx as jsx322 } from "react/jsx-runtime";
-import React36, { useMemo as useMemo35 } from "react";
+import React36, { useMemo as useMemo36 } from "react";
 import { jsx as jsx332 } from "react/jsx-runtime";
-import { Children, forwardRef as forwardRef12, useMemo as useMemo36 } from "react";
+import { Children, forwardRef as forwardRef12, useMemo as useMemo37 } 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 forwardRef14, useCallback as useCallback20, useContext as useContext37 } from "react";
+import { forwardRef as forwardRef14, useCallback as useCallback22, useContext as useContext37 } from "react";
 import {
   forwardRef as forwardRef13,
   useContext as useContext36,
   useEffect as useEffect19,
   useImperativeHandle as useImperativeHandle9,
   useLayoutEffect as useLayoutEffect12,
-  useMemo as useMemo37,
-  useRef as useRef23
+  useMemo as useMemo38,
+  useRef as useRef24
 } from "react";
 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: __exportSetter2.bind(all, name)
+      set: (newValue) => all[name] = () => newValue
     });
 };
 if (typeof createContext !== "function") {
@@ -7198,75 +7207,33 @@ 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 VERSION = "4.0.464";
+var checkMultipleRemotionVersions = () => {
+  if (typeof globalThis === "undefined") {
+    return;
   }
-};
-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: {}
+  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(truthy2).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.`);
   }
-};
-var sequenceSchemaDefaultLayoutNone = {
-  ...sequenceSchema,
-  layout: {
-    ...sequenceSchema.layout,
-    default: "none"
-  }
+  set();
 };
 var SequenceContext = createContext12(null);
 var exports_timeline_position_state = {};
@@ -7602,6 +7569,82 @@ var Freeze = ({
 var PremountContext = createContext14({
   premountFramesRemaining: 0
 });
+var sequenceVisualStyleSchema = {
+  "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"
+  }
+};
+var sequencePremountSchema = {
+  premountFor: {
+    type: "number",
+    default: 0,
+    description: "Premount For",
+    min: 0,
+    step: 1
+  },
+  postmountFor: {
+    type: "hidden"
+  },
+  styleWhilePremounted: {
+    type: "hidden"
+  },
+  styleWhilePostmounted: {
+    type: "hidden"
+  }
+};
+var sequenceStyleSchema = {
+  ...sequenceVisualStyleSchema,
+  ...sequencePremountSchema
+};
+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 SequenceManager = React11.createContext({
   registerSequence: () => {
     throw new Error("SequenceManagerContext not initialized");
@@ -8284,7 +8327,8 @@ var RegularSequenceRefForwardingFunction = ({
   }, [name]);
   const env = useRemotionEnvironment();
   const inheritedStack = other?.stack ?? null;
-  const [stackDoesntChange] = useState5(() => stack ?? inheritedStack);
+  const stackRef = useRef6(null);
+  stackRef.current = stack ?? inheritedStack;
   useEffect3(() => {
     if (!env.isStudio) {
       return;
@@ -8308,7 +8352,7 @@ var RegularSequenceRefForwardingFunction = ({
         rootId,
         showInTimeline,
         src: isMedia.data.src,
-        stack: stackDoesntChange,
+        getStack: () => stackRef.current,
         startMediaFrom: isMedia.data.startMediaFrom,
         volume: isMedia.data.volumes
       });
@@ -8327,7 +8371,7 @@ var RegularSequenceRefForwardingFunction = ({
       showInTimeline,
       nonce: nonce.get(),
       loopDisplay,
-      stack: stackDoesntChange,
+      getStack: () => stackRef.current,
       premountDisplay: premountDisplay ?? null,
       postmountDisplay: postmountDisplay ?? null,
       controls: controls ?? null,
@@ -8350,7 +8394,6 @@ var RegularSequenceRefForwardingFunction = ({
     showInTimeline,
     nonce,
     loopDisplay,
-    stackDoesntChange,
     premountDisplay,
     postmountDisplay,
     env.isStudio,
@@ -8459,6 +8502,10 @@ var SequenceRefForwardingFunction = (props, ref) => {
 };
 var SequenceInner = forwardRef3(SequenceRefForwardingFunction);
 var Sequence = wrapInSchema(SequenceInner, sequenceSchema);
+var WEBGL_CONTEXT_DOCS_URL = "https://remotion.dev/docs/troubleshooting/webgl2-context";
+var webGlContextErrorMessage = (versionLabel, effectName) => `Failed to acquire ${versionLabel} context for ${effectName}. ` + 'Pass --gl=angle when using the CLI, set chromiumOptions: { gl: "angle" } when using SSR APIs, ' + 'or set "OpenGL render backend" to "angle" in the Advanced section when rendering in the Studio. ' + `See ${WEBGL_CONTEXT_DOCS_URL}`;
+var createWebGLContextError = (effectName) => new Error(webGlContextErrorMessage("WebGL", effectName));
+var createWebGL2ContextError = (effectName) => new Error(webGlContextErrorMessage("WebGL2", effectName));
 
 class CanvasPool {
   width;
@@ -8507,7 +8554,7 @@ class CanvasPool {
           preserveDrawingBuffer: true
         });
         if (!ctx) {
-          throw new Error("Failed to acquire WebGL2 context for canvas effect");
+          throw createWebGL2ContextError("canvas effect");
         }
         canvas.addEventListener("webglcontextlost", (e) => {
           e.preventDefault();
@@ -8665,216 +8712,36 @@ var runEffectChain = async ({
   if (!lastTarget) {
     return true;
   }
-  const outCtx = output.getContext("2d");
-  if (!outCtx) {
-    throw new Error("Failed to acquire 2D context for output canvas");
-  }
-  outCtx.clearRect(0, 0, width, height);
-  outCtx.drawImage(lastTarget, 0, 0, width, height);
-  return true;
-};
-var useEffectChainState = () => {
-  const chainStateRef = useRef6(null);
-  const sizeRef = useRef6(null);
-  useEffect4(() => {
-    return () => {
-      if (chainStateRef.current) {
-        cleanupEffectChainState(chainStateRef.current);
-      }
-    };
-  }, []);
-  return useMemo15(() => ({
-    get: (width, height) => {
-      if (!sizeRef.current || sizeRef.current.width !== width || sizeRef.current.height !== height) {
-        if (chainStateRef.current) {
-          cleanupEffectChainState(chainStateRef.current);
-        }
-        chainStateRef.current = createEffectChainState(width, height);
-        sizeRef.current = { width, height };
-      }
-      return chainStateRef.current;
-    }
-  }), []);
-};
-var solidSchema = {
-  color: {
-    type: "color",
-    default: "#ffffff",
-    description: "Color"
-  },
-  width: {
-    type: "number",
-    min: 1,
-    step: 1,
-    default: 1920,
-    description: "Width"
-  },
-  height: {
-    type: "number",
-    min: 1,
-    step: 1,
-    default: 1080,
-    description: "Height"
-  },
-  ...sequenceStyleSchema
-};
-var SolidInner = ({
-  color,
-  width,
-  height,
-  _experimentalEffects: experimentalEffects = [],
-  className,
-  style,
-  overrideId,
-  ref
-}) => {
-  const { delayRender: delayRender2, continueRender: continueRender2, cancelRender: cancelRender2 } = useDelayRender();
-  const [outputCanvas, setOutputCanvas] = useState6(null);
-  const memoizedEffects = useMemoizedEffects({
-    effects: experimentalEffects,
-    overrideId: overrideId ?? null
-  });
-  const sourceCanvas = useMemo16(() => {
-    if (typeof document === "undefined") {
-      return null;
-    }
-    const canvas = document.createElement("canvas");
-    canvas.width = 1;
-    canvas.height = 1;
-    return canvas;
-  }, []);
-  const chainState = useEffectChainState();
-  const canvasRef = useCallback6((canvas) => {
-    setOutputCanvas(canvas);
-    if (typeof ref === "function") {
-      ref(canvas);
-    } else if (ref) {
-      ref.current = canvas;
-    }
-  }, [ref]);
-  useEffect5(() => {
-    if (!outputCanvas || !sourceCanvas) {
-      return;
-    }
-    const handle = delayRender2("Solid effect chain");
-    if (!chainState) {
-      continueRender2(handle);
-      return () => {
-        continueRender2(handle);
-      };
-    }
-    const ctx = sourceCanvas.getContext("2d", { colorSpace: "srgb" });
-    if (!ctx) {
-      cancelRender2(new Error("Failed to acquire 2D context for <Solid> source"));
-      return;
-    }
-    ctx.fillStyle = color;
-    ctx.fillRect(0, 0, 1, 1);
-    runEffectChain({
-      state: chainState.get(width, height),
-      source: sourceCanvas,
-      effects: memoizedEffects,
-      output: outputCanvas,
-      width,
-      height
-    }).then((completed) => {
-      if (completed) {
-        continueRender2(handle);
-      }
-    }).catch((err) => {
-      cancelRender2(err);
-    });
-    return () => {
-      continueRender2(handle);
-    };
-  }, [
-    color,
-    outputCanvas,
-    sourceCanvas,
-    chainState,
-    width,
-    height,
-    delayRender2,
-    continueRender2,
-    cancelRender2,
-    memoizedEffects
-  ]);
-  return /* @__PURE__ */ jsx12("canvas", {
-    ref: canvasRef,
-    width,
-    height,
-    className,
-    style
-  });
-};
-var SolidOuter = forwardRef4(({
-  _experimentalEffects = [],
-  _experimentalControls: controls,
-  color,
-  height,
-  width,
-  className,
-  durationInFrames,
-  style,
-  name,
-  from,
-  hidden,
-  showInTimeline,
-  ...props
-}, ref) => {
-  const memoizedEffectDefinitions = useMemoizedEffectDefinitions(_experimentalEffects);
-  return /* @__PURE__ */ jsx12(Sequence, {
-    layout: "none",
-    from,
-    hidden,
-    showInTimeline,
-    _experimentalControls: controls,
-    _experimentalEffects: memoizedEffectDefinitions,
-    durationInFrames,
-    name: name ?? "<Solid>",
-    ...props,
-    children: /* @__PURE__ */ jsx12(SolidInner, {
-      ref,
-      overrideId: controls?.overrideId ?? null,
-      color,
-      height,
-      width,
-      className,
-      style,
-      _experimentalEffects
-    })
-  });
-});
-var Solid = wrapInSchema(SolidOuter, solidSchema);
-Solid.displayName = "Solid";
-addSequenceStackTraces(Solid);
-var VERSION = "4.0.463";
-var checkMultipleRemotionVersions = () => {
-  if (typeof globalThis === "undefined") {
-    return;
-  }
-  const set = () => {
-    globalThis.remotion_imported = VERSION;
-    if (typeof window !== "undefined") {
-      window.remotion_imported = VERSION;
-    }
-  };
-  const alreadyImported = globalThis.remotion_imported || typeof window !== "undefined" && window.remotion_imported;
-  if (alreadyImported) {
-    if (alreadyImported === VERSION) {
-      return;
-    }
-    if (typeof alreadyImported === "string" && alreadyImported.includes("webcodecs")) {
-      set();
-      return;
-    }
-    throw new TypeError(`\uD83D\uDEA8 Multiple versions of Remotion detected: ${[
-      VERSION,
-      typeof alreadyImported === "string" ? alreadyImported : "an older version"
-    ].filter(truthy2).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.`);
+  const outCtx = output.getContext("2d");
+  if (!outCtx) {
+    throw new Error("Failed to acquire 2D context for output canvas");
   }
-  set();
+  outCtx.clearRect(0, 0, width, height);
+  outCtx.drawImage(lastTarget, 0, 0, width, height);
+  return true;
+};
+var useEffectChainState = () => {
+  const chainStateRef = useRef7(null);
+  const sizeRef = useRef7(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 calcArgs = (fit, frameSize, canvasSize) => {
   switch (fit) {
@@ -8924,29 +8791,49 @@ var calcArgs = (fit, frameSize, canvasSize) => {
       throw new Error("Unknown fit: " + fit);
   }
 };
-var CanvasRefForwardingFunction = ({ width, height, fit, className, style }, ref) => {
-  const canvasRef = useRef7(null);
-  const draw = useCallback7((imageData) => {
+var CanvasRefForwardingFunction = ({ width, height, fit, className, style, effects }, ref) => {
+  const canvasRef = useRef8(null);
+  const chainState = useEffectChainState();
+  const sourceCanvas = useMemo16(() => {
+    if (typeof document === "undefined") {
+      return null;
+    }
+    return document.createElement("canvas");
+  }, []);
+  const draw = useCallback6(async (imageData) => {
     const canvas = canvasRef.current;
     const canvasWidth = width ?? imageData.displayWidth;
     const canvasHeight = height ?? imageData.displayHeight;
     if (!canvas) {
       throw new Error("Canvas ref is not set");
     }
-    const ctx = canvasRef.current?.getContext("2d");
-    if (!ctx) {
-      throw new Error("Could not get 2d context");
+    if (!sourceCanvas) {
+      throw new Error("Source canvas is not available");
     }
-    canvas.width = canvasWidth;
-    canvas.height = canvasHeight;
-    ctx.drawImage(imageData, ...calcArgs(fit, {
+    sourceCanvas.width = canvasWidth;
+    sourceCanvas.height = canvasHeight;
+    const sourceCtx = sourceCanvas.getContext("2d");
+    if (!sourceCtx) {
+      throw new Error("Could not get 2d context for source canvas");
+    }
+    sourceCtx.drawImage(imageData, ...calcArgs(fit, {
       height: imageData.displayHeight,
       width: imageData.displayWidth
     }, {
       width: canvasWidth,
       height: canvasHeight
     }));
-  }, [fit, height, width]);
+    canvas.width = canvasWidth;
+    canvas.height = canvasHeight;
+    return runEffectChain({
+      state: chainState.get(canvasWidth, canvasHeight),
+      source: sourceCanvas,
+      effects,
+      output: canvas,
+      width: canvasWidth,
+      height: canvasHeight
+    });
+  }, [chainState, effects, fit, height, sourceCanvas, width]);
   useImperativeHandle(ref, () => {
     return {
       draw,
@@ -8965,13 +8852,13 @@ var CanvasRefForwardingFunction = ({ width, height, fit, className, style }, ref
       }
     };
   }, [draw]);
-  return /* @__PURE__ */ jsx13("canvas", {
+  return /* @__PURE__ */ jsx12("canvas", {
     ref: canvasRef,
     className,
     style
   });
 };
-var Canvas = React15.forwardRef(CanvasRefForwardingFunction);
+var Canvas = React14.forwardRef(CanvasRefForwardingFunction);
 var CACHE_SIZE = 5;
 var getActualTime = ({
   loopBehavior,
@@ -9127,10 +9014,10 @@ var animatedImageSchema = {
     default: 1,
     description: "Playback Rate"
   },
-  ...sequenceStyleSchema,
+  ...sequenceVisualStyleSchema,
   hidden: hiddenField
 };
-var AnimatedImageContent = forwardRef5(({
+var AnimatedImageContent = forwardRef4(({
   src,
   width,
   height,
@@ -9138,26 +9025,24 @@ var AnimatedImageContent = forwardRef5(({
   loopBehavior = "loop",
   playbackRate = 1,
   fit = "fill",
+  effects,
+  controls,
   ...props
 }, canvasRef) => {
-  const mountState = useRef8({ isMounted: true });
-  useEffect6(() => {
-    const { current } = mountState;
-    current.isMounted = true;
-    return () => {
-      current.isMounted = false;
-    };
-  }, []);
   const resolvedSrc = resolveAnimatedImageSource(src);
-  const [imageDecoder, setImageDecoder] = useState7(null);
+  const [imageDecoder, setImageDecoder] = useState6(null);
   const { delayRender: delayRender2, continueRender: continueRender2 } = useDelayRender();
-  const [decodeHandle] = useState7(() => delayRender2(`Rendering <AnimatedImage/> with src="${resolvedSrc}"`));
+  const [decodeHandle] = useState6(() => delayRender2(`Rendering <AnimatedImage/> with src="${resolvedSrc}"`));
   const frame = useCurrentFrame();
   const { fps } = useVideoConfig();
   const currentTime = frame / playbackRate / fps;
-  const currentTimeRef = useRef8(currentTime);
+  const currentTimeRef = useRef9(currentTime);
   currentTimeRef.current = currentTime;
-  const ref = useRef8(null);
+  const ref = useRef9(null);
+  const memoizedEffects = useMemoizedEffects({
+    effects,
+    overrideId: controls?.overrideId ?? null
+  });
   useImperativeHandle2(canvasRef, () => {
     const c = ref.current?.getCanvas();
     if (!c) {
@@ -9165,8 +9050,8 @@ var AnimatedImageContent = forwardRef5(({
     }
     return c;
   }, []);
-  const [initialLoopBehavior] = useState7(() => loopBehavior);
-  useEffect6(() => {
+  const [initialLoopBehavior] = useState6(() => loopBehavior);
+  useEffect5(() => {
     const controller = new AbortController;
     decodeImage({
       resolvedSrc,
@@ -9203,16 +9088,24 @@ var AnimatedImageContent = forwardRef5(({
       return;
     }
     const delay = delayRender2(`Rendering frame at ${currentTime} of <AnimatedImage src="${src}"/>`);
-    imageDecoder.getFrame(currentTime, loopBehavior).then((videoFrame) => {
-      if (mountState.current.isMounted) {
-        if (videoFrame === null) {
-          ref.current?.clear();
-        } else {
-          ref.current?.draw(videoFrame.frame);
-        }
+    let cancelled = false;
+    imageDecoder.getFrame(currentTime, loopBehavior).then(async (videoFrame) => {
+      if (cancelled) {
+        return;
+      }
+      if (videoFrame === null) {
+        ref.current?.clear();
+        continueRender2(delay);
+        return;
+      }
+      const completed = await ref.current?.draw(videoFrame.frame);
+      if (completed && !cancelled) {
+        continueRender2(delay);
       }
-      continueRender2(delay);
     }).catch((err) => {
+      if (cancelled) {
+        return;
+      }
       if (onError) {
         onError(err);
         continueRender2(delay);
@@ -9220,6 +9113,10 @@ var AnimatedImageContent = forwardRef5(({
         cancelRender(err);
       }
     });
+    return () => {
+      cancelled = true;
+      continueRender2(delay);
+    };
   }, [
     currentTime,
     imageDecoder,
@@ -9227,13 +9124,18 @@ var AnimatedImageContent = forwardRef5(({
     onError,
     src,
     continueRender2,
-    delayRender2
+    delayRender2,
+    memoizedEffects,
+    fit,
+    width,
+    height
   ]);
-  return /* @__PURE__ */ jsx14(Canvas, {
+  return /* @__PURE__ */ jsx13(Canvas, {
     ref,
     width,
     height,
     fit,
+    effects: memoizedEffects,
     ...props
   });
 });
@@ -9250,12 +9152,14 @@ var AnimatedImageInner = ({
   className,
   style,
   durationInFrames,
+  _experimentalEffects: effects = [],
   _experimentalControls: controls,
   ref,
   ...sequenceProps
 }) => {
   const { durationInFrames: videoDuration } = useVideoConfig();
   const resolvedDuration = durationInFrames ?? videoDuration;
+  const memoizedEffectDefinitions = useMemoizedEffectDefinitions(effects);
   const animatedImageProps = {
     src,
     width,
@@ -9268,21 +9172,179 @@ var AnimatedImageInner = ({
     className,
     style
   };
-  return /* @__PURE__ */ jsx14(Sequence, {
+  return /* @__PURE__ */ jsx13(Sequence, {
     layout: "none",
     durationInFrames: resolvedDuration,
     name: "<AnimatedImage>",
     _experimentalControls: controls,
+    _experimentalEffects: memoizedEffectDefinitions,
     ...sequenceProps,
-    children: /* @__PURE__ */ jsx14(AnimatedImageContent, {
+    children: /* @__PURE__ */ jsx13(AnimatedImageContent, {
       ...animatedImageProps,
-      ref
+      ref,
+      effects,
+      controls
     })
   });
 };
 var AnimatedImage = wrapInSchema(AnimatedImageInner, animatedImageSchema);
 AnimatedImage.displayName = "AnimatedImage";
 addSequenceStackTraces(AnimatedImage);
+var solidSchema = {
+  color: {
+    type: "color",
+    default: "transparent",
+    description: "Color"
+  },
+  width: {
+    type: "number",
+    min: 1,
+    step: 1,
+    default: 1920,
+    description: "Width"
+  },
+  height: {
+    type: "number",
+    min: 1,
+    step: 1,
+    default: 1080,
+    description: "Height"
+  },
+  ...sequenceVisualStyleSchema
+};
+var SolidInner = ({
+  color,
+  width,
+  height,
+  _experimentalEffects: experimentalEffects = [],
+  className,
+  style,
+  overrideId,
+  ref
+}) => {
+  const { delayRender: delayRender2, continueRender: continueRender2, cancelRender: cancelRender2 } = useDelayRender();
+  const [outputCanvas, setOutputCanvas] = useState7(null);
+  const memoizedEffects = useMemoizedEffects({
+    effects: experimentalEffects,
+    overrideId: overrideId ?? null
+  });
+  const sourceCanvas = useMemo17(() => {
+    if (typeof document === "undefined") {
+      return null;
+    }
+    const canvas = document.createElement("canvas");
+    canvas.width = 1;
+    canvas.height = 1;
+    return canvas;
+  }, []);
+  const chainState = useEffectChainState();
+  const canvasRef = useCallback7((canvas) => {
+    setOutputCanvas(canvas);
+    if (typeof ref === "function") {
+      ref(canvas);
+    } else if (ref) {
+      ref.current = canvas;
+    }
+  }, [ref]);
+  useEffect6(() => {
+    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.clearRect(0, 0, 1, 1);
+    if (color !== undefined) {
+      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__ */ jsx14("canvas", {
+    ref: canvasRef,
+    width,
+    height,
+    className,
+    style
+  });
+};
+var SolidOuter = forwardRef5(({
+  _experimentalEffects = [],
+  _experimentalControls: controls,
+  color,
+  height,
+  width,
+  className,
+  durationInFrames,
+  style,
+  name,
+  from,
+  hidden,
+  showInTimeline,
+  ...props
+}, ref) => {
+  const memoizedEffectDefinitions = useMemoizedEffectDefinitions(_experimentalEffects);
+  return /* @__PURE__ */ jsx14(Sequence, {
+    layout: "none",
+    from,
+    hidden,
+    showInTimeline,
+    _experimentalControls: controls,
+    _experimentalEffects: memoizedEffectDefinitions,
+    durationInFrames,
+    name: name ?? "<Solid>",
+    ...props,
+    children: /* @__PURE__ */ jsx14(SolidInner, {
+      ref,
+      overrideId: controls?.overrideId ?? null,
+      color,
+      height,
+      width,
+      className,
+      style,
+      _experimentalEffects
+    })
+  });
+});
+var Solid = wrapInSchema(SolidOuter, solidSchema);
+Solid.displayName = "Solid";
+addSequenceStackTraces(Solid);
 var cachedSupport = null;
 var isHtmlInCanvasSupported = () => {
   if (cachedSupport !== null) {
@@ -9293,7 +9355,7 @@ var isHtmlInCanvasSupported = () => {
   }
   const canvas = document.createElement("canvas");
   const ctx = canvas.getContext("2d");
-  cachedSupport = typeof ctx?.drawElementImage === "function" && typeof canvas.requestPaint === "function" && typeof canvas.captureElementImage === "function";
+  cachedSupport = typeof ctx?.drawElementImage === "function" && typeof canvas.requestPaint === "function" && typeof canvas.captureElementImage === "function" && "transferControlToOffscreen" in HTMLCanvasElement.prototype;
   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).";
@@ -9329,8 +9391,10 @@ var HtmlInCanvasContent = forwardRef6(({ width, height, effects, children, onPai
   if (!isHtmlInCanvasSupported()) {
     cancelRender2(new Error(HTML_IN_CANVAS_UNSUPPORTED_MESSAGE));
   }
-  const canvas2dRef = useRef9(null);
-  const divRef = useRef9(null);
+  const canvas2dRef = useRef10(null);
+  const offscreenRef = useRef10(null);
+  const divRef = useRef10(null);
+  const canvasSizeKey = `${width}x${height}`;
   const setLayoutCanvasRef = useCallback8((node) => {
     canvas2dRef.current = node;
     if (typeof ref === "function") {
@@ -9339,45 +9403,48 @@ var HtmlInCanvasContent = forwardRef6(({ width, height, effects, children, onPai
       ref.current = node;
     }
   }, [ref]);
-  const [offscreenCanvas] = useState8(() => new OffscreenCanvas(1, 1));
   const chainState = useEffectChainState();
   const memoizedEffects = useMemoizedEffects({
     effects,
     overrideId: controls?.overrideId ?? null
   });
-  const effectsRef = useRef9(memoizedEffects);
+  const effectsRef = useRef10(memoizedEffects);
   effectsRef.current = memoizedEffects;
-  const onPaintRef = useRef9(onPaint);
+  const onPaintRef = useRef10(onPaint);
   onPaintRef.current = onPaint;
-  const onInitRef = useRef9(onInit);
+  const onInitRef = useRef10(onInit);
   onInitRef.current = onInit;
-  const initializedRef = useRef9(false);
-  const onInitCleanupRef = useRef9(null);
-  const unmountedRef = useRef9(false);
+  const initializedRef = useRef10(false);
+  const onInitCleanupRef = useRef10(null);
+  const unmountedRef = useRef10(false);
   const onPaintCb = useCallback8(async () => {
     const element = divRef.current;
     if (!element) {
       throw new Error("Canvas or scene element not found");
     }
-    offscreenCanvas.width = width;
-    offscreenCanvas.height = height;
+    const offscreen = offscreenRef.current;
+    if (!offscreen) {
+      throw new Error("HtmlInCanvas: offscreen canvas not ready (transferControlToOffscreen failed or canvas is remounting)");
+    }
+    offscreen.width = width;
+    offscreen.height = height;
     try {
-      const layoutCanvas = canvas2dRef.current;
-      if (!layoutCanvas) {
+      const placeholderCanvas = canvas2dRef.current;
+      if (!placeholderCanvas) {
         throw new Error("Canvas not found");
       }
-      const layout2d = layoutCanvas.getContext("2d");
-      if (!layout2d) {
-        throw new Error("Failed to acquire 2D context for <HtmlInCanvas> layout canvas");
+      const offscreen2d = offscreen.getContext("2d");
+      if (!offscreen2d) {
+        throw new Error("Failed to acquire 2D context for <HtmlInCanvas> offscreen canvas");
       }
       const handle = delayRender("onPaint");
       if (!initializedRef.current) {
         initializedRef.current = true;
-        const initImage = layoutCanvas.captureElementImage(element);
+        const initImage = placeholderCanvas.captureElementImage(element);
         const currentOnInit = onInitRef.current;
         if (currentOnInit) {
           const cleanup = await currentOnInit({
-            canvas: offscreenCanvas,
+            canvas: offscreen,
             element,
             elementImage: initImage
           });
@@ -9392,17 +9459,17 @@ var HtmlInCanvasContent = forwardRef6(({ width, height, effects, children, onPai
         }
       }
       const handler = onPaintRef.current ?? defaultOnPaint;
-      const elImage = layoutCanvas.captureElementImage(element);
+      const elImage = placeholderCanvas.captureElementImage(element);
       await handler({
-        canvas: offscreenCanvas,
+        canvas: offscreen,
         element,
         elementImage: elImage
       });
       await runEffectChain({
         state: chainState.get(width, height),
-        source: offscreenCanvas,
+        source: offscreen,
         effects: effectsRef.current,
-        output: canvas2dRef.current,
+        output: offscreen,
         width,
         height
       });
@@ -9410,29 +9477,30 @@ var HtmlInCanvasContent = forwardRef6(({ width, height, effects, children, onPai
     } catch (error2) {
       cancelRender2(error2);
     }
-  }, [
-    chainState,
-    continueRender2,
-    cancelRender2,
-    width,
-    height,
-    offscreenCanvas
-  ]);
+  }, [chainState, continueRender2, cancelRender2, width, height]);
   useLayoutEffect3(() => {
-    const canvas = canvas2dRef.current;
-    if (!canvas) {
+    const placeholder = canvas2dRef.current;
+    if (!placeholder) {
       throw new Error("Canvas not found");
     }
-    canvas.layoutSubtree = true;
-    canvas.addEventListener("paint", onPaintCb);
+    placeholder.layoutSubtree = true;
+    const offscreen = placeholder.transferControlToOffscreen();
+    offscreenRef.current = offscreen;
+    offscreen.width = width;
+    offscreen.height = height;
+    initializedRef.current = false;
+    unmountedRef.current = false;
+    placeholder.addEventListener("paint", onPaintCb);
     return () => {
-      canvas.removeEventListener("paint", onPaintCb);
+      placeholder.removeEventListener("paint", onPaintCb);
+      offscreenRef.current = null;
+      initializedRef.current = false;
       unmountedRef.current = true;
       onInitCleanupRef.current?.();
       onInitCleanupRef.current = null;
     };
-  }, [onPaintCb, cancelRender2]);
-  const onPaintChangedRef = useRef9(false);
+  }, [onPaintCb, cancelRender2, width, height]);
+  const onPaintChangedRef = useRef10(false);
   useLayoutEffect3(() => {
     if (!onPaintChangedRef.current) {
       onPaintChangedRef.current = true;
@@ -9456,8 +9524,8 @@ var HtmlInCanvasContent = forwardRef6(({ width, height, effects, children, onPai
     return () => {
       continueRender2(handle);
     };
-  }, [width, height, continueRender2]);
-  const innerStyle = useMemo17(() => {
+  }, [width, height, continueRender2, canvasSizeKey]);
+  const innerStyle = useMemo18(() => {
     return {
       width,
       height
@@ -9478,7 +9546,7 @@ var HtmlInCanvasContent = forwardRef6(({ width, height, effects, children, onPai
         style: innerStyle,
         children
       })
-    })
+    }, canvasSizeKey)
   });
 });
 HtmlInCanvasContent.displayName = "HtmlInCanvasContent";
@@ -9520,7 +9588,7 @@ var HtmlInCanvasInner = forwardRef6(({
 });
 HtmlInCanvasInner.displayName = "HtmlInCanvas";
 var htmlInCanvasSchema = {
-  ...sequenceStyleSchema,
+  ...sequenceVisualStyleSchema,
   hidden: hiddenField
 };
 var HtmlInCanvasWrapped = wrapInSchema(HtmlInCanvasInner, htmlInCanvasSchema);
@@ -9568,8 +9636,8 @@ var RenderAssetManager = createContext17({
   renderAssets: []
 });
 var RenderAssetManagerProvider = ({ children, collectAssets }) => {
-  const [renderAssets, setRenderAssets] = useState9([]);
-  const renderAssetsRef = useRef10([]);
+  const [renderAssets, setRenderAssets] = useState8([]);
+  const renderAssetsRef = useRef11([]);
   const registerRenderAsset = useCallback9((renderAsset) => {
     validateRenderAsset(renderAsset);
     renderAssetsRef.current = [...renderAssetsRef.current, renderAsset];
@@ -9601,7 +9669,7 @@ var RenderAssetManagerProvider = ({ children, collectAssets }) => {
       };
     }
   }, []);
-  const contextValue = useMemo18(() => {
+  const contextValue = useMemo19(() => {
     return {
       registerRenderAsset,
       unregisterRenderAsset,
@@ -9618,7 +9686,7 @@ var Artifact = ({ filename, content, downloadBehavior }) => {
   const { registerRenderAsset, unregisterRenderAsset } = useContext19(RenderAssetManager);
   const env = useRemotionEnvironment();
   const frame = useCurrentFrame();
-  const [id] = useState10(() => {
+  const [id] = useState9(() => {
     return String(Math.random());
   });
   useLayoutEffect5(() => {
@@ -9730,14 +9798,14 @@ var Loop = ({
   const iteration = Math.floor(currentFrame / durationInFrames);
   const start = iteration * durationInFrames;
   const from = Math.min(start, maxFrame);
-  const loopDisplay = useMemo19(() => {
+  const loopDisplay = useMemo20(() => {
     return {
       numberOfTimes: Math.min(compDuration / durationInFrames, times),
       startOffset: -from,
       durationInFrames
     };
   }, [compDuration, durationInFrames, from, times]);
-  const loopContext = useMemo19(() => {
+  const loopContext = useMemo20(() => {
     return {
       iteration: Math.floor(currentFrame / durationInFrames),
       durationInFrames
@@ -9775,7 +9843,7 @@ var setPreloads = (updater) => {
   updaters.forEach((u) => u());
 };
 var PrefetchProvider = ({ children }) => {
-  const [_preloads, _setPreloads] = useState11(() => preloads);
+  const [_preloads, _setPreloads] = useState10(() => preloads);
   useEffect7(() => {
     const updaterFunction = () => {
       _setPreloads(preloads);
@@ -10099,7 +10167,7 @@ var DurationsContext = createContext20({
 });
 var DurationsContextProvider = ({ children }) => {
   const [durations, setDurations] = useReducer(durationReducer, {});
-  const value = useMemo20(() => {
+  const value = useMemo21(() => {
     return {
       durations,
       setDurations
@@ -10233,7 +10301,7 @@ var useSingletonAudioContext = ({
   audioEnabled
 }) => {
   const env = useRemotionEnvironment();
-  const context = useMemo21(() => {
+  const context = useMemo22(() => {
     if (env.isRendering) {
       return null;
     }
@@ -10314,11 +10382,11 @@ var SharedAudioContextProvider = ({ children, audioLatencyHint, audioEnabled })
     latencyHint: audioLatencyHint,
     audioEnabled
   });
-  const audioContextIsPlayingEventually = useRef11(false);
-  const isResuming = useRef11(null);
-  const audioSyncAnchor = useMemo22(() => ({ value: 0 }), []);
-  const audioSyncAnchorListeners = useRef11([]);
-  const audioSyncAnchorEmitter = useMemo22(() => {
+  const audioContextIsPlayingEventually = useRef12(false);
+  const isResuming = useRef12(null);
+  const audioSyncAnchor = useMemo23(() => ({ value: 0 }), []);
+  const audioSyncAnchorListeners = useRef12([]);
+  const audioSyncAnchorEmitter = useMemo23(() => {
     return {
       dispatch: (event) => {
         audioSyncAnchorListeners.current.forEach((l) => l(event));
@@ -10333,12 +10401,12 @@ var SharedAudioContextProvider = ({ children, audioLatencyHint, audioEnabled })
       }
     };
   }, []);
-  const prevEndTimes = useRef11({ scheduledEndTime: null, mediaEndTime: null });
-  const nodesToResume = useRef11(new Map);
+  const prevEndTimes = useRef12({ scheduledEndTime: null, mediaEndTime: null });
+  const nodesToResume = useRef12(new Map);
   const unscheduleAudioNode = useCallback10((node) => {
     nodesToResume.current.delete(node);
   }, []);
-  const scheduleAudioNode = useMemo22(() => {
+  const scheduleAudioNode = useMemo23(() => {
     return ({
       node,
       mediaTimestamp,
@@ -10423,7 +10491,7 @@ var SharedAudioContextProvider = ({ children, audioLatencyHint, audioEnabled })
     audioContextIsPlayingEventually.current = false;
     ctxAndGain.audioContext.suspend();
   }, [ctxAndGain]);
-  const audioContextValue = useMemo22(() => {
+  const audioContextValue = useMemo23(() => {
     return {
       audioContext: ctxAndGain?.audioContext ?? null,
       gainNode: ctxAndGain?.gainNode ?? null,
@@ -10451,8 +10519,8 @@ var SharedAudioContextProvider = ({ children, audioLatencyHint, audioEnabled })
   });
 };
 var SharedAudioTagsContextProvider = ({ children, numberOfAudioTags }) => {
-  const audios = useRef11([]);
-  const [initialNumberOfAudioTags] = useState12(numberOfAudioTags);
+  const audios = useRef12([]);
+  const [initialNumberOfAudioTags] = useState11(numberOfAudioTags);
   if (numberOfAudioTags !== initialNumberOfAudioTags) {
     throw new Error("The number of shared audio tags has changed dynamically. Once you have set this property, you cannot change it afterwards.");
   }
@@ -10462,7 +10530,7 @@ var SharedAudioTagsContextProvider = ({ children, numberOfAudioTags }) => {
   const audioCtx = useContext21(SharedAudioContext);
   const audioContext = audioCtx?.audioContext ?? null;
   const resume = audioCtx?.resume;
-  const refs = useMemo22(() => {
+  const refs = useMemo23(() => {
     return new Array(numberOfAudioTags).fill(true).map(() => {
       const ref = createRef2();
       return {
@@ -10485,7 +10553,7 @@ var SharedAudioTagsContextProvider = ({ children, numberOfAudioTags }) => {
       });
     };
   }, [refs]);
-  const takenAudios = useRef11(new Array(numberOfAudioTags).fill(false));
+  const takenAudios = useRef12(new Array(numberOfAudioTags).fill(false));
   const rerenderAudios = useCallback10(() => {
     refs.forEach(({ ref, id }) => {
       const data = audios.current?.find((a) => a.id === id);
@@ -10599,7 +10667,7 @@ var SharedAudioTagsContextProvider = ({ children, numberOfAudioTags }) => {
     });
     resume?.();
   }, [logLevel, mountTime, refs, env.isPlayer, resume]);
-  const audioTagsValue = useMemo22(() => {
+  const audioTagsValue = useMemo23(() => {
     return {
       registerAudio,
       unregisterAudio,
@@ -10636,7 +10704,7 @@ var useSharedAudio = ({
 }) => {
   const audioCtx = useContext21(SharedAudioContext);
   const tagsCtx = useContext21(SharedAudioTagsContext);
-  const [elem] = useState12(() => {
+  const [elem] = useState11(() => {
     if (tagsCtx && tagsCtx.numberOfAudioTags > 0) {
       return tagsCtx.registerAudio({ aud, audioId, premounting, postmounting });
     }
@@ -10772,9 +10840,9 @@ var useAppendVideoFragment = ({
   duration: initialDuration,
   fps
 }) => {
-  const actualFromRef = useRef12(initialActualFrom);
-  const actualDuration = useRef12(initialDuration);
-  const actualSrc = useRef12(initialActualSrc);
+  const actualFromRef = useRef13(initialActualFrom);
+  const actualDuration = useRef13(initialDuration);
+  const actualSrc = useRef13(initialActualSrc);
   if (!isSubsetOfDuration({
     prevStartFrom: actualFromRef.current,
     newStartFrom: initialActualFrom,
@@ -10811,8 +10879,8 @@ var useVolume = ({
   source,
   shouldUseWebAudioApi
 }) => {
-  const audioStuffRef = useRef13(null);
-  const currentVolumeRef = useRef13(volume);
+  const audioStuffRef = useRef14(null);
+  const currentVolumeRef = useRef14(volume);
   currentVolumeRef.current = volume;
   const sharedAudioContext = useContext22(SharedAudioContext);
   if (!sharedAudioContext) {
@@ -10969,7 +11037,7 @@ var useBasicMediaInTimeline = ({
     throw new Error("No src passed");
   }
   const parentSequence = useContext24(SequenceContext);
-  const [initialVolume] = useState13(() => volume);
+  const [initialVolume] = useState12(() => volume);
   const duration = getTimelineDuration({
     compositionDurationInFrames: sequenceDurationInFrames,
     playbackRate,
@@ -10978,7 +11046,7 @@ var useBasicMediaInTimeline = ({
     parentSequenceDurationInFrames: parentSequence?.durationInFrames ?? null,
     loop
   });
-  const volumes = useMemo23(() => {
+  const volumes = useMemo24(() => {
     if (typeof volume === "number") {
       return volume;
     }
@@ -10999,7 +11067,7 @@ var useBasicMediaInTimeline = ({
   const nonce = useNonce();
   const { rootId } = useTimelineContext();
   const startMediaFrom = 0 - mediaStartsAt + (trimBefore ?? 0);
-  const memoizedResult = useMemo23(() => {
+  const memoizedResult = useMemo24(() => {
     return {
       volumes,
       duration,
@@ -11028,7 +11096,7 @@ var useImageInTimeline = ({
   src,
   displayName,
   id,
-  stack,
+  getStack,
   showInTimeline,
   premountDisplay,
   postmountDisplay,
@@ -11075,7 +11143,7 @@ var useImageInTimeline = ({
       showInTimeline: true,
       nonce: nonce.get(),
       loopDisplay,
-      stack,
+      getStack,
       premountDisplay,
       postmountDisplay,
       controls,
@@ -11092,7 +11160,7 @@ var useImageInTimeline = ({
     registerSequence,
     unregisterSequence,
     nonce,
-    stack,
+    getStack,
     showInTimeline,
     premountDisplay,
     postmountDisplay,
@@ -11111,7 +11179,7 @@ var useMediaInTimeline = ({
   playbackRate,
   displayName,
   id,
-  stack,
+  getStack,
   showInTimeline,
   premountDisplay,
   postmountDisplay,
@@ -11162,7 +11230,7 @@ var useMediaInTimeline = ({
       doesVolumeChange,
       loopDisplay,
       playbackRate,
-      stack,
+      getStack,
       premountDisplay,
       postmountDisplay,
       controls: null,
@@ -11184,7 +11252,7 @@ var useMediaInTimeline = ({
     mediaType,
     startsAt,
     playbackRate,
-    stack,
+    getStack,
     showInTimeline,
     premountDisplay,
     postmountDisplay,
@@ -11195,12 +11263,12 @@ var useMediaInTimeline = ({
   ]);
 };
 var useBufferManager = (logLevel, mountTime) => {
-  const [blocks, setBlocks] = useState14([]);
-  const [onBufferingCallbacks, setOnBufferingCallbacks] = useState14([]);
-  const [onResumeCallbacks, setOnResumeCallbacks] = useState14([]);
+  const [blocks, setBlocks] = useState13([]);
+  const [onBufferingCallbacks, setOnBufferingCallbacks] = useState13([]);
+  const [onResumeCallbacks, setOnResumeCallbacks] = useState13([]);
   const env = useRemotionEnvironment();
   const rendering = env.isRendering;
-  const buffering = useRef14(false);
+  const buffering = useRef15(false);
   const addBlock = useCallback11((block) => {
     if (rendering) {
       return {
@@ -11273,7 +11341,7 @@ var useBufferManager = (logLevel, mountTime) => {
       }
     }, [blocks]);
   }
-  return useMemo24(() => {
+  return useMemo25(() => {
     return { addBlock, listenForBuffering, listenForResume, buffering };
   }, [addBlock, buffering, listenForBuffering, listenForResume]);
 };
@@ -11287,7 +11355,7 @@ var BufferingProvider = ({ children }) => {
   });
 };
 var useIsPlayerBuffering = (bufferManager) => {
-  const [isBuffering, setIsBuffering] = useState14(bufferManager.buffering.current);
+  const [isBuffering, setIsBuffering] = useState13(bufferManager.buffering.current);
   useEffect9(() => {
     const onBuffer = () => {
       setIsBuffering(true);
@@ -11312,7 +11380,7 @@ var useBufferState = () => {
   const buffer = useContext26(BufferingContextReact);
   const logLevel = useLogLevel();
   const addBlock = buffer ? buffer.addBlock : null;
-  return useMemo25(() => ({
+  return useMemo26(() => ({
     delayPlayback: () => {
       if (!addBlock) {
         throw new Error("Tried to enable the buffering state, but a Remotion context was not found. This API can only be called in a component that was passed to the Remotion Player or a <Composition>. Or you might have experienced a version mismatch - run `npx remotion versions` and ensure all packages have the same version. This error is thrown by the buffer state https://remotion.dev/docs/player/buffer-state");
@@ -11347,7 +11415,7 @@ var useBufferUntilFirstFrame = ({
   logLevel,
   mountTime
 }) => {
-  const bufferingRef = useRef15(false);
+  const bufferingRef = useRef16(false);
   const { delayPlayback } = useBufferState();
   const bufferUntilFirstFrame = useCallback12((requestedTime) => {
     if (mediaType !== "video") {
@@ -11420,7 +11488,7 @@ var useBufferUntilFirstFrame = ({
     onVariableFpsVideoDetected,
     pauseWhenBuffering
   ]);
-  return useMemo26(() => {
+  return useMemo27(() => {
     return {
       isBuffering: () => bufferingRef.current,
       bufferUntilFirstFrame
@@ -11468,7 +11536,7 @@ var useMediaBuffering = ({
   src
 }) => {
   const buffer = useBufferState();
-  const [isBuffering, setIsBuffering] = useState15(false);
+  const [isBuffering, setIsBuffering] = useState14(false);
   useEffect10(() => {
     let cleanupFns = [];
     const { current } = element;
@@ -11601,7 +11669,7 @@ var useRequestVideoCallbackTime = ({
   lastSeek,
   onVariableFpsVideoDetected
 }) => {
-  const currentTime = useRef16(null);
+  const currentTime = useRef17(null);
   useEffect11(() => {
     const { current } = mediaRef;
     if (current) {
@@ -11858,14 +11926,14 @@ var useMediaPlayback = ({
   const buffering = useContext27(BufferingContextReact);
   const { fps } = useVideoConfig();
   const mediaStartsAt = useMediaStartsAt();
-  const lastSeekDueToShift = useRef17(null);
-  const lastSeek = useRef17(null);
+  const lastSeekDueToShift = useRef18(null);
+  const lastSeek = useRef18(null);
   const logLevel = useLogLevel();
   const mountTime = useMountTime();
   if (!buffering) {
     throw new Error("useMediaPlayback must be used inside a <BufferingContext>");
   }
-  const isVariableFpsVideoMap = useRef17({});
+  const isVariableFpsVideoMap = useRef18({});
   const onVariableFpsVideoDetected = useCallback13(() => {
     if (!src) {
       return;
@@ -12148,14 +12216,14 @@ var SetMediaVolumeContext = createContext22({
 var useMediaVolumeState = () => {
   const { mediaVolume } = useContext28(MediaVolumeContext);
   const { setMediaVolume } = useContext28(SetMediaVolumeContext);
-  return useMemo27(() => {
+  return useMemo28(() => {
     return [mediaVolume, setMediaVolume];
   }, [mediaVolume, setMediaVolume]);
 };
 var useMediaMutedState = () => {
   const { mediaMuted } = useContext28(MediaVolumeContext);
   const { setMediaMuted } = useContext28(SetMediaVolumeContext);
-  return useMemo27(() => {
+  return useMemo28(() => {
     return [mediaMuted, setMediaMuted];
   }, [mediaMuted, setMediaMuted]);
 };
@@ -12165,7 +12233,7 @@ var warnAboutTooHighVolume = (volume) => {
   }
 };
 var AudioForDevelopmentForwardRefFunction = (props, ref) => {
-  const [initialShouldPreMountAudioElements] = useState16(props.shouldPreMountAudioTags);
+  const [initialShouldPreMountAudioElements] = useState15(props.shouldPreMountAudioTags);
   if (props.shouldPreMountAudioTags !== initialShouldPreMountAudioElements) {
     throw new Error("Cannot change the behavior for pre-mounting audio tags dynamically.");
   }
@@ -12210,7 +12278,7 @@ var AudioForDevelopmentForwardRefFunction = (props, ref) => {
   }
   const preloadedSrc = usePreload(src);
   const sequenceContext = useContext29(SequenceContext);
-  const [timelineId] = useState16(() => String(Math.random()));
+  const [timelineId] = useState15(() => String(Math.random()));
   const userPreferredVolume = evaluateVolume({
     frame: volumePropFrame,
     volume,
@@ -12222,7 +12290,7 @@ var AudioForDevelopmentForwardRefFunction = (props, ref) => {
     requestsVideoFrame: false,
     isClientSideRendering: false
   });
-  const propsToPass = useMemo28(() => {
+  const propsToPass = useMemo29(() => {
     return {
       muted: muted || mediaMuted || userPreferredVolume <= 0,
       src: preloadedSrc,
@@ -12239,7 +12307,7 @@ var AudioForDevelopmentForwardRefFunction = (props, ref) => {
     userPreferredVolume,
     crossOriginValue
   ]);
-  const id = useMemo28(() => `audio-${random(src ?? "")}-${sequenceContext?.relativeFrom}-${sequenceContext?.cumulatedFrom}-${sequenceContext?.durationInFrames}-muted:${props.muted}-loop:${props.loop}`, [
+  const id = useMemo29(() => `audio-${random(src ?? "")}-${sequenceContext?.relativeFrom}-${sequenceContext?.cumulatedFrom}-${sequenceContext?.durationInFrames}-muted:${props.muted}-loop:${props.loop}`, [
     src,
     sequenceContext?.relativeFrom,
     sequenceContext?.cumulatedFrom,
@@ -12257,6 +12325,9 @@ var AudioForDevelopmentForwardRefFunction = (props, ref) => {
     premounting: Boolean(sequenceContext?.premounting),
     postmounting: Boolean(sequenceContext?.postmounting)
   });
+  const getStack = useCallback14(() => {
+    return _remotionInternalStack ?? null;
+  }, [_remotionInternalStack]);
   useMediaInTimeline({
     volume,
     mediaVolume,
@@ -12265,7 +12336,7 @@ var AudioForDevelopmentForwardRefFunction = (props, ref) => {
     playbackRate: playbackRate ?? 1,
     displayName: name ?? null,
     id: timelineId,
-    stack: _remotionInternalStack,
+    getStack,
     showInTimeline,
     premountDisplay: sequenceContext?.premountDisplay ?? null,
     postmountDisplay: sequenceContext?.postmountDisplay ?? null,
@@ -12310,7 +12381,7 @@ var AudioForDevelopmentForwardRefFunction = (props, ref) => {
   useImperativeHandle4(ref, () => {
     return audioRef.current;
   }, [audioRef]);
-  const currentOnDurationCallback = useRef18(onDuration);
+  const currentOnDurationCallback = useRef19(onDuration);
   currentOnDurationCallback.current = onDuration;
   useEffect14(() => {
     const { current } = audioRef;
@@ -12341,7 +12412,7 @@ var AudioForDevelopmentForwardRefFunction = (props, ref) => {
 };
 var AudioForPreview = forwardRef7(AudioForDevelopmentForwardRefFunction);
 var AudioForRenderingRefForwardingFunction = (props, ref) => {
-  const audioRef = useRef19(null);
+  const audioRef = useRef20(null);
   const {
     volume: volumeProp,
     playbackRate,
@@ -12367,7 +12438,7 @@ var AudioForRenderingRefForwardingFunction = (props, ref) => {
   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}`, [
+  const id = useMemo30(() => `audio-${random(props.src ?? "")}-${sequenceContext?.relativeFrom}-${sequenceContext?.cumulatedFrom}-${sequenceContext?.durationInFrames}`, [
     props.src,
     sequenceContext?.relativeFrom,
     sequenceContext?.cumulatedFrom,
@@ -12498,7 +12569,7 @@ var AudioRefForwardingFunction = (props, ref) => {
     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 = useCallback14((e) => {
+  const onError = useCallback15((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) {
@@ -12512,7 +12583,7 @@ var AudioRefForwardingFunction = (props, ref) => {
       console.warn(errMessage);
     }
   }, [loop, onRemotionError, preloadedSrc]);
-  const onDuration = useCallback14((src, durationInSeconds) => {
+  const onDuration = useCallback15((src, durationInSeconds) => {
     setDurations({ type: "got-duration", durationInSeconds, src });
   }, [setDurations]);
   const durationFetched = durations[getAbsoluteSrc(preloadedSrc)] ?? durations[getAbsoluteSrc(props.src)];
@@ -12602,15 +12673,15 @@ var IFrameRefForwarding = ({
   ...props2
 }, ref) => {
   const { delayRender: delayRender2, continueRender: continueRender2 } = useDelayRender();
-  const [handle] = useState17(() => delayRender2(`Loading <IFrame> with source ${props2.src}`, {
+  const [handle] = useState16(() => delayRender2(`Loading <IFrame> with source ${props2.src}`, {
     retries: delayRenderRetries ?? undefined,
     timeoutInMilliseconds: delayRenderTimeoutInMilliseconds ?? undefined
   }));
-  const didLoad = useCallback15((e) => {
+  const didLoad = useCallback16((e) => {
     continueRender2(handle);
     onLoad?.(e);
   }, [handle, onLoad, continueRender2]);
-  const didGetError = useCallback15((e) => {
+  const didGetError = useCallback16((e) => {
     continueRender2(handle);
     if (onError) {
       onError(e);
@@ -12648,8 +12719,8 @@ var ImgContent = ({
   ref,
   ...props2
 }) => {
-  const imageRef = useRef20(null);
-  const errors = useRef20({});
+  const imageRef = useRef21(null);
+  const errors = useRef21({});
   const { delayPlayback } = useBufferState();
   const sequenceContext = useContext32(SequenceContext);
   const _propsValid = true;
@@ -12660,7 +12731,7 @@ var ImgContent = ({
     return imageRef.current;
   }, []);
   const actualSrc = usePreload(src);
-  const retryIn = useCallback16((timeout) => {
+  const retryIn = useCallback17((timeout) => {
     if (!imageRef.current) {
       return;
     }
@@ -12678,7 +12749,7 @@ var ImgContent = ({
     }, timeout);
   }, []);
   const { delayRender: delayRender2, continueRender: continueRender2, cancelRender: cancelRender2 } = useDelayRender();
-  const didGetError = useCallback16((e) => {
+  const didGetError = useCallback17((e) => {
     if (!errors.current) {
       return;
     }
@@ -12790,15 +12861,18 @@ var ImgInner = ({
   ...props2
 }) => {
   const sequenceContext = useContext32(SequenceContext);
-  const [timelineId] = useState18(() => String(Math.random()));
+  const [timelineId] = useState17(() => String(Math.random()));
   if (!src) {
     throw new Error('No "src" prop was passed to <Img>.');
   }
+  const stackRef = useRef21(null);
+  stackRef.current = stack ?? null;
+  const getStack = useCallback17(() => stackRef.current, []);
   useImageInTimeline({
     src,
     displayName: name ?? null,
     id: timelineId,
-    stack: stack ?? null,
+    getStack,
     showInTimeline: showInTimeline ?? true,
     premountDisplay: sequenceContext?.premountDisplay ?? null,
     postmountDisplay: sequenceContext?.postmountDisplay ?? null,
@@ -12814,7 +12888,7 @@ var ImgInner = ({
   });
 };
 var imgSchema = {
-  ...sequenceStyleSchema,
+  ...sequenceVisualStyleSchema,
   hidden: hiddenField
 };
 var Img = wrapInSchema(ImgInner, imgSchema);
@@ -12827,18 +12901,18 @@ var CompositionManagerProvider = ({
   initialCompositions,
   initialCanvasContent
 }) => {
-  const [folders, setFolders] = useState19([]);
-  const [canvasContent, setCanvasContent] = useState19(initialCanvasContent);
-  const [compositions, setCompositions] = useState19(initialCompositions);
-  const currentcompositionsRef = useRef21(compositions);
-  const updateCompositions = useCallback17((updateComps) => {
+  const [folders, setFolders] = useState18([]);
+  const [canvasContent, setCanvasContent] = useState18(initialCanvasContent);
+  const [compositions, setCompositions] = useState18(initialCompositions);
+  const currentcompositionsRef = useRef22(compositions);
+  const updateCompositions = useCallback18((updateComps) => {
     setCompositions((comps) => {
       const updated = updateComps(comps);
       currentcompositionsRef.current = updated;
       return updated;
     });
   }, []);
-  const registerComposition = useCallback17((comp) => {
+  const registerComposition = useCallback18((comp) => {
     updateCompositions((comps) => {
       if (comps.find((c2) => c2.id === comp.id)) {
         throw new Error(`Multiple composition with id ${comp.id} are registered.`);
@@ -12846,12 +12920,12 @@ var CompositionManagerProvider = ({
       return [...comps, comp];
     });
   }, [updateCompositions]);
-  const unregisterComposition = useCallback17((id) => {
+  const unregisterComposition = useCallback18((id) => {
     setCompositions((comps) => {
       return comps.filter((c2) => c2.id !== id);
     });
   }, []);
-  const registerFolder = useCallback17((name, parent, nonce) => {
+  const registerFolder = useCallback18((name, parent, nonce) => {
     setFolders((prevFolders) => {
       return [
         ...prevFolders,
@@ -12863,7 +12937,7 @@ var CompositionManagerProvider = ({
       ];
     });
   }, []);
-  const unregisterFolder = useCallback17((name, parent) => {
+  const unregisterFolder = useCallback18((name, parent) => {
     setFolders((prevFolders) => {
       return prevFolders.filter((p) => !(p.name === name && p.parent === parent));
     });
@@ -12873,7 +12947,7 @@ var CompositionManagerProvider = ({
       getCompositions: () => currentcompositionsRef.current
     };
   }, []);
-  const compositionManagerSetters = useMemo30(() => {
+  const compositionManagerSetters = useMemo31(() => {
     return {
       registerComposition,
       unregisterComposition,
@@ -12889,7 +12963,7 @@ var CompositionManagerProvider = ({
     unregisterFolder,
     onlyRenderComposition
   ]);
-  const compositionManagerContextValue = useMemo30(() => {
+  const compositionManagerContextValue = useMemo31(() => {
     return {
       compositions,
       folders,
@@ -12969,7 +13043,7 @@ var disabledEffectField = {
   description: "Disabled"
 };
 var createEffect = (definition) => {
-  const userCalculateKey = definition.calculateKey;
+  const { calculateKey: userCalculateKey, validateParams } = definition;
   const widened = {
     ...definition,
     calculateKey: (params) => {
@@ -12981,12 +13055,15 @@ var createEffect = (definition) => {
       ...definition.schema
     }
   };
-  const factory = (params = {}) => ({
-    definition: widened,
-    params,
-    effectKey: widened.calculateKey(params),
-    memoized: false
-  });
+  const factory = (params = {}) => {
+    validateParams(params);
+    return {
+      definition: widened,
+      params,
+      effectKey: widened.calculateKey(params),
+      memoized: false
+    };
+  };
   return factory;
 };
 var REMOTION_STUDIO_CONTAINER_ELEMENT = "__remotion-studio-container";
@@ -13037,7 +13114,7 @@ var MediaEnabledProvider = ({
   videoEnabled,
   audioEnabled
 }) => {
-  const value = useMemo31(() => ({ videoEnabled, audioEnabled }), [videoEnabled, audioEnabled]);
+  const value = useMemo322(() => ({ videoEnabled, audioEnabled }), [videoEnabled, audioEnabled]);
   return /* @__PURE__ */ jsx28(MediaEnabledContext.Provider, {
     value,
     children
@@ -13052,13 +13129,13 @@ var RemotionRootContexts = ({
   audioEnabled,
   frameState
 }) => {
-  const nonceContext = useMemo322(() => {
+  const nonceContext = useMemo33(() => {
     let counter = 0;
     return {
       getNonce: () => counter++
     };
   }, []);
-  const logging = useMemo322(() => {
+  const logging = useMemo33(() => {
     return { logLevel, mountTime: Date.now() };
   }, [logLevel]);
   return /* @__PURE__ */ jsx29(LogLevelContext.Provider, {
@@ -13352,7 +13429,7 @@ var OffthreadVideoForRendering = ({
   if (!src) {
     throw new TypeError("No `src` was passed to <OffthreadVideo>.");
   }
-  const id = useMemo33(() => `offthreadvideo-${random(src)}-${sequenceContext?.cumulatedFrom}-${sequenceContext?.relativeFrom}-${sequenceContext?.durationInFrames}`, [
+  const id = useMemo34(() => `offthreadvideo-${random(src)}-${sequenceContext?.cumulatedFrom}-${sequenceContext?.relativeFrom}-${sequenceContext?.durationInFrames}`, [
     src,
     sequenceContext?.cumulatedFrom,
     sequenceContext?.relativeFrom,
@@ -13407,14 +13484,14 @@ var OffthreadVideoForRendering = ({
     sequenceContext?.relativeFrom,
     audioStreamIndex
   ]);
-  const currentTime = useMemo33(() => {
+  const currentTime = useMemo34(() => {
     return getExpectedMediaFrameUncorrected({
       frame,
       playbackRate: playbackRate || 1,
       startFrom: -mediaStartsAt
     }) / videoConfig.fps;
   }, [frame, mediaStartsAt, playbackRate, videoConfig.fps]);
-  const actualSrc = useMemo33(() => {
+  const actualSrc = useMemo34(() => {
     return getOffthreadVideoSource({
       src,
       currentTime,
@@ -13422,7 +13499,7 @@ var OffthreadVideoForRendering = ({
       toneMapped
     });
   }, [toneMapped, currentTime, src, transparent]);
-  const [imageSrc, setImageSrc] = useState20(null);
+  const [imageSrc, setImageSrc] = useState19(null);
   const { delayRender: delayRender2, continueRender: continueRender2 } = useDelayRender();
   useLayoutEffect11(() => {
     if (!window.remotion_videoEnabled) {
@@ -13495,17 +13572,17 @@ var OffthreadVideoForRendering = ({
     continueRender2,
     delayRender2
   ]);
-  const onErr = useCallback18(() => {
+  const onErr = useCallback19(() => {
     if (onError) {
       onError?.(new Error("Failed to load image with src " + imageSrc));
     } else {
       cancelRender("Failed to load image with src " + imageSrc);
     }
   }, [imageSrc, onError]);
-  const className = useMemo33(() => {
+  const className = useMemo34(() => {
     return [OBJECTFIT_CONTAIN_CLASS_NAME, props2.className].filter(truthy2).join(" ");
   }, [props2.className]);
-  const onImageFrame = useCallback18((img) => {
+  const onImageFrame = useCallback19((img) => {
     if (onVideoFrame) {
       onVideoFrame(img);
     }
@@ -13564,8 +13641,8 @@ var VideoForDevelopmentRefForwardingFunction = (props2, ref) => {
   if (!context) {
     throw new Error("SharedAudioContext not found");
   }
-  const videoRef = useRef22(null);
-  const sharedSource = useMemo34(() => {
+  const videoRef = useRef23(null);
+  const sharedSource = useMemo35(() => {
     if (!context.audioContext) {
       return null;
     }
@@ -13620,7 +13697,7 @@ var VideoForDevelopmentRefForwardingFunction = (props2, ref) => {
   const parentSequence = useContext35(SequenceContext);
   const logLevel = useLogLevel();
   const mountTime = useMountTime();
-  const [timelineId] = useState21(() => String(Math.random()));
+  const [timelineId] = useState20(() => String(Math.random()));
   if (typeof acceptableTimeShift !== "undefined") {
     throw new Error("acceptableTimeShift has been removed. Use acceptableTimeShiftInSeconds instead.");
   }
@@ -13632,6 +13709,9 @@ var VideoForDevelopmentRefForwardingFunction = (props2, ref) => {
     mediaVolume
   });
   warnAboutTooHighVolume(userPreferredVolume);
+  const getStack = useCallback20(() => {
+    return _remotionInternalStack ?? null;
+  }, [_remotionInternalStack]);
   useMediaInTimeline({
     volume,
     mediaVolume,
@@ -13640,7 +13720,7 @@ var VideoForDevelopmentRefForwardingFunction = (props2, ref) => {
     playbackRate: props2.playbackRate ?? 1,
     displayName: name ?? null,
     id: timelineId,
-    stack: _remotionInternalStack,
+    getStack,
     showInTimeline,
     premountDisplay: parentSequence?.premountDisplay ?? null,
     postmountDisplay: parentSequence?.postmountDisplay ?? null,
@@ -13686,7 +13766,7 @@ var VideoForDevelopmentRefForwardingFunction = (props2, ref) => {
   useImperativeHandle8(ref, () => {
     return videoRef.current;
   }, []);
-  useState21(() => playbackLogging({
+  useState20(() => playbackLogging({
     logLevel,
     message: `Mounting video with source = ${actualSrc}, v=${VERSION}, user agent=${typeof navigator === "undefined" ? "server" : navigator.userAgent}`,
     tag: "video",
@@ -13732,7 +13812,7 @@ var VideoForDevelopmentRefForwardingFunction = (props2, ref) => {
       current.removeEventListener("error", errorHandler);
     };
   }, [onError, src]);
-  const currentOnDurationCallback = useRef22(onDuration);
+  const currentOnDurationCallback = useRef23(onDuration);
   currentOnDurationCallback.current = onDuration;
   useEmitVideoFrame({ ref: videoRef, onVideoFrame });
   useEffect18(() => {
@@ -13763,7 +13843,7 @@ var VideoForDevelopmentRefForwardingFunction = (props2, ref) => {
       current.preload = "auto";
     }
   }, []);
-  const actualStyle = useMemo34(() => {
+  const actualStyle = useMemo35(() => {
     return {
       ...style
     };
@@ -13802,7 +13882,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 = useCallback19(() => {
+  const onDuration = useCallback21(() => {
     return;
   }, []);
   if (typeof props2.src !== "string") {
@@ -13958,7 +14038,7 @@ function useRemotionContexts() {
   const sequenceManagerContext = React36.useContext(SequenceManager);
   const bufferManagerContext = React36.useContext(BufferingContextReact);
   const logLevelContext = React36.useContext(LogLevelContext);
-  return useMemo35(() => ({
+  return useMemo36(() => ({
     compositionManagerCtx,
     timelineContext,
     setTimelineContext,
@@ -14050,6 +14130,8 @@ var Internals = {
   wrapInSchema,
   sequenceSchema,
   sequenceStyleSchema,
+  sequenceVisualStyleSchema,
+  sequencePremountSchema,
   flattenActiveSchema,
   getFlatSchemaWithAllKeys,
   RemotionRootContexts,
@@ -14144,6 +14226,8 @@ var Internals = {
   useMemoizedEffects,
   useMemoizedEffectDefinitions,
   createEffect,
+  createWebGLContextError,
+  createWebGL2ContextError,
   computeEffectiveSchemaValuesDotNotation,
   OverrideIdsToNodePathsGettersContext,
   OverrideIdsToNodePathsSettersContext,
@@ -14216,7 +14300,7 @@ var SeriesSequenceRefForwardingFunction = ({ children }, _ref) => {
 };
 var SeriesSequence = forwardRef12(SeriesSequenceRefForwardingFunction);
 var SeriesInner = (props2) => {
-  const childrenValue = useMemo36(() => {
+  const childrenValue = useMemo37(() => {
     let startFrame = 0;
     const flattenedChildren = flattenChildren(props2.children);
     return Children.map(flattenedChildren, (child, i) => {
@@ -14746,7 +14830,7 @@ var VideoForRenderingForwardFunction = ({
   const frame = useCurrentFrame();
   const volumePropsFrame = useFrameForVolumeProp(loopVolumeCurveBehavior ?? "repeat");
   const videoConfig = useUnsafeVideoConfig();
-  const videoRef = useRef23(null);
+  const videoRef = useRef24(null);
   const sequenceContext = useContext36(SequenceContext);
   const mediaStartsAt = useMediaStartsAt();
   const environment = useRemotionEnvironment();
@@ -14754,7 +14838,7 @@ var VideoForRenderingForwardFunction = ({
   const mountTime = useMountTime();
   const { delayRender: delayRender2, continueRender: continueRender2 } = useDelayRender();
   const { registerRenderAsset, unregisterRenderAsset } = useContext36(RenderAssetManager);
-  const id = useMemo37(() => `video-${random(props2.src ?? "")}-${sequenceContext?.cumulatedFrom}-${sequenceContext?.relativeFrom}-${sequenceContext?.durationInFrames}`, [
+  const id = useMemo38(() => `video-${random(props2.src ?? "")}-${sequenceContext?.cumulatedFrom}-${sequenceContext?.relativeFrom}-${sequenceContext?.durationInFrames}`, [
     props2.src,
     sequenceContext?.cumulatedFrom,
     sequenceContext?.relativeFrom,
@@ -14971,10 +15055,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 = useCallback20((src, durationInSeconds) => {
+  const onDuration = useCallback22((src, durationInSeconds) => {
     setDurations({ type: "got-duration", durationInSeconds, src });
   }, [setDurations]);
-  const onVideoFrame = useCallback20(() => {}, []);
+  const onVideoFrame = useCallback22(() => {}, []);
   const durationFetched = durations[getAbsoluteSrc(preloadedSrc)] ?? durations[getAbsoluteSrc(props2.src)];
   validateMediaTrimProps({ startFrom, endAt, trimBefore, trimAfter });
   const { trimBeforeValue, trimAfterValue } = resolveTrimProps({
@@ -15082,7 +15166,7 @@ addSequenceStackTraces(Composition);
 // ../design/dist/esm/index.mjs
 import { jsx as jsx210, Fragment as Fragment3 } from "react/jsx-runtime";
 import { jsx as jsx39, jsxs as jsxs5 } from "react/jsx-runtime";
-import { useEffect as useEffect22, useMemo as useMemo210, useRef as useRef25 } from "react";
+import { useEffect as useEffect22, useMemo as useMemo210, useRef as useRef26 } from "react";
 import { jsx as jsx44 } from "react/jsx-runtime";
 import { jsx as jsx53, jsxs as jsxs23 } from "react/jsx-runtime";
 import React62 from "react";
@@ -15109,8 +15193,8 @@ import * as React16 from "react";
 import * as React13 from "react";
 import * as ReactDOM from "react-dom";
 import { jsx as jsx172 } from "react/jsx-runtime";
-import * as React14 from "react";
-import * as React152 from "react";
+import * as React142 from "react";
+import * as React15 from "react";
 import { jsx as jsx182 } from "react/jsx-runtime";
 import * as React172 from "react";
 import * as React18 from "react";
@@ -15134,8 +15218,8 @@ import * as React282 from "react";
 import { jsx as jsx233 } from "react/jsx-runtime";
 import * as React35 from "react";
 import * as React312 from "react";
-import * as React292 from "react";
 import { useState as useState112 } from "react";
+import * as React292 from "react";
 import * as React30 from "react";
 import * as React342 from "react";
 import * as React332 from "react";
@@ -15336,7 +15420,7 @@ var useHoverTransforms = (ref, disabled) => {
     progress: 0,
     isActive: false
   });
-  const eventTarget = useMemo38(() => new EventTarget, []);
+  const eventTarget = useMemo39(() => new EventTarget, []);
   useEffect20(() => {
     if (disabled) {
       eventTarget.dispatchEvent(new Event("disabled"));
@@ -15483,7 +15567,7 @@ var getAngle = (ref, coordinates) => {
 };
 var lastCoordinates = null;
 var useMousePosition = (ref) => {
-  const [angle, setAngle] = useState23(getAngle(ref.current, lastCoordinates));
+  const [angle, setAngle] = useState21(getAngle(ref.current, lastCoordinates));
   useEffect20(() => {
     const element = ref.current;
     if (!element) {
@@ -15604,7 +15688,7 @@ var Spinner = ({ size, duration }) => {
       height: size
     };
   }, [size]);
-  const pathsRef = useRef25([]);
+  const pathsRef = useRef26([]);
   useEffect22(() => {
     const animate = () => {
       const now = performance.now();
@@ -15650,9 +15734,9 @@ var Button = ({
   ...rest
 }) => {
   const [dimensions, setDimensions] = useState22(null);
-  const ref = useRef24(null);
+  const ref = useRef25(null);
   const { isActive, progress } = useHoverTransforms(ref, Boolean(disabled || loading));
-  const onPointerEnter = useCallback22((e) => {
+  const onPointerEnter = useCallback24((e) => {
     if (e.pointerType !== "mouse") {
       return;
     }
@@ -15689,7 +15773,7 @@ var Button = ({
   const isDisabled = disabled || loading;
   const isAnchor = !asChild && "href" in rest && rest.href !== undefined;
   const sharedClasses = cn("text-text", "inline-flex", "justify-center", "bg-button-bg", "items-center", "font-brand", "border-solid", "text-[1em]", "rounded-lg", "border-black", "border-2", "border-b-4", "cursor-pointer", "px-4", "h-12", "flex-row", "items-center", "relative", "overflow-hidden", isDisabled && "cursor-default opacity-50", className);
-  const preventInteraction = useCallback22((e) => {
+  const preventInteraction = useCallback24((e) => {
     e.preventDefault();
     e.stopPropagation();
   }, []);
@@ -16164,15 +16248,15 @@ function dispatchDiscreteCustomEvent(target, event) {
     ReactDOM.flushSync(() => target.dispatchEvent(event));
 }
 function useCallbackRef(callback) {
-  const callbackRef = React14.useRef(callback);
-  React14.useEffect(() => {
+  const callbackRef = React142.useRef(callback);
+  React142.useEffect(() => {
     callbackRef.current = callback;
   });
-  return React14.useMemo(() => (...args) => callbackRef.current?.(...args), []);
+  return React142.useMemo(() => (...args) => callbackRef.current?.(...args), []);
 }
 function useEscapeKeydown(onEscapeKeyDownProp, ownerDocument = globalThis?.document) {
   const onEscapeKeyDown = useCallbackRef(onEscapeKeyDownProp);
-  React152.useEffect(() => {
+  React15.useEffect(() => {
     const handleKeyDown = (event) => {
       if (event.key === "Escape") {
         onEscapeKeyDown(event);
@@ -18890,7 +18974,7 @@ var hideOthers = function(originalTarget, parentNode, markerName) {
   return applyAttributeToOthers(targets, activeParentNode, markerName, "aria-hidden");
 };
 var __assign = function() {
-  __assign = Object.assign || function __assign2(t) {
+  __assign = Object.assign || function __assign(t) {
     for (var s, i = 1, n = arguments.length;i < n; i++) {
       s = arguments[i];
       for (var p in s)
@@ -20677,17 +20761,17 @@ function createContextScope2(scopeName, createContextScopeDeps = []) {
   let defaultContexts = [];
   function createContext32(rootComponentName, defaultContext) {
     const BaseContext = React382.createContext(defaultContext);
-    const index3 = defaultContexts.length;
+    const index2 = defaultContexts.length;
     defaultContexts = [...defaultContexts, defaultContext];
     const Provider = (props) => {
       const { scope, children, ...context } = props;
-      const Context = scope?.[scopeName]?.[index3] || BaseContext;
+      const Context = scope?.[scopeName]?.[index2] || BaseContext;
       const value = React382.useMemo(() => context, Object.values(context));
       return /* @__PURE__ */ jsx272(Context.Provider, { value, children });
     };
     Provider.displayName = rootComponentName + "Provider";
     function useContext222(consumerName, scope) {
-      const Context = scope?.[scopeName]?.[index3] || BaseContext;
+      const Context = scope?.[scopeName]?.[index2] || BaseContext;
       const context = React382.useContext(Context);
       if (context)
         return context;
@@ -20884,10 +20968,10 @@ var OrderedDict = class _OrderedDict extends Map {
     super.set(key, value);
     return this;
   }
-  insert(index3, key, value) {
+  insert(index2, key, value) {
     const has = this.has(key);
     const length2 = this.#keys.length;
-    const relativeIndex = toSafeInteger(index3);
+    const relativeIndex = toSafeInteger(index2);
     let actualIndex = relativeIndex >= 0 ? relativeIndex : length2 + relativeIndex;
     const safeIndex = actualIndex < 0 || actualIndex >= length2 ? -1 : actualIndex;
     if (safeIndex === this.size || has && safeIndex === this.size - 1 || safeIndex === -1) {
@@ -20925,39 +21009,39 @@ var OrderedDict = class _OrderedDict extends Map {
     }
     return this;
   }
-  with(index3, key, value) {
+  with(index2, key, value) {
     const copy = new _OrderedDict(this);
-    copy.insert(index3, key, value);
+    copy.insert(index2, key, value);
     return copy;
   }
   before(key) {
-    const index3 = this.#keys.indexOf(key) - 1;
-    if (index3 < 0) {
+    const index2 = this.#keys.indexOf(key) - 1;
+    if (index2 < 0) {
       return;
     }
-    return this.entryAt(index3);
+    return this.entryAt(index2);
   }
   setBefore(key, newKey, value) {
-    const index3 = this.#keys.indexOf(key);
-    if (index3 === -1) {
+    const index2 = this.#keys.indexOf(key);
+    if (index2 === -1) {
       return this;
     }
-    return this.insert(index3, newKey, value);
+    return this.insert(index2, newKey, value);
   }
   after(key) {
-    let index3 = this.#keys.indexOf(key);
-    index3 = index3 === -1 || index3 === this.size - 1 ? -1 : index3 + 1;
-    if (index3 === -1) {
+    let index2 = this.#keys.indexOf(key);
+    index2 = index2 === -1 || index2 === this.size - 1 ? -1 : index2 + 1;
+    if (index2 === -1) {
       return;
     }
-    return this.entryAt(index3);
+    return this.entryAt(index2);
   }
   setAfter(key, newKey, value) {
-    const index3 = this.#keys.indexOf(key);
-    if (index3 === -1) {
+    const index2 = this.#keys.indexOf(key);
+    if (index2 === -1) {
       return this;
     }
-    return this.insert(index3 + 1, newKey, value);
+    return this.insert(index2 + 1, newKey, value);
   }
   first() {
     return this.entryAt(0);
@@ -20976,21 +21060,21 @@ var OrderedDict = class _OrderedDict extends Map {
     }
     return deleted;
   }
-  deleteAt(index3) {
-    const key = this.keyAt(index3);
+  deleteAt(index2) {
+    const key = this.keyAt(index2);
     if (key !== undefined) {
       return this.delete(key);
     }
     return false;
   }
-  at(index3) {
-    const key = at(this.#keys, index3);
+  at(index2) {
+    const key = at(this.#keys, index2);
     if (key !== undefined) {
       return this.get(key);
     }
   }
-  entryAt(index3) {
-    const key = at(this.#keys, index3);
+  entryAt(index2) {
+    const key = at(this.#keys, index2);
     if (key !== undefined) {
       return [key, this.get(key)];
     }
@@ -20998,15 +21082,15 @@ var OrderedDict = class _OrderedDict extends Map {
   indexOf(key) {
     return this.#keys.indexOf(key);
   }
-  keyAt(index3) {
-    return at(this.#keys, index3);
+  keyAt(index2) {
+    return at(this.#keys, index2);
   }
   from(key, offset4) {
-    const index3 = this.indexOf(key);
-    if (index3 === -1) {
+    const index2 = this.indexOf(key);
+    if (index2 === -1) {
       return;
     }
-    let dest = index3 + offset4;
+    let dest = index2 + offset4;
     if (dest < 0)
       dest = 0;
     if (dest >= this.size)
@@ -21014,11 +21098,11 @@ var OrderedDict = class _OrderedDict extends Map {
     return this.at(dest);
   }
   keyFrom(key, offset4) {
-    const index3 = this.indexOf(key);
-    if (index3 === -1) {
+    const index2 = this.indexOf(key);
+    if (index2 === -1) {
       return;
     }
-    let dest = index3 + offset4;
+    let dest = index2 + offset4;
     if (dest < 0)
       dest = 0;
     if (dest >= this.size)
@@ -21026,68 +21110,68 @@ var OrderedDict = class _OrderedDict extends Map {
     return this.keyAt(dest);
   }
   find(predicate, thisArg) {
-    let index3 = 0;
+    let index2 = 0;
     for (const entry of this) {
-      if (Reflect.apply(predicate, thisArg, [entry, index3, this])) {
+      if (Reflect.apply(predicate, thisArg, [entry, index2, this])) {
         return entry;
       }
-      index3++;
+      index2++;
     }
     return;
   }
   findIndex(predicate, thisArg) {
-    let index3 = 0;
+    let index2 = 0;
     for (const entry of this) {
-      if (Reflect.apply(predicate, thisArg, [entry, index3, this])) {
-        return index3;
+      if (Reflect.apply(predicate, thisArg, [entry, index2, this])) {
+        return index2;
       }
-      index3++;
+      index2++;
     }
     return -1;
   }
   filter(predicate, thisArg) {
     const entries = [];
-    let index3 = 0;
+    let index2 = 0;
     for (const entry of this) {
-      if (Reflect.apply(predicate, thisArg, [entry, index3, this])) {
+      if (Reflect.apply(predicate, thisArg, [entry, index2, this])) {
         entries.push(entry);
       }
-      index3++;
+      index2++;
     }
     return new _OrderedDict(entries);
   }
   map(callbackfn, thisArg) {
     const entries = [];
-    let index3 = 0;
+    let index2 = 0;
     for (const entry of this) {
-      entries.push([entry[0], Reflect.apply(callbackfn, thisArg, [entry, index3, this])]);
-      index3++;
+      entries.push([entry[0], Reflect.apply(callbackfn, thisArg, [entry, index2, this])]);
+      index2++;
     }
     return new _OrderedDict(entries);
   }
   reduce(...args) {
     const [callbackfn, initialValue] = args;
-    let index3 = 0;
+    let index2 = 0;
     let accumulator = initialValue ?? this.at(0);
     for (const entry of this) {
-      if (index3 === 0 && args.length === 1) {
+      if (index2 === 0 && args.length === 1) {
         accumulator = entry;
       } else {
-        accumulator = Reflect.apply(callbackfn, this, [accumulator, entry, index3, this]);
+        accumulator = Reflect.apply(callbackfn, this, [accumulator, entry, index2, this]);
       }
-      index3++;
+      index2++;
     }
     return accumulator;
   }
   reduceRight(...args) {
     const [callbackfn, initialValue] = args;
     let accumulator = initialValue ?? this.at(-1);
-    for (let index3 = this.size - 1;index3 >= 0; index3--) {
-      const entry = this.at(index3);
-      if (index3 === this.size - 1 && args.length === 1) {
+    for (let index2 = this.size - 1;index2 >= 0; index2--) {
+      const entry = this.at(index2);
+      if (index2 === this.size - 1 && args.length === 1) {
         accumulator = entry;
       } else {
-        accumulator = Reflect.apply(callbackfn, this, [accumulator, entry, index3, this]);
+        accumulator = Reflect.apply(callbackfn, this, [accumulator, entry, index2, this]);
       }
     }
     return accumulator;
@@ -21098,8 +21182,8 @@ var OrderedDict = class _OrderedDict extends Map {
   }
   toReversed() {
     const reversed = new _OrderedDict;
-    for (let index3 = this.size - 1;index3 >= 0; index3--) {
-      const key = this.keyAt(index3);
+    for (let index2 = this.size - 1;index2 >= 0; index2--) {
+      const key = this.keyAt(index2);
       const element = this.get(key);
       reversed.set(key, element);
     }
@@ -21122,44 +21206,44 @@ var OrderedDict = class _OrderedDict extends Map {
     if (end !== undefined && end > 0) {
       stop = end - 1;
     }
-    for (let index3 = start;index3 <= stop; index3++) {
-      const key = this.keyAt(index3);
+    for (let index2 = start;index2 <= stop; index2++) {
+      const key = this.keyAt(index2);
       const element = this.get(key);
       result.set(key, element);
     }
     return result;
   }
   every(predicate, thisArg) {
-    let index3 = 0;
+    let index2 = 0;
     for (const entry of this) {
-      if (!Reflect.apply(predicate, thisArg, [entry, index3, this])) {
+      if (!Reflect.apply(predicate, thisArg, [entry, index2, this])) {
         return false;
       }
-      index3++;
+      index2++;
     }
     return true;
   }
   some(predicate, thisArg) {
-    let index3 = 0;
+    let index2 = 0;
     for (const entry of this) {
-      if (Reflect.apply(predicate, thisArg, [entry, index3, this])) {
+      if (Reflect.apply(predicate, thisArg, [entry, index2, this])) {
         return true;
       }
-      index3++;
+      index2++;
     }
     return false;
   }
 };
-function at(array, index3) {
+function at(array, index2) {
   if ("at" in Array.prototype) {
-    return Array.prototype.at.call(array, index3);
+    return Array.prototype.at.call(array, index2);
   }
-  const actualIndex = toSafeIndex(array, index3);
+  const actualIndex = toSafeIndex(array, index2);
   return actualIndex === -1 ? undefined : array[actualIndex];
 }
-function toSafeIndex(array, index3) {
+function toSafeIndex(array, index2) {
   const length2 = array.length;
-  const relativeIndex = toSafeInteger(index3);
+  const relativeIndex = toSafeInteger(index2);
   const actualIndex = relativeIndex >= 0 ? relativeIndex : length2 + relativeIndex;
   return actualIndex < 0 || actualIndex >= length2 ? -1 : actualIndex;
 }
@@ -21211,7 +21295,7 @@ var Primitive2 = NODES2.reduce((primitive, node) => {
   Node2.displayName = `Primitive.${node}`;
   return { ...primitive, [node]: Node2 };
 }, {});
-function useCallbackRef4(callback) {
+function useCallbackRef3(callback) {
   const callbackRef = React44.useRef(callback);
   React44.useEffect(() => {
     callbackRef.current = callback;
@@ -21315,7 +21399,7 @@ var RovingFocusGroupImpl = React47.forwardRef((props, forwardedRef) => {
     caller: GROUP_NAME2
   });
   const [isTabbingBackOut, setIsTabbingBackOut] = React47.useState(false);
-  const handleEntryFocus = useCallbackRef4(onEntryFocus);
+  const handleEntryFocus = useCallbackRef3(onEntryFocus);
   const getItems = useCollection2(__scopeRovingFocusGroup);
   const isClickFocusRef = React47.useRef(false);
   const [focusableItemsCount, setFocusableItemsCount] = React47.useState(0);
@@ -21468,7 +21552,7 @@ function focusFirst2(candidates, preventScroll = false) {
   }
 }
 function wrapArray2(array, startIndex) {
-  return array.map((_, index3) => array[(startIndex + index3) % array.length]);
+  return array.map((_, index2) => array[(startIndex + index2) % array.length]);
 }
 var Root3 = RovingFocusGroup;
 var Item2 = RovingFocusGroupItem;