agent_patch

diff --git a/app/packages/zod/src/v4/core/tests/locales/es.test.ts b/app/packages/zod/src/v4/core/tests/locales/es.test.ts
new file mode 100644
index 0000000..2f96436
--- /dev/null
+++ b/app/packages/zod/src/v4/core/tests/locales/es.test.ts
@@ -0,0 +1,69 @@
+import { describe, expect, it } from "vitest";
+import es from "../../../locales/es.js";
+
+describe("Spanish localization", () => {
+  const localeError = es().localeError;
+
+  it("translates type names in invalid_type messages", () => {
+    expect(
+      localeError({
+        code: "invalid_type",
+        expected: "string",
+        input: new Map(),
+        path: [],
+        message: "",
+      })
+    ).toBe("Entrada inválida: se esperaba cadena, recibido mapa");
+  });
+
+  it("translates type names in size messages", () => {
+    expect(
+      localeError({
+        code: "too_small",
+        minimum: 2,
+        inclusive: true,
+        origin: "array",
+        input: [],
+        path: [],
+        message: "",
+      })
+    ).toBe("Demasiado pequeño: se esperaba que arreglo tuviera >=2 elementos");
+
+    expect(
+      localeError({
+        code: "too_big",
+        maximum: 1,
+        inclusive: true,
+        origin: "date",
+        input: new Date(),
+        path: [],
+        message: "",
+      })
+    ).toBe("Demasiado grande: se esperaba que fecha fuera <=1");
+  });
+
+  it("translates type names in invalid_key and invalid_element messages", () => {
+    expect(
+      localeError({
+        code: "invalid_key",
+        origin: "record",
+        issues: [],
+        input: {},
+        path: [],
+        message: "",
+      })
+    ).toBe("Llave inválida en registro");
+
+    expect(
+      localeError({
+        code: "invalid_element",
+        origin: "set",
+        key: 0,
+        issues: [],
+        input: new Set(),
+        path: [],
+        message: "",
+      })
+    ).toBe("Valor inválido en conjunto");
+  });
+});
diff --git a/tmp/agent-patch-flux-pr-5187.1-of-1.2026-02-27__21-30-28__gpt-5-4/app/packages/zod/src/v4/locales/es.ts b/app/packages/zod/src/v4/locales/es.ts
index 195ab74..43e1d59 100644
--- a/tmp/agent-patch-flux-pr-5187.1-of-1.2026-02-27__21-30-28__gpt-5-4/app/packages/zod/src/v4/locales/es.ts
+++ b/app/packages/zod/src/v4/locales/es.ts
@@ -10,31 +10,58 @@ const error: () => errors.$ZodErrorMap = () => {
     set: { unit: "elementos", verb: "tener" },
   };
 
+  const TypeNames: Record<string, string> = {
+    string: "cadena",
+    number: "número",
+    bigint: "entero grande",
+    boolean: "booleano",
+    symbol: "símbolo",
+    undefined: "indefinido",
+    object: "objeto",
+    function: "función",
+    file: "archivo",
+    date: "fecha",
+    array: "arreglo",
+    map: "mapa",
+    set: "conjunto",
+    nan: "NaN",
+    null: "nulo",
+    promise: "promesa",
+    int: "entero",
+    void: "vacío",
+    never: "nunca",
+    any: "cualquiera",
+    unknown: "desconocido",
+    union: "unión",
+    intersection: "intersección",
+    tuple: "tupla",
+    record: "registro",
+    enum: "enumeración",
+    literal: "literal",
+    optional: "opcional",
+    nullable: "nullable",
+    default: "predeterminado",
+    prefault: "predeterminado previo",
+    nonoptional: "no opcional",
+    success: "éxito",
+    catch: "captura",
+    pipe: "tubería",
+    readonly: "solo lectura",
+    template_literal: "literal de plantilla",
+    transform: "transformación",
+    lazy: "perezoso",
+    custom: "personalizado",
+  };
+
   function getSizing(origin: string): { unit: string; verb: string } | null {
     return Sizable[origin] ?? null;
   }
 
-  const parsedType = (data: any): string => {
-    const t = typeof data;
+  function typeName(type: string): string {
+    return TypeNames[type] ?? type;
+  }
 
-    switch (t) {
-      case "number": {
-        return Number.isNaN(data) ? "NaN" : "número";
-      }
-      case "object": {
-        if (Array.isArray(data)) {
-          return "arreglo";
-        }
-        if (data === null) {
-          return "nulo";
-        }
-        if (Object.getPrototypeOf(data) !== Object.prototype) {
-          return data.constructor.name;
-        }
-      }
-    }
-    return t;
-  };
+  const parsedType = (data: any): string => typeName(util.getParsedType(data));
 
   const Nouns: {
     [k in $ZodStringFormats | (string & {})]?: string;
@@ -72,7 +99,7 @@ const error: () => errors.$ZodErrorMap = () => {
   return (issue) => {
     switch (issue.code) {
       case "invalid_type":
-        return `Entrada inválida: se esperaba ${issue.expected}, recibido ${parsedType(issue.input)}`;
+        return `Entrada inválida: se esperaba ${typeName(issue.expected)}, recibido ${parsedType(issue.input)}`;
       // return `Entrada inválida: se esperaba ${issue.expected}, recibido ${util.getParsedType(issue.input)}`;
       case "invalid_value":
         if (issue.values.length === 1)
@@ -82,17 +109,17 @@ const error: () => errors.$ZodErrorMap = () => {
         const adj = issue.inclusive ? "<=" : "<";
         const sizing = getSizing(issue.origin);
         if (sizing)
-          return `Demasiado grande: se esperaba que ${issue.origin ?? "valor"} tuviera ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elementos"}`;
-        return `Demasiado grande: se esperaba que ${issue.origin ?? "valor"} fuera ${adj}${issue.maximum.toString()}`;
+          return `Demasiado grande: se esperaba que ${typeName(issue.origin ?? "valor")} tuviera ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elementos"}`;
+        return `Demasiado grande: se esperaba que ${typeName(issue.origin ?? "valor")} fuera ${adj}${issue.maximum.toString()}`;
       }
       case "too_small": {
         const adj = issue.inclusive ? ">=" : ">";
         const sizing = getSizing(issue.origin);
         if (sizing) {
-          return `Demasiado pequeño: se esperaba que ${issue.origin} tuviera ${adj}${issue.minimum.toString()} ${sizing.unit}`;
+          return `Demasiado pequeño: se esperaba que ${typeName(issue.origin)} tuviera ${adj}${issue.minimum.toString()} ${sizing.unit}`;
         }
 
-        return `Demasiado pequeño: se esperaba que ${issue.origin} fuera ${adj}${issue.minimum.toString()}`;
+        return `Demasiado pequeño: se esperaba que ${typeName(issue.origin)} fuera ${adj}${issue.minimum.toString()}`;
       }
       case "invalid_format": {
         const _issue = issue as errors.$ZodStringFormatIssues;
@@ -107,11 +134,11 @@ const error: () => errors.$ZodErrorMap = () => {
       case "unrecognized_keys":
         return `Llave${issue.keys.length > 1 ? "s" : ""} desconocida${issue.keys.length > 1 ? "s" : ""}: ${util.joinValues(issue.keys, ", ")}`;
       case "invalid_key":
-        return `Llave inválida en ${issue.origin}`;
+        return `Llave inválida en ${typeName(issue.origin)}`;
       case "invalid_union":
         return "Entrada inválida";
       case "invalid_element":
-        return `Valor inválido en ${issue.origin}`;
+        return `Valor inválido en ${typeName(issue.origin)}`;
       default:
         return `Entrada inválida`;
     }