@@ -638,7 +638,9 @@
 	 * Disable sorted bean properties.
 	 *
 	 * <p>
-	 * When <jk>true</jk>, bean properties are serialized and accessed in natural JVM order instead of the default alphabetical order.
+	 * When <jk>true</jk>, bean properties are serialized and accessed in declaration order instead of the default
+	 * alphabetical order: record component order for records, field declaration order (superclass first) for other
+	 * classes, then method-only properties alphabetically.
 	 *
 	 * <ul class='values'>
 	 * 	<li><js>"true"</js>
@@ -654,6 +656,36 @@
 	 */
 	String unsortedProperties() default "";
 
+	/**
+	 * Record component order.
+	 *
+	 * <p>
+	 * When <jk>true</jk>, the properties of {@link Record} beans use record component (declaration) order even when
+	 * other beans are sorted alphabetically.  Non-record beans are unaffected.
+	 *
+	 * <h5 class='section'>Example:</h5>
+	 * <p class='bjava'>
+	 * 	<ja>@BeanConfig</ja>(recordComponentOrder=<js>"true"</js>)
+	 * 	<jk>public class</jk> MyRestResource { ... }
+	 *
+	 * 	<jk>public record</jk> Person(String <jv>name</jv>, <jk>int</jk> <jv>age</jv>) {}
+	 * 	<jc>// Serialized as {"name":"Alice","age":30} instead of {"age":30,"name":"Alice"}</jc>
+	 * </p>
+	 *
+	 * <ul class='values'>
+	 * 	<li><js>"true"</js>
+	 * 	<li><js>"false"</js> (default: record properties are sorted alphabetically like other beans)
+	 * </ul>
+	 *
+	 * <h5 class='section'>Notes:</h5><ul>
+	 * 	<li>
+	 * 		Supports <a class="doclink" href="https://juneau.apache.org/docs/topics/DefaultVarResolver">VarResolver.DEFAULT</a> (e.g. <js>"$C{myConfigVar}"</js>).
+	 * </ul>
+	 *
+	 * @return The annotation value.
+	 */
+	String recordComponentOrder() default "";
+
 	/**
 	 * Use Java Introspector.
 	 *
 
@@ -113,6 +113,7 @@ public static Builder create() {
 	private final boolean ignoreUnknownBeanProperties;
 	private final boolean ignoreUnknownNullBeanProperties;
 	private final boolean unsortedProperties;
+	private final boolean recordComponentOrder;
 	private final boolean useInterfaceProxies;
 	private final boolean useJavaBeanIntrospector;
 
@@ -147,6 +148,7 @@ private BeanConfigContext(Builder b) {
 		ignoreUnknownBeanProperties = b.ignoreUnknownBeanProperties;
 		ignoreUnknownNullBeanProperties = b.ignoreUnknownNullBeanProperties;
 		unsortedProperties = b.unsortedProperties;
+		recordComponentOrder = b.recordComponentOrder;
 		useInterfaceProxies = b.useInterfaceProxies;
 		useJavaBeanIntrospector = b.useJavaBeanIntrospector;
 		propertyNamer = b.propertyNamer;
@@ -301,12 +303,27 @@ public Builder copy() {
 	public boolean isIgnoreUnknownNullBeanProperties() { return ignoreUnknownNullBeanProperties; }
 
 	/**
-	 * Returns whether properties should preserve their JVM-discovered (non-alphabetical) order.
+	 * Returns whether properties use declaration order instead of alphabetical order.
+	 *
+	 * <p>
+	 * Declaration order means record component order for records, field declaration order (superclass first) for
+	 * other classes, followed by method-only properties in alphabetical order.
 	 *
 	 * @return <jk>true</jk> if properties remain unsorted.
 	 */
 	public boolean isUnsortedProperties() { return unsortedProperties; }
 
+	/**
+	 * Returns whether record properties use record component (declaration) order.
+	 *
+	 * <p>
+	 * When <jk>true</jk>, the properties of a {@link Record} are ordered by {@link Class#getRecordComponents()} even in
+	 * the default sorted mode.  Non-record beans are unaffected.
+	 *
+	 * @return <jk>true</jk> if records use component order.
+	 */
+	public boolean isRecordComponentOrder() { return recordComponentOrder; }
+
 	/**
 	 * Returns whether interface proxies should be created for bean interfaces.
 	 *
@@ -453,6 +470,7 @@ public static final class Builder {
 		private boolean ignoreUnknownBeanProperties;
 		private boolean ignoreUnknownNullBeanProperties = true;
 		private boolean unsortedProperties;
+		private boolean recordComponentOrder;
 		private boolean useInterfaceProxies = true;
 		private boolean useJavaBeanIntrospector;
 
@@ -489,6 +507,7 @@ private Builder(BeanConfigContext src) {
 			ignoreUnknownBeanProperties = src.ignoreUnknownBeanProperties;
 			ignoreUnknownNullBeanProperties = src.ignoreUnknownNullBeanProperties;
 			unsortedProperties = src.unsortedProperties;
+			recordComponentOrder = src.recordComponentOrder;
 			useInterfaceProxies = src.useInterfaceProxies;
 			useJavaBeanIntrospector = src.useJavaBeanIntrospector;
 			propertyNamer = src.propertyNamer;
@@ -641,13 +660,21 @@ public BeanConfigContext build() {
 		public Builder ignoreUnknownNullBeanProperties(boolean value) { ignoreUnknownNullBeanProperties = value; return this; }
 
 		/**
-		 * Toggles whether properties remain in JVM-discovered (non-alphabetical) order.
+		 * Toggles declaration order (instead of alphabetical order) for bean properties.
 		 *
 		 * @param value The new value.
 		 * @return This object.
 		 */
 		public Builder unsortedProperties(boolean value) { unsortedProperties = value; return this; }
 
+		/**
+		 * Toggles record component (declaration) ordering for {@link Record} beans.
+		 *
+		 * @param value The new value.
+		 * @return This object.
+		 */
+		public Builder recordComponentOrder(boolean value) { recordComponentOrder = value; return this; }
+
 		/**
 		 * Toggles automatic creation of interface proxies for bean interfaces.
 		 *
 
@@ -112,6 +112,8 @@ public static <T> BeanMap<T> of(T bean, BeanMeta<T> meta) {
 	/** Temporary holding cache for beans with read-only properties.  Normally null. */
 	protected Map<String,Object> propertyCache;
 
+	private Set<String> presentProperties;  // Names of required properties seen so far.  null when the bean has no required properties.
+
 	/** Temporary holding cache for bean properties of array types when the add() method is being used. */
 	protected Map<String,List<?>> arrayPropertyCache;
 
@@ -138,6 +140,43 @@ public BeanMap(T bean, BeanMeta<T> meta) {
 		if (ine(meta.getConstructorArgs()))
 			propertyCache = new TreeMap<>();
 		this.typePropertyName = meta.getTypePropertyName();
+		if (meta.hasRequiredProperties())
+			presentProperties = new HashSet<>();
+	}
+
+	/**
+	 * Records that a property was written from input.  Only tracked when the bean has required properties.
+	 *
+	 * @param name The property name.
+	 */
+	void recordPresent(String name) {
+		if (nn(presentProperties))
+			presentProperties.add(name);
+	}
+
+	/**
+	 * Returns the {@code @BeanProp(required=true)} properties that have not been written to this map.
+	 *
+	 * <p>
+	 * A property counts as written once {@link #put(String, Object)} (or a collection {@code add}) has been called for
+	 * it, even with a <jk>null</jk> value.  Parsers call this once per bean, before the bean is constructed.
+	 *
+	 * <h5 class='section'>Example:</h5>
+	 * <p class='bjava'>
+	 * 	<jc>// MyBean has @BeanProp(required=true) on 'name' and 'zip'.</jc>
+	 * 	BeanMap&lt;MyBean&gt; <jv>m</jv> = <jv>session</jv>.newBeanMap(MyBean.<jk>class</jk>);
+	 * 	<jv>m</jv>.put(<js>"name"</js>, <jk>null</jk>);
+	 *
+	 * 	<jc>// [zip]</jc>
+	 * 	List&lt;String&gt; <jv>missing</jv> = <jv>m</jv>.getMissingRequiredProperties();
+	 * </p>
+	 *
+	 * @return The missing required property names, in property order.  Empty (never <jk>null</jk>) if none.
+	 */
+	public List<String> getMissingRequiredProperties() {
+		if (presentProperties == null)
+			return List.of();
+		return meta.getRequiredPropertyNames().stream().filter(x -> ! presentProperties.contains(x)).toList();
 	}
 
 	/**
 
@@ -54,20 +54,31 @@
  *
  * <h5 class='topic'>Bean property ordering</h5>
  *
- * The order of the properties are as follows:
+ * The order of the properties is as follows:
  * <ul class='spaced-list'>
  * 	<li>
  * 		If {@link BeanType#properties() @BeanType(properties)} is specified on the class, the order matches the
  * 		list of properties in the annotation.
  * 	<li>
- * 		Otherwise, the order is based on the following:
+ * 		Otherwise, by default, properties are sorted alphabetically.
+ * 	<li>
+ * 		When unsorted properties are enabled ({@link BeanConfigContext#isUnsortedProperties()},
+ * 		{@link BeanType#unsorted() @BeanType(unsorted=true)}, or a bean filter), properties use declaration order:
  * 		<ul>
- * 			<li>Public fields (same order as {@code Class.getFields()}).
- * 			<li>Properties returned by {@code BeanInfo.getPropertyDescriptors()}.
- * 			<li>Non-standard getters/setters with {@link BeanProp @BeanProp} annotation defined on them.
+ * 			<li>Records: record component order.
+ * 			<li>Other classes: field declaration order, superclass fields first.  Getter/setter properties are ranked
+ * 				by their same-named field (even a private one), which is used as an ordering hint only.
+ * 			<li>Method-only properties (no backing field) follow, alphabetically.
  * 		</ul>
+ * 	<li>
+ * 		{@link BeanConfigContext#isRecordComponentOrder()} gives records component order even when other beans are
+ * 		sorted.
  * </ul>
  *
+ * <p>
+ * Field order comes from {@link Class#getDeclaredFields()}, which is declaration order on HotSpot and OpenJ9 but is
+ * not guaranteed by the JLS.
+ *
  * <h5 class='topic'>Thread safety</h5>
  *
  * Instances are effectively immutable after construction and are safe for concurrent read access.
@@ -368,7 +379,8 @@ private static <T> BeanMetaValue<T> notABean(String reason) {
 	final String notABeanReason;                                       // Readable string explaining why this class wasn't a bean.
 	private final Map<String,BeanPropertyMeta> properties;                     // The properties on the target class.
 	private final Map<Method,String> setterProps;                              // The setter properties on the target class.
-	private final boolean unsortedProperties;                                  // Whether properties should use natural JVM-dependent order.
+	private final List<String> requiredPropertyNames;                         // Names of @BeanProp(required=true) properties, in property order.
+	private final boolean unsortedProperties;                                  // Whether properties use declaration order instead of alphabetical order.
 	private final PropertyNamer propertyNamerOverride;                         // Optional per-instance namer override.  Null means resolve the normal way (bean filter, then config).  Non-null takes precedence over both.
 	private final ClassInfo stopClass;                                         // The stop class for hierarchy traversal.
 	private final BeanPropertyMeta typeProperty;                               // "_type" mock bean property.
@@ -616,11 +628,23 @@ private BeanMeta(BeanInfo<T> cm, ClassInfo ci0, BeanConfigContext config, Object
 				m.setAsConstructorArg();
 			}
 
+			// @BeanProp(required=true) must be satisfiable from input (WORK-J0585).
+			for (var p : normalProps.values())
+				if (p.isRequired() && ! p.canSatisfyRequired())
+					throw brex(c, "Property '%s' on class '%s' is marked @BeanProp(required=true) but cannot be written (read-only, dynamic, or no field, setter or constructor argument).", p.name, ci.getNameSimple());
+
 			// Make sure at least one property was found (records with no components are exempt).
 			if (bf == null && config.isBeansRequireSomeProperties() && normalProps.isEmpty() && ! ci.isRecord())
 				notABeanReasonTemp = "No properties detected on bean class";
 
-			unsortedPropertiesTemp = config.isUnsortedProperties() || bfo.map(x -> x.isUnsortedProperties()).orElse(false) || !fixedBeanProps.isEmpty();
+			// Records opt into component order via recordComponentOrder(); that is unsorted mode scoped to records.
+			var recordComponentOrder = ci.isRecord() && config.isRecordComponentOrder();
+			unsortedPropertiesTemp = recordComponentOrder || config.isUnsortedProperties() || bfo.map(x -> x.isUnsortedProperties()).orElse(false) || !fixedBeanProps.isEmpty();
+
+			// Declaration-order seeding (WORK-J0585).  Skipped when an explicit @BeanType(properties) list exists
+			// (that list keeps absolute precedence) and on the java.beans.Introspector path.
+			if (unsortedPropertiesTemp && fixedBeanProps.isEmpty() && ! config.isUseJavaBeanIntrospector())
+				orderByDeclaration(normalProps);
 
 			propertiesValue.set(unsortedPropertiesTemp ? map() : sortedMap());
 
@@ -682,6 +706,7 @@ private BeanMeta(BeanInfo<T> cm, ClassInfo ci0, BeanConfigContext config, Object
 		setterProps = u(setterPropsMap);
 		dynaProperty = dynaPropertyValue.get();
 		unsortedProperties = unsortedPropertiesTemp;
+		requiredPropertyNames = properties == null ? List.<String>of() : properties.values().stream().filter(BeanPropertyMeta::isRequired).map(BeanPropertyMeta::getName).toList();
 		typeProperty = BeanPropertyMeta.builder(this, typePropertyName).canRead().canWrite().rawMetaType(String.class).build();
 		// Map the synthetic "_type" property to the bean-level BeanRegistry so consumers calling
 		// typeProperty.getBeanRegistry() (currently none in-tree, but a public API path) get the same
@@ -726,6 +751,54 @@ private void validateAndRegisterProperty(BeanPropertyMeta.Builder p, Class<?> c,
 		}
 	}
 
+	/**
+	 * Re-keys the discovered properties into declaration order.
+	 *
+	 * <ul class='spaced-list'>
+	 * 	<li>Records: record component order ({@link ClassInfo#getRecordComponents()}, defined by the JLS).  A component
+	 * 		is matched to its property through the property's field or accessor name, so renamed components keep
+	 * 		their position.
+	 * 	<li>Other classes: the position of the property's backing field (the visible field, or the same-named private
+	 * 		field recorded as {@code innerField}) in a superclass-first walk of
+	 * 		{@link ClassInfo#getDeclaredFieldsInDeclarationOrder()}.
+	 * 	<li>Properties with no backing field or component (method-only) go after all ranked properties, alphabetically.
+	 * </ul>
+	 *
+	 * <p>
+	 * Visibility is unchanged: private fields only <i>rank</i> properties, they never become properties.
+	 *
+	 * @param props The discovered properties.  Re-ordered in place.
+	 */
+	private void orderByDeclaration(Map<String,BeanPropertyMeta.Builder> props) {
+		var rank = new HashMap<String,Integer>();
+		if (classInfo.isRecord()) {
+			var components = classInfo.getRecordComponents();
+			for (var i = 0; i < components.size(); i++) {
+				var rcName = components.get(i).getName();
+				for (var e : props.entrySet()) {
+					var p = e.getValue();
+					if ((nn(p.field) && p.field.hasName(rcName)) || (nn(p.getter) && p.getter.hasName(rcName)))
+						rank.putIfAbsent(e.getKey(), i);
+				}
+			}
+		} else {
+			var fieldRank = new HashMap<Field,Integer>();
+			for (var c2 : classHierarchy.get())
+				for (var f : c2.getDeclaredFieldsInDeclarationOrder())
+					fieldRank.putIfAbsent(f.inner(), fieldRank.size());
+			props.forEach((k, p) -> {
+				var f = nn(p.field) ? p.field : p.innerField;
+				if (nn(f) && fieldRank.containsKey(f.inner()))
+					rank.put(k, fieldRank.get(f.inner()));
+			});
+		}
+		var keys = new ArrayList<>(props.keySet());
+		keys.sort(Comparator.<String>comparingInt(k -> rank.getOrDefault(k, Integer.MAX_VALUE)).thenComparing(Comparator.naturalOrder()));
+		var copy = new LinkedHashMap<>(props);
+		props.clear();
+		keys.forEach(k -> props.put(k, copy.get(k)));
+	}
+
 	@Override /* Overridden from Object */
 	public boolean equals(Object o) {
 		return (o instanceof BeanMeta<?> o2) && eq(this, o2, (x, y) -> eq(x.classInfo, y.classInfo));
@@ -1085,10 +1158,35 @@ public boolean hasConstructor() {
 		return beanConstructor.constructor().isPresent();
 	}
 
+	/**
+	 * Returns whether any property of this bean is marked {@code @BeanProp(required=true)}.
+	 *
+	 * @return <jk>true</jk> if at least one property is required.
+	 */
+	public boolean hasRequiredProperties() { return ! requiredPropertyNames.isEmpty(); }
+
+	/**
+	 * Returns the names of the properties marked {@code @BeanProp(required=true)}.
+	 *
+	 * <p>
+	 * Hidden and excluded properties are not included, since input can never set them.
+	 *
+	 * <h5 class='section'>Example:</h5>
+	 * <p class='bjava'>
+	 * 	<jk>public record</jk> Person(<ja>@BeanProp</ja>(required=<jk>true</jk>) String <jv>name</jv>, Integer <jv>age</jv>) {}
+	 *
+	 * 	<jc>// [name]</jc>
+	 * 	List&lt;String&gt; <jv>required</jv> = BeanMeta.<jsm>of</jsm>(Person.<jk>class</jk>, BeanConfigContext.<jsf>DEFAULT</jsf>).getRequiredPropertyNames();
+	 * </p>
+	 *
+	 * @return An unmodifiable list of property names, in property order.  Never <jk>null</jk>.
+	 */
+	public List<String> getRequiredPropertyNames() { return requiredPropertyNames; }
+
 	/**
 	 * Returns whether this bean has opted out of alphabetical property sorting.
 	 *
-	 * @return <jk>true</jk> if properties should use natural JVM-dependent order.
+	 * @return <jk>true</jk> if properties use declaration order (see the class Javadoc).
 	 */
 	protected boolean isUnsortedProperties() { return unsortedProperties; }