@@ -1203,8 +1203,8 @@ public void createObjectsBulk(ObjectConnection c, MetaObject mc, Collection<Obje
             if (getDatabaseDriver() instanceof BulkOperationSupport bulkDriver) {
                 bulkDriver.createBulk(conn, mc, mapping, objects);
             } else {
-                // Fallback to individual creates with better batching
-                createObjectsBatchFallback(conn, mc, mapping, objects);
+                // Fallback to individual creates inside a single transaction
+                createObjectsBatchFallback(c, mc, mapping, objects);
             }
         } catch (SQLException e) {
             throw new PersistenceException("Unable to bulk create objects of class [" + mc + "]: " + e.getMessage(), e);
@@ -1241,36 +1241,66 @@ public void updateObjectsBulk(ObjectConnection c, MetaObject mc, Collection<Obje
     }
 
     /**
-     * Batch fallback for create operations when bulk support is not available
+     * Batch fallback for create operations when the driver provides no native
+     * bulk support. Runs the whole batch as a single all-or-nothing
+     * transaction: any failure rolls back every row, so the datastore is never
+     * left with a partially-applied batch. The live {@link ObjectConnection} is
+     * passed to the pre/post-persistence hooks (previously {@code null}), so
+     * auto-field handlers and event listeners see the same connection a single
+     * {@link #createObject} would give them.
+     *
+     * <p>The per-1000-row mid-commit of the prior implementation was removed:
+     * intermediate commits made earlier chunks unrecoverable on a later
+     * failure, defeating atomicity.
+     *
+     * <p><strong>Transaction ownership.</strong> Commit / rollback / auto-commit
+     * restore are performed ONLY when this method opened the transaction (the
+     * connection arrived with auto-commit on). When the caller already owns the
+     * transaction — e.g. inside an {@code ObjectManager.inTransaction(...)} lambda
+     * which sets auto-commit off — this method commits nothing, rolls back nothing,
+     * and lets exceptions propagate so the caller's transaction boundary stays
+     * authoritative (no premature commit, no double rollback). This mirrors single
+     * {@link #createObject}, which never manages a commit of its own.
      */
-    private void createObjectsBatchFallback(Connection conn, MetaObject mc, ObjectMappingDB mapping, Collection<Object> objects) throws SQLException {
-        // Disable auto-commit for better performance
+    private void createObjectsBatchFallback(ObjectConnection c, MetaObject mc, ObjectMappingDB mapping, Collection<Object> objects) throws SQLException {
+        Connection conn = (Connection) c.getDatastoreConnection();
+
         boolean originalAutoCommit = conn.getAutoCommit();
         if (originalAutoCommit) {
             conn.setAutoCommit(false);
         }
-        
+
         try {
-            int batchCount = 0;
             for (Object obj : objects) {
-                prePersistence(null, mc, obj, CREATE);
-                
+                prePersistence(c, mc, obj, CREATE);
+
                 if (!getTypedDatabaseDriver().create(conn, mc, mapping, obj)) {
                     throw new PersistenceException("No rows created for object [" + obj + "] of class [" + mc + "]");
                 }
-                
-                postPersistence(null, mc, obj, CREATE);
-                
-                // Commit in batches of 1000 for memory management
-                if (++batchCount % 1000 == 0) {
-                    conn.commit();
-                }
+
+                postPersistence(c, mc, obj, CREATE);
             }
-            
-            // Commit any remaining
-            if (batchCount % 1000 != 0) {
+
+            // Only commit when THIS method opened the transaction. If the caller
+            // arrived already non-autocommit (e.g. inside an inTransaction lambda),
+            // the boundary is theirs to manage — committing here would prematurely
+            // commit the outer unit of work.
+            if (originalAutoCommit) {
                 conn.commit();
             }
+        } catch (SQLException | RuntimeException e) {
+            // All-or-nothing: undo every row inserted in this batch — but only when
+            // we own the transaction. When the caller owns it, let the exception
+            // propagate untouched (the caller rolls back); rolling back here would
+            // double-rollback the outer transaction.
+            if (originalAutoCommit) {
+                try {
+                    conn.rollback();
+                } catch (SQLException rollbackEx) {
+                    e.addSuppressed(rollbackEx);
+                }
+            }
+            throw e;
         } finally {
             // Restore original auto-commit
             if (originalAutoCommit) {
 
@@ -36,6 +36,7 @@ public class SimpleMappingHandlerDB implements MappingHandler {
 
 	public final static String AUTO_ID  = "id";
 	public final static String AUTO_LAST_ID  = "last";
+	public final static String AUTO_UUID  = "uuid";
 
 	public final static String IS_INDEX     = "isIndex";
 	public final static String IS_UNIQUE 	  = "isUnique";
@@ -208,9 +209,12 @@ protected void loadColumns( Collection<MetaField> fields, BaseTableDef table, Ob
 					if ( AUTO_ID.equals( auto )) {
 						colDef.setAutoType( ColumnDef.AUTO_ID );
 					}
-					if ( AUTO_LAST_ID.equals( auto )) {
+					else if ( AUTO_LAST_ID.equals( auto )) {
 						colDef.setAutoType( ColumnDef.AUTO_LAST_ID );
 					}
+					else if ( AUTO_UUID.equals( auto )) {
+						colDef.setAutoType( ColumnDef.AUTO_UUID );
+					}
 					else if ( ObjectManager.AUTO_CREATE.equals( auto )) {
 						colDef.setAutoType( ColumnDef.AUTO_DATE_CREATE );
 					}
@@ -357,7 +361,7 @@ protected String getAutoGenerated( MetaField mf ) {
 						case MetaIdentity.GENERATION_INCREMENT:
 							return AUTO_LAST_ID; // "last" -> database auto-increment (Derby IDENTITY, etc.)
 						case MetaIdentity.GENERATION_UUID:
-							return AUTO_LAST_ID; // "last" -> UUID generation
+							return AUTO_UUID; // app-side UUID minted before INSERT (DB-portable)
 						case MetaIdentity.GENERATION_ASSIGNED:
 						default:
 							return null; // No auto-increment
 
@@ -123,13 +123,16 @@ static final class DateCodec implements JdbcFieldCodec {
     }
 
     /**
-     * TimeField has a write-side path (LocalTime → java.sql.Time) but no read
-     * branch in the original ladder; reads fall through to the default
-     * setObject behavior (matches prior runtime behavior for TimeField rows).
+     * TimeField read mirrors the write side (LocalTime ⇄ java.sql.Time): read
+     * the column as a {@link java.sql.Time} and convert to {@link LocalTime},
+     * the canonical Java representation for {@code field.time}. The previous
+     * stub fell through to {@code getObject} (driver-dependent type) which had
+     * drifted from the write codec.
      */
     static final class TimeCodec implements JdbcFieldCodec {
         @Override public void readInto(Object o, MetaField f, ResultSet rs, int j) throws SQLException {
-            f.setObject(o, rs.getObject(j));
+            java.sql.Time tv = rs.getTime(j);
+            f.setObject(o, rs.wasNull() ? null : tv.toLocalTime());
         }
         @Override public void write(PreparedStatement s, MetaField f, int j, Object v) throws SQLException {
             if (v == null) s.setNull(j, Types.TIME);
 
@@ -9,6 +9,8 @@ public class ColumnDef extends BaseArgDef {
 	public final static int AUTO_LAST_ID   		= 2;
 	public final static int AUTO_DATE_CREATE 	= 3;
 	public final static int AUTO_DATE_UPDATE 	= 4;
+	/** App-side UUID PK: OMDB mints a java.util.UUID string before INSERT (DB-portable). */
+	public final static int AUTO_UUID   		= 5;
 
 	private int length = DEFAULT_LENGTH;
 	private boolean isPrimaryKey = false;
 
@@ -11,7 +11,6 @@
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;
-import java.sql.Timestamp;
 import java.sql.Types;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -880,6 +879,28 @@ public String getRangeString(Range range) {
                 "The GenericDriver cannot perform a range during select");
     }
 
+    /**
+     * Whether this driver's range/paging clause requires an ORDER BY to be
+     * well-formed. ANSI {@code OFFSET ? ROWS FETCH NEXT ? ROWS ONLY} (SQL Server
+     * 2012+, Oracle 12c+) is only valid when preceded by an ORDER BY; LIMIT/OFFSET
+     * (Postgres) and Derby's FETCH FIRST do not have this requirement. When true
+     * and a paged query supplies no explicit sort, {@link #getDefaultRangeOrderBy()}
+     * is appended before the range clause.
+     */
+    protected boolean rangeRequiresOrderBy() {
+        return false;
+    }
+
+    /**
+     * The fallback ORDER BY clause to append when a paged query supplies no
+     * explicit sort order and {@link #rangeRequiresOrderBy()} is true. Drivers
+     * that require ORDER BY for paging override this.
+     */
+    protected String getDefaultRangeOrderBy() {
+        throw new UnsupportedOperationException(
+                "Driver does not define a default range ORDER BY clause");
+    }
+
     /*private void setAutoFields(Connection c, MetaClass mc,
      ObjectMappingDB omdb, Collection<MetaField> fields, Object o,
      int mode ) throws SQLException {
@@ -1504,15 +1525,6 @@ protected PreparedStatement getSelectStatementWhere(Connection c, MetaObject mc,
         if (options.isDistinct()) {
             query.append("DISTINCT ");
         }
-        if (options.getRange() != null) {
-            // TODO: Make this a little smarter for christ's sake!
-            // Recommendation: Have the driver form the final SELECT call, then
-            // it can insert the limit where needed
-            //if (getDatabaseDriver() instanceof MSSQLDriver) {
-            //	query.append("TOP ").append(options.getRange().getEnd())
-            //			.append(' ');
-            //}
-        }
 
         String fieldStr = getFieldString(omdb, fields, "A");
 
@@ -1555,24 +1567,30 @@ protected PreparedStatement getSelectStatementWhere(Connection c, MetaObject mc,
             query.append(" WHERE ").append(getExpressionString(mc, omdb, where, args, "A"));
         }
 
+        Range range = options.getRange();
+        boolean applyRange = supportsRangeInQuery() && range != null
+                && range.getStart() > 0 && range.getEnd() > 0;
+
+        if (applyRange && range.getStart() > range.getEnd()) {
+            throw new IllegalArgumentException("The range end (" + range.getEnd() + ") cannot be greater than the start value (" + range.getStart() + ")");
+        }
+
         if (order != null) {
             query.append(" ORDER BY ").append(getOrderString(mc, omdb, order));
+        } else if (applyRange && rangeRequiresOrderBy()) {
+            // ANSI OFFSET/FETCH (SQL Server 2012+, Oracle 12c+) is only valid
+            // when preceded by an ORDER BY. Supply a deterministic fallback when
+            // the caller did not specify a sort order.
+            query.append(" ").append(getDefaultRangeOrderBy());
         }
 
-        if (options.withLock()) {
-            query.append(" ").append(getLockString());
+        // Add on the range (must follow ORDER BY for OFFSET/FETCH dialects)
+        if (applyRange) {
+            query.append(" ").append(getRangeString(range));
         }
 
-        // Add on the range
-        Range range = options.getRange();
-        if (supportsRangeInQuery() && options.getRange() != null
-                && range.getStart() > 0 && range.getEnd() > 0) {
-
-            if (range.getStart() > range.getEnd()) {
-                throw new IllegalArgumentException("The range end (" + range.getEnd() + ") cannot be greater than the start value (" + range.getStart() + ")");
-            }
-
-            query.append(" ").append(getRangeString(range));
+        if (options.withLock()) {
+            query.append(" ").append(getLockString());
         }
 
         PreparedStatement s = c.prepareStatement(query.toString());
@@ -1746,6 +1764,13 @@ protected PreparedStatement getInsertStatement(Connection c, MetaObject mc,
                 if (colDef.getAutoType() == ColumnDef.AUTO_ID) {
                     f.setString(o, getNextAutoId(c, colDef));
                 }
+                else if (colDef.getAutoType() == ColumnDef.AUTO_UUID) {
+                    // App-side UUID PK: OMDB mints the value before INSERT (no DB
+                    // identity / default). DB-portable as a string column.
+                    if (f.getString(o) == null) {
+                        f.setString(o, java.util.UUID.randomUUID().toString());
+                    }
+                }
                 else if (colDef.isAutoIncrementor()) {
                     continue;
                 }
@@ -1950,37 +1975,23 @@ protected void parseObject(ResultSet rs, Collection<MetaField> fields,
     }
 
     /**
-     * Enhanced field parsing with modern Java patterns and proper null handling
+     * Reads a single column from the ResultSet into the target object via the
+     * {@link com.metaobjects.manager.db.codec.JdbcCodecs} registry — the same
+     * single source of truth used by {@link #setStatementValue} on the write
+     * side (FR-003 Plan 4, Debt 1 — ADR-0002). This replaces the former
+     * {@code instanceof} ladder, which had drifted from the write-side codec
+     * (e.g. TimeField).
+     *
+     * <p>The jsonb pre-check mirrors {@code setStatementValue}: jsonb
+     * serialization depends on driver-local state ({@link #isJsonbField} /
+     * {@link #deserializeJsonb}), not on field subtype alone, and is gated on
+     * {@code codec == defaultCodec()} so explicit per-subtype codecs always win.
      */
     protected void parseField(Object o, MetaField f, ResultSet rs, int j) throws SQLException {
-        if (f instanceof com.metaobjects.field.BooleanField) {
-            boolean bv = rs.getBoolean(j);
-            f.setBoolean(o, rs.wasNull() ? null : bv);
-        } else if (f instanceof com.metaobjects.field.DecimalField) {
-            java.math.BigDecimal dv = rs.getBigDecimal(j);
-            f.setObject(o, rs.wasNull() ? null : dv);
-        } else if (f instanceof com.metaobjects.field.IntegerField) {
-            int iv = rs.getInt(j);
-            f.setInt(o, rs.wasNull() ? null : iv);
-        } else if (f instanceof com.metaobjects.field.DateField) {
-            Timestamp tv = rs.getTimestamp(j);
-            f.setDate(o, rs.wasNull() ? null : new Date(tv.getTime()));
-        } else if (f instanceof com.metaobjects.field.TimeField) {
-            java.sql.Time tv = rs.getTime(j);
-            f.setObject(o, rs.wasNull() ? null : tv.toLocalTime());
-        } else if (f instanceof com.metaobjects.field.LongField) {
-            long lv = rs.getLong(j);
-            f.setLong(o, rs.wasNull() ? null : lv);
-        } else if (f instanceof com.metaobjects.field.FloatField) {
-            float fv = rs.getFloat(j);
-            f.setFloat(o, rs.wasNull() ? null : fv);
-        } else if (f instanceof com.metaobjects.field.DoubleField) {
-            double dv = rs.getDouble(j);
-            f.setDouble(o, rs.wasNull() ? null : dv);
-        } else if (f instanceof com.metaobjects.field.StringField) {
-            f.setString(o, rs.getString(j));
-        } else if (isJsonbField(f)) {
-            // jsonb: read JSON text from column, deserialize via deserializeJsonb().
+        com.metaobjects.manager.db.codec.JdbcFieldCodec codec =
+                com.metaobjects.manager.db.codec.JdbcCodecs.forField(f);
+        if (codec == com.metaobjects.manager.db.codec.JdbcCodecs.defaultCodec() && isJsonbField(f)) {
+            // jsonb: read JSON text from the column, deserialize via deserializeJsonb().
             // Step 1 consults ObjectClassRegistry for a bound class (registry wins for
             // explicit POJO bindings); step 2 falls back to MetaObjectDeserializer which
             // returns the MetaObject's declared class (e.g. ValueObject) when no binding
@@ -1991,12 +2002,9 @@ protected void parseField(Object o, MetaField f, ResultSet rs, int j) throws SQL
             } else {
                 f.setObject(o, deserializeJsonb(f, json));
             }
-        } else if (f instanceof com.metaobjects.field.ObjectField) {
-            f.setObject(o, rs.getObject(j));
-        } else {
-            log.warn("Unknown field type {} for field {}, defaulting to Object", f.getClass().getSimpleName(), f.getName());
-            f.setObject(o, rs.getObject(j));
+            return;
         }
+        codec.readInto(o, f, rs, j);
     }
 
     // /////////////////////////////////////////////////////
 
@@ -356,26 +356,39 @@ protected String getLastAutoId(Connection conn, ColumnDef col) throws SQLExcepti
     }
 
     /**
-     * SQL Server supports TOP and OFFSET/FETCH for range queries
+     * SQL Server supports standard ANSI OFFSET/FETCH for range queries
+     * (requires SQL Server 2012+).
      */
     @Override
     protected boolean supportsRangeInQuery() {
         return true;
     }
-    
+
     /**
-     * SQL Server OFFSET/FETCH syntax (SQL Server 2012+)
+     * SQL Server OFFSET/FETCH syntax (SQL Server 2012+). Used uniformly for
+     * every page, including the first -- the legacy TOP path (which never
+     * paged the first page at all) has been removed. Requires a preceding
+     * ORDER BY; see {@link #rangeRequiresOrderBy()}.
      */
     @Override
     public String getRangeString(Range range) {
-        if (range.getStart() <= 1) {
-            // Use TOP for simple cases
-            return ""; // Will be handled by modifying SELECT clause
-        } else {
-            // Use OFFSET/FETCH for complex ranges
-            return "OFFSET " + (range.getStart() - 1) + " ROWS FETCH NEXT " + 
-                   (range.getEnd() - range.getStart() + 1) + " ROWS ONLY";
-        }
+        return "OFFSET " + (range.getStart() - 1) + " ROWS FETCH NEXT " +
+               (range.getEnd() - range.getStart() + 1) + " ROWS ONLY";
+    }
+
+    /** SQL Server OFFSET/FETCH requires an ORDER BY to be well-formed. */
+    @Override
+    protected boolean rangeRequiresOrderBy() {
+        return true;
+    }
+
+    /**
+     * SQL Server accepts a constant ORDER BY for paging when the caller
+     * supplies no explicit sort order.
+     */
+    @Override
+    protected String getDefaultRangeOrderBy() {
+        return "ORDER BY (SELECT NULL)";
     }
 
     /**