remotion 4.0.537 → 4.0.539

package/dist/cjs/no-react.d.ts

@@ -1,57 +1,55 @@
-export type { ArtifactAsset, AudioOrVideoAsset, InlineAudioAsset, TRenderAsset, } from './CompositionManager';
+import type { ArtifactAsset, AudioOrVideoAsset as InternalAudioOrVideoAsset, InlineAudioAsset } from './CompositionManager';
+import { evaluateSourceNumericValue, evaluateSourcePropStatuses } from './evaluate-source-expressions.js';
+export type { ArtifactAsset, InlineAudioAsset } from './CompositionManager';
+export type AudioOrVideoAsset = Omit<InternalAudioOrVideoAsset, 'preservePitch'> & {
+    preservePitch?: boolean | null;
+};
+export type TRenderAsset = AudioOrVideoAsset | ArtifactAsset | InlineAudioAsset;
 export type { DownloadBehavior } from './download-behavior';
 export { assertValidInterpolateEasingOption, assertValidInterpolatePosterizeOption, interpolate, } from './interpolate';
 export type { EasingFunction, ExtrapolateType, InterpolateOptions, InterpolateOutputOption, InterpolateOutputType, } from './interpolate';
 export { random } from './random.js';
 export type { RandomSeed } from './random.js';
 export type { VideoConfig } from './video-config';
+import { validateDefaultPremountInSeconds } from './default-premount-in-seconds';
+import { findPropsToDelete } from './find-props-to-delete';
+import { fetchFontData, getRegisteredFontFaces, registerFontFace } from './font-face-registry';
+import { deserializeJSONWithSpecialTypes, serializeJSONWithSpecialTypes } from './input-props-serialization';
 import { processColor } from './interpolate-colors';
+import { parseScaleValue, serializeScaleValue } from './scale-value';
 import { truthy } from './truthy';
+import { validateFrame } from './validate-frame';
 import { validateCodec } from './validation/validate-default-codec';
+import { validateDefaultAndInputProps } from './validation/validate-default-props';
 import { validateDimension } from './validation/validate-dimensions';
 import { validateDurationInFrames } from './validation/validate-duration-in-frames';
 import { validateFps } from './validation/validate-fps';
+import { getExpectedMediaFrameUncorrected } from './video/get-current-time';
+import { getOffthreadVideoSource } from './video/offthread-video-source';
 export declare const NoReactInternals: {
     DEFAULT_PREMOUNT_IN_SECONDS: number;
     DEFAULT_STUDIO_PREMOUNT_IN_SECONDS: number;
     DEFAULT_SEQUENCE_ACTIVITY_LIMIT: number;
-    validateDefaultPremountInSeconds: (value: unknown) => void;
-    evaluateSourceNumericValue: (expression: import("./use-schema.js").SourceNumericValue, config: import("./video-config").VideoConfigValues | null) => number;
-    evaluateSourcePropStatuses: (props: Record<string, import("./use-schema.js").CanUpdateSequencePropSource>, config: import("./video-config").VideoConfigValues | null) => Record<string, import("./use-schema.js").CanUpdateSequencePropStatus>;
+    validateDefaultPremountInSeconds: typeof validateDefaultPremountInSeconds;
+    evaluateSourceNumericValue: typeof evaluateSourceNumericValue;
+    evaluateSourcePropStatuses: typeof evaluateSourcePropStatuses;
     processColor: typeof processColor;
     truthy: typeof truthy;
     validateFps: typeof validateFps;
     validateDimension: typeof validateDimension;
     validateDurationInFrames: typeof validateDurationInFrames;
-    validateDefaultAndInputProps: (defaultProps: unknown, name: "defaultProps" | "inputProps", compositionId: string | null) => void;
-    validateFrame: ({ allowFloats, durationInFrames, frame, }: {
-        frame: number;
-        durationInFrames: number;
-        allowFloats: boolean;
-    }) => void;
-    serializeJSONWithSpecialTypes: ({ data, indent, staticBase, }: {
-        data: Record<string, unknown>;
-        indent: number | undefined;
-        staticBase: string | null;
-    }) => import("./input-props-serialization").SerializedJSONWithCustomFields;
+    validateDefaultAndInputProps: typeof validateDefaultAndInputProps;
+    validateFrame: typeof validateFrame;
+    serializeJSONWithSpecialTypes: typeof serializeJSONWithSpecialTypes;
     bundleName: string;
     bundleMapName: string;
-    deserializeJSONWithSpecialTypes: <T = Record<string, unknown>>(data: string) => T;
+    deserializeJSONWithSpecialTypes: typeof deserializeJSONWithSpecialTypes;
     DELAY_RENDER_CALLSTACK_TOKEN: string;
     DELAY_RENDER_RETRY_TOKEN: string;
     DELAY_RENDER_CLEAR_TOKEN: string;
     DELAY_RENDER_ATTEMPT_TOKEN: string;
-    getOffthreadVideoSource: ({ src, transparent, currentTime, toneMapped, }: {
-        src: string;
-        transparent: boolean;
-        currentTime: number;
-        toneMapped: boolean;
-    }) => string;
-    getExpectedMediaFrameUncorrected: ({ frame, playbackRate, startFrom, }: {
-        frame: number;
-        playbackRate: number;
-        startFrom: number;
-    }) => number;
+    getOffthreadVideoSource: typeof getOffthreadVideoSource;
+    getExpectedMediaFrameUncorrected: typeof getExpectedMediaFrameUncorrected;
     ENABLE_V5_BREAKING_CHANGES: false;
     MIN_NODE_VERSION: number;
     MIN_BUN_VERSION: string;
@@ -63,43 +61,39 @@ export declare const NoReactInternals: {
     FILE_TOKEN: string;
     validateCodec: typeof validateCodec;
     proResProfileOptions: readonly ["4444-xq", "4444", "hq", "standard", "light", "proxy"];
-    findPropsToDelete: ({ schema, key, value, }: {
-        schema: import("./interactivity-schema").InteractivitySchema;
-        key: string;
-        value: unknown;
-    }) => string[];
+    findPropsToDelete: typeof findPropsToDelete;
     sequenceSchema: {
         readonly durationInFrames: {
-            readonly type: "number";
+            readonly type: 'number';
             readonly default: undefined;
             readonly min: 1;
             readonly step: 1;
             readonly hiddenFromList: true;
         };
         readonly from: {
-            readonly type: "number";
+            readonly type: 'number';
             readonly default: 0;
             readonly step: 1;
             readonly hiddenFromList: true;
         };
         readonly trimBefore: {
-            readonly type: "number";
+            readonly type: 'number';
             readonly default: 0;
             readonly min: 0;
             readonly step: 1;
             readonly hiddenFromList: true;
         };
         readonly playbackRate: {
-            readonly type: "number";
+            readonly type: 'number';
             readonly default: 1;
             readonly min: 0.01;
             readonly step: 0.1;
-            readonly description: "Playback rate";
+            readonly description: 'Playback rate';
             readonly hiddenFromList: false;
             readonly keyframable: false;
         };
         readonly freeze: {
-            readonly type: "number";
+            readonly type: 'number';
             readonly default: null;
             readonly step: 1;
             readonly hiddenFromList: true;
@@ -108,58 +102,58 @@ export declare const NoReactInternals: {
         readonly name: import("./interactivity-schema").HiddenFieldSchema;
         readonly showInTimeline: import("./interactivity-schema").HiddenFieldSchema;
         readonly layout: {
-            readonly type: "enum";
-            readonly default: "absolute-fill";
-            readonly description: "Layout";
+            readonly type: 'enum';
+            readonly default: 'absolute-fill';
+            readonly description: 'Layout';
             readonly variants: {
                 readonly 'absolute-fill': {
                     readonly 'style.transformOrigin': {
-                        readonly type: "transform-origin";
+                        readonly type: 'transform-origin';
                         readonly step: 1;
-                        readonly default: "50% 50%";
-                        readonly description: "Transform origin";
+                        readonly default: '50% 50%';
+                        readonly description: 'Transform origin';
                     };
                     readonly 'style.translate': {
-                        readonly type: "translate";
+                        readonly type: 'translate';
                         readonly step: 1;
-                        readonly default: "0px 0px";
-                        readonly description: "Offset";
+                        readonly default: '0px 0px';
+                        readonly description: 'Offset';
                     };
                     readonly 'style.scale': {
-                        readonly type: "scale";
+                        readonly type: 'scale';
                         readonly max: 100;
                         readonly step: 0.01;
                         readonly default: 1;
-                        readonly description: "Scale";
-                        readonly defaultKeyframeOutput: "perceptual-scale";
+                        readonly description: 'Scale';
+                        readonly defaultKeyframeOutput: 'perceptual-scale';
                     };
                     readonly 'style.rotate': {
-                        readonly type: "rotation-css";
+                        readonly type: 'rotation-css';
                         readonly step: 1;
-                        readonly default: "0deg";
-                        readonly description: "Rotation";
+                        readonly default: '0deg';
+                        readonly description: 'Rotation';
                     };
                     readonly 'style.opacity': {
-                        readonly type: "number";
+                        readonly type: 'number';
                         readonly min: 0;
                         readonly max: 1;
                         readonly step: 0.01;
                         readonly default: 1;
-                        readonly description: "Opacity";
+                        readonly description: 'Opacity';
                         readonly hiddenFromList: false;
                     };
                     readonly 'style.borderWidth': {
-                        readonly type: "number";
+                        readonly type: 'number';
                         readonly default: undefined;
                         readonly min: 0;
                         readonly step: 1;
-                        readonly description: "Border width";
+                        readonly description: 'Border width';
                         readonly hiddenFromList: false;
                     };
                     readonly 'style.borderStyle': {
-                        readonly type: "enum";
-                        readonly default: "none";
-                        readonly description: "Border style";
+                        readonly type: 'enum';
+                        readonly default: 'none';
+                        readonly description: 'Border style';
                         readonly variants: {
                             readonly none: {};
                             readonly hidden: {};
@@ -174,67 +168,67 @@ export declare const NoReactInternals: {
                         };
                     };
                     readonly 'style.borderColor': {
-                        readonly type: "color";
+                        readonly type: 'color';
                         readonly default: undefined;
-                        readonly description: "Border color";
+                        readonly description: 'Border color';
                     };
                     readonly 'style.borderRadius': {
-                        readonly type: "number";
+                        readonly type: 'number';
                         readonly default: 0;
                         readonly min: 0;
                         readonly step: 1;
-                        readonly description: "Border radius";
+                        readonly description: 'Border radius';
                         readonly hiddenFromList: false;
                         readonly keyframable: true;
                     };
                     readonly 'style.borderTopLeftRadius': {
-                        readonly type: "number";
+                        readonly type: 'number';
                         readonly default: 0;
                         readonly min: 0;
                         readonly step: 1;
-                        readonly description: "Top left radius";
+                        readonly description: 'Top left radius';
                         readonly hiddenFromList: false;
                     };
                     readonly 'style.borderTopRightRadius': {
-                        readonly type: "number";
+                        readonly type: 'number';
                         readonly default: 0;
                         readonly min: 0;
                         readonly step: 1;
-                        readonly description: "Top right radius";
+                        readonly description: 'Top right radius';
                         readonly hiddenFromList: false;
                     };
                     readonly 'style.borderBottomRightRadius': {
-                        readonly type: "number";
+                        readonly type: 'number';
                         readonly default: 0;
                         readonly min: 0;
                         readonly step: 1;
-                        readonly description: "Bottom right radius";
+                        readonly description: 'Bottom right radius';
                         readonly hiddenFromList: false;
                     };
                     readonly 'style.borderBottomLeftRadius': {
-                        readonly type: "number";
+                        readonly type: 'number';
                         readonly default: 0;
                         readonly min: 0;
                         readonly step: 1;
-                        readonly description: "Bottom left radius";
+                        readonly description: 'Bottom left radius';
                         readonly hiddenFromList: false;
                     };
                     readonly 'style.backgroundColor': {
-                        readonly type: "color";
-                        readonly default: "transparent";
-                        readonly description: "Color";
+                        readonly type: 'color';
+                        readonly default: 'transparent';
+                        readonly description: 'Color';
                     };
                     readonly premountFor: {
-                        readonly type: "number";
+                        readonly type: 'number';
                         readonly default: undefined;
-                        readonly description: "Premount For";
+                        readonly description: 'Premount For';
                         readonly min: 0;
                         readonly step: 1;
                         readonly hiddenFromList: false;
                         readonly keyframable: false;
                     };
                     readonly postmountFor: {
-                        readonly type: "number";
+                        readonly type: 'number';
                         readonly default: 0;
                         readonly min: 0;
                         readonly step: 1;
@@ -242,9 +236,9 @@ export declare const NoReactInternals: {
                         readonly keyframable: false;
                     };
                     readonly cropLeft: {
-                        readonly type: "number";
+                        readonly type: 'number';
                         readonly default: 0;
-                        readonly description: "Crop left";
+                        readonly description: 'Crop left';
                         readonly min: 0;
                         readonly max: 1;
                         readonly step: 0.01;
@@ -252,9 +246,9 @@ export declare const NoReactInternals: {
                         readonly keyframable: true;
                     };
                     readonly cropRight: {
-                        readonly type: "number";
+                        readonly type: 'number';
                         readonly default: 0;
-                        readonly description: "Crop right";
+                        readonly description: 'Crop right';
                         readonly min: 0;
                         readonly max: 1;
                         readonly step: 0.01;
@@ -262,9 +256,9 @@ export declare const NoReactInternals: {
                         readonly keyframable: true;
                     };
                     readonly cropTop: {
-                        readonly type: "number";
+                        readonly type: 'number';
                         readonly default: 0;
-                        readonly description: "Crop top";
+                        readonly description: 'Crop top';
                         readonly min: 0;
                         readonly max: 1;
                         readonly step: 0.01;
@@ -272,9 +266,9 @@ export declare const NoReactInternals: {
                         readonly keyframable: true;
                     };
                     readonly cropBottom: {
-                        readonly type: "number";
+                        readonly type: 'number';
                         readonly default: 0;
-                        readonly description: "Crop bottom";
+                        readonly description: 'Crop bottom';
                         readonly min: 0;
                         readonly max: 1;
                         readonly step: 0.01;
@@ -286,9 +280,9 @@ export declare const NoReactInternals: {
             };
         };
     };
-    parseScaleValue: (value: unknown) => import("./scale-value").ScaleValue;
-    serializeScaleValue: ([x, y, z]: import("./scale-value").ScaleValue) => string | number;
-    getRegisteredFontFaces: () => import("./font-face-registry").RegisteredFontFace[];
-    registerFontFace: (fontFace: import("./font-face-registry").RegisteredFontFace) => void;
-    fetchFontData: (fontUrl: string) => Promise<ArrayBuffer>;
+    parseScaleValue: typeof parseScaleValue;
+    serializeScaleValue: typeof serializeScaleValue;
+    getRegisteredFontFaces: typeof getRegisteredFontFaces;
+    registerFontFace: typeof registerFontFace;
+    fetchFontData: typeof fetchFontData;
 };

package/dist/cjs/no-react.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NoReactInternals = exports.random = exports.interpolate = exports.assertValidInterpolatePosterizeOption = exports.assertValidInterpolateEasingOption = void 0;
 const evaluate_source_expressions_js_1 = require("./evaluate-source-expressions.js");
 const sequence_activity_defaults_js_1 = require("./sequence-activity-defaults.js");
-const interpolate_1 = require("./interpolate");
+var interpolate_1 = require("./interpolate");
 Object.defineProperty(exports, "assertValidInterpolateEasingOption", { enumerable: true, get: function () { return interpolate_1.assertValidInterpolateEasingOption; } });
 Object.defineProperty(exports, "assertValidInterpolatePosterizeOption", { enumerable: true, get: function () { return interpolate_1.assertValidInterpolatePosterizeOption; } });
 Object.defineProperty(exports, "interpolate", { enumerable: true, get: function () { return interpolate_1.interpolate; } });
-const random_js_1 = require("./random.js");
+var random_js_1 = require("./random.js");
 Object.defineProperty(exports, "random", { enumerable: true, get: function () { return random_js_1.random; } });
 const default_premount_in_seconds_1 = require("./default-premount-in-seconds");
 const delay_render_constants_1 = require("./delay-render-constants");

package/dist/cjs/nonce.d.ts

@@ -0,0 +1,11 @@
+export type TNonceContext = {
+    getNonce: () => number;
+};
+type NonceHistoryItem = [number, number];
+export type NonceHistory = NonceHistoryItem[];
+export type NonceHistoryContext = {
+    get: () => NonceHistory;
+};
+export declare const NonceContext: import("react").Context<TNonceContext>;
+export declare const useNonce: () => NonceHistoryContext;
+export {};

package/dist/cjs/nonce.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useNonce = exports.NonceContext = void 0;
+const react_1 = require("react");
+exports.NonceContext = (0, react_1.createContext)({
+    getNonce: () => 0,
+});
+let fastRefreshNonce = 0;
+try {
+    if (typeof __webpack_module__ !== 'undefined') {
+        if (__webpack_module__.hot) {
+            __webpack_module__.hot.addStatusHandler((status) => {
+                if (status === 'idle') {
+                    fastRefreshNonce++;
+                }
+            });
+        }
+    }
+}
+catch (_a) {
+    // __webpack_module__ may throw ReferenceError in some environments
+}
+const useNonce = () => {
+    const context = (0, react_1.useContext)(exports.NonceContext);
+    const nonce = context.getNonce();
+    const nonceRef = (0, react_1.useRef)(nonce);
+    nonceRef.current = nonce;
+    const history = (0, react_1.useRef)([[fastRefreshNonce, nonce]]);
+    const get = (0, react_1.useCallback)(() => {
+        if (fastRefreshNonce !== history.current[history.current.length - 1][0]) {
+            history.current = [
+                ...history.current,
+                [fastRefreshNonce, nonceRef.current],
+            ];
+        }
+        return history.current;
+    }, [history]);
+    return (0, react_1.useMemo)(() => {
+        return { get };
+    }, [get]);
+};
+exports.useNonce = useNonce;

package/dist/cjs/play-and-handle-not-allowed-error.d.ts

@@ -1,9 +1,10 @@
 import type { RefObject } from 'react';
+import { type LogLevel } from './log';
 export declare const playAndHandleNotAllowedError: ({ mediaRef, mediaType, onAutoPlayError, logLevel, mountTime, reason, isPlayer, }: {
-    mediaRef: RefObject<HTMLAudioElement | HTMLVideoElement | null>;
-    mediaType: "audio" | "video";
-    onAutoPlayError: (() => void) | null;
-    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    mediaRef: RefObject<HTMLVideoElement | HTMLAudioElement | null>;
+    mediaType: 'audio' | 'video';
+    onAutoPlayError: null | (() => void);
+    logLevel: LogLevel;
     mountTime: number;
     reason: string;
     isPlayer: boolean;

package/dist/cjs/playback-logging.d.ts

@@ -1,5 +1,6 @@
+import { type LogLevel } from './log';
 export declare const playbackLogging: ({ logLevel, tag, message, mountTime, }: {
-    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    logLevel: LogLevel;
     tag: string;
     message: string;
     mountTime: number | null;

package/dist/cjs/playback-pitch-context.d.ts

@@ -0,0 +1 @@
+export declare const PlaybackPitchContext: import("react").Context<boolean>;

package/dist/cjs/playback-pitch-context.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaybackPitchContext = void 0;
+const react_1 = require("react");
+exports.PlaybackPitchContext = (0, react_1.createContext)(false);

package/dist/cjs/prefetch-state.js

@@ -22,6 +22,6 @@ const PrefetchProvider = ({ children }) => {
             updaters = updaters.filter((u) => u !== updaterFunction);
         };
     }, []);
-    return (jsx_runtime_1.jsx(exports.PreloadContext.Provider, { value: _preloads, children: children }));
+    return ((0, jsx_runtime_1.jsx)(exports.PreloadContext.Provider, { value: _preloads, children: children }));
 };
 exports.PrefetchProvider = PrefetchProvider;

package/dist/cjs/prefetch.d.ts

@@ -1,3 +1,4 @@
+import type { LogLevel } from './log.js';
 export declare const removeAndGetHashFragment: (src: string) => number | null;
 export declare const getSrcWithoutHash: (src: string) => string;
 export declare const usePreload: (src: string) => string;
@@ -10,10 +11,10 @@ export type PrefetchOnProgress = (options: {
     loadedBytes: number;
 }) => void;
 export declare const prefetch: (src: string, options?: {
-    method?: "base64" | "blob-url" | undefined;
-    contentType?: string | undefined;
-    onProgress?: PrefetchOnProgress | undefined;
-    credentials?: RequestCredentials | undefined;
-    logLevel?: "error" | "info" | "trace" | "verbose" | "warn" | undefined;
-} | undefined) => FetchAndPreload;
+    method?: 'blob-url' | 'base64';
+    contentType?: string;
+    onProgress?: PrefetchOnProgress;
+    credentials?: RequestCredentials;
+    logLevel?: LogLevel;
+}) => FetchAndPreload;
 export {};

package/dist/cjs/prefetch.js

@@ -35,6 +35,7 @@ const usePreload = (src) => {
     return preloads[withoutHashFragment];
 };
 exports.usePreload = usePreload;
+const activePrefetches = new Map();
 const blobToBase64 = function (blob) {
     const reader = new FileReader();
     return new Promise((resolve, reject) => {
@@ -98,6 +99,7 @@ const prefetch = (src, options) => {
     });
     waitUntilDone.catch(() => undefined);
     const controller = new AbortController();
+    const prefetchId = Symbol('prefetch');
     let reader = null;
     fetch(srcWithoutHash, {
         signal: controller.signal,
@@ -148,7 +150,11 @@ const prefetch = (src, options) => {
         return URL.createObjectURL(actualBlob);
     })
         .then((url) => {
+        var _a;
         if (canceled) {
+            if (url && method === 'blob-url') {
+                URL.revokeObjectURL(url);
+            }
             return;
         }
         (0, playback_logging_js_1.playbackLogging)({
@@ -158,6 +164,9 @@ const prefetch = (src, options) => {
             mountTime: null,
         });
         objectUrl = url;
+        const prefetchesForSrc = (_a = activePrefetches.get(srcWithoutHash)) !== null && _a !== void 0 ? _a : new Map();
+        prefetchesForSrc.set(prefetchId, objectUrl);
+        activePrefetches.set(srcWithoutHash, prefetchesForSrc);
         (0, prefetch_state_js_1.setPreloads)((p) => ({
             ...p,
             [srcWithoutHash]: objectUrl,
@@ -172,6 +181,10 @@ const prefetch = (src, options) => {
     });
     return {
         free: () => {
+            if (canceled) {
+                return;
+            }
+            canceled = true;
             (0, playback_logging_js_1.playbackLogging)({
                 logLevel,
                 tag: 'prefetch',
@@ -182,17 +195,29 @@ const prefetch = (src, options) => {
                 if (method === 'blob-url') {
                     URL.revokeObjectURL(objectUrl);
                 }
+                const prefetchesForSrc = activePrefetches.get(srcWithoutHash);
+                prefetchesForSrc === null || prefetchesForSrc === void 0 ? void 0 : prefetchesForSrc.delete(prefetchId);
+                const remainingUrl = prefetchesForSrc
+                    ? [...prefetchesForSrc.values()].pop()
+                    : undefined;
+                if ((prefetchesForSrc === null || prefetchesForSrc === void 0 ? void 0 : prefetchesForSrc.size) === 0) {
+                    activePrefetches.delete(srcWithoutHash);
+                }
                 (0, prefetch_state_js_1.setPreloads)((p) => {
+                    if (p[srcWithoutHash] === remainingUrl) {
+                        return p;
+                    }
                     const copy = { ...p };
-                    delete copy[srcWithoutHash];
+                    if (remainingUrl === undefined) {
+                        delete copy[srcWithoutHash];
+                    }
+                    else {
+                        copy[srcWithoutHash] = remainingUrl;
+                    }
                     return copy;
                 });
             }
             else {
-                if (canceled) {
-                    return;
-                }
-                canceled = true;
                 const cancellationError = new Error('free() called');
                 reject(cancellationError);
                 try {

package/dist/cjs/props-if-has-props.d.ts

@@ -17,5 +17,6 @@ export type PropsIfHasProps<Schema extends AnyZodObject, Props extends Record<st
 } : {
     defaultProps: InferProps<Schema, Props>;
 };
-export type InferProps<Schema extends AnyZodObject, Props extends Record<string, unknown>> = AnyZodObject extends Schema ? {} extends Props ? Record<string, unknown> : Props : {} extends Props ? InferZodInput<Schema> : InferZodInput<Schema> & Props;
+export type InferProps<Schema extends AnyZodObject, Props extends Record<string, unknown>> = AnyZodObject extends Schema ? {} extends Props ? Record<string, unknown> : Props : {} extends Props ? InferZodInput<Schema> : // Props and schema specified
+InferZodInput<Schema> & Props;
 export {};

package/dist/cjs/prores-profile.d.ts

@@ -1,2 +1,2 @@
-export declare const proResProfileOptions: readonly ["4444-xq", "4444", "hq", "standard", "light", "proxy"];
+export declare const proResProfileOptions: readonly ['4444-xq', '4444', 'hq', 'standard', 'light', 'proxy'];
 export type ProResProfile = (typeof proResProfileOptions)[number];

package/dist/cjs/register-root.d.ts

@@ -1,4 +1,4 @@
 import type React from 'react';
-export declare const registerRoot: (comp: React.FC<{}>) => void;
+export declare const registerRoot: (comp: React.FC) => void;
 export declare const getRoot: () => React.FC<{}> | null;
-export declare const waitForRoot: (fn: (comp: React.FC<{}>) => void) => () => void;
+export declare const waitForRoot: (fn: (comp: React.FC) => void) => (() => void);

package/dist/cjs/render-resource-manager.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 export type RenderResourceManager = {
-    getOrCreateResource: <T>({ key, create }: {
+    getOrCreateResource: <T>({ key, create, }: {
         key: string;
         create: () => {
             resource: T;

package/dist/cjs/render-types.d.ts

@@ -1,4 +1,4 @@
-export declare const validVideoImageFormats: readonly ["png", "jpeg", "none"];
+export declare const validVideoImageFormats: readonly ['png', 'jpeg', 'none'];
 export type VideoImageFormat = (typeof validVideoImageFormats)[number];
-export declare const validPixelFormats: readonly ["yuv420p", "yuva420p", "yuv422p", "yuv444p", "yuv420p10le", "yuv422p10le", "yuv444p10le", "yuva444p10le"];
+export declare const validPixelFormats: readonly ['yuv420p', 'yuva420p', 'yuv422p', 'yuv444p', 'yuv420p10le', 'yuv422p10le', 'yuv444p10le', 'yuva444p10le'];
 export type PixelFormat = (typeof validPixelFormats)[number];