@remotion/studio 4.0.425 → 4.0.426

package/dist/esm/{chunk-5wcqz8k8.js → chunk-kde77jse.js}

@@ -3693,7 +3693,8 @@ var AssetFolderItem = ({
   parentFolder,
   toggleFolder,
   dropLocation,
-  setDropLocation
+  setDropLocation,
+  readOnlyStudio
 }) => {
   const [hovered, setHovered] = useState15(false);
   const openFolderTimerRef = useRef12(null);
@@ -3776,7 +3777,8 @@ var AssetFolderItem = ({
         tabIndex,
         toggleFolder,
         dropLocation,
-        setDropLocation
+        setDropLocation,
+        readOnlyStudio
       }, item.name) : null
     ]
   });
@@ -3789,7 +3791,8 @@ var AssetFolderTree = ({
   toggleFolder,
   tabIndex,
   dropLocation,
-  setDropLocation
+  setDropLocation,
+  readOnlyStudio
 }) => {
   const combinedParents = useMemo23(() => {
     return [parentFolder, name].filter(NoReactInternals3.truthy).join("/");
@@ -3804,7 +3807,8 @@ var AssetFolderTree = ({
           parentFolder: combinedParents,
           toggleFolder,
           dropLocation,
-          setDropLocation
+          setDropLocation,
+          readOnlyStudio
         }, folder.name);
       }),
       item.files.map((file) => {
@@ -3812,13 +3816,14 @@ var AssetFolderTree = ({
           item: file,
           tabIndex,
           level,
-          parentFolder: combinedParents
+          parentFolder: combinedParents,
+          readOnlyStudio
         }, file.src);
       })
     ]
   });
 };
-var AssetSelectorItem = ({ item, tabIndex, level, parentFolder }) => {
+var AssetSelectorItem = ({ item, tabIndex, level, parentFolder, readOnlyStudio }) => {
   const isMobileLayout = useMobileLayout();
   const [hovered, setHovered] = useState15(false);
   const { setSidebarCollapsedState } = useContext10(SidebarContext);
@@ -3925,13 +3930,17 @@ var AssetSelectorItem = ({ item, tabIndex, level, parentFolder }) => {
               renderAction: renderCopyAction,
               onClick: copyToClipboard
             }),
-            /* @__PURE__ */ jsx35(Spacing, {
-              x: 0.5
-            }),
-            /* @__PURE__ */ jsx35(InlineAction, {
-              title: "Open in Explorer",
-              renderAction: renderFileExplorerAction,
-              onClick: revealInExplorer
+            readOnlyStudio ? null : /* @__PURE__ */ jsxs9(Fragment5, {
+              children: [
+                /* @__PURE__ */ jsx35(Spacing, {
+                  x: 0.5
+                }),
+                /* @__PURE__ */ jsx35(InlineAction, {
+                  title: "Open in Explorer",
+                  renderAction: renderFileExplorerAction,
+                  onClick: revealInExplorer
+                })
+              ]
             })
           ]
         }) : null
@@ -4286,7 +4295,8 @@ var AssetSelector = ({ readOnlyStudio }) => {
           tabIndex,
           toggleFolder,
           dropLocation,
-          setDropLocation
+          setDropLocation,
+          readOnlyStudio
         })
       })
     ]
@@ -4579,10 +4589,16 @@ var InitialCompositionLoader = () => {
   const selectAsset = useSelectAsset();
   const staticFiles = useStaticFiles();
   useEffect15(() => {
+    const canvasContentFromUrl = deriveCanvasContentFromUrl();
     if (canvasContent) {
+      if (canvasContentFromUrl && canvasContentFromUrl.type === "composition" && canvasContent.type === "composition" && canvasContentFromUrl.compositionId !== canvasContent.compositionId) {
+        const exists = compositions.find((c) => c.id === canvasContentFromUrl.compositionId);
+        if (exists) {
+          selectComposition(exists, false);
+        }
+      }
       return;
     }
-    const canvasContentFromUrl = deriveCanvasContentFromUrl();
     if (canvasContentFromUrl && canvasContentFromUrl.type === "composition") {
       const exists = compositions.find((c) => c.id === canvasContentFromUrl.compositionId);
       if (exists) {
@@ -10841,6 +10857,14 @@ async function getZodIfPossible() {
     return null;
   }
 }
+var getZodV3IfPossible = async () => {
+  try {
+    const mod = await import("zod/v3");
+    return mod;
+  } catch {
+    return null;
+  }
+};
 var getZTypesIfPossible = async () => {
   try {
     const mod = await import("@remotion/zod-types");
@@ -10860,19 +10884,24 @@ var useZodTypesIfPossible = () => {
 var ZodContext = createContext16(null);
 var ZodProvider = ({ children }) => {
   const [zod, setZod] = useState39(null);
+  const [zodV3, setZodV3] = useState39(null);
   const [zodTypes, setZodTypes] = useState39(null);
   useEffect39(() => {
     getZodIfPossible().then((z) => setZod(z));
   }, []);
+  useEffect39(() => {
+    getZodV3IfPossible().then((z) => setZodV3(z));
+  }, []);
   useEffect39(() => {
     getZTypesIfPossible().then((z) => setZodTypes(z));
   }, []);
   const contextValue = useMemo53(() => {
     return {
       zod,
+      zodV3,
       zodTypes
     };
-  }, [zod, zodTypes]);
+  }, [zod, zodV3, zodTypes]);
   return /* @__PURE__ */ jsx95(ZodContext.Provider, {
     value: contextValue,
     children
@@ -11014,6 +11043,184 @@ import { Internals as Internals30 } from "remotion";
 // src/api/save-default-props.ts
 import { getRemotionEnvironment as getRemotionEnvironment4 } from "remotion";
 
+// src/components/RenderModal/SchemaEditor/zod-schema-type.ts
+var zodSafeParse = (schema, data) => {
+  return schema.safeParse(data);
+};
+var getZodDef = (schema) => {
+  if (schema._def)
+    return schema._def;
+  if (schema._zod)
+    return schema._zod.def;
+  throw new Error("Invalid zod schema: missing _def and _zod");
+};
+var v3TypeNameMap = {
+  ZodString: "string",
+  ZodNumber: "number",
+  ZodBoolean: "boolean",
+  ZodObject: "object",
+  ZodArray: "array",
+  ZodEnum: "enum",
+  ZodUnion: "union",
+  ZodDiscriminatedUnion: "discriminatedUnion",
+  ZodOptional: "optional",
+  ZodNullable: "nullable",
+  ZodDefault: "default",
+  ZodTuple: "tuple",
+  ZodDate: "date",
+  ZodAny: "any",
+  ZodUnknown: "unknown",
+  ZodBigInt: "bigint",
+  ZodNull: "null",
+  ZodUndefined: "undefined",
+  ZodEffects: "effects",
+  ZodLiteral: "literal",
+  ZodRecord: "record",
+  ZodNever: "never",
+  ZodVoid: "void",
+  ZodNaN: "nan",
+  ZodSymbol: "symbol",
+  ZodIntersection: "intersection",
+  ZodMap: "map",
+  ZodSet: "set",
+  ZodLazy: "lazy",
+  ZodFunction: "function",
+  ZodNativeEnum: "nativeEnum",
+  ZodCatch: "catch",
+  ZodPromise: "promise",
+  ZodBranded: "branded",
+  ZodPipeline: "pipeline"
+};
+var isZodV3Schema = (schema) => {
+  const def = getZodDef(schema);
+  return "typeName" in def;
+};
+var getZodSchemaType = (schema) => {
+  const def = getZodDef(schema);
+  if ("typeName" in def) {
+    const { typeName } = def;
+    return v3TypeNameMap[typeName] ?? typeName;
+  }
+  const { type } = def;
+  if (type === "union" && def.discriminator !== undefined) {
+    return "discriminatedUnion";
+  }
+  return type;
+};
+var getZodSchemaDescription = (schema) => {
+  if (isZodV3Schema(schema)) {
+    return getZodDef(schema).description;
+  }
+  return schema.description;
+};
+var getObjectShape = (schema) => {
+  const { shape } = getZodDef(schema);
+  return typeof shape === "function" ? shape() : shape;
+};
+var getArrayElement = (schema) => {
+  const def = getZodDef(schema);
+  return isZodV3Schema(schema) ? def.type : def.element;
+};
+var getInnerType = (schema) => {
+  return getZodDef(schema).innerType;
+};
+var getEffectsInner = (schema) => {
+  return getZodDef(schema).schema;
+};
+var getLiteralValue = (schema) => {
+  const def = getZodDef(schema);
+  if (isZodV3Schema(schema)) {
+    return def.value;
+  }
+  return def.values?.[0];
+};
+var getEnumValues = (schema) => {
+  const def = getZodDef(schema);
+  if (isZodV3Schema(schema)) {
+    return def.values;
+  }
+  const { entries } = def;
+  return Object.values(entries);
+};
+var getFirstEnumValue = (schema) => {
+  const def = getZodDef(schema);
+  if (isZodV3Schema(schema)) {
+    if (def.typeName === "ZodNativeEnum") {
+      const vals = Object.values(def.values);
+      return vals[0];
+    }
+    return def.values[0];
+  }
+  const { entries } = def;
+  const pairs = Object.entries(entries);
+  const hasReverseMapping = pairs.some(([key, value]) => key !== String(value));
+  if (hasReverseMapping) {
+    const forwardPairs = pairs.filter(([key]) => Number.isNaN(Number(key)));
+    if (forwardPairs.length > 0) {
+      return forwardPairs[0][1];
+    }
+  }
+  return Object.values(entries)[0];
+};
+var getUnionOptions = (schema) => {
+  return getZodDef(schema).options;
+};
+var getDefaultValue = (schema) => {
+  const dv = getZodDef(schema).defaultValue;
+  return typeof dv === "function" ? dv() : dv;
+};
+var getDiscriminator = (schema) => {
+  return getZodDef(schema).discriminator;
+};
+var getDiscriminatedOptionKeys = (schema) => {
+  const def = getZodDef(schema);
+  const discriminator = getDiscriminator(schema);
+  if (isZodV3Schema(schema) && def.optionsMap) {
+    return [...def.optionsMap.keys()];
+  }
+  const options = getUnionOptions(schema);
+  return options.map((option) => {
+    const shape = getObjectShape(option);
+    const discriminatorSchema = shape[discriminator];
+    return getLiteralValue(discriminatorSchema);
+  });
+};
+var getDiscriminatedOption = (schema, discriminatorValue) => {
+  const def = getZodDef(schema);
+  const discriminator = getDiscriminator(schema);
+  if (isZodV3Schema(schema) && def.optionsMap) {
+    return def.optionsMap.get(discriminatorValue);
+  }
+  const options = getUnionOptions(schema);
+  return options.find((option) => {
+    const shape = getObjectShape(option);
+    const discriminatorSchema = shape[discriminator];
+    return getLiteralValue(discriminatorSchema) === discriminatorValue;
+  });
+};
+var getIntersectionSchemas = (schema) => {
+  const def = getZodDef(schema);
+  return { left: def.left, right: def.right };
+};
+var getTupleItems = (schema) => {
+  return getZodDef(schema).items;
+};
+var getRecordValueType = (schema) => {
+  return getZodDef(schema).valueType;
+};
+var getRecordKeyType = (schema) => {
+  return getZodDef(schema).keyType;
+};
+var getPipelineOutput = (schema) => {
+  return getZodDef(schema).out;
+};
+var getPipelineInput = (schema) => {
+  return getZodDef(schema).in;
+};
+var getBrandedInner = (schema) => {
+  return isZodV3Schema(schema) ? getZodDef(schema).type : schema;
+};
+
 // src/components/RenderModal/SchemaEditor/extract-enum-json-paths.ts
 var extractEnumJsonPaths = ({
   schema,
@@ -11021,11 +11228,14 @@ var extractEnumJsonPaths = ({
   currentPath,
   zodTypes
 }) => {
-  const def = schema._def;
-  const typeName = def.typeName;
+  const description = getZodSchemaDescription(schema);
+  if (zodTypes && description === zodTypes.ZodZypesInternals.REMOTION_MATRIX_BRAND) {
+    return [currentPath];
+  }
+  const typeName = getZodSchemaType(schema);
   switch (typeName) {
-    case zodRuntime.ZodFirstPartyTypeKind.ZodObject: {
-      const shape = def.shape();
+    case "object": {
+      const shape = getObjectShape(schema);
       const keys = Object.keys(shape);
       return keys.map((key) => {
         return extractEnumJsonPaths({
@@ -11036,16 +11246,16 @@ var extractEnumJsonPaths = ({
         });
       }).flat(1);
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodArray: {
+    case "array": {
       return extractEnumJsonPaths({
-        schema: def.type,
+        schema: getArrayElement(schema),
         zodRuntime,
         currentPath: [...currentPath, "[]"],
         zodTypes
       });
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodUnion: {
-      return def.options.map((option) => {
+    case "union": {
+      return getUnionOptions(schema).map((option) => {
         return extractEnumJsonPaths({
           schema: option,
           zodRuntime,
@@ -11054,8 +11264,8 @@ var extractEnumJsonPaths = ({
         });
       }).flat(1);
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodDiscriminatedUnion: {
-      return def.options.map((op) => {
+    case "discriminatedUnion": {
+      return getUnionOptions(schema).map((op) => {
         return extractEnumJsonPaths({
           schema: op,
           zodRuntime,
@@ -11064,22 +11274,19 @@ var extractEnumJsonPaths = ({
         });
       }).flat(1);
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodLiteral: {
+    case "literal": {
       return [currentPath];
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodEffects: {
-      if (zodTypes && schema._def.description === zodTypes.ZodZypesInternals.REMOTION_MATRIX_BRAND) {
-        return [currentPath];
-      }
+    case "effects": {
       return extractEnumJsonPaths({
-        schema: def.schema,
+        schema: getEffectsInner(schema),
         zodRuntime,
         currentPath,
         zodTypes
       });
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodIntersection: {
-      const { left: left3, right } = def;
+    case "intersection": {
+      const { left: left3, right } = getIntersectionSchemas(schema);
       const leftValue = extractEnumJsonPaths({
         schema: left3,
         zodRuntime,
@@ -11094,109 +11301,94 @@ var extractEnumJsonPaths = ({
       });
       return [...leftValue, ...rightValue];
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodTuple: {
-      return def.items.map((item, i) => extractEnumJsonPaths({
+    case "tuple": {
+      return getTupleItems(schema).map((item, i) => extractEnumJsonPaths({
         schema: item,
         zodRuntime,
         currentPath: [...currentPath, i],
         zodTypes
       })).flat(1);
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodRecord: {
-      const values = extractEnumJsonPaths({
-        schema: def.valueType,
+    case "record": {
+      const recordPath = [...currentPath, "{}"];
+      const keyResults = extractEnumJsonPaths({
+        schema: getRecordKeyType(schema),
         zodRuntime,
-        currentPath: [...currentPath, "{}"],
+        currentPath: recordPath,
         zodTypes
       });
-      return values;
+      const valueResults = extractEnumJsonPaths({
+        schema: getRecordValueType(schema),
+        zodRuntime,
+        currentPath: recordPath,
+        zodTypes
+      });
+      return [...keyResults, ...valueResults];
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodFunction: {
+    case "function": {
       throw new Error("Cannot create a value for type function");
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodEnum: {
+    case "enum": {
       return [currentPath];
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodNativeEnum: {
+    case "nativeEnum": {
       return [];
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodOptional: {
-      const defType = def;
-      const value = extractEnumJsonPaths({
-        schema: defType.innerType,
-        zodRuntime,
-        currentPath,
-        zodTypes
-      });
-      return value;
-    }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodNullable: {
-      const defType = def;
-      const value = extractEnumJsonPaths({
-        schema: defType.innerType,
-        zodRuntime,
-        currentPath,
-        zodTypes
-      });
-      return value;
-    }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodDefault: {
-      const defType = def;
+    case "optional":
+    case "nullable":
+    case "catch": {
       return extractEnumJsonPaths({
-        schema: defType.innerType,
+        schema: getInnerType(schema),
         zodRuntime,
         currentPath,
         zodTypes
       });
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodCatch: {
-      const defType = def;
+    case "default": {
       return extractEnumJsonPaths({
-        schema: defType.innerType,
+        schema: getInnerType(schema),
         zodRuntime,
         currentPath,
         zodTypes
       });
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodPromise: {
+    case "promise": {
       return [];
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodBranded: {
-      const defType = def;
-      const value = extractEnumJsonPaths({
-        schema: defType.type,
+    case "branded": {
+      return extractEnumJsonPaths({
+        schema: getBrandedInner(schema),
         zodRuntime,
         currentPath,
         zodTypes
       });
-      return value;
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodPipeline: {
-      const defType = def;
-      const value = extractEnumJsonPaths({
-        schema: defType.out,
+    case "pipeline":
+    case "pipe": {
+      return extractEnumJsonPaths({
+        schema: getPipelineOutput(schema),
         zodRuntime,
         currentPath,
         zodTypes
       });
-      return value;
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodString:
-    case zodRuntime.ZodFirstPartyTypeKind.ZodNumber:
-    case zodRuntime.ZodFirstPartyTypeKind.ZodBigInt:
-    case zodRuntime.ZodFirstPartyTypeKind.ZodBoolean:
-    case zodRuntime.ZodFirstPartyTypeKind.ZodNaN:
-    case zodRuntime.ZodFirstPartyTypeKind.ZodDate:
-    case zodRuntime.ZodFirstPartyTypeKind.ZodSymbol:
-    case zodRuntime.ZodFirstPartyTypeKind.ZodUndefined:
-    case zodRuntime.ZodFirstPartyTypeKind.ZodNull:
-    case zodRuntime.ZodFirstPartyTypeKind.ZodAny:
-    case zodRuntime.ZodFirstPartyTypeKind.ZodUnknown:
-    case zodRuntime.ZodFirstPartyTypeKind.ZodNever:
-    case zodRuntime.ZodFirstPartyTypeKind.ZodVoid:
-    case zodRuntime.ZodFirstPartyTypeKind.ZodMap:
-    case zodRuntime.ZodFirstPartyTypeKind.ZodLazy:
-    case zodRuntime.ZodFirstPartyTypeKind.ZodSet: {
+    case "string":
+    case "number":
+    case "bigint":
+    case "boolean":
+    case "nan":
+    case "date":
+    case "symbol":
+    case "undefined":
+    case "null":
+    case "any":
+    case "unknown":
+    case "never":
+    case "void":
+    case "map":
+    case "lazy":
+    case "set":
+    case "custom": {
       return [];
     }
     default:
@@ -11552,7 +11744,7 @@ var ZodErrorMessages = ({ zodValidationResult, viewTab }) => {
   }, []);
   if (viewTab === "json") {
     return /* @__PURE__ */ jsx102("div", {
-      children: zodValidationResult.error.errors.map((error) => {
+      children: zodValidationResult.error.issues.map((error) => {
         return /* @__PURE__ */ jsxs46("div", {
           style: style7,
           children: [
@@ -11572,7 +11764,7 @@ var ZodErrorMessages = ({ zodValidationResult, viewTab }) => {
     });
   }
   return /* @__PURE__ */ jsx102("div", {
-    children: zodValidationResult.error.errors.map((error) => {
+    children: zodValidationResult.error.issues.map((error) => {
       return /* @__PURE__ */ jsxs46("div", {
         style: style7,
         children: [
@@ -11629,7 +11821,7 @@ var scrollable = {
 var parseJSON = (str, schema) => {
   try {
     const value = NoReactInternals8.deserializeJSONWithSpecialTypes(str);
-    const zodValidation = schema.safeParse(value);
+    const zodValidation = zodSafeParse(schema, value);
     return { str, value, validJSON: true, zodValidation };
   } catch (e) {
     return { str, validJSON: false, error: e.message };
@@ -11661,7 +11853,7 @@ var RenderModalJSONPropsEditor = ({
   const onChange = useCallback47((e) => {
     const parsed = parseJSON(e.target.value, schema);
     if (parsed.validJSON) {
-      const validationResult = schema.safeParse(parsed.value);
+      const validationResult = zodSafeParse(schema, parsed.value);
       setLocalValue({
         str: e.target.value,
         value: parsed.value,
@@ -12273,46 +12465,72 @@ var createZodValues = (schema, zodRuntime, zodTypes) => {
   if (!schema) {
     throw new Error("Invalid zod schema");
   }
-  const def = schema._def;
-  const typeName = def.typeName;
+  const description = 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 = 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;
-        }
-        if (check.kind === "max" && check.value < 0) {
-          return check.value;
+    case "number": {
+      const { checks } = getZodDef(schema);
+      if (checks) {
+        if (isZodV3Schema(schema)) {
+          for (const check of checks) {
+            if (check.kind === "min")
+              return check.value;
+            if (check.kind === "max" && check.value < 0)
+              return check.value;
+          }
+        } else {
+          for (const check of checks) {
+            const cd = check._zod?.def;
+            if (cd?.check === "greater_than")
+              return cd.value;
+            if (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;
-    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;
-    case zodRuntime.ZodFirstPartyTypeKind.ZodObject: {
-      const shape = def.shape();
+    case "object": {
+      const shape = getObjectShape(schema);
       const keys = Object.keys(shape);
       const returnValue = keys.reduce((existing, key) => {
         existing[key] = createZodValues(shape[key], zodRuntime, zodTypes);
@@ -12320,40 +12538,25 @@ var createZodValues = (schema, zodRuntime, zodTypes) => {
       }, {});
       return returnValue;
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodArray: {
-      return [
-        createZodValues(def.type, zodRuntime, zodTypes)
-      ];
+    case "array": {
+      return [createZodValues(getArrayElement(schema), zodRuntime, zodTypes)];
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodUnion: {
-      const firstOptions = def.options[0];
-      return firstOptions ? createZodValues(firstOptions, zodRuntime, zodTypes) : undefined;
+    case "union": {
+      const firstOption = getUnionOptions(schema)[0];
+      return firstOption ? createZodValues(firstOption, zodRuntime, zodTypes) : undefined;
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodDiscriminatedUnion: {
-      const options = def.options[0];
-      return createZodValues(options, zodRuntime, zodTypes);
+    case "discriminatedUnion": {
+      const firstOption = getUnionOptions(schema)[0];
+      return createZodValues(firstOption, zodRuntime, zodTypes);
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodLiteral: {
-      return def.value;
+    case "literal": {
+      return 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 createZodValues(def.schema, zodRuntime, zodTypes);
+    case "effects": {
+      return createZodValues(getEffectsInner(schema), zodRuntime, zodTypes);
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodIntersection: {
-      const { left: left3, right } = def;
+    case "intersection": {
+      const { left: left3, right } = getIntersectionSchemas(schema);
       const leftValue = createZodValues(left3, zodRuntime, zodTypes);
       if (typeof leftValue !== "object") {
         throw new Error("Cannot create value for type z.intersection: Left side is not an object");
@@ -12364,73 +12567,59 @@ var createZodValues = (schema, zodRuntime, zodTypes) => {
       }
       return { ...leftValue, ...rightValue };
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodTuple: {
-      const items = def.items.map((item2) => createZodValues(item2, zodRuntime, zodTypes));
-      return items;
+    case "tuple": {
+      return getTupleItems(schema).map((item2) => createZodValues(item2, zodRuntime, zodTypes));
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodRecord: {
-      const values = createZodValues(def.valueType, zodRuntime, zodTypes);
+    case "record": {
+      const values = createZodValues(getRecordValueType(schema), zodRuntime, zodTypes);
       return { key: values };
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodMap: {
-      const defType = def;
-      const values = createZodValues(defType.valueType, zodRuntime, zodTypes);
-      const key = createZodValues(defType.keyType, zodRuntime, zodTypes);
+    case "map": {
+      const values = createZodValues(getRecordValueType(schema), zodRuntime, zodTypes);
+      const key = createZodValues(getRecordKeyType(schema), zodRuntime, zodTypes);
       return new Map([[key, values]]);
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodLazy: {
-      const defType = def;
-      const type = defType.getter();
+    case "lazy": {
+      const type = getZodDef(schema).getter();
       return createZodValues(type, zodRuntime, zodTypes);
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodSet: {
-      const defType = def;
-      const values = createZodValues(defType.valueType, zodRuntime, zodTypes);
+    case "set": {
+      const values = createZodValues(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 getFirstEnumValue(schema);
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodNativeEnum: {
+    case "nativeEnum": {
       return 0;
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodOptional: {
-      const defType = def;
-      const value = createZodValues(defType.innerType, zodRuntime, zodTypes);
-      return value;
-    }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodNullable: {
-      const defType = def;
-      const value = createZodValues(defType.innerType, zodRuntime, zodTypes);
-      return value;
+    case "optional":
+    case "nullable":
+    case "catch": {
+      return createZodValues(getInnerType(schema), zodRuntime, zodTypes);
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodDefault: {
-      const defType = def;
-      return defType.defaultValue();
+    case "default": {
+      return getDefaultValue(schema);
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodCatch: {
-      const defType = def;
-      const value = createZodValues(defType.innerType, zodRuntime, zodTypes);
-      return value;
-    }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodPromise: {
-      const defType = def;
-      const value = createZodValues(defType.type, zodRuntime, zodTypes);
+    case "promise": {
+      const def = getZodDef(schema);
+      const inner = isZodV3Schema(schema) ? def.type : def.innerType;
+      const value = createZodValues(inner, zodRuntime, zodTypes);
       return Promise.resolve(value);
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodBranded: {
-      const defType = def;
-      const value = createZodValues(defType.type, zodRuntime, zodTypes);
-      return value;
+    case "branded": {
+      return createZodValues(getBrandedInner(schema), zodRuntime, zodTypes);
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodPipeline: {
-      const defType = def;
-      const value = createZodValues(defType.out, zodRuntime, zodTypes);
-      return value;
+    case "pipeline":
+    case "pipe": {
+      const out = getPipelineOutput(schema);
+      if (getZodSchemaType(out) === "transform") {
+        return createZodValues(getPipelineInput(schema), zodRuntime, zodTypes);
+      }
+      return createZodValues(out, zodRuntime, zodTypes);
     }
     default:
       throw new Error("Not implemented: " + typeName);
@@ -12463,16 +12652,16 @@ var SchemaArrayItemSeparationLine = ({ onChange, index, schema, isLast, showAddB
   if (!z) {
     throw new Error("expected zod");
   }
-  const def = schema._def;
+  const arrayElement = getArrayElement(schema);
   const onAdd = useCallback50(() => {
     onChange((oldV) => {
       return [
         ...oldV.slice(0, index + 1),
-        createZodValues(def.type, z, zodTypes),
+        createZodValues(arrayElement, z, zodTypes),
         ...oldV.slice(index + 1)
       ];
     }, false, true);
-  }, [def.type, index, onChange, z, zodTypes]);
+  }, [arrayElement, index, onChange, z, zodTypes]);
   const dynamicAddButtonStyle = useMemo61(() => {
     return {
       display: "flex",
@@ -12603,7 +12792,7 @@ import React78, { useMemo as useMemo67, useState as useState46 } from "react";
 import { useCallback as useCallback51, useMemo as useMemo63 } from "react";
 import { jsx as jsx111 } from "react/jsx-runtime";
 var ZodArrayItemEditor = ({
-  def,
+  elementSchema,
   onChange,
   jsonPath,
   index,
@@ -12641,7 +12830,7 @@ var ZodArrayItemEditor = ({
   return /* @__PURE__ */ jsx111("div", {
     children: /* @__PURE__ */ jsx111(ZodSwitch, {
       jsonPath: newJsonPath,
-      schema: def.type,
+      schema: elementSchema,
       value,
       setValue,
       defaultValue,
@@ -12875,7 +13064,8 @@ var stackTraceLabel = {
   fontSize: 14
 };
 var ZodFieldValidation = ({ localValue, path }) => {
-  if (localValue.zodValidation.success) {
+  const { zodValidation } = localValue;
+  if (zodValidation.success) {
     return null;
   }
   return /* @__PURE__ */ jsxs54("div", {
@@ -12883,7 +13073,7 @@ var ZodFieldValidation = ({ localValue, path }) => {
     children: [
       /* @__PURE__ */ jsx114(ValidationMessage, {
         align: "flex-start",
-        message: localValue.zodValidation.error.format()._errors[0],
+        message: zodValidation.error.format()._errors[0],
         type: "error"
       }),
       /* @__PURE__ */ jsx114(Spacing, {
@@ -12898,7 +13088,7 @@ var ZodFieldValidation = ({ localValue, path }) => {
               style: stackTraceLabel,
               children: "Zod Validation has failed:"
             }),
-            localValue.zodValidation.error.errors.map((error, index) => /* @__PURE__ */ jsxs54("div", {
+            zodValidation.error.issues.map((error, index) => /* @__PURE__ */ jsxs54("div", {
               style: stackTraceLabel,
               children: [
                 "Type: ",
@@ -12950,7 +13140,7 @@ var useLocalState = ({
       [parentRevision]: {
         value: unsavedValue,
         keyStabilityRevision: 0,
-        zodValidation: schema.safeParse(unsavedValue)
+        zodValidation: zodSafeParse(schema, unsavedValue)
       }
     };
   });
@@ -12959,7 +13149,7 @@ var useLocalState = ({
       return {
         value: unsavedValue,
         keyStabilityRevision: 0,
-        zodValidation: schema.safeParse(unsavedValue)
+        zodValidation: zodSafeParse(schema, unsavedValue)
       };
     }
     return localValueOrNull[parentRevision];
@@ -12978,7 +13168,7 @@ var useLocalState = ({
     return localUnsavedValue ?? {
       value: savedValue,
       keyStabilityRevision: 0,
-      zodValidation: schema.safeParse(savedValue)
+      zodValidation: zodSafeParse(schema, savedValue)
     };
   }, [localUnsavedValue, savedValue, schema]);
   const stateRef = useRef26(currentLocalValue);
@@ -12989,7 +13179,7 @@ var useLocalState = ({
     if (isSame) {
       return;
     }
-    const safeParse = schema.safeParse(newValue);
+    const safeParse = zodSafeParse(schema, newValue);
     if (safeParse.success || forceApply) {
       setValue(updater, forceApply, increment);
     }
@@ -13057,7 +13247,7 @@ var ZodArrayEditor = ({
     savedValue: defaultValue
   });
   const [expanded, setExpanded] = useState46(true);
-  const def = schema._def;
+  const arrayElement = getArrayElement(schema);
   const suffix2 = useMemo67(() => {
     return expanded ? " [" : " [...] ";
   }, [expanded]);
@@ -13066,10 +13256,6 @@ var ZodArrayEditor = ({
     throw new Error("expected zod");
   }
   const zodTypes = useZodTypesIfPossible();
-  const typeName = def.typeName;
-  if (typeName !== z.ZodFirstPartyTypeKind.ZodArray) {
-    throw new Error("expected object");
-  }
   const isDefaultValue = useMemo67(() => {
     return deepEqual(localValue.value, defaultValue);
   }, [defaultValue, localValue]);
@@ -13108,10 +13294,10 @@ var ZodArrayEditor = ({
                   /* @__PURE__ */ jsx116(ZodArrayItemEditor, {
                     onChange,
                     value: child,
-                    def,
+                    elementSchema: arrayElement,
                     index: i,
                     jsonPath,
-                    defaultValue: defaultValue?.[i] ?? createZodValues(def.type, z, zodTypes),
+                    defaultValue: defaultValue?.[i] ?? createZodValues(arrayElement, z, zodTypes),
                     onSave,
                     showSaveButton,
                     saving,
@@ -13760,7 +13946,7 @@ var ZodDefaultEditor = ({
   saveDisabledByParent,
   mayPad
 }) => {
-  const { innerType } = schema._def;
+  const innerType = getInnerType(schema);
   return /* @__PURE__ */ jsx123(ZodSwitch, {
     defaultValue,
     jsonPath,
@@ -13797,8 +13983,8 @@ var ZodDiscriminatedUnionEditor = ({
     throw new Error("expected zod");
   }
   const zodTypes = useZodTypesIfPossible();
-  const typedSchema = schema._def;
-  const options = useMemo72(() => [...typedSchema.optionsMap.keys()], [typedSchema.optionsMap]);
+  const discriminator = getDiscriminator(schema);
+  const options = useMemo72(() => getDiscriminatedOptionKeys(schema), [schema]);
   const {
     localValue,
     onChange: setLocalValue,
@@ -13816,9 +14002,13 @@ var ZodDiscriminatedUnionEditor = ({
         label: option,
         id: option,
         keyHint: null,
-        leftItem: option === value[typedSchema.discriminator] ? /* @__PURE__ */ jsx124(Checkmark, {}) : null,
+        leftItem: option === value[discriminator] ? /* @__PURE__ */ jsx124(Checkmark, {}) : null,
         onClick: () => {
-          const val = createZodValues(typedSchema.optionsMap.get(option), z, zodTypes);
+          const optionSchema = getDiscriminatedOption(schema, option);
+          if (!optionSchema) {
+            throw new Error(`No schema found for discriminator value: ${option}`);
+          }
+          const val = createZodValues(optionSchema, z, zodTypes);
           setLocalValue(() => val, false, false);
         },
         quickSwitcherLabel: null,
@@ -13826,29 +14016,21 @@ var ZodDiscriminatedUnionEditor = ({
         type: "item"
       };
     });
-  }, [
-    options,
-    setLocalValue,
-    typedSchema.discriminator,
-    typedSchema.optionsMap,
-    value,
-    z,
-    zodTypes
-  ]);
+  }, [options, setLocalValue, discriminator, schema, value, z, zodTypes]);
   const save = useCallback58(() => {
     onSave(() => value, false, false);
   }, [onSave, value]);
   const discriminatedUnionReplacement = useMemo72(() => {
     return {
-      discriminator: typedSchema.discriminator,
+      discriminator,
       markup: /* @__PURE__ */ jsxs60(Fieldset, {
         shouldPad: mayPad,
         success: true,
         children: [
           /* @__PURE__ */ jsx124(SchemaLabel, {
             handleClick: null,
-            isDefaultValue: localValue.value[typedSchema.discriminator] === defaultValue[typedSchema.discriminator],
-            jsonPath: [...jsonPath, typedSchema.discriminator],
+            isDefaultValue: localValue.value[discriminator] === defaultValue[discriminator],
+            jsonPath: [...jsonPath, discriminator],
             onRemove,
             onReset: reset,
             onSave: save,
@@ -13861,7 +14043,7 @@ var ZodDiscriminatedUnionEditor = ({
           /* @__PURE__ */ jsx124(Combobox, {
             title: "Select type",
             values: comboBoxValues,
-            selectedId: value[typedSchema.discriminator]
+            selectedId: value[discriminator]
           })
         ]
       }, "replacement")
@@ -13879,9 +14061,13 @@ var ZodDiscriminatedUnionEditor = ({
     saveDisabledByParent,
     saving,
     showSaveButton,
-    typedSchema.discriminator,
+    discriminator,
     value
   ]);
+  const currentOptionSchema = getDiscriminatedOption(schema, value[discriminator]);
+  if (!currentOptionSchema) {
+    throw new Error("No matching option found for discriminated union");
+  }
   return /* @__PURE__ */ jsx124(ZodObjectEditor, {
     jsonPath,
     mayPad,
@@ -13890,12 +14076,12 @@ var ZodDiscriminatedUnionEditor = ({
     onSave,
     saveDisabledByParent,
     saving,
-    schema: typedSchema.optionsMap.get(value[typedSchema.discriminator]),
+    schema: currentOptionSchema,
     setValue: setLocalValue,
     showSaveButton,
     unsavedValue: value,
     discriminatedUnionReplacement
-  }, value[typedSchema.discriminator]);
+  }, value[discriminator]);
 };
 
 // src/components/RenderModal/SchemaEditor/ZodEffectEditor.tsx
@@ -13915,9 +14101,9 @@ var ZodEffectEditor = ({
   saving,
   mayPad
 }) => {
-  const z = useZodIfPossible();
-  if (!z) {
-    throw new Error("expected zod");
+  const typeName = getZodSchemaType(schema);
+  if (typeName !== "effects") {
+    throw new Error("expected effect");
   }
   const { localValue, onChange } = useLocalState({
     unsavedValue: value,
@@ -13925,11 +14111,7 @@ var ZodEffectEditor = ({
     setValue: updateValue,
     savedValue: defaultValue
   });
-  const def = schema._def;
-  const typeName = def.typeName;
-  if (typeName !== z.ZodFirstPartyTypeKind.ZodEffects) {
-    throw new Error("expected effect");
-  }
+  const innerSchema = getEffectsInner(schema);
   return /* @__PURE__ */ jsxs61(Fieldset, {
     shouldPad: mayPad,
     success: localValue.zodValidation.success,
@@ -13940,7 +14122,7 @@ var ZodEffectEditor = ({
           value,
           setValue: onChange,
           jsonPath,
-          schema: def.schema,
+          schema: innerSchema,
           defaultValue,
           onSave,
           showSaveButton,
@@ -13975,10 +14157,6 @@ var ZodEnumEditor = ({
   onRemove,
   saving
 }) => {
-  const z = useZodIfPossible();
-  if (!z) {
-    throw new Error("expected zod");
-  }
   const {
     localValue,
     onChange: setLocalValue,
@@ -13989,14 +14167,10 @@ var ZodEnumEditor = ({
     unsavedValue: value,
     savedValue: defaultValue
   });
-  const def = schema._def;
-  const typeName = def.typeName;
-  if (typeName !== z.ZodFirstPartyTypeKind.ZodEnum) {
-    throw new Error("expected enum");
-  }
+  const enumValues = getEnumValues(schema);
   const isRoot = jsonPath.length === 0;
   const comboBoxValues = useMemo73(() => {
-    return def.values.map((option) => {
+    return enumValues.map((option) => {
       return {
         value: option,
         label: option,
@@ -14011,7 +14185,7 @@ var ZodEnumEditor = ({
         type: "item"
       };
     });
-  }, [def.values, setLocalValue, value]);
+  }, [enumValues, setLocalValue, value]);
   const save = useCallback59(() => {
     onSave(() => value, false, false);
   }, [onSave, value]);
@@ -14076,7 +14250,7 @@ var ZodMatrixEditor = ({
     savedValue: defaultValue
   });
   const [expanded, setExpanded] = useState49(true);
-  const def = schema._def;
+  const arrayElement = getArrayElement(schema);
   const suffix2 = useMemo74(() => {
     return expanded ? " [" : " [...] ";
   }, [expanded]);
@@ -14134,10 +14308,10 @@ var ZodMatrixEditor = ({
                       children: /* @__PURE__ */ jsx127(ZodArrayItemEditor, {
                         onChange,
                         value: item2,
-                        def,
+                        elementSchema: arrayElement,
                         index: actualIndex,
                         jsonPath,
-                        defaultValue: defaultValue?.[actualIndex] ?? createZodValues(def.type, z, zodTypes),
+                        defaultValue: defaultValue?.[actualIndex] ?? createZodValues(arrayElement, z, zodTypes),
                         onSave,
                         showSaveButton,
                         saving,
@@ -14337,7 +14511,7 @@ var ZodNullableEditor = ({
   saveDisabledByParent,
   mayPad
 }) => {
-  const { innerType } = schema._def;
+  const innerType = getInnerType(schema);
   return /* @__PURE__ */ jsx130(ZodOrNullishEditor, {
     defaultValue,
     jsonPath,
@@ -14362,40 +14536,58 @@ var fullWidth6 = {
   width: "100%"
 };
 var getMinValue = (schema) => {
-  const minCheck = schema._def.checks.find((c) => c.kind === "min");
-  if (!minCheck) {
-    return -Infinity;
-  }
-  if (minCheck.kind !== "min") {
-    throw new Error("Expected min check");
-  }
-  if (!minCheck.inclusive) {
+  const { checks } = getZodDef(schema);
+  if (!checks)
     return -Infinity;
+  if (isZodV3Schema(schema)) {
+    const minCheck = checks.find((c) => c.kind === "min");
+    if (!minCheck || !minCheck.inclusive)
+      return -Infinity;
+    return minCheck.value;
+  }
+  for (const c of checks) {
+    const def = c._zod?.def;
+    if (def?.check === "greater_than" && def.inclusive) {
+      return def.value;
+    }
   }
-  return minCheck.value;
+  return -Infinity;
 };
 var getMaxValue = (schema) => {
-  const maxCheck = schema._def.checks.find((c) => c.kind === "max");
-  if (!maxCheck) {
-    return Infinity;
-  }
-  if (maxCheck.kind !== "max") {
-    throw new Error("Expected max check");
-  }
-  if (!maxCheck.inclusive) {
+  const { checks } = getZodDef(schema);
+  if (!checks)
     return Infinity;
+  if (isZodV3Schema(schema)) {
+    const maxCheck = checks.find((c) => c.kind === "max");
+    if (!maxCheck || !maxCheck.inclusive)
+      return Infinity;
+    return maxCheck.value;
+  }
+  for (const c of checks) {
+    const def = c._zod?.def;
+    if (def?.check === "less_than" && def.inclusive) {
+      return def.value;
+    }
   }
-  return maxCheck.value;
+  return Infinity;
 };
 var getStep = (schema) => {
-  const multipleStep = schema._def.checks.find((c) => c.kind === "multipleOf");
-  if (!multipleStep) {
+  const { checks } = getZodDef(schema);
+  if (!checks)
     return;
+  if (isZodV3Schema(schema)) {
+    const multipleStep = checks.find((c) => c.kind === "multipleOf");
+    if (!multipleStep)
+      return;
+    return multipleStep.value;
   }
-  if (multipleStep.kind !== "multipleOf") {
-    throw new Error("Expected multipleOf check");
+  for (const c of checks) {
+    const def = c._zod?.def;
+    if (def?.check === "multiple_of") {
+      return def.value;
+    }
   }
-  return multipleStep.value;
+  return;
 };
 var ZodNumberEditor = ({
   jsonPath,
@@ -14488,7 +14680,7 @@ var ZodOptionalEditor = ({
   saveDisabledByParent,
   mayPad
 }) => {
-  const { innerType } = schema._def;
+  const innerType = getInnerType(schema);
   return /* @__PURE__ */ jsx132(ZodOrNullishEditor, {
     defaultValue,
     jsonPath,
@@ -14525,10 +14717,6 @@ var ZodStaticFileEditor = ({
   saveDisabledByParent,
   mayPad
 }) => {
-  const z = useZodIfPossible();
-  if (!z) {
-    throw new Error("expected zod");
-  }
   const {
     localValue,
     onChange: setLocalValue,
@@ -14539,11 +14727,6 @@ var ZodStaticFileEditor = ({
     unsavedValue: value,
     savedValue: defaultValue
   });
-  const def = schema._def;
-  const typeName = def.typeName;
-  if (typeName !== z.ZodFirstPartyTypeKind.ZodString) {
-    throw new Error("expected enum");
-  }
   const isRoot = jsonPath.length === 0;
   const staticFiles = useStaticFiles();
   const comboBoxValues = useMemo75(() => {
@@ -14768,7 +14951,7 @@ import React92, { useMemo as useMemo77, useState as useState50 } from "react";
 import { useCallback as useCallback66, useMemo as useMemo76 } from "react";
 import { jsx as jsx136 } from "react/jsx-runtime";
 var ZodTupleItemEditor = ({
-  def,
+  tupleItems,
   onChange,
   jsonPath,
   index,
@@ -14802,7 +14985,7 @@ var ZodTupleItemEditor = ({
   return /* @__PURE__ */ jsx136("div", {
     children: /* @__PURE__ */ jsx136(ZodSwitch, {
       jsonPath: newJsonPath,
-      schema: def.items[index],
+      schema: tupleItems[index],
       value,
       setValue,
       defaultValue,
@@ -14838,7 +15021,7 @@ var ZodTupleEditor = ({
     savedValue: defaultValue
   });
   const [expanded, setExpanded] = useState50(true);
-  const def = schema._def;
+  const tupleItems = getTupleItems(schema);
   const suffix2 = useMemo77(() => {
     return expanded ? " [" : " [...] ";
   }, [expanded]);
@@ -14847,10 +15030,6 @@ var ZodTupleEditor = ({
     throw new Error("expected zod");
   }
   const zodTypes = useZodTypesIfPossible();
-  const typeName = def.typeName;
-  if (typeName !== z.ZodFirstPartyTypeKind.ZodTuple) {
-    throw new Error("expected object");
-  }
   const isDefaultValue = useMemo77(() => {
     return deepEqual(localValue.value, defaultValue);
   }, [defaultValue, localValue]);
@@ -14889,10 +15068,10 @@ var ZodTupleEditor = ({
                   /* @__PURE__ */ jsx137(ZodTupleItemEditor, {
                     onChange,
                     value: child,
-                    def,
+                    tupleItems,
                     index: i,
                     jsonPath,
-                    defaultValue: defaultValue?.[i] ?? createZodValues(def.items[i], z, zodTypes),
+                    defaultValue: defaultValue?.[i] ?? createZodValues(tupleItems[i], z, zodTypes),
                     onSave,
                     showSaveButton,
                     saving,
@@ -14929,14 +15108,18 @@ var ZodTupleEditor = ({
 
 // src/components/RenderModal/SchemaEditor/ZodUnionEditor.tsx
 import { jsx as jsx138 } from "react/jsx-runtime";
-var findNull = (value, zodType) => {
-  const nullIndex = value.findIndex((v) => v._def.typeName === zodType.ZodFirstPartyTypeKind.ZodNull || v._def.typeName === zodType.ZodFirstPartyTypeKind.ZodUndefined);
+var findNull = (value) => {
+  const nullIndex = value.findIndex((v) => {
+    const type = 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 = 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 = getZodSchemaType(otherSchema);
+  const otherSchemaIsAlsoNullish = otherType === "null" || otherType === "undefined";
   return {
     nullIndex,
     nullishValue,
@@ -14957,11 +15140,7 @@ var ZodUnionEditor = ({
   saveDisabledByParent,
   mayPad
 }) => {
-  const { options } = schema._def;
-  const z = useZodIfPossible();
-  if (!z) {
-    throw new Error("expected zod");
-  }
+  const options = getUnionOptions(schema);
   if (options.length > 2) {
     return /* @__PURE__ */ jsx138(ZonNonEditableValue, {
       jsonPath,
@@ -14980,7 +15159,7 @@ var ZodUnionEditor = ({
       mayPad
     });
   }
-  const nullResult = findNull(options, z);
+  const nullResult = findNull(options);
   if (!nullResult) {
     return /* @__PURE__ */ jsx138(ZonNonEditableValue, {
       jsonPath,
@@ -15032,14 +15211,10 @@ var ZodSwitch = ({
   saveDisabledByParent,
   mayPad
 }) => {
-  const def = schema._def;
-  const typeName = def.typeName;
-  const z = useZodIfPossible();
-  if (!z) {
-    throw new Error("expected zod");
-  }
+  const typeName = getZodSchemaType(schema);
+  const description = getZodSchemaDescription(schema);
   const zodTypes = useZodTypesIfPossible();
-  if (typeName === z.ZodFirstPartyTypeKind.ZodObject) {
+  if (typeName === "object") {
     return /* @__PURE__ */ jsx139(ZodObjectEditor, {
       setValue,
       unsavedValue: value,
@@ -15055,7 +15230,22 @@ var ZodSwitch = ({
       discriminatedUnionReplacement: null
     });
   }
-  if (typeName === z.ZodFirstPartyTypeKind.ZodString) {
+  if (typeName === "string") {
+    if (zodTypes && description === zodTypes.ZodZypesInternals.REMOTION_COLOR_BRAND) {
+      return /* @__PURE__ */ jsx139(ZodColorEditor, {
+        value,
+        setValue,
+        jsonPath,
+        schema,
+        onSave,
+        defaultValue,
+        showSaveButton,
+        onRemove,
+        saving,
+        saveDisabledByParent,
+        mayPad
+      });
+    }
     if (value.startsWith(window.remotion_staticBase)) {
       return /* @__PURE__ */ jsx139(ZodStaticFileEditor, {
         setValue,
@@ -15071,7 +15261,7 @@ var ZodSwitch = ({
         mayPad
       });
     }
-    if (zodTypes && schema._def.description === zodTypes.ZodZypesInternals.REMOTION_TEXTAREA_BRAND) {
+    if (zodTypes && description === zodTypes.ZodZypesInternals.REMOTION_TEXTAREA_BRAND) {
       return /* @__PURE__ */ jsx139(ZodTextareaEditor, {
         value,
         setValue,
@@ -15100,7 +15290,7 @@ var ZodSwitch = ({
       mayPad
     });
   }
-  if (typeName === z.ZodFirstPartyTypeKind.ZodDate) {
+  if (typeName === "date") {
     return /* @__PURE__ */ jsx139(ZodDateEditor, {
       value,
       setValue,
@@ -15115,7 +15305,7 @@ var ZodSwitch = ({
       mayPad
     });
   }
-  if (typeName === z.ZodFirstPartyTypeKind.ZodNumber) {
+  if (typeName === "number") {
     return /* @__PURE__ */ jsx139(ZodNumberEditor, {
       value,
       setValue,
@@ -15130,7 +15320,7 @@ var ZodSwitch = ({
       mayPad
     });
   }
-  if (typeName === z.ZodFirstPartyTypeKind.ZodBoolean) {
+  if (typeName === "boolean") {
     return /* @__PURE__ */ jsx139(ZodBooleanEditor, {
       value,
       setValue,
@@ -15145,7 +15335,7 @@ var ZodSwitch = ({
       schema
     });
   }
-  if (typeName === z.ZodFirstPartyTypeKind.ZodUndefined) {
+  if (typeName === "undefined") {
     return /* @__PURE__ */ jsx139(ZonNonEditableValue, {
       jsonPath,
       showSaveButton,
@@ -15154,7 +15344,7 @@ var ZodSwitch = ({
       mayPad
     });
   }
-  if (typeName === z.ZodFirstPartyTypeKind.ZodNull) {
+  if (typeName === "null") {
     return /* @__PURE__ */ jsx139(ZonNonEditableValue, {
       jsonPath,
       showSaveButton,
@@ -15163,7 +15353,7 @@ var ZodSwitch = ({
       mayPad
     });
   }
-  if (typeName === z.ZodFirstPartyTypeKind.ZodAny) {
+  if (typeName === "any") {
     return /* @__PURE__ */ jsx139(ZonNonEditableValue, {
       jsonPath,
       showSaveButton,
@@ -15172,7 +15362,7 @@ var ZodSwitch = ({
       mayPad
     });
   }
-  if (typeName === z.ZodFirstPartyTypeKind.ZodBigInt) {
+  if (typeName === "bigint") {
     return /* @__PURE__ */ jsx139(ZonNonEditableValue, {
       jsonPath,
       showSaveButton,
@@ -15181,7 +15371,7 @@ var ZodSwitch = ({
       mayPad
     });
   }
-  if (typeName === z.ZodFirstPartyTypeKind.ZodUnknown) {
+  if (typeName === "unknown") {
     return /* @__PURE__ */ jsx139(ZonNonEditableValue, {
       jsonPath,
       showSaveButton,
@@ -15190,7 +15380,22 @@ var ZodSwitch = ({
       mayPad
     });
   }
-  if (typeName === z.ZodFirstPartyTypeKind.ZodArray) {
+  if (typeName === "array") {
+    if (zodTypes && description === zodTypes.ZodZypesInternals.REMOTION_MATRIX_BRAND) {
+      return /* @__PURE__ */ jsx139(ZodMatrixEditor, {
+        setValue,
+        value,
+        jsonPath,
+        schema,
+        defaultValue,
+        onSave,
+        showSaveButton,
+        onRemove,
+        saving,
+        saveDisabledByParent,
+        mayPad
+      });
+    }
     return /* @__PURE__ */ jsx139(ZodArrayEditor, {
       setValue,
       value,
@@ -15205,7 +15410,7 @@ var ZodSwitch = ({
       mayPad
     });
   }
-  if (typeName === z.ZodFirstPartyTypeKind.ZodEnum) {
+  if (typeName === "enum") {
     return /* @__PURE__ */ jsx139(ZodEnumEditor, {
       setValue,
       value,
@@ -15218,8 +15423,8 @@ var ZodSwitch = ({
       saving
     });
   }
-  if (typeName === z.ZodFirstPartyTypeKind.ZodEffects) {
-    if (zodTypes && schema._def.description === zodTypes.ZodZypesInternals.REMOTION_COLOR_BRAND) {
+  if (typeName === "effects") {
+    if (zodTypes && description === zodTypes.ZodZypesInternals.REMOTION_COLOR_BRAND) {
       return /* @__PURE__ */ jsx139(ZodColorEditor, {
         value,
         setValue,
@@ -15234,12 +15439,12 @@ var ZodSwitch = ({
         mayPad
       });
     }
-    if (zodTypes && schema._def.description === zodTypes.ZodZypesInternals.REMOTION_MATRIX_BRAND) {
+    if (zodTypes && description === zodTypes.ZodZypesInternals.REMOTION_MATRIX_BRAND) {
       return /* @__PURE__ */ jsx139(ZodMatrixEditor, {
         setValue,
         value,
         jsonPath,
-        schema: schema._def.schema,
+        schema: getEffectsInner(schema),
         defaultValue,
         onSave,
         showSaveButton,
@@ -15262,7 +15467,7 @@ var ZodSwitch = ({
       mayPad
     });
   }
-  if (typeName === z.ZodFirstPartyTypeKind.ZodUnion) {
+  if (typeName === "union") {
     return /* @__PURE__ */ jsx139(ZodUnionEditor, {
       schema,
       showSaveButton,
@@ -15277,7 +15482,7 @@ var ZodSwitch = ({
       mayPad
     });
   }
-  if (typeName === z.ZodFirstPartyTypeKind.ZodOptional) {
+  if (typeName === "optional") {
     return /* @__PURE__ */ jsx139(ZodOptionalEditor, {
       jsonPath,
       showSaveButton,
@@ -15292,7 +15497,7 @@ var ZodSwitch = ({
       mayPad
     });
   }
-  if (typeName === z.ZodFirstPartyTypeKind.ZodNullable) {
+  if (typeName === "nullable") {
     return /* @__PURE__ */ jsx139(ZodNullableEditor, {
       jsonPath,
       showSaveButton,
@@ -15307,7 +15512,7 @@ var ZodSwitch = ({
       mayPad
     });
   }
-  if (typeName === z.ZodFirstPartyTypeKind.ZodDefault) {
+  if (typeName === "default") {
     return /* @__PURE__ */ jsx139(ZodDefaultEditor, {
       jsonPath,
       showSaveButton,
@@ -15322,7 +15527,7 @@ var ZodSwitch = ({
       mayPad
     });
   }
-  if (typeName === z.ZodFirstPartyTypeKind.ZodDiscriminatedUnion) {
+  if (typeName === "discriminatedUnion") {
     return /* @__PURE__ */ jsx139(ZodDiscriminatedUnionEditor, {
       defaultValue,
       mayPad,
@@ -15337,7 +15542,7 @@ var ZodSwitch = ({
       showSaveButton
     });
   }
-  if (typeName === z.ZodFirstPartyTypeKind.ZodTuple) {
+  if (typeName === "tuple") {
     return /* @__PURE__ */ jsx139(ZodTupleEditor, {
       setValue,
       value,
@@ -15377,10 +15582,6 @@ var ZodObjectEditor = ({
   mayPad,
   discriminatedUnionReplacement
 }) => {
-  const z = useZodIfPossible();
-  if (!z) {
-    throw new Error("expected zod");
-  }
   const [expanded, setExpanded] = useState51(true);
   const { localValue, onChange, RevisionContextProvider, reset } = useLocalState({
     schema,
@@ -15388,12 +15589,11 @@ var ZodObjectEditor = ({
     unsavedValue,
     savedValue
   });
-  const def = schema._def;
-  const typeName = def.typeName;
-  if (typeName !== z.ZodFirstPartyTypeKind.ZodObject) {
+  const typeName = getZodSchemaType(schema);
+  if (typeName !== "object") {
     throw new Error("expected object");
   }
-  const shape = def.shape();
+  const shape = getObjectShape(schema);
   const keys = Object.keys(shape);
   const isRoot = jsonPath.length === 0;
   const isDefaultValue = useMemo78(() => {
@@ -15538,13 +15738,12 @@ var SchemaEditor = ({
       save.unregister();
     };
   }, [keybindings, onQuickSave, onSave]);
-  const def = schema._def;
-  const typeName = def.typeName;
+  const typeName = getZodSchemaType(schema);
   const reset = useCallback67(() => {
     setValue(savedDefaultProps);
   }, [savedDefaultProps, setValue]);
   if (!zodValidationResult.success) {
-    const defaultPropsValid = schema.safeParse(savedDefaultProps);
+    const defaultPropsValid = zodSafeParse(schema, savedDefaultProps);
     if (!defaultPropsValid.success) {
       return /* @__PURE__ */ jsx141(InvalidDefaultProps, {
         zodValidationResult
@@ -15555,7 +15754,7 @@ var SchemaEditor = ({
       zodValidationResult
     });
   }
-  if (typeName !== z.ZodFirstPartyTypeKind.ZodObject) {
+  if (typeName !== "object") {
     return /* @__PURE__ */ jsx141(TopLevelZodValue, {
       typeReceived: typeName
     });
@@ -15817,7 +16016,7 @@ var DataEditor = ({
     if (schema === "no-schema") {
       return "no-schema";
     }
-    return schema.safeParse(defaultProps);
+    return zodSafeParse(schema, defaultProps);
   }, [defaultProps, schema]);
   const setShowWarning = useCallback69((val) => {
     setShowWarningWithoutPersistance((prevVal) => {
@@ -15992,9 +16191,8 @@ var DataEditor = ({
   if (zodValidationResult === "no-schema") {
     throw new Error("expected schema");
   }
-  const def = schema._def;
-  const typeName = def.typeName;
-  if (typeName === z.ZodFirstPartyTypeKind.ZodAny) {
+  const typeName = getZodSchemaType(schema);
+  if (typeName === "any") {
     return /* @__PURE__ */ jsx143(NoSchemaDefined, {});
   }
   if (!unresolvedComposition.defaultProps) {
@@ -23346,7 +23544,8 @@ var CodemodFooter = ({
   successNotification,
   errorNotification,
   genericSubmitLabel,
-  submitLabel
+  submitLabel,
+  onSuccess
 }) => {
   const [submitting, setSubmitting] = useState72(false);
   const { setSelectedModal } = useContext78(ModalsContext);
@@ -23375,6 +23574,7 @@ var CodemodFooter = ({
       signal: new AbortController().signal
     }).then(() => {
       notification2.replaceContent(successNotification, 2000);
+      onSuccess?.();
     }).catch((err) => {
       notification2.replaceContent(`${errorNotification}: ${err.message}`, 2000);
     });
@@ -23382,6 +23582,7 @@ var CodemodFooter = ({
     codemod,
     errorNotification,
     loadingNotification,
+    onSuccess,
     setSelectedModal,
     successNotification
   ]);
@@ -23526,7 +23727,8 @@ var DeleteCompositionLoaded = ({ compositionId }) => {
               genericSubmitLabel: `Delete`,
               submitLabel: ({ relativeRootPath }) => `Delete from ${relativeRootPath}`,
               codemod,
-              valid: true
+              valid: true,
+              onSuccess: null
             })
           })
         ]
@@ -23787,6 +23989,9 @@ var DuplicateCompositionLoaded = ({ initialType }) => {
     size4.width,
     type
   ]);
+  const onDuplicateSuccess = useCallback106(() => {
+    pushUrl(`/${newId}`);
+  }, [newId]);
   const onSubmit = useCallback106((e) => {
     e.preventDefault();
   }, []);
@@ -23985,7 +24190,8 @@ var DuplicateCompositionLoaded = ({ initialType }) => {
               genericSubmitLabel: "Duplicate",
               submitLabel: ({ relativeRootPath }) => `Add to ${relativeRootPath}`,
               codemod,
-              valid
+              valid,
+              onSuccess: onDuplicateSuccess
             })
           })
         ]
@@ -24097,7 +24303,8 @@ var RenameCompositionLoaded = () => {
               genericSubmitLabel: "Rename",
               submitLabel: ({ relativeRootPath }) => `Modify ${relativeRootPath}`,
               codemod,
-              valid
+              valid,
+              onSuccess: null
             })
           })
         ]