remotion 4.0.506 → 4.0.508

package/dist/esm/index.mjs

@@ -517,6 +517,24 @@ var Loading = () => {
 
 // src/portal-node.ts
 var _portalNode = null;
+var portalNodeCurrentScale = 1;
+var portalNodeCurrentScaleListeners = [];
+var getPortalNodeCurrentScale = () => portalNodeCurrentScale;
+var subscribeToPortalNodeCurrentScale = (listener) => {
+  portalNodeCurrentScaleListeners.push(listener);
+  return () => {
+    portalNodeCurrentScaleListeners = portalNodeCurrentScaleListeners.filter((currentListener) => currentListener !== listener);
+  };
+};
+var setPortalNodeCurrentScale = (scale) => {
+  if (portalNodeCurrentScale === scale) {
+    return;
+  }
+  portalNodeCurrentScale = scale;
+  for (const listener of portalNodeCurrentScaleListeners) {
+    listener();
+  }
+};
 var portalNode = () => {
   if (!_portalNode) {
     if (typeof document === "undefined") {
@@ -1322,7 +1340,7 @@ var getSingleChildComponent = (children) => {
 };
 
 // src/version.ts
-var VERSION = "4.0.506";
+var VERSION = "4.0.508";
 
 // src/multiple-versions-warning.ts
 var checkMultipleRemotionVersions = () => {
@@ -1924,7 +1942,15 @@ var backgroundSchema = {
     description: "Color"
   }
 };
+var svgColorSchema = {
+  color: {
+    type: "color",
+    default: undefined,
+    description: "Current color"
+  }
+};
 var svgStrokeSchema = {
+  ...svgColorSchema,
   stroke: {
     type: "color",
     default: "none",
@@ -2217,6 +2243,9 @@ var VisualModeSettersContext = React12.createContext({
   },
   setPropStatuses: () => {
     throw new Error("VisualModeSettersContext not initialized");
+  },
+  remapPropStatuses: () => {
+    throw new Error("VisualModeSettersContext not initialized");
   }
 });
 var effectDragOverridesKey = (nodePath, effectIndex) => `${makeSequencePropsSubscriptionKey(nodePath)}.effects.${effectIndex}`;
@@ -2285,6 +2314,20 @@ var SequenceManagerProvider = ({ children }) => {
       return { ...prev, [key]: newKey };
     });
   }, []);
+  const remapPropStatuses = useCallback5((remappings) => {
+    setPropStatusesMapState((prev) => {
+      const next = { ...prev };
+      for (const remapping of remappings) {
+        delete next[makeSequencePropsSubscriptionKey(remapping.previousNodePath)];
+      }
+      for (const remapping of remappings) {
+        if (remapping.nodePath !== null && remapping.result !== null) {
+          next[makeSequencePropsSubscriptionKey(remapping.nodePath)] = remapping.result;
+        }
+      }
+      return next;
+    });
+  }, []);
   const registerSequence = useCallback5((seq) => {
     setSequences((seqs) => {
       return [...seqs, seq];
@@ -2323,14 +2366,16 @@ var SequenceManagerProvider = ({ children }) => {
       clearDragOverrides,
       setEffectDragOverrides,
       clearEffectDragOverrides,
-      setPropStatuses
+      setPropStatuses,
+      remapPropStatuses
     };
   }, [
     setDragOverrides,
     clearDragOverrides,
     setEffectDragOverrides,
     clearEffectDragOverrides,
-    setPropStatuses
+    setPropStatuses,
+    remapPropStatuses
   ]);
   return /* @__PURE__ */ jsx10(SequenceManagerRefContext.Provider, {
     value: sequencesRef,
@@ -2790,9 +2835,45 @@ var parseTransformOriginValue = (output, parts) => {
   });
   return {
     kind: "translate",
-    values: [x.value, y.value, z.value],
-    units: [x.unit, y.unit, z.unit],
-    dimensions: parts[2] === undefined ? 2 : 3
+    values: [x.value, y.value, z.value, 0],
+    units: [x.unit, y.unit, z.unit, null],
+    dimensions: parts[2] === undefined ? 2 : 3,
+    axisRotation: false
+  };
+};
+var parseAxisRotationValue = (output) => {
+  const parts = output.trim().split(/\s+/);
+  const keywordAxis = parts.length === 2 ? parts[0].toLowerCase() : null;
+  if (keywordAxis === "x" || keywordAxis === "y" || keywordAxis === "z") {
+    const keywordAngle = parseStringInterpolationComponent(parts[1], output);
+    if (keywordAngle.kind !== "rotate") {
+      return null;
+    }
+    return {
+      kind: "rotate",
+      values: keywordAxis === "x" ? [1, 0, 0, keywordAngle.value] : keywordAxis === "y" ? [0, 1, 0, keywordAngle.value] : [0, 0, 1, keywordAngle.value],
+      units: [null, null, null, keywordAngle.unit],
+      dimensions: 4,
+      axisRotation: true
+    };
+  }
+  if (parts.length !== 4) {
+    return null;
+  }
+  const axis = parts.slice(0, 3).map(Number);
+  if (!axis.every(Number.isFinite)) {
+    return null;
+  }
+  const vectorAngle = parseStringInterpolationComponent(parts[3], output);
+  if (vectorAngle.kind !== "rotate") {
+    return null;
+  }
+  return {
+    kind: "rotate",
+    values: [axis[0], axis[1], axis[2], vectorAngle.value],
+    units: [null, null, null, vectorAngle.unit],
+    dimensions: 4,
+    axisRotation: true
   };
 };
 var parseStringInterpolationValue = (output) => {
@@ -2802,11 +2883,16 @@ var parseStringInterpolationValue = (output) => {
     }
     return {
       kind: "scale",
-      values: [output, output, 1],
-      units: [null, null, null],
-      dimensions: 1
+      values: [output, output, 1, 0],
+      units: [null, null, null, null],
+      dimensions: 1,
+      axisRotation: false
     };
   }
+  const axisRotation = parseAxisRotationValue(output);
+  if (axisRotation !== null) {
+    return axisRotation;
+  }
   const parts = output.trim().split(/\s+/);
   if (parts.length < 1 || parts.length > 3 || parts[0] === "") {
     throw new TypeError(`String outputRange values must contain 1 to 3 components, but got "${output}"`);
@@ -2827,24 +2913,35 @@ var parseStringInterpolationValue = (output) => {
     const z = parsed[2]?.value ?? 1;
     return {
       kind,
-      values: [x, y, z],
-      units: [null, null, null],
-      dimensions: parsed.length
+      values: [x, y, z, 0],
+      units: [null, null, null, null],
+      dimensions: parsed.length,
+      axisRotation: false
     };
   }
   return {
     kind,
-    values: [parsed[0].value, parsed[1]?.value ?? 0, parsed[2]?.value ?? 0],
-    units: [parsed[0].unit, parsed[1]?.unit ?? null, parsed[2]?.unit ?? null],
-    dimensions: parsed.length
+    values: [parsed[0].value, parsed[1]?.value ?? 0, parsed[2]?.value ?? 0, 0],
+    units: [
+      parsed[0].unit,
+      parsed[1]?.unit ?? null,
+      parsed[2]?.unit ?? null,
+      null
+    ],
+    dimensions: parsed.length,
+    axisRotation: false
   };
 };
 var serializeStringInterpolationValue = ({
   kind,
   values,
   units,
-  dimensions
+  dimensions,
+  axisRotation
 }) => {
+  if (axisRotation) {
+    return `${stringifyNumber(values[0])} ${stringifyNumber(values[1])} ${stringifyNumber(values[2])} ${stringifyNumber(values[3])}${units[3]}`;
+  }
   if (kind === "scale") {
     return values.slice(0, dimensions).map((value) => stringifyNumber(value)).join(" ");
   }
@@ -3012,7 +3109,26 @@ var interpolateString = ({
   outputRange,
   options
 }) => {
-  const parsedOutputRange = outputRange.map(parseStringInterpolationValue);
+  const initiallyParsedOutputRange = outputRange.map(parseStringInterpolationValue);
+  const hasAxisRotation = initiallyParsedOutputRange.some((parsed) => parsed.axisRotation);
+  const parsedOutputRange = hasAxisRotation ? initiallyParsedOutputRange.map((parsed) => {
+    if (parsed.kind !== "rotate") {
+      return parsed;
+    }
+    if (parsed.axisRotation) {
+      return parsed;
+    }
+    if (parsed.dimensions !== 1) {
+      throw new TypeError("Cannot interpolate a multi-angle rotate value with an axis rotation");
+    }
+    return {
+      kind: "rotate",
+      values: [0, 0, 1, parsed.values[0]],
+      units: [null, null, null, parsed.units[0]],
+      dimensions: 4,
+      axisRotation: true
+    };
+  }) : initiallyParsedOutputRange;
   const kind = parsedOutputRange[0]?.kind;
   if (kind === undefined) {
     throw new Error("outputRange must have at least 1 element");
@@ -3024,12 +3140,16 @@ var interpolateString = ({
   }
   const dimensions = Math.max(...parsedOutputRange.map((parsed) => parsed.dimensions));
   const units = [
+    null,
     null,
     null,
     null
   ];
   if (kind !== "scale") {
     for (let axis = 0;axis < dimensions; axis++) {
+      if (hasAxisRotation && axis < 3) {
+        continue;
+      }
       for (const parsed of parsedOutputRange) {
         const unit = parsed.units[axis];
         if (unit === null) {
@@ -3048,7 +3168,7 @@ var interpolateString = ({
       }
     }
   }
-  const values = [0, 0, 0];
+  const values = [0, 0, 0, 0];
   for (let axis = 0;axis < dimensions; axis++) {
     values[axis] = interpolateNumber({
       input,
@@ -3061,7 +3181,8 @@ var interpolateString = ({
     kind,
     values,
     units,
-    dimensions
+    dimensions,
+    axisRotation: hasAxisRotation
   });
 };
 var validateTupleOutputRange = (outputRange) => {
@@ -4076,6 +4197,8 @@ var easingToFn = ({
   switch (easing.type) {
     case "linear":
       return Easing.linear;
+    case "step1":
+      return Easing.step1;
     case "spring":
       return Easing.spring({
         allowTail: forceSpringAllowTail ?? easing.allowTail ?? undefined,
@@ -4689,7 +4812,8 @@ var withInteractivitySchema = ({
     } = props;
     const cleanProps = propsWithoutInternalStack;
     const env = useRemotionEnvironment();
-    if (!env.isStudio || env.isRendering) {
+    const canUseRemotionHooks = useContext17(CanUseRemotionHooks);
+    if (!env.isStudio || env.isRendering || !canUseRemotionHooks) {
       return React14.createElement(Component, {
         ...cleanProps,
         controls: null,
@@ -7139,24 +7263,56 @@ var useSingletonAudioContext = ({
 };
 
 // src/audio/wait-until-actually-resumed.ts
-var waitUntilActuallyResumed = (audioContext, logLevel) => {
+var RESUME_WAIT_TIMEOUT = 1000;
+var waitUntilActuallyResumed = (audioContext, logLevel, signal) => {
   return new Promise((resolve) => {
     const startCurrentTime = audioContext.currentTime;
     const start = audioContext.getOutputTimestamp();
     const startOutputPerformanceTime = start.performanceTime;
     const startWallClock = performance.now();
+    let animationFrame = null;
+    let timeout = null;
+    let settled = false;
+    let onAbort = () => {
+      return;
+    };
+    const finish = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (animationFrame !== null) {
+        cancelAnimationFrame(animationFrame);
+      }
+      if (timeout !== null) {
+        clearTimeout(timeout);
+      }
+      signal.removeEventListener("abort", onAbort);
+      resolve(result);
+    };
+    onAbort = () => finish("cancelled");
     const check = () => {
+      animationFrame = null;
       const { currentTime } = audioContext;
       const outputTimestamp = audioContext.getOutputTimestamp();
       const elapsedWallClock = performance.now() - startWallClock;
       if (startOutputPerformanceTime !== undefined && outputTimestamp.performanceTime !== undefined && outputTimestamp.performanceTime > startOutputPerformanceTime && outputTimestamp.contextTime !== undefined && outputTimestamp.contextTime > startCurrentTime) {
         Log.verbose({ logLevel, tag: "audio" }, `waitUntilActuallyResumed: getOutputTimestamp.performanceTime advanced from ${startOutputPerformanceTime.toFixed(6)} to ${outputTimestamp.performanceTime.toFixed(6)} after ${elapsedWallClock.toFixed(1)}ms. currentTime=${currentTime.toFixed(6)} (advanced by ${(currentTime - startCurrentTime).toFixed(6)}), getOutputTimestamp.performanceTime=${outputTimestamp.performanceTime?.toFixed(1) ?? "undefined"}`);
-        resolve();
+        finish("resumed");
         return;
       }
-      requestAnimationFrame(check);
+      animationFrame = requestAnimationFrame(check);
     };
-    requestAnimationFrame(check);
+    if (signal.aborted) {
+      finish("cancelled");
+      return;
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+    timeout = setTimeout(() => {
+      Log.warn({ logLevel, tag: "audio" }, "WARNING: You enabled autoPlay on an unmuted <Player /> and the browser did not allow the video to be started. Remotion muted the <Player /> so it can play. To properly handle this, either set the `muted` prop or remove the `autoPlay` prop");
+      finish("failed");
+    }, RESUME_WAIT_TIMEOUT);
+    animationFrame = requestAnimationFrame(check);
   });
 };
 
@@ -7216,6 +7372,7 @@ var SharedAudioContextProvider = ({ children, audioLatencyHint, audioEnabled, pr
   });
   const audioContextIsPlayingEventually = useRef13(false);
   const isResuming = useRef13(null);
+  const nextResumeAttemptId = useRef13(0);
   const audioSyncAnchor = useMemo23(() => ({ value: 0 }), []);
   const audioSyncAnchorListeners = useRef13([]);
   const audioSyncAnchorEmitter = useMemo23(() => {
@@ -7306,21 +7463,32 @@ var SharedAudioContextProvider = ({ children, audioLatencyHint, audioEnabled, pr
     });
     nodesToResume.current.clear();
     const resumePromise = ctxAndGain.resume();
-    isResuming.current = new Promise((resolve) => {
-      waitUntilActuallyResumed(ctxAndGain.audioContext, logLevel).then(resolve);
+    const abortController = new AbortController;
+    const resumeAttemptId = nextResumeAttemptId.current++;
+    const waitPromise = new Promise((resolve) => {
+      waitUntilActuallyResumed(ctxAndGain.audioContext, logLevel, abortController.signal).then(resolve);
       resumePromise.catch((err) => {
-        Log.warn({ logLevel, tag: "audio" }, "AudioContext resume rejected, continuing without audio sync", err);
-        resolve();
+        Log.warn({ logLevel, tag: "audio" }, "AudioContext resume rejected, muting playback and continuing without audio", err);
+        abortController.abort();
+        resolve("failed");
       });
     }).finally(() => {
-      isResuming.current = null;
+      if (isResuming.current?.id === resumeAttemptId) {
+        isResuming.current = null;
+      }
     });
+    isResuming.current = {
+      abortController,
+      id: resumeAttemptId,
+      promise: waitPromise
+    };
     return resumePromise.catch(() => {});
   }, [ctxAndGain, logLevel]);
   const getIsResumingAudioContext = useCallback10(() => {
-    return isResuming.current;
+    return isResuming.current?.promise ?? null;
   }, []);
   const suspend = useCallback10(() => {
+    isResuming.current?.abortController.abort();
     if (!ctxAndGain) {
       return Promise.resolve();
     }
@@ -8088,8 +8256,8 @@ import React22, {
 import { jsx as jsx21 } from "react/jsx-runtime";
 var useBufferManager = (logLevel, mountTime) => {
   const [blocks, setBlocks] = useState12([]);
-  const [onBufferingCallbacks, setOnBufferingCallbacks] = useState12([]);
-  const [onResumeCallbacks, setOnResumeCallbacks] = useState12([]);
+  const onBufferingCallbacks = useRef16([]);
+  const onResumeCallbacks = useRef16([]);
   const env = useRemotionEnvironment();
   const rendering = env.isRendering;
   const buffering = useRef16(false);
@@ -8120,18 +8288,21 @@ var useBufferManager = (logLevel, mountTime) => {
     };
   }, [rendering]);
   const listenForBuffering = useCallback11((callback) => {
-    setOnBufferingCallbacks((c2) => [...c2, callback]);
+    onBufferingCallbacks.current = [
+      ...onBufferingCallbacks.current,
+      callback
+    ];
     return {
       remove: () => {
-        setOnBufferingCallbacks((c2) => c2.filter((cb) => cb !== callback));
+        onBufferingCallbacks.current = onBufferingCallbacks.current.filter((cb) => cb !== callback);
       }
     };
   }, []);
   const listenForResume = useCallback11((callback) => {
-    setOnResumeCallbacks((c2) => [...c2, callback]);
+    onResumeCallbacks.current = [...onResumeCallbacks.current, callback];
     return {
       remove: () => {
-        setOnResumeCallbacks((c2) => c2.filter((cb) => cb !== callback));
+        onResumeCallbacks.current = onResumeCallbacks.current.filter((cb) => cb !== callback);
       }
     };
   }, []);
@@ -8141,7 +8312,7 @@ var useBufferManager = (logLevel, mountTime) => {
     }
     if (blocks.length > 0 && !buffering.current) {
       buffering.current = true;
-      onBufferingCallbacks.forEach((c2) => c2());
+      [...onBufferingCallbacks.current].forEach((c2) => c2());
       playbackLogging({
         logLevel,
         message: "Player is entering buffer state",
@@ -8157,7 +8328,7 @@ var useBufferManager = (logLevel, mountTime) => {
       }
       if (blocks.length === 0 && buffering.current) {
         buffering.current = false;
-        onResumeCallbacks.forEach((c2) => c2());
+        [...onResumeCallbacks.current].forEach((c2) => c2());
         playbackLogging({
           logLevel,
           message: "Player is exiting buffer state",
@@ -11649,6 +11820,50 @@ var RemotionRootContexts = ({
   });
 };
 
+// src/render-resource-manager.ts
+import React35 from "react";
+var makeRenderResourceManager = () => {
+  const resources = new Map;
+  let disposed = false;
+  return {
+    getOrCreateResource: ({
+      key,
+      create
+    }) => {
+      if (disposed) {
+        throw new Error("Render resource manager has already been disposed");
+      }
+      const existing = resources.get(key);
+      if (existing) {
+        return existing.resource;
+      }
+      const created = create();
+      resources.set(key, created);
+      return created.resource;
+    },
+    dispose: () => {
+      if (disposed) {
+        return;
+      }
+      disposed = true;
+      const resourcesToDispose = Array.from(resources.values());
+      resources.clear();
+      let firstError = null;
+      for (const resource of resourcesToDispose) {
+        try {
+          resource.dispose();
+        } catch (error2) {
+          firstError ??= error2;
+        }
+      }
+      if (firstError !== null) {
+        throw firstError;
+      }
+    }
+  };
+};
+var RenderResourceManagerContext = React35.createContext(null);
+
 // src/codec.ts
 var validCodecs = [
   "h264",
@@ -11838,8 +12053,8 @@ var resolveVideoConfigOrCatch = (params) => {
 };
 
 // src/sequence-stack-traces.ts
-import React35 from "react";
-var SequenceStackTracesUpdateContext = React35.createContext(() => {});
+import React36 from "react";
+var SequenceStackTracesUpdateContext = React36.createContext(() => {});
 
 // src/setup-env-variables.ts
 var getEnvVariables = () => {
@@ -11869,8 +12084,8 @@ var setupEnvVariables = () => {
 };
 
 // src/use-current-scale.ts
-import React36, { createContext as createContext25 } from "react";
-var CurrentScaleContext = React36.createContext(null);
+import React37, { createContext as createContext25 } from "react";
+var CurrentScaleContext = React37.createContext(null);
 var PreviewSizeContext = createContext25({
   setSize: () => {
     return;
@@ -11895,10 +12110,16 @@ var calculateScale = ({
   return Number(previewSize);
 };
 var useCurrentScale = (options) => {
-  const hasContext = React36.useContext(CurrentScaleContext);
-  const zoomContext = React36.useContext(PreviewSizeContext);
+  const hasContext = React37.useContext(CurrentScaleContext);
+  const zoomContext = React37.useContext(PreviewSizeContext);
   const config = useUnsafeVideoConfig();
   const env = useRemotionEnvironment();
+  const [portalScale, setPortalScale] = React37.useState(getPortalNodeCurrentScale);
+  React37.useEffect(() => {
+    const update = () => setPortalScale(getPortalNodeCurrentScale());
+    update();
+    return subscribeToPortalNodeCurrentScale(update);
+  }, []);
   if (hasContext === null || config === null || zoomContext === null) {
     if (options?.dontThrowIfOutsideOfRemotion) {
       return 1;
@@ -11917,17 +12138,12 @@ var useCurrentScale = (options) => {
   if (hasContext.type === "scale") {
     return hasContext.scale;
   }
-  return calculateScale({
-    canvasSize: hasContext.canvasSizeForAuto,
-    compositionHeight: config.height,
-    compositionWidth: config.width,
-    previewSize: zoomContext.size.size
-  });
+  return portalScale;
 };
 
 // src/use-pixel-density.ts
-import React37, { useContext as useContext36 } from "react";
-var PixelDensityContext = React37.createContext(null);
+import React38, { useContext as useContext36 } from "react";
+var PixelDensityContext = React38.createContext(null);
 var getBrowserPixelDensity = () => {
   if (typeof window === "undefined") {
     return 1;
@@ -12181,7 +12397,7 @@ var OffthreadVideoForRendering = ({
 };
 
 // src/video/VideoForPreview.tsx
-import React39, {
+import React40, {
   forwardRef as forwardRef13,
   useCallback as useCallback24,
   useContext as useContext38,
@@ -12254,7 +12470,7 @@ var VideoForDevelopmentRefForwardingFunction = (props2, ref) => {
       ref: videoRef
     });
   }, [context.audioContext]);
-  const effectToUse = React39.useInsertionEffect ?? React39.useLayoutEffect;
+  const effectToUse = React40.useInsertionEffect ?? React40.useLayoutEffect;
   effectToUse(() => {
     return () => {
       requestAnimationFrame(() => {
@@ -12671,24 +12887,24 @@ var watchStaticFile = (fileName, callback) => {
 };
 
 // src/wrap-remotion-context.tsx
-import React41, { useMemo as useMemo39 } from "react";
+import React42, { useMemo as useMemo39 } from "react";
 import { jsx as jsx37 } from "react/jsx-runtime";
 function useRemotionContexts() {
-  const compositionManagerCtx = React41.useContext(CompositionManager);
-  const timelineContext = React41.useContext(TimelineContext);
-  const timelineImperativeContext = React41.useContext(TimelineImperativeContext);
-  const setTimelineContext = React41.useContext(SetTimelineContext);
-  const sequenceContext = React41.useContext(SequenceContext);
-  const nonceContext = React41.useContext(NonceContext);
-  const canUseRemotionHooksContext = React41.useContext(CanUseRemotionHooks);
-  const preloadContext = React41.useContext(PreloadContext);
-  const resolveCompositionContext = React41.useContext(ResolveCompositionContext);
-  const renderAssetManagerContext = React41.useContext(RenderAssetManager);
-  const sequenceManagerContext = React41.useContext(SequenceManager);
-  const sequenceManagerRefContext = React41.useContext(SequenceManagerRefContext);
-  const visualModePropStatusesRefContext = React41.useContext(VisualModePropStatusesRefContext);
-  const bufferManagerContext = React41.useContext(BufferingContextReact);
-  const logLevelContext = React41.useContext(LogLevelContext);
+  const compositionManagerCtx = React42.useContext(CompositionManager);
+  const timelineContext = React42.useContext(TimelineContext);
+  const timelineImperativeContext = React42.useContext(TimelineImperativeContext);
+  const setTimelineContext = React42.useContext(SetTimelineContext);
+  const sequenceContext = React42.useContext(SequenceContext);
+  const nonceContext = React42.useContext(NonceContext);
+  const canUseRemotionHooksContext = React42.useContext(CanUseRemotionHooks);
+  const preloadContext = React42.useContext(PreloadContext);
+  const resolveCompositionContext = React42.useContext(ResolveCompositionContext);
+  const renderAssetManagerContext = React42.useContext(RenderAssetManager);
+  const sequenceManagerContext = React42.useContext(SequenceManager);
+  const sequenceManagerRefContext = React42.useContext(SequenceManagerRefContext);
+  const visualModePropStatusesRefContext = React42.useContext(VisualModePropStatusesRefContext);
+  const bufferManagerContext = React42.useContext(BufferingContextReact);
+  const logLevelContext = React42.useContext(LogLevelContext);
   return useMemo39(() => ({
     compositionManagerCtx,
     timelineContext,
@@ -12777,6 +12993,8 @@ var RemotionContextProvider = (props2) => {
 var compositionSelectorRef = createRef3();
 var Internals = {
   MaxMediaCacheSizeContext,
+  makeRenderResourceManager,
+  RenderResourceManagerContext,
   useUnsafeVideoConfig,
   useFrameForVolumeProp,
   useTimelinePosition,
@@ -12842,6 +13060,7 @@ var Internals = {
   getPreviewDomElement,
   compositionsRef,
   portalNode,
+  setPortalNodeCurrentScale,
   waitForRoot,
   SetTimelineContext,
   CanUseRemotionHooksProvider,
@@ -12937,17 +13156,17 @@ var Internals = {
   useCropStyle
 };
 // src/series/index.tsx
-import React43, {
+import React44, {
   forwardRef as forwardRef14,
   useMemo as useMemo40
 } from "react";
 
 // src/series/flatten-children.tsx
-import React42 from "react";
+import React43 from "react";
 var flattenChildren = (children) => {
-  const childrenArray = React42.Children.toArray(children);
+  const childrenArray = React43.Children.toArray(children);
   return childrenArray.reduce((flatChildren, child) => {
-    if (child.type === React42.Fragment) {
+    if (child.type === React43.Fragment) {
       return flatChildren.concat(flattenChildren(child.props.children));
     }
     flatChildren.push(child);
@@ -13033,7 +13252,7 @@ var SeriesInner = (props2) => {
         index: i,
         childrenLength: flattenedChildren.length
       });
-      return React43.cloneElement(castedElement, {
+      return React44.cloneElement(castedElement, {
         _remotionInternalRender: (resolvedProps, ref) => {
           const durationInFramesProp = resolvedProps.durationInFrames;
           const {
@@ -13191,14 +13410,14 @@ var staticFile = (path) => {
   return preparsed;
 };
 // src/Still.tsx
-import React44 from "react";
+import React45 from "react";
 var Still = (props2) => {
   const newProps = {
     ...props2,
     durationInFrames: 1,
     fps: 1
   };
-  return React44.createElement(Composition, newProps);
+  return React45.createElement(Composition, newProps);
 };
 addSequenceStackTraces(Still);
 // src/video/html5-video.tsx