@remotion/studio 4.0.424 → 4.0.426

package/dist/components/RenderModal/SchemaEditor/ZodSwitch.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZodSwitch = void 0;
 const jsx_runtime_1 = require("react/jsx-runtime");
 const get_zod_if_possible_1 = require("../../get-zod-if-possible");
+const zod_schema_type_1 = require("./zod-schema-type");
 const ZodArrayEditor_1 = require("./ZodArrayEditor");
 const ZodBooleanEditor_1 = require("./ZodBooleanEditor");
 const ZodColorEditor_1 = require("./ZodColorEditor");
@@ -23,87 +24,91 @@ const ZodTextareaEditor_1 = require("./ZodTextareaEditor");
 const ZodTupleEditor_1 = require("./ZodTupleEditor");
 const ZodUnionEditor_1 = require("./ZodUnionEditor");
 const ZodSwitch = ({ schema, jsonPath, value, setValue, defaultValue, onSave, showSaveButton, onRemove, saving, saveDisabledByParent, mayPad, }) => {
-    const def = schema._def;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const typeName = def.typeName;
-    const z = (0, get_zod_if_possible_1.useZodIfPossible)();
-    if (!z) {
-        throw new Error('expected zod');
-    }
+    const typeName = (0, zod_schema_type_1.getZodSchemaType)(schema);
+    const description = (0, zod_schema_type_1.getZodSchemaDescription)(schema);
     const zodTypes = (0, get_zod_if_possible_1.useZodTypesIfPossible)();
-    if (typeName === z.ZodFirstPartyTypeKind.ZodObject) {
+    if (typeName === 'object') {
         return (jsx_runtime_1.jsx(ZodObjectEditor_1.ZodObjectEditor, { setValue: setValue, unsavedValue: value, savedValue: defaultValue, jsonPath: jsonPath, schema: schema, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad, discriminatedUnionReplacement: null }));
     }
-    if (typeName === z.ZodFirstPartyTypeKind.ZodString) {
+    if (typeName === 'string') {
+        // In v4, .refine() doesn't wrap in ZodEffects, so check brand here too
+        if (zodTypes &&
+            description === zodTypes.ZodZypesInternals.REMOTION_COLOR_BRAND) {
+            return (jsx_runtime_1.jsx(ZodColorEditor_1.ZodColorEditor, { value: value, setValue: setValue, jsonPath: jsonPath, schema: schema, onSave: onSave, defaultValue: defaultValue, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
+        }
         if (value.startsWith(window.remotion_staticBase)) {
             return (jsx_runtime_1.jsx(ZodStaticFileEditor_1.ZodStaticFileEditor, { setValue: setValue, value: value, jsonPath: jsonPath, schema: schema, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
         }
         if (zodTypes &&
-            schema._def.description ===
-                zodTypes.ZodZypesInternals.REMOTION_TEXTAREA_BRAND) {
+            description === zodTypes.ZodZypesInternals.REMOTION_TEXTAREA_BRAND) {
             return (jsx_runtime_1.jsx(ZodTextareaEditor_1.ZodTextareaEditor, { value: value, setValue: setValue, jsonPath: jsonPath, schema: schema, onSave: onSave, defaultValue: defaultValue, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
         }
         return (jsx_runtime_1.jsx(ZodStringEditor_1.ZodStringEditor, { value: value, setValue: setValue, jsonPath: jsonPath, schema: schema, onSave: onSave, defaultValue: defaultValue, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
     }
-    if (typeName === z.ZodFirstPartyTypeKind.ZodDate) {
+    if (typeName === 'date') {
         return (jsx_runtime_1.jsx(ZodDateEditor_1.ZodDateEditor, { value: value, setValue: setValue, jsonPath: jsonPath, schema: schema, onSave: onSave, defaultValue: defaultValue, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
     }
-    if (typeName === z.ZodFirstPartyTypeKind.ZodNumber) {
+    if (typeName === 'number') {
         return (jsx_runtime_1.jsx(ZodNumberEditor_1.ZodNumberEditor, { value: value, setValue: setValue, jsonPath: jsonPath, schema: schema, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
     }
-    if (typeName === z.ZodFirstPartyTypeKind.ZodBoolean) {
+    if (typeName === 'boolean') {
         return (jsx_runtime_1.jsx(ZodBooleanEditor_1.ZodBooleanEditor, { value: value, setValue: setValue, jsonPath: jsonPath, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad, schema: schema }));
     }
-    if (typeName === z.ZodFirstPartyTypeKind.ZodUndefined) {
+    if (typeName === 'undefined') {
         return (jsx_runtime_1.jsx(ZodNonEditableValue_1.ZonNonEditableValue, { jsonPath: jsonPath, showSaveButton: showSaveButton, label: 'undefined', saving: saving, mayPad: mayPad }));
     }
-    if (typeName === z.ZodFirstPartyTypeKind.ZodNull) {
+    if (typeName === 'null') {
         return (jsx_runtime_1.jsx(ZodNonEditableValue_1.ZonNonEditableValue, { jsonPath: jsonPath, showSaveButton: showSaveButton, label: 'null', saving: saving, mayPad: mayPad }));
     }
-    if (typeName === z.ZodFirstPartyTypeKind.ZodAny) {
+    if (typeName === 'any') {
         return (jsx_runtime_1.jsx(ZodNonEditableValue_1.ZonNonEditableValue, { jsonPath: jsonPath, showSaveButton: showSaveButton, label: 'any (not editable)', saving: saving, mayPad: mayPad }));
     }
-    if (typeName === z.ZodFirstPartyTypeKind.ZodBigInt) {
+    if (typeName === 'bigint') {
         return (jsx_runtime_1.jsx(ZodNonEditableValue_1.ZonNonEditableValue, { jsonPath: jsonPath, showSaveButton: showSaveButton, label: 'BigInt (not editable)', saving: saving, mayPad: mayPad }));
     }
-    if (typeName === z.ZodFirstPartyTypeKind.ZodUnknown) {
+    if (typeName === 'unknown') {
         return (jsx_runtime_1.jsx(ZodNonEditableValue_1.ZonNonEditableValue, { jsonPath: jsonPath, showSaveButton: showSaveButton, label: 'unknown (not editable)', saving: saving, mayPad: mayPad }));
     }
-    if (typeName === z.ZodFirstPartyTypeKind.ZodArray) {
+    if (typeName === 'array') {
+        // In v4, .refine() doesn't wrap in ZodEffects, so check brand here too
+        if (zodTypes &&
+            description === zodTypes.ZodZypesInternals.REMOTION_MATRIX_BRAND) {
+            return (jsx_runtime_1.jsx(ZodMatrixEditor_1.ZodMatrixEditor, { setValue: setValue, value: value, jsonPath: jsonPath, schema: schema, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
+        }
         return (jsx_runtime_1.jsx(ZodArrayEditor_1.ZodArrayEditor, { setValue: setValue, value: value, jsonPath: jsonPath, schema: schema, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
     }
-    if (typeName === z.ZodFirstPartyTypeKind.ZodEnum) {
+    if (typeName === 'enum') {
         return (jsx_runtime_1.jsx(ZodEnumEditor_1.ZodEnumEditor, { setValue: setValue, value: value, jsonPath: jsonPath, schema: schema, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving }));
     }
-    if (typeName === z.ZodFirstPartyTypeKind.ZodEffects) {
+    // In v3, effects wrap schemas (e.g. .refine(), .transform()).
+    // In v4, refine/transform are embedded as checks, so this only applies to v3.
+    if (typeName === 'effects') {
         if (zodTypes &&
-            schema._def.description ===
-                zodTypes.ZodZypesInternals.REMOTION_COLOR_BRAND) {
+            description === zodTypes.ZodZypesInternals.REMOTION_COLOR_BRAND) {
             return (jsx_runtime_1.jsx(ZodColorEditor_1.ZodColorEditor, { value: value, setValue: setValue, jsonPath: jsonPath, schema: schema, onSave: onSave, defaultValue: defaultValue, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
         }
         if (zodTypes &&
-            schema._def.description ===
-                zodTypes.ZodZypesInternals.REMOTION_MATRIX_BRAND) {
-            return (jsx_runtime_1.jsx(ZodMatrixEditor_1.ZodMatrixEditor, { setValue: setValue, value: value, jsonPath: jsonPath, schema: schema._def.schema, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
+            description === zodTypes.ZodZypesInternals.REMOTION_MATRIX_BRAND) {
+            return (jsx_runtime_1.jsx(ZodMatrixEditor_1.ZodMatrixEditor, { setValue: setValue, value: value, jsonPath: jsonPath, schema: (0, zod_schema_type_1.getEffectsInner)(schema), defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
         }
         return (jsx_runtime_1.jsx(ZodEffectEditor_1.ZodEffectEditor, { value: value, setValue: setValue, jsonPath: jsonPath, schema: schema, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, mayPad: mayPad }));
     }
-    if (typeName === z.ZodFirstPartyTypeKind.ZodUnion) {
+    if (typeName === 'union') {
         return (jsx_runtime_1.jsx(ZodUnionEditor_1.ZodUnionEditor, { schema: schema, showSaveButton: showSaveButton, jsonPath: jsonPath, value: value, defaultValue: defaultValue, setValue: setValue, onSave: onSave, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
     }
-    if (typeName === z.ZodFirstPartyTypeKind.ZodOptional) {
+    if (typeName === 'optional') {
         return (jsx_runtime_1.jsx(ZodOptionalEditor_1.ZodOptionalEditor, { jsonPath: jsonPath, showSaveButton: showSaveButton, defaultValue: defaultValue, value: value, setValue: setValue, onSave: onSave, onRemove: onRemove, schema: schema, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
     }
-    if (typeName === z.ZodFirstPartyTypeKind.ZodNullable) {
+    if (typeName === 'nullable') {
         return (jsx_runtime_1.jsx(ZodNullableEditor_1.ZodNullableEditor, { jsonPath: jsonPath, showSaveButton: showSaveButton, defaultValue: defaultValue, value: value, setValue: setValue, onSave: onSave, onRemove: onRemove, schema: schema, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
     }
-    if (typeName === z.ZodFirstPartyTypeKind.ZodDefault) {
+    if (typeName === 'default') {
         return (jsx_runtime_1.jsx(ZodDefaultEditor_1.ZodDefaultEditor, { jsonPath: jsonPath, showSaveButton: showSaveButton, defaultValue: defaultValue, value: value, setValue: setValue, onSave: onSave, onRemove: onRemove, schema: schema, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
     }
-    if (typeName === z.ZodFirstPartyTypeKind.ZodDiscriminatedUnion) {
+    if (typeName === 'discriminatedUnion') {
         return (jsx_runtime_1.jsx(ZodDiscriminatedUnionEditor_1.ZodDiscriminatedUnionEditor, { defaultValue: defaultValue, mayPad: mayPad, schema: schema, setValue: setValue, value: value, jsonPath: jsonPath, onRemove: onRemove, onSave: onSave, saving: saving, saveDisabledByParent: saveDisabledByParent, showSaveButton: showSaveButton }));
     }
-    if (typeName === z.ZodFirstPartyTypeKind.ZodTuple) {
+    if (typeName === 'tuple') {
         return (jsx_runtime_1.jsx(ZodTupleEditor_1.ZodTupleEditor, { setValue: setValue, value: value, jsonPath: jsonPath, schema: schema, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
     }
     return (jsx_runtime_1.jsx(ZodNonEditableValue_1.ZonNonEditableValue, { jsonPath: jsonPath, showSaveButton: showSaveButton, label: `${typeName} (not editable)`, saving: saving, mayPad: mayPad }));

package/dist/components/RenderModal/SchemaEditor/ZodTextareaEditor.d.ts

@@ -1,9 +1,9 @@
 import React from 'react';
-import type { z } from 'zod';
 import type { UpdaterFunction } from './ZodSwitch';
+import type { AnyZodSchema } from './zod-schema-type';
 import type { JSONPath } from './zod-types';
 export declare const ZodTextareaEditor: React.FC<{
-    readonly schema: z.ZodTypeAny;
+    readonly schema: AnyZodSchema;
     readonly jsonPath: JSONPath;
     readonly value: string;
     readonly defaultValue: string;

package/dist/components/RenderModal/SchemaEditor/ZodTupleEditor.d.ts

@@ -1,9 +1,9 @@
 import React from 'react';
-import type { z } from 'zod';
+import type { AnyZodSchema } from './zod-schema-type';
 import type { JSONPath } from './zod-types';
 import type { UpdaterFunction } from './ZodSwitch';
 export declare const ZodTupleEditor: React.FC<{
-    readonly schema: z.ZodTypeAny;
+    readonly schema: AnyZodSchema;
     readonly jsonPath: JSONPath;
     readonly value: unknown[];
     readonly defaultValue: unknown[];

package/dist/components/RenderModal/SchemaEditor/ZodTupleEditor.js

@@ -44,6 +44,7 @@ const local_state_1 = require("./local-state");
 const SchemaLabel_1 = require("./SchemaLabel");
 const SchemaSeparationLine_1 = require("./SchemaSeparationLine");
 const SchemaVerticalGuide_1 = require("./SchemaVerticalGuide");
+const zod_schema_type_1 = require("./zod-schema-type");
 const ZodFieldValidation_1 = require("./ZodFieldValidation");
 const ZodTupleItemEditor_1 = require("./ZodTupleItemEditor");
 const ZodTupleEditor = ({ schema, jsonPath, setValue, defaultValue, value, onSave, showSaveButton, onRemove, saving, saveDisabledByParent, mayPad, }) => {
@@ -54,7 +55,7 @@ const ZodTupleEditor = ({ schema, jsonPath, setValue, defaultValue, value, onSav
         savedValue: defaultValue,
     });
     const [expanded, setExpanded] = (0, react_1.useState)(true);
-    const def = schema._def;
+    const tupleItems = (0, zod_schema_type_1.getTupleItems)(schema);
     const suffix = (0, react_1.useMemo)(() => {
         return expanded ? ' [' : ' [...] ';
     }, [expanded]);
@@ -63,10 +64,6 @@ const ZodTupleEditor = ({ schema, jsonPath, setValue, defaultValue, value, onSav
         throw new Error('expected zod');
     }
     const zodTypes = (0, get_zod_if_possible_1.useZodTypesIfPossible)();
-    const typeName = def.typeName;
-    if (typeName !== z.ZodFirstPartyTypeKind.ZodTuple) {
-        throw new Error('expected object');
-    }
     const isDefaultValue = (0, react_1.useMemo)(() => {
         return (0, deep_equal_1.deepEqual)(localValue.value, defaultValue);
     }, [defaultValue, localValue]);
@@ -81,7 +78,7 @@ const ZodTupleEditor = ({ schema, jsonPath, setValue, defaultValue, value, onSav
                             return (
                             // eslint-disable-next-line react/no-array-index-key
                             jsx_runtime_1.jsxs(react_1.default.Fragment, { children: [
-                                    jsx_runtime_1.jsx(ZodTupleItemEditor_1.ZodTupleItemEditor, { onChange: onChange, value: child, def: def, index: i, jsonPath: jsonPath, defaultValue: (_a = defaultValue === null || defaultValue === void 0 ? void 0 : defaultValue[i]) !== null && _a !== void 0 ? _a : (0, create_zod_values_1.createZodValues)(def.items[i], z, zodTypes), onSave: onSave, showSaveButton: showSaveButton, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }), jsx_runtime_1.jsx(SchemaSeparationLine_1.SchemaArrayItemSeparationLine, { schema: schema, index: i, onChange: onChange, isLast: i === localValue.value.length - 1, showAddButton: false })
+                                    jsx_runtime_1.jsx(ZodTupleItemEditor_1.ZodTupleItemEditor, { onChange: onChange, value: child, tupleItems: tupleItems, index: i, jsonPath: jsonPath, defaultValue: (_a = defaultValue === null || defaultValue === void 0 ? void 0 : defaultValue[i]) !== null && _a !== void 0 ? _a : (0, create_zod_values_1.createZodValues)(tupleItems[i], z, zodTypes), onSave: onSave, showSaveButton: showSaveButton, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }), jsx_runtime_1.jsx(SchemaSeparationLine_1.SchemaArrayItemSeparationLine, { schema: schema, index: i, onChange: onChange, isLast: i === localValue.value.length - 1, showAddButton: false })
                                 ] }, `${i}${localValue.keyStabilityRevision}`));
                         }), value.length === 0 ? (jsx_runtime_1.jsx(SchemaSeparationLine_1.SchemaArrayItemSeparationLine, { schema: schema, index: 0, onChange: onChange, isLast: true, showAddButton: false })) : null] }) })) : null, jsx_runtime_1.jsx(ZodFieldValidation_1.ZodFieldValidation, { path: jsonPath, localValue: localValue })
         ] }));

package/dist/components/RenderModal/SchemaEditor/ZodTupleItemEditor.d.ts

@@ -1,9 +1,10 @@
 import type { UpdaterFunction } from './ZodSwitch';
+import type { AnyZodSchema } from './zod-schema-type';
 import type { JSONPath } from './zod-types';
 export declare const ZodTupleItemEditor: React.FC<{
     jsonPath: JSONPath;
     onChange: UpdaterFunction<unknown[]>;
-    def: any;
+    tupleItems: AnyZodSchema[];
     index: number;
     value: unknown;
     defaultValue: unknown;

package/dist/components/RenderModal/SchemaEditor/ZodTupleItemEditor.js

@@ -5,7 +5,7 @@ const jsx_runtime_1 = require("react/jsx-runtime");
 const react_1 = require("react");
 const get_zod_if_possible_1 = require("../../get-zod-if-possible");
 const ZodSwitch_1 = require("./ZodSwitch");
-const ZodTupleItemEditor = ({ def, onChange, jsonPath, index, value, defaultValue, onSave: onSaveObject, showSaveButton, saving, saveDisabledByParent, mayPad, }) => {
+const ZodTupleItemEditor = ({ tupleItems, onChange, jsonPath, index, value, defaultValue, onSave: onSaveObject, showSaveButton, saving, saveDisabledByParent, mayPad, }) => {
     const z = (0, get_zod_if_possible_1.useZodIfPossible)();
     if (!z) {
         throw new Error('expected zod');
@@ -25,6 +25,6 @@ const ZodTupleItemEditor = ({ def, onChange, jsonPath, index, value, defaultValu
             ...oldV.slice(index + 1),
         ], false, false);
     }, [index, onSaveObject]);
-    return (jsx_runtime_1.jsx("div", { children: jsx_runtime_1.jsx(ZodSwitch_1.ZodSwitch, { jsonPath: newJsonPath, schema: def.items[index], value: value, setValue: setValue, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: null, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }) }));
+    return (jsx_runtime_1.jsx("div", { children: jsx_runtime_1.jsx(ZodSwitch_1.ZodSwitch, { jsonPath: newJsonPath, schema: tupleItems[index], value: value, setValue: setValue, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: null, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }) }));
 };
 exports.ZodTupleItemEditor = ZodTupleItemEditor;

package/dist/components/RenderModal/SchemaEditor/ZodUnionEditor.d.ts

@@ -1,12 +1,12 @@
-import type { z } from 'zod';
 import type { UpdaterFunction } from './ZodSwitch';
+import type { AnyZodSchema } from './zod-schema-type';
 import type { JSONPath } from './zod-types';
 export declare const ZodUnionEditor: React.FC<{
     showSaveButton: boolean;
     jsonPath: JSONPath;
     value: unknown;
     defaultValue: unknown;
-    schema: z.ZodTypeAny;
+    schema: AnyZodSchema;
     setValue: UpdaterFunction<unknown>;
     onSave: UpdaterFunction<unknown>;
     onRemove: null | (() => void);

package/dist/components/RenderModal/SchemaEditor/ZodUnionEditor.js

@@ -2,21 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZodUnionEditor = void 0;
 const jsx_runtime_1 = require("react/jsx-runtime");
-const get_zod_if_possible_1 = require("../../get-zod-if-possible");
 const ZodNonEditableValue_1 = require("./ZodNonEditableValue");
 const ZodOrNullishEditor_1 = require("./ZodOrNullishEditor");
-const findNull = (value, zodType) => {
-    const nullIndex = value.findIndex((v) => v._def.typeName === zodType.ZodFirstPartyTypeKind.ZodNull ||
-        v._def.typeName === zodType.ZodFirstPartyTypeKind.ZodUndefined);
+const zod_schema_type_1 = require("./zod-schema-type");
+const findNull = (value) => {
+    const nullIndex = value.findIndex((v) => {
+        const type = (0, zod_schema_type_1.getZodSchemaType)(v);
+        return type === 'null' || type === 'undefined';
+    });
     if (nullIndex === -1) {
         return null;
     }
-    const nullishValue = value[nullIndex]._def.typeName === zodType.ZodFirstPartyTypeKind.ZodNull
-        ? null
-        : undefined;
+    const nullishValue = (0, zod_schema_type_1.getZodSchemaType)(value[nullIndex]) === 'null' ? null : undefined;
     const otherSchema = value[nullIndex === 0 ? 1 : 0];
-    const otherSchemaIsAlsoNullish = otherSchema._def.typeName === zodType.ZodFirstPartyTypeKind.ZodNull ||
-        otherSchema._def.typeName === zodType.ZodFirstPartyTypeKind.ZodUndefined;
+    const otherType = (0, zod_schema_type_1.getZodSchemaType)(otherSchema);
+    const otherSchemaIsAlsoNullish = otherType === 'null' || otherType === 'undefined';
     return {
         nullIndex,
         nullishValue,
@@ -25,18 +25,14 @@ const findNull = (value, zodType) => {
     };
 };
 const ZodUnionEditor = ({ jsonPath, schema, setValue, onSave, defaultValue, value, showSaveButton, onRemove, saving, saveDisabledByParent, mayPad, }) => {
-    const { options } = schema._def;
-    const z = (0, get_zod_if_possible_1.useZodIfPossible)();
-    if (!z) {
-        throw new Error('expected zod');
-    }
+    const options = (0, zod_schema_type_1.getUnionOptions)(schema);
     if (options.length > 2) {
         return (jsx_runtime_1.jsx(ZodNonEditableValue_1.ZonNonEditableValue, { jsonPath: jsonPath, label: 'Union with more than 2 options not editable', showSaveButton: showSaveButton, saving: saving, mayPad: mayPad }));
     }
     if (options.length < 2) {
         return (jsx_runtime_1.jsx(ZodNonEditableValue_1.ZonNonEditableValue, { jsonPath: jsonPath, label: 'Union with less than 2 options not editable', showSaveButton: showSaveButton, saving: saving, mayPad: mayPad }));
     }
-    const nullResult = findNull(options, z);
+    const nullResult = findNull(options);
     if (!nullResult) {
         return (jsx_runtime_1.jsx(ZodNonEditableValue_1.ZonNonEditableValue, { jsonPath: jsonPath, label: 'Union only editable with 1 value being null', showSaveButton: showSaveButton, saving: saving, mayPad: mayPad }));
     }

package/dist/components/RenderModal/SchemaEditor/create-zod-values.d.ts

@@ -1,2 +1,2 @@
-import type { z } from 'zod';
-export declare const createZodValues: (schema: z.ZodTypeAny, zodRuntime: typeof z, zodTypes: typeof import("@remotion/zod-types") | null) => unknown;
+import { type AnyZodSchema } from './zod-schema-type';
+export declare const createZodValues: (schema: AnyZodSchema, zodRuntime: unknown, zodTypes: typeof import("@remotion/zod-types") | null) => unknown;

package/dist/components/RenderModal/SchemaEditor/create-zod-values.js

@@ -1,50 +1,82 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createZodValues = void 0;
+const zod_schema_type_1 = require("./zod-schema-type");
 const createZodValues = (schema, zodRuntime, zodTypes) => {
+    var _a;
     if (!schema) {
         throw new Error('Invalid zod schema');
     }
-    const def = schema._def;
-    const typeName = def.typeName;
+    // In v4, .refine()/.describe() don't wrap in effects — the description
+    // lives directly on the schema. Check for branded descriptions early
+    // so they are detected regardless of the underlying type.
+    const description = (0, zod_schema_type_1.getZodSchemaDescription)(schema);
+    if (zodTypes) {
+        if (description === zodTypes.ZodZypesInternals.REMOTION_COLOR_BRAND) {
+            return '#ffffff';
+        }
+        if (description === zodTypes.ZodZypesInternals.REMOTION_TEXTAREA_BRAND) {
+            return '';
+        }
+        if (description === zodTypes.ZodZypesInternals.REMOTION_MATRIX_BRAND) {
+            return [
+                [1, 0, 0],
+                [0, 1, 0],
+                [0, 0, 1],
+            ];
+        }
+    }
+    const typeName = (0, zod_schema_type_1.getZodSchemaType)(schema);
     switch (typeName) {
-        case zodRuntime.ZodFirstPartyTypeKind.ZodString:
+        case 'string':
             return '';
-        case zodRuntime.ZodFirstPartyTypeKind.ZodNumber: {
-            for (const check of def.checks) {
-                if (check.kind === 'min') {
-                    return check.value;
+        case 'number': {
+            const { checks } = (0, zod_schema_type_1.getZodDef)(schema);
+            if (checks) {
+                if ((0, zod_schema_type_1.isZodV3Schema)(schema)) {
+                    for (const check of checks) {
+                        if (check.kind === 'min')
+                            return check.value;
+                        if (check.kind === 'max' && check.value < 0)
+                            return check.value;
+                    }
                 }
-                if (check.kind === 'max' && check.value < 0) {
-                    return check.value;
+                else {
+                    for (const check of checks) {
+                        const cd = (_a = check._zod) === null || _a === void 0 ? void 0 : _a.def;
+                        if ((cd === null || cd === void 0 ? void 0 : cd.check) === 'greater_than')
+                            return cd.value;
+                        if ((cd === null || cd === void 0 ? void 0 : cd.check) === 'less_than' && cd.value < 0)
+                            return cd.value;
+                    }
                 }
             }
             return 0;
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodBigInt:
+        case 'bigint':
             return BigInt(0);
-        case zodRuntime.ZodFirstPartyTypeKind.ZodBoolean:
+        case 'boolean':
             return false;
-        case zodRuntime.ZodFirstPartyTypeKind.ZodNaN:
+        case 'nan':
             return NaN;
-        case zodRuntime.ZodFirstPartyTypeKind.ZodDate:
+        case 'date':
             return new Date();
-        case zodRuntime.ZodFirstPartyTypeKind.ZodSymbol:
+        case 'symbol':
             return Symbol('remotion');
-        case zodRuntime.ZodFirstPartyTypeKind.ZodUndefined:
+        case 'undefined':
+        case 'void':
             return undefined;
-        case zodRuntime.ZodFirstPartyTypeKind.ZodNull:
+        case 'null':
             return null;
-        case zodRuntime.ZodFirstPartyTypeKind.ZodAny:
+        case 'any':
+        case 'custom':
             throw new Error('Cannot create a value for type z.any()');
-        case zodRuntime.ZodFirstPartyTypeKind.ZodUnknown:
+        case 'unknown':
             throw new Error('Cannot create a value for type z.unknown()');
-        case zodRuntime.ZodFirstPartyTypeKind.ZodNever:
+        case 'never':
             throw new Error('Cannot create a value for type z.never()');
-        case zodRuntime.ZodFirstPartyTypeKind.ZodVoid:
-            return undefined;
-        case zodRuntime.ZodFirstPartyTypeKind.ZodObject: {
-            const shape = def.shape();
+        case 'object': {
+            const shape = (0, zod_schema_type_1.getObjectShape)(schema);
             const keys = Object.keys(shape);
             const returnValue = keys.reduce((existing, key) => {
                 existing[key] = (0, exports.createZodValues)(shape[key], zodRuntime, zodTypes);
@@ -52,48 +84,27 @@ const createZodValues = (schema, zodRuntime, zodTypes) => {
             }, {});
             return returnValue;
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodArray: {
-            return [
-                (0, exports.createZodValues)(def.type, zodRuntime, zodTypes),
-            ];
+        case 'array': {
+            return [(0, exports.createZodValues)((0, zod_schema_type_1.getArrayElement)(schema), zodRuntime, zodTypes)];
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodUnion: {
-            const firstOptions = def.options[0];
-            return firstOptions
-                ? (0, exports.createZodValues)(firstOptions, zodRuntime, zodTypes)
+        case 'union': {
+            const firstOption = (0, zod_schema_type_1.getUnionOptions)(schema)[0];
+            return firstOption
+                ? (0, exports.createZodValues)(firstOption, zodRuntime, zodTypes)
                 : undefined;
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodDiscriminatedUnion: {
-            const options = def.options[0];
-            return (0, exports.createZodValues)(options, zodRuntime, zodTypes);
+        case 'discriminatedUnion': {
+            const firstOption = (0, zod_schema_type_1.getUnionOptions)(schema)[0];
+            return (0, exports.createZodValues)(firstOption, zodRuntime, zodTypes);
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodLiteral: {
-            return def.value;
+        case 'literal': {
+            return (0, zod_schema_type_1.getLiteralValue)(schema);
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodEffects: {
-            if (zodTypes &&
-                schema._def.description ===
-                    zodTypes.ZodZypesInternals.REMOTION_COLOR_BRAND) {
-                return '#ffffff';
-            }
-            if (zodTypes &&
-                schema._def.description ===
-                    zodTypes.ZodZypesInternals.REMOTION_TEXTAREA_BRAND) {
-                return '';
-            }
-            if (zodTypes &&
-                schema._def.description ===
-                    zodTypes.ZodZypesInternals.REMOTION_MATRIX_BRAND) {
-                return [
-                    [1, 0, 0],
-                    [0, 1, 0],
-                    [0, 0, 1],
-                ];
-            }
-            return (0, exports.createZodValues)(def.schema, zodRuntime, zodTypes);
+        case 'effects': {
+            return (0, exports.createZodValues)((0, zod_schema_type_1.getEffectsInner)(schema), zodRuntime, zodTypes);
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodIntersection: {
-            const { left, right } = def;
+        case 'intersection': {
+            const { left, right } = (0, zod_schema_type_1.getIntersectionSchemas)(schema);
             const leftValue = (0, exports.createZodValues)(left, zodRuntime, zodTypes);
             if (typeof leftValue !== 'object') {
                 throw new Error('Cannot create value for type z.intersection: Left side is not an object');
@@ -104,75 +115,62 @@ const createZodValues = (schema, zodRuntime, zodTypes) => {
             }
             return { ...leftValue, ...rightValue };
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodTuple: {
-            const items = def.items.map((item) => (0, exports.createZodValues)(item, zodRuntime, zodTypes));
-            return items;
+        case 'tuple': {
+            return (0, zod_schema_type_1.getTupleItems)(schema).map((item) => (0, exports.createZodValues)(item, zodRuntime, zodTypes));
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodRecord: {
-            const values = (0, exports.createZodValues)(def.valueType, zodRuntime, zodTypes);
+        case 'record': {
+            const values = (0, exports.createZodValues)((0, zod_schema_type_1.getRecordValueType)(schema), zodRuntime, zodTypes);
             return { key: values };
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodMap: {
-            const defType = def;
-            const values = (0, exports.createZodValues)(defType.valueType, zodRuntime, zodTypes);
-            const key = (0, exports.createZodValues)(defType.keyType, zodRuntime, zodTypes);
+        case 'map': {
+            const values = (0, exports.createZodValues)((0, zod_schema_type_1.getRecordValueType)(schema), zodRuntime, zodTypes);
+            const key = (0, exports.createZodValues)((0, zod_schema_type_1.getRecordKeyType)(schema), zodRuntime, zodTypes);
             return new Map([[key, values]]);
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodLazy: {
-            const defType = def;
-            const type = defType.getter();
+        case 'lazy': {
+            const type = (0, zod_schema_type_1.getZodDef)(schema).getter();
             return (0, exports.createZodValues)(type, zodRuntime, zodTypes);
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodSet: {
-            const defType = def;
-            const values = (0, exports.createZodValues)(defType.valueType, zodRuntime, zodTypes);
+        case 'set': {
+            const values = (0, exports.createZodValues)((0, zod_schema_type_1.getZodDef)(schema).valueType, zodRuntime, zodTypes);
             return new Set([values]);
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodFunction: {
+        case 'function': {
             throw new Error('Cannot create a value for type function');
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodEnum: {
-            const { values } = def;
-            return values[0];
+        case 'enum': {
+            return (0, zod_schema_type_1.getFirstEnumValue)(schema);
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodNativeEnum: {
+        case 'nativeEnum': {
             return 0;
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodOptional: {
-            const defType = def;
-            const value = (0, exports.createZodValues)(defType.innerType, zodRuntime, zodTypes);
-            return value;
+        case 'optional':
+        case 'nullable':
+        case 'catch': {
+            return (0, exports.createZodValues)((0, zod_schema_type_1.getInnerType)(schema), zodRuntime, zodTypes);
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodNullable: {
-            const defType = def;
-            const value = (0, exports.createZodValues)(defType.innerType, zodRuntime, zodTypes);
-            return value;
+        case 'default': {
+            return (0, zod_schema_type_1.getDefaultValue)(schema);
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodDefault: {
-            const defType = def;
-            return defType.defaultValue();
-        }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodCatch: {
-            const defType = def;
-            const value = (0, exports.createZodValues)(defType.innerType, zodRuntime, zodTypes);
-            return value;
-        }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodPromise: {
-            const defType = def;
-            const value = (0, exports.createZodValues)(defType.type, zodRuntime, zodTypes);
+        case 'promise': {
+            const def = (0, zod_schema_type_1.getZodDef)(schema);
+            // v3: _def.type, v4: _def.innerType
+            const inner = (0, zod_schema_type_1.isZodV3Schema)(schema) ? def.type : def.innerType;
+            const value = (0, exports.createZodValues)(inner, zodRuntime, zodTypes);
             return Promise.resolve(value);
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodBranded: {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const defType = def;
-            const value = (0, exports.createZodValues)(defType.type, zodRuntime, zodTypes);
-            return value;
-        }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodPipeline: {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const defType = def;
-            const value = (0, exports.createZodValues)(defType.out, zodRuntime, zodTypes);
-            return value;
+        case 'branded': {
+            return (0, exports.createZodValues)((0, zod_schema_type_1.getBrandedInner)(schema), zodRuntime, zodTypes);
+        }
+        case 'pipeline':
+        case 'pipe': {
+            const out = (0, zod_schema_type_1.getPipelineOutput)(schema);
+            // In v4, .transform() creates pipe { in, out: transform }.
+            // Since we don't apply transforms, use the input side.
+            if ((0, zod_schema_type_1.getZodSchemaType)(out) === 'transform') {
+                return (0, exports.createZodValues)((0, zod_schema_type_1.getPipelineInput)(schema), zodRuntime, zodTypes);
+            }
+            return (0, exports.createZodValues)(out, zodRuntime, zodTypes);
         }
         default:
             throw new Error('Not implemented: ' + typeName);

package/dist/components/RenderModal/SchemaEditor/extract-enum-json-paths.d.ts

@@ -1,7 +1,7 @@
-import type { z } from 'zod';
+import { type AnyZodSchema } from './zod-schema-type';
 export declare const extractEnumJsonPaths: ({ schema, zodRuntime, currentPath, zodTypes, }: {
-    schema: z.ZodTypeAny;
-    zodRuntime: typeof z;
+    schema: AnyZodSchema;
+    zodRuntime: unknown;
     zodTypes: typeof import("@remotion/zod-types") | null;
     currentPath: (string | number)[];
 }) => (string | number)[][];