remotion 4.0.537 → 4.0.539

package/dist/cjs/effects/canvas-pool.js

@@ -16,16 +16,13 @@ const webgl2_context_error_js_1 = require("./webgl2-context-error.js");
 // contexts and backing stores as soon as the chain is torn down instead of
 // leaving that to the garbage collector.
 class CanvasPool {
-    width;
-    height;
-    pairs = new Map();
-    // Tracked individually rather than through `pairs` so that a canvas whose
-    // sibling failed to allocate still gets released.
-    allocated = [];
-    lostContexts = new Set();
-    onContextLost;
-    disposed = false;
     constructor(width, height, onContextLost) {
+        this.pairs = new Map();
+        // Tracked individually rather than through `pairs` so that a canvas whose
+        // sibling failed to allocate still gets released.
+        this.allocated = [];
+        this.lostContexts = new Set();
+        this.disposed = false;
         this.width = width;
         this.height = height;
         this.onContextLost = onContextLost;

package/dist/cjs/effects/create-curve-sampler.d.ts

@@ -0,0 +1 @@
+export declare const createCurveSampler: (points: readonly (readonly [number, number])[], interpolation: 'smooth' | 'linear') => ((input: number) => number);

package/dist/cjs/effects/create-curve-sampler.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCurveSampler = void 0;
+// Shared by the Curves renderer and Studio so the graph matches the pixels.
+// Points are validated by the effect: at least two, with increasing inputs.
+const createCurveSampler = (points, interpolation) => {
+    // Parameterize by distance along the graph so a steep segment gets room
+    // to bend, even when its input values are close together.
+    const distances = points
+        .slice(1)
+        .map((point, index) => Math.hypot(point[0] - points[index][0], point[1] - points[index][1]));
+    const tangents = points.map(() => [0, 0]);
+    if (interpolation === 'smooth' && points.length > 2) {
+        for (let axis = 0; axis < 2; axis++) {
+            const slopes = distances.map((distance, index) => (points[index + 1][axis] - points[index][axis]) / distance);
+            const curvatures = new Array(points.length).fill(0);
+            const upper = new Array(points.length).fill(0);
+            // Solve the natural cubic spline for each coordinate.
+            for (let index = 1; index < points.length - 1; index++) {
+                const diagonal = 2 * (distances[index - 1] + distances[index]) -
+                    distances[index - 1] * upper[index - 1];
+                upper[index] = distances[index] / diagonal;
+                curvatures[index] =
+                    (6 * (slopes[index] - slopes[index - 1]) -
+                        distances[index - 1] * curvatures[index - 1]) /
+                        diagonal;
+            }
+            for (let index = points.length - 2; index > 0; index--) {
+                curvatures[index] -= upper[index] * curvatures[index + 1];
+            }
+            for (let index = 0; index < points.length; index++) {
+                tangents[index][axis] =
+                    index === 0
+                        ? slopes[0] - (distances[0] * curvatures[1]) / 6
+                        : slopes[index - 1] +
+                            (distances[index - 1] *
+                                (curvatures[index - 1] + 2 * curvatures[index])) /
+                                6;
+            }
+        }
+        for (let index = 0; index < points.length; index++) {
+            // Keep both Bezier handles within their segment's input range so
+            // the curve never doubles back and every input has one output.
+            const maxTangent = 3 *
+                Math.min(index === 0
+                    ? Infinity
+                    : (points[index][0] - points[index - 1][0]) / distances[index - 1], index === points.length - 1
+                    ? Infinity
+                    : (points[index + 1][0] - points[index][0]) / distances[index]);
+            if (tangents[index][0] > maxTangent) {
+                tangents[index][1] *= maxTangent / tangents[index][0];
+            }
+            tangents[index][0] = Math.max(0, Math.min(maxTangent, tangents[index][0]));
+        }
+    }
+    return (input) => {
+        if (input <= points[0][0])
+            return points[0][1];
+        if (input >= points[points.length - 1][0]) {
+            return points[points.length - 1][1];
+        }
+        const index = points.findIndex((point) => point[0] > input) - 1;
+        const start = points[index];
+        const end = points[index + 1];
+        if (input === start[0])
+            return start[1];
+        if (interpolation === 'linear' || points.length === 2) {
+            return (start[1] +
+                (end[1] - start[1]) * ((input - start[0]) / (end[0] - start[0])));
+        }
+        const handleLength = distances[index] / 3;
+        const firstX = start[0] + handleLength * tangents[index][0];
+        const secondX = end[0] - handleLength * tangents[index + 1][0];
+        let low = 0;
+        let high = 1;
+        // Invert the monotonic Bezier input coordinate before sampling output.
+        for (let iteration = 0; iteration < 32; iteration++) {
+            const candidate = (low + high) / 2;
+            const inverse = 1 - candidate;
+            const x = inverse ** 3 * start[0] +
+                3 * inverse ** 2 * candidate * firstX +
+                3 * inverse * candidate ** 2 * secondX +
+                candidate ** 3 * end[0];
+            if (x < input)
+                low = candidate;
+            else
+                high = candidate;
+        }
+        const progress = (low + high) / 2;
+        const remaining = 1 - progress;
+        const firstY = start[1] + handleLength * tangents[index][1];
+        const secondY = end[1] - handleLength * tangents[index + 1][1];
+        const value = remaining ** 3 * start[1] +
+            3 * remaining ** 2 * progress * firstY +
+            3 * remaining * progress ** 2 * secondY +
+            progress ** 3 * end[1];
+        return Math.max(0, Math.min(1, value));
+    };
+};
+exports.createCurveSampler = createCurveSampler;

package/dist/cjs/effects/effect-source-observer.d.ts

@@ -0,0 +1,13 @@
+import type { EffectDefinitionAndStack } from './effect-types.js';
+import type { EffectChainState } from './run-effect-chain.js';
+type SourceListener = (source: CanvasImageSource | null) => void;
+/** Studio-only inspection. The source is borrowed and must be consumed synchronously. */
+export declare const subscribeToEffectSource: ({ sequenceKey, effectIndex, onSource, }: {
+    readonly sequenceKey: string;
+    readonly effectIndex: number;
+    readonly onSource: SourceListener;
+}) => (() => void);
+export declare const publishEffectSource: (effect: EffectDefinitionAndStack<unknown>, source: CanvasImageSource, chain: EffectChainState) => void;
+export declare const invalidateEffectChainSources: (chain: EffectChainState) => void;
+export declare const useEffectSourceInspection: (effects: EffectDefinitionAndStack<unknown>[], sequenceKey: string | null) => EffectDefinitionAndStack<unknown>[];
+export {};

package/dist/cjs/effects/effect-source-observer.js

@@ -0,0 +1,177 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useEffectSourceInspection = exports.invalidateEffectChainSources = exports.publishEffectSource = exports.subscribeToEffectSource = void 0;
+const react_1 = __importStar(require("react"));
+const observers = new Map();
+const redrawListeners = new Map();
+const identities = new WeakMap();
+const inspectedChains = new WeakMap();
+const sourceChainOwners = new Map();
+const useIdentityCommitEffect = (_a = react_1.default.useInsertionEffect) !== null && _a !== void 0 ? _a : react_1.useLayoutEffect;
+/** Studio-only inspection. The source is borrowed and must be consumed synchronously. */
+const subscribeToEffectSource = ({ sequenceKey, effectIndex, onSource, }) => {
+    var _a;
+    let sequence = observers.get(sequenceKey);
+    if (!sequence) {
+        sequence = new Map();
+        observers.set(sequenceKey, sequence);
+    }
+    let listeners = sequence.get(effectIndex);
+    if (!listeners) {
+        listeners = new Set();
+        sequence.set(effectIndex, listeners);
+    }
+    listeners.add(onSource);
+    // Repaint once when the inspector opens, including while playback is paused.
+    (_a = redrawListeners.get(sequenceKey)) === null || _a === void 0 ? void 0 : _a.forEach((redraw) => redraw());
+    return () => {
+        listeners.delete(onSource);
+        if (listeners.size === 0) {
+            sequence.delete(effectIndex);
+        }
+        if (sequence.size === 0) {
+            observers.delete(sequenceKey);
+        }
+    };
+};
+exports.subscribeToEffectSource = subscribeToEffectSource;
+const publishEffectSource = (effect, source, chain) => {
+    var _a;
+    if (observers.size === 0) {
+        return;
+    }
+    const identity = identities.get(effect);
+    if (!identity) {
+        return;
+    }
+    const listeners = (_a = observers
+        .get(identity.sequenceKey)) === null || _a === void 0 ? void 0 : _a.get(identity.effectIndex);
+    if (!listeners || listeners.size === 0) {
+        return;
+    }
+    let inspected = inspectedChains.get(chain);
+    if (!inspected) {
+        inspected = new Map();
+        inspectedChains.set(chain, inspected);
+    }
+    const key = `${identity.sequenceKey}\0${identity.effectIndex}`;
+    inspected.set(key, identity);
+    sourceChainOwners.set(key, chain);
+    listeners.forEach((listener) => {
+        try {
+            listener(source);
+        }
+        catch (_a) {
+            // Optional inspector readback must never interrupt rendering.
+        }
+    });
+};
+exports.publishEffectSource = publishEffectSource;
+const invalidateEffectChainSources = (chain) => {
+    const inspected = inspectedChains.get(chain);
+    inspectedChains.delete(chain);
+    inspected === null || inspected === void 0 ? void 0 : inspected.forEach((identity, key) => {
+        var _a, _b;
+        // A replacement canvas may already have painted before the old canvas's
+        // passive cleanup. Only the current owner can invalidate its histogram.
+        if (sourceChainOwners.get(key) !== chain) {
+            return;
+        }
+        sourceChainOwners.delete(key);
+        (_b = (_a = observers
+            .get(identity.sequenceKey)) === null || _a === void 0 ? void 0 : _a.get(identity.effectIndex)) === null || _b === void 0 ? void 0 : _b.forEach((listener) => {
+            try {
+                listener(null);
+            }
+            catch (_a) {
+                // Optional inspection must not interfere with canvas cleanup.
+            }
+        });
+    });
+};
+exports.invalidateEffectChainSources = invalidateEffectChainSources;
+const useEffectSourceInspection = (effects, sequenceKey) => {
+    const [revision, setRevision] = (0, react_1.useState)(0);
+    (0, react_1.useLayoutEffect)(() => {
+        if (sequenceKey === null) {
+            return;
+        }
+        let listeners = redrawListeners.get(sequenceKey);
+        if (!listeners) {
+            listeners = new Set();
+            redrawListeners.set(sequenceKey, listeners);
+        }
+        const redraw = () => setRevision((previous) => previous + 1);
+        listeners.add(redraw);
+        if (observers.has(sequenceKey)) {
+            redraw();
+        }
+        return () => {
+            var _a;
+            listeners.delete(redraw);
+            if (listeners.size === 0) {
+                redrawListeners.delete(sequenceKey);
+                (_a = observers.get(sequenceKey)) === null || _a === void 0 ? void 0 : _a.forEach((sourceListeners) => {
+                    sourceListeners.forEach((listener) => {
+                        try {
+                            listener(null);
+                        }
+                        catch (_a) {
+                            // An inspector must not interfere with source cleanup.
+                        }
+                    });
+                });
+            }
+        };
+    }, [sequenceKey]);
+    useIdentityCommitEffect(() => {
+        if (sequenceKey === null) {
+            return;
+        }
+        effects.forEach((effect, effectIndex) => {
+            identities.set(effect, { sequenceKey, effectIndex });
+        });
+        return () => {
+            effects.forEach((effect) => identities.delete(effect));
+        };
+    }, [effects, sequenceKey]);
+    // Source components already repaint when their effect array changes.
+    return (0, react_1.useMemo)(() => {
+        return sequenceKey === null || revision === 0 ? effects : effects.slice();
+    }, [effects, revision, sequenceKey]);
+};
+exports.useEffectSourceInspection = useEffectSourceInspection;

package/dist/cjs/effects/index.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createEffect = void 0;
-const create_effect_js_1 = require("./create-effect.js");
+var create_effect_js_1 = require("./create-effect.js");
 Object.defineProperty(exports, "createEffect", { enumerable: true, get: function () { return create_effect_js_1.createEffect; } });

package/dist/cjs/effects/run-effect-chain.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runEffectChain = exports.cleanupEffectChainState = exports.createEffectChainState = void 0;
 const canvas_pool_js_1 = require("./canvas-pool.js");
 const effect_internals_js_1 = require("./effect-internals.js");
+const effect_source_observer_js_1 = require("./effect-source-observer.js");
 const gpu_device_js_1 = require("./gpu-device.js");
 const createEffectChainState = (width, height) => {
     const state = {
@@ -35,6 +36,7 @@ exports.createEffectChainState = createEffectChainState;
 // canvases and contexts. The state must not be used afterwards.
 const cleanupEffectChainState = (state) => {
     state.currentRunId++;
+    (0, effect_source_observer_js_1.invalidateEffectChainSources)(state);
     try {
         for (const entry of state.cleanupRegistry) {
             entry.definition.cleanup(entry.state);
@@ -119,6 +121,7 @@ const runEffectChainWithoutResize = async ({ state, source, effects, output, wid
                     state.pool.assertContextNotLost(dst);
                 }
                 const setupState = ensureSetup(state, def, dst);
+                (0, effect_source_observer_js_1.publishEffectSource)(eff, currentImage, state);
                 def.apply({
                     source: currentImage,
                     target: dst,

package/dist/cjs/effects/use-memoized-effects.d.ts

@@ -1,5 +1,5 @@
 import type { RuntimeValueStore } from '../runtime-value-store.js';
-import type { CannotUpdateEffectReason, CannotUpdateSequenceReason } from '../SequenceManager.js';
+import type { CannotUpdateEffectReason, CannotUpdateSequenceReason, CanUpdateSequencePropsResponse } from '../SequenceManager.js';
 import { type SequencePropsSubscriptionKey } from '../SequenceManager.js';
 import { type CanUpdateSequencePropStatus, type PropStatuses } from '../use-schema.js';
 import type { VideoConfigValues } from '../video-config.js';
@@ -22,6 +22,7 @@ export declare const getEffectPropStatusesCtx: ({ propStatuses, nodePath, effect
     nodePath: SequencePropsSubscriptionKey;
     effectIndex: number;
 }) => EffectStatus;
+export declare const getPropStatusesForSequenceStatus: (status: CanUpdateSequencePropsResponse | null, videoConfigValues: VideoConfigValues | null) => Record<string, CanUpdateSequencePropStatus> | undefined;
 export declare const getPropStatusesCtx: (propStatuses: PropStatuses, nodePath: SequencePropsSubscriptionKey) => Record<string, CanUpdateSequencePropStatus> | undefined;
 export type GetPropStatusesType = typeof getPropStatusesCtx;
 export declare const useMemoizedEffects: ({ effects, overrideId, videoConfigValues, }: {

package/dist/cjs/effects/use-memoized-effects.js

@@ -34,7 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useMemoizedEffects = exports.getPropStatusesCtx = exports.getEffectPropStatusesCtx = exports.useMemoizedEffectDefinitions = void 0;
+exports.useMemoizedEffects = exports.getPropStatusesCtx = exports.getPropStatusesForSequenceStatus = exports.getEffectPropStatusesCtx = exports.useMemoizedEffectDefinitions = void 0;
 const react_1 = __importStar(require("react"));
 const evaluate_source_expressions_js_1 = require("../evaluate-source-expressions.js");
 const get_effective_visual_mode_value_js_1 = require("../get-effective-visual-mode-value.js");
@@ -45,6 +45,8 @@ const sequence_activity_context_js_1 = require("../sequence-activity-context.js"
 const sequence_node_path_js_1 = require("../sequence-node-path.js");
 const SequenceManager_js_1 = require("../SequenceManager.js");
 const use_current_frame_js_1 = require("../use-current-frame.js");
+const use_remotion_environment_js_1 = require("../use-remotion-environment.js");
+const effect_source_observer_js_1 = require("./effect-source-observer.js");
 const emptyDragOverrides = {};
 const useCacheCommitEffect = (_a = react_1.default.useInsertionEffect) !== null && _a !== void 0 ? _a : react_1.useLayoutEffect;
 const areEffectParamsEqual = (previous, next) => {
@@ -181,8 +183,7 @@ const useMemoizedEffectDefinitions = (effects) => {
     return stableDefinitions;
 };
 exports.useMemoizedEffectDefinitions = useMemoizedEffectDefinitions;
-const getEffectPropStatusesCtx = ({ propStatuses, nodePath, effectIndex, }) => {
-    const status = propStatuses[(0, SequenceManager_js_1.makeSequencePropsSubscriptionKey)(nodePath)];
+const getEffectStatusForSequenceStatus = ({ status, effectIndex, videoConfigValues, }) => {
     if (!status) {
         return { type: 'cannot-update-sequence', reason: 'not-found' };
     }
@@ -198,42 +199,55 @@ const getEffectPropStatusesCtx = ({ propStatuses, nodePath, effectIndex, }) => {
     }
     return {
         type: 'can-update-effect',
-        props: (0, evaluate_source_expressions_js_1.evaluateSourcePropStatuses)(effect.props, nodePath.videoConfigValues),
+        props: (0, evaluate_source_expressions_js_1.evaluateSourcePropStatuses)(effect.props, videoConfigValues),
     };
 };
+const getEffectPropStatusesCtx = ({ propStatuses, nodePath, effectIndex, }) => {
+    var _a;
+    return getEffectStatusForSequenceStatus({
+        status: (_a = propStatuses[(0, SequenceManager_js_1.makeSequencePropsSubscriptionKey)(nodePath)]) !== null && _a !== void 0 ? _a : null,
+        effectIndex,
+        videoConfigValues: nodePath.videoConfigValues,
+    });
+};
 exports.getEffectPropStatusesCtx = getEffectPropStatusesCtx;
-const getPropStatusesCtx = (propStatuses, nodePath) => {
-    const status = propStatuses[(0, SequenceManager_js_1.makeSequencePropsSubscriptionKey)(nodePath)];
+const getPropStatusesForSequenceStatus = (status, videoConfigValues) => {
     if (!status) {
         return undefined;
     }
     if (!status.canUpdate) {
         return undefined;
     }
-    return (0, evaluate_source_expressions_js_1.evaluateSourcePropStatuses)(status.props, nodePath.videoConfigValues);
+    return (0, evaluate_source_expressions_js_1.evaluateSourcePropStatuses)(status.props, videoConfigValues);
+};
+exports.getPropStatusesForSequenceStatus = getPropStatusesForSequenceStatus;
+const getPropStatusesCtx = (propStatuses, nodePath) => {
+    var _a;
+    return (0, exports.getPropStatusesForSequenceStatus)((_a = propStatuses[(0, SequenceManager_js_1.makeSequencePropsSubscriptionKey)(nodePath)]) !== null && _a !== void 0 ? _a : null, nodePath.videoConfigValues);
 };
 exports.getPropStatusesCtx = getPropStatusesCtx;
 const useMemoizedEffects = ({ effects, overrideId, videoConfigValues, }) => {
     var _a;
     const previousRef = (0, react_1.useRef)(null);
-    const { propStatuses } = (0, react_1.useContext)(SequenceManager_js_1.VisualModePropStatusesContext);
+    const { isStudio } = (0, use_remotion_environment_js_1.useRemotionEnvironment)();
     const { overrideIdToNodePathMappings } = (0, react_1.useContext)(sequence_node_path_js_1.OverrideIdsToNodePathsGettersContext);
     const previous = previousRef.current;
     const nodePath = overrideId
         ? ((_a = overrideIdToNodePathMappings[overrideId]) !== null && _a !== void 0 ? _a : null)
         : null;
     const effectDragOverrides = (0, SequenceManager_js_1.useEffectDragOverridesForNodePath)(nodePath);
+    const sequenceStatus = (0, SequenceManager_js_1.usePropStatusForNodePath)(nodePath);
     const effectPropStatuses = (0, react_1.useMemo)(() => Array.from({ length: effects.length }, (_, effectIndex) => {
         if (nodePath === null) {
             return null;
         }
-        const status = (0, exports.getEffectPropStatusesCtx)({
-            propStatuses,
-            nodePath: { ...nodePath, videoConfigValues },
+        const status = getEffectStatusForSequenceStatus({
+            status: sequenceStatus,
             effectIndex,
+            videoConfigValues,
         });
         return status.type === 'can-update-effect' ? status.props : null;
-    }), [effects.length, nodePath, propStatuses, videoConfigValues]);
+    }), [effects.length, nodePath, sequenceStatus, videoConfigValues]);
     const animatedEffects = (0, react_1.useMemo)(() => effectPropStatuses.map((status, index) => {
         var _a;
         return Object.values(status !== null && status !== void 0 ? status : {}).some((prop) => prop.status === 'keyframed') ||
@@ -297,6 +311,8 @@ const useMemoizedEffects = ({ effects, overrideId, videoConfigValues, }) => {
     useCacheCommitEffect(() => {
         previousRef.current = { prepared, effects: next };
     }, [next, prepared]);
-    return next;
+    return (0, effect_source_observer_js_1.useEffectSourceInspection)(next, isStudio && nodePath !== null
+        ? (0, SequenceManager_js_1.makeSequencePropsSubscriptionKey)({ ...nodePath, videoConfigValues })
+        : null);
 };
 exports.useMemoizedEffects = useMemoizedEffects;

package/dist/cjs/freeze.js

@@ -77,7 +77,7 @@ const Freeze = ({ frame: frameToFreeze, children, active = true, _remotionIntern
         };
     }, [sequenceContext, isActive]);
     const providedTimeline = isActive ? frozenTimelineValue : timelineContext;
-    return (jsx_runtime_1.jsx(NonPremountFreezeContext.Provider, { value: isInsideNonPremountFreeze ||
-            (Boolean(isActive) && !_remotionInternalIsPremounting), children: jsx_runtime_1.jsx(TimelineContext_js_1.TimelineContext.Provider, { value: providedTimeline, children: jsx_runtime_1.jsx(sequence_activity_context_js_1.SequenceActivityTimelineContext.Provider, { value: activityDormant ? providedTimeline : null, children: jsx_runtime_1.jsx(SequenceContext_js_1.SequenceContext.Provider, { value: newSequenceContext, children: children }) }) }) }));
+    return ((0, jsx_runtime_1.jsx)(NonPremountFreezeContext.Provider, { value: isInsideNonPremountFreeze ||
+            (Boolean(isActive) && !_remotionInternalIsPremounting), children: (0, jsx_runtime_1.jsx)(TimelineContext_js_1.TimelineContext.Provider, { value: providedTimeline, children: (0, jsx_runtime_1.jsx)(sequence_activity_context_js_1.SequenceActivityTimelineContext.Provider, { value: activityDormant ? providedTimeline : null, children: (0, jsx_runtime_1.jsx)(SequenceContext_js_1.SequenceContext.Provider, { value: newSequenceContext, children: children }) }) }) }));
 };
 exports.Freeze = Freeze;

package/dist/cjs/get-cross-origin-value.d.ts

@@ -1,5 +1,5 @@
 export declare const getCrossOriginValue: ({ crossOrigin, requestsVideoFrame, isClientSideRendering, }: {
-    crossOrigin: "" | "anonymous" | "use-credentials" | undefined;
+    crossOrigin: '' | 'anonymous' | 'use-credentials' | undefined;
     requestsVideoFrame: boolean;
     isClientSideRendering: boolean;
 }) => "" | "anonymous" | "use-credentials" | undefined;

package/dist/cjs/get-effective-visual-mode-value.d.ts

@@ -14,9 +14,9 @@ export declare const resolveDragOverrideValue: ({ dragOverrideValue, frame, }: {
     frame: number | null;
 }) => ResolvedDragOverrideValue;
 export declare const getEffectiveVisualModeValue: ({ propStatus, dragOverrideValue, defaultValue, frame, shouldResortToDefaultValueIfUndefined, }: {
-    propStatus: CanUpdateSequencePropStatusKeyframed | CanUpdateSequencePropStatusStatic;
+    propStatus: CanUpdateSequencePropStatusStatic | CanUpdateSequencePropStatusKeyframed;
     dragOverrideValue: DragOverrideValue | undefined;
     defaultValue: unknown;
-    frame?: number | null | undefined;
+    frame?: number | null;
     shouldResortToDefaultValueIfUndefined: boolean;
 }) => unknown;

package/dist/cjs/index.d.ts

@@ -6,6 +6,7 @@ import type { DelayRenderScope } from './delay-render.js';
 import { type TFolder } from './Folder.js';
 import type { StaticFile } from './get-static-files.js';
 import type { ArrayFieldSchema, ArrayItemFieldSchema, AssetFieldSchema, CaptionsFieldSchema, InteractivitySchema, InteractivitySchemaField } from './interactivity-schema.js';
+import { useIsPlayer } from './is-player.js';
 import type { LogLevel } from './log.js';
 import type { ProResProfile } from './prores-profile.js';
 import type { PixelFormat, VideoImageFormat } from './render-types.js';
@@ -28,6 +29,7 @@ declare global {
         };
         remotion_delayRenderHandles: number[];
         remotion_cancelledError: string | undefined;
+        remotion_cancelledErrorObject: Error | undefined;
         remotion_getCompositionNames: () => string[];
         remotion_seenCompositionIds: string[];
         getStaticCompositions: () => Promise<VideoConfigWithSerializedProps[]>;
@@ -170,7 +172,7 @@ export declare const Experimental: {
      * @description This is a special component, that, when rendered, will skip rendering the frame altogether.
      */
     Null: import("react").FC<{}>;
-    useIsPlayer: () => boolean;
+    useIsPlayer: typeof useIsPlayer;
 };
 export declare const Config: {};
 export type _InternalTypes = {