diff --git a/.github/workflows/dart.yml b/.github/workflows/dart.yml
index ca11dcc..0422896 100644
--- a/.github/workflows/dart.yml
+++ b/.github/workflows/dart.yml
@@ -10,8 +10,8 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: dart-lang/setup-dart@v1
+      - uses: actions/checkout@v7
+      - uses: dart-lang/setup-dart@v1.7.2
       - name: Dart version
         run: |
           dart --version
@@ -34,8 +34,8 @@ jobs:
   test_vm:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: dart-lang/setup-dart@v1
+      - uses: actions/checkout@v7
+      - uses: dart-lang/setup-dart@v1.7.2
       - name: Dart version
         run: |
           dart --version
@@ -51,10 +51,11 @@ jobs:
           dart pub global activate coverage
           dart pub global run coverage:format_coverage --packages=.dart_tool/package_config.json --report-on=lib --lcov -o ./coverage/lcov.info -i ./coverage
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v3
-        env:
-          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+        uses: codecov/codecov-action@v7
         with:
+          # `codecov-action` v4+ takes the token as an input
+          # (it was an env var in v3):
+          token: ${{ secrets.CODECOV_TOKEN }}
           directory: ./coverage/
           flags: unittests
           env_vars: OS,DART
@@ -65,8 +66,8 @@ jobs:
   test_chrome:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: dart-lang/setup-dart@v1
+      - uses: actions/checkout@v7
+      - uses: dart-lang/setup-dart@v1.7.2
       - name: Dart version
         run: |
           dart --version
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f81dfa5..ddf9adc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,102 @@
+## 1.11.0
+
+- `selectByQuery` and its siblings gained 4 optional parameters, for pagination
+  and ordering:
+  - `offset`: the return offset.
+  - `page`: the 1-based page to return, an ergonomic alternative to `offset`
+    that computes it from the page size: `(page - 1) * limit`.
+  - `orderByID`: orders the result by the table's ID column, resolved
+    automatically from the existing scheme machinery (`TableScheme.idFieldName`
+    → `EncodingContext.tableFieldID`, or `EntityHandler.idFieldName`).
+  - `orderDirection`: the new `OrderDirection` enum, `ascending` (default) or
+    `descending`.
+
+  Semantics:
+  - The effective ordering is `orderByID ?? (offset != null)`: a non-null
+    `offset` turns the ordering **on** by default, since an offset-based
+    pagination needs a stable order to be correct. Pass `orderByID: false` to
+    opt out and get a bare `OFFSET`.
+  - `orderDirection` is **ignored** while the ordering is not active.
+  - `page` is a public convenience resolved to an `offset` at the repository
+    layer (see `resolveSelectOffset`); the adapter contract keeps taking only
+    `offset`. It throws an `ArgumentError` when combined with an `offset` (two
+    spellings of one thing), when there is no positive `limit` to use as the
+    page size, or when it is `< 1`. `page: 1` resolves to `offset: 0`, which
+    still activates the ordering, so even the first page is stable.
+  - All 4 are optional and default to the previous behavior: with them unset the
+    generated SQL is character-identical to 1.10.0.
+
+  Added to `EntitySource`/`EntityRepository` (`selectByQuery`,
+  `selectFirstByQuery`, `select`, `selectIDsByQuery`, `selectIDsBy`,
+  `selectAll`), `APIRepository`, `IterableEntityRepository`
+  (`matches`/`all` included), `DBEntityRepository`, `DBRelationalAdapter`/
+  `DBRelationalRepositoryAdapter`/`DBRelationalEntityRepository`,
+  `DBAdapter.doSelectAll`/`doSelectByIDs`, `DBSQLAdapter.doSelect`/
+  `doSelectIDsBy`/`generateSelectSQL`/`generateSelectIDsSQL` and
+  `DBSQLRepositoryAdapter.generateSelectSQL`.
+
+- New `OrderDirection` enum (`bones_api_types.dart`), with `sqlKeyword`,
+  `parse` and the resolvers `resolve` and `resolveOrderByID` that state the
+  semantics above exactly once.
+
+- New `compareEntityIDs` and `applySelectOrderAndPagination`
+  (`bones_api_entity.dart`): the shared Dart-side "order by ID → skip → take"
+  used by every adapter that can't delegate the ordering to a DB engine.
+
+- New `resolveSelectOffset` (`bones_api_entity.dart`): resolves `page` to an
+  `offset`, and states the `page`/`offset`/`limit` validation rules once.
+
+- `SQLDialect`:
+  - New `orderBySQL` and `limitOffsetSQL` clause builders, so all the
+    dialect-specific `SELECT` tail syntax lives in one place.
+  - New `offsetRequiresLimit` and `offsetMaxLimitValue` capabilities. MySQL sets
+    `offsetRequiresLimit: true` since it can't parse an `OFFSET` that is not
+    preceded by a `LIMIT`; an offset-only select there emits
+    `LIMIT 18446744073709551615 OFFSET n`. PostgreSQL and the `generic`
+    (in-memory) dialect emit a bare `OFFSET n`.
+
+- `SQL`: new `offset`, `orderByID` and `orderDirection` fields (carried by
+  `copy()`), read by `DBSQLMemoryAdapter` to apply the same semantics in Dart.
+
+- `APIDBModule.select` (`/db/select/<table>`): new `LIMIT=<n>`, `OFFSET=<n>`,
+  `PAGE=<n>` and `ORDER=asc|desc` query directives
+  (see `APIDBModule.selectQueryDirectives`),
+  parsed from the query `String` alongside the pre-existing `EAGER=true` and
+  stripped before the remainder is parsed as the entity condition query. The
+  endpoint no longer selects the whole table and sorts it in Dart — the ordering
+  is now resolved by the DB. Its output order is unchanged. An invalid `PAGE`
+  becomes an error response rather than an uncaught `ArgumentError`.
+
+- **Behavior change**: `limit` is now honored on the paths that previously
+  accepted and silently ignored it — `DBEntityRepository.select`'s
+  `ConditionID`/`ConditionIdIN`/`ConditionANY`/`KeyConditionEQ` fast paths,
+  `DBAdapter.doSelectAll`/`doSelectByIDs`, and the `DBObjectMemoryAdapter`,
+  `DBObjectDirectoryAdapter` and `DBObjectGCSAdapter` adapters. For example,
+  `selectAll(limit: 2)` on an object adapter returned *every* row before this
+  release; it now returns 2.
+
+- **Source-breaking for external subclasses**: new named parameters were added
+  to abstract members (`EntitySource.select`/`selectIDsBy`/`selectAll`,
+  `DBAdapter.doSelectAll`/`doSelectByIDs`,
+  `DBRelationalAdapter.doSelect`/`doSelectIDsBy`). Dart requires an override to
+  accept every named parameter of the supertype, so third-party
+  `EntityRepository`/`DBAdapter` implementations must widen their overrides.
+
+- Known limitation: a query over a to-many relationship generates a `JOIN`
+  without a `DISTINCT`, so it can return the same entity more than once
+  (pre-existing). Paginating such a query is therefore best-effort.
+
+- Tests:
+  - New `bones_api_entity_select_order_test.dart` (`OrderDirection`,
+    `compareEntityIDs`, `applySelectOrderAndPagination`, `SQLDialect` clause
+    builders), `bones_api_entity_db_sql_select_test.dart` (exact generated SQL
+    per case + end-to-end paging over the in-memory SQL adapter) and
+    `bones_api_db_module_test.dart` (first coverage of `APIDBModule`).
+  - `bones_api_entity_db_tests_base.dart`: 3 new tests in the shared adapter
+    template, so the generated SQL and real page-by-page reads are asserted for
+    the in-memory, PostgreSQL, MySQL, object-memory and object-directory
+    adapters. Verified against real PostgreSQL and MySQL containers.
+
 ## 1.10.0
 
 - `docker_commander`: `^2.1.8` → `^3.0.0`.
diff --git a/README.md b/README.md
index 11330b6..c960e79 100644
--- a/README.md
+++ b/README.md
@@ -416,10 +416,49 @@ class AccountAPIRepository extends APIRepository<Account> {
     // This condition will be translated to a SQL with INNER JOIN (when using an SQLAdapter):
     return selectByQuery(' address.state == ? ', parameters: [state]);
   }
+
+  /// Selects a page of [Account]s by field `state` (`page` starts at 1):
+  FutureOr<Iterable<Account>> selectAccountsPage(String state, int page) {
+    // `page` computes the offset from the page size, and implies `orderByID`,
+    // so the pagination is stable
+    // (translated to: ORDER BY <id> ASC LIMIT 20 OFFSET <(page - 1) * 20>).
+    return selectByQuery(
+      ' address.state == ? ',
+      parameters: [state],
+      limit: 20,
+      page: page,
+    );
+  }
+
+  /// Selects the 10 newest [Account]s (highest IDs first):
+  FutureOr<Iterable<Account>> selectNewestAccounts() {
+    return selectAll(
+      limit: 10,
+      orderByID: true,
+      orderDirection: OrderDirection.descending,
+    );
+  }
 }
 
 ```
 
+### Ordering and pagination
+
+The `select*` methods accept `limit`, `offset`, `page`, `orderByID` and
+`orderDirection`:
+
+- `orderByID` orders by the table's ID column, resolved automatically from the
+  table scheme — no column name to spell out.
+- A non-null `offset` turns `orderByID` on by default, since an offset without
+  a stable order can return overlapping or missing rows across pages. Pass
+  `orderByID: false` to opt out.
+- `orderDirection` is `OrderDirection.ascending` by default, and is ignored
+  while the ordering is not active.
+- `page` is the 1-based ergonomic form of `offset`, using `limit` as the page
+  size: `page: 3, limit: 20` is `offset: 40`. It throws an `ArgumentError` if
+  combined with an `offset`, if there is no positive `limit` to page by, or if
+  it is below 1.
+
 The config file used above:
 
 File: `api-local.yaml`
diff --git a/lib/src/bones_api_base.dart b/lib/src/bones_api_base.dart
index 9456c2b..9953b6c 100644
--- a/lib/src/bones_api_base.dart
+++ b/lib/src/bones_api_base.dart
@@ -48,7 +48,7 @@ typedef APILogger =
 /// Bones API Library class.
 class BonesAPI {
   // ignore: constant_identifier_names
-  static const String VERSION = '1.10.0';
+  static const String VERSION = '1.11.0';
 
   static bool _boot = false;
 
diff --git a/lib/src/bones_api_db_module.dart b/lib/src/bones_api_db_module.dart
index b091f85..758b59e 100644
--- a/lib/src/bones_api_db_module.dart
+++ b/lib/src/bones_api_db_module.dart
@@ -15,6 +15,7 @@ import 'bones_api_entity_rules.dart';
 import 'bones_api_extension.dart';
 import 'bones_api_html_document.dart';
 import 'bones_api_module.dart';
+import 'bones_api_types.dart';
 import 'bones_api_utils_json.dart';
 
 final _log = logging.Logger('APIDBModule');
@@ -263,11 +264,68 @@ class APIDBModule extends APIModule {
     return APIResponse.ok(html, mimeType: 'html');
   }
 
+  /// The directives accepted by the query `String` of [select], as
+  /// `&`-joined `KEY=VALUE` tokens. Everything else in the query `String` is
+  /// the entity condition query.
+  ///
+  /// - `EAGER=true`: resolves the referenced entities.
+  /// - `LIMIT=<n>`: the maximum number of returned entities, and the page size
+  ///   of `PAGE`.
+  /// - `OFFSET=<n>`: the return offset, for pagination.
+  /// - `PAGE=<n>`: the 1-based page to return; requires `LIMIT` and can't be
+  ///   combined with `OFFSET`. See [resolveSelectOffset].
+  /// - `ORDER=asc|desc`: the [OrderDirection] of the ordering.
+  ///
+  /// Example: `/db/select/user/json?email == "a@b.c"&LIMIT=10&PAGE=3`
+  static const List<String> selectQueryDirectives = [
+    'EAGER',
+    'LIMIT',
+    'OFFSET',
+    'PAGE',
+    'ORDER',
+  ];
+
+  /// Extracts the `KEY=VALUE` directive [key] from the raw [query] `String`,
+  /// returning the value and the [query] without it.
+  ///
+  /// Follows the pre-existing `EAGER=true` convention: the directive can be
+  /// the whole [query] or one of its `&`-joined tokens.
+  static ({String query, String? value}) _extractQueryDirective(
+    String query,
+    String key,
+  ) {
+    if (query.isEmpty) return (query: query, value: null);
+
+    var prefix = '$key=';
+
+    var parts = query.split('&');
+
+    String? value;
+    var rest = <String>[];
+
+    for (var part in parts) {
+      if (value == null && part.startsWith(prefix)) {
+        value = part.substring(prefix.length);
+      } else {
+        rest.add(part);
+      }
+    }
+
+    if (value == null) return (query: query, value: null);
+
+    return (query: rest.join('&'), value: value);
+  }
+
   Future<APIResponse<dynamic>> select(
     String table,
     APIRequest apiRequest, {
     bool? eager,
     bool json = false,
+    int? limit,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
   }) async {
     if (onlyOnDevelopment && !development) {
       return APIResponse.error(error: "Unsupported request!");
@@ -287,20 +345,62 @@ class APIDBModule extends APIModule {
 
     var query = Uri.decodeQueryComponent(requestedUri.query);
 
-    if (query == 'EAGER=true') {
-      query = '';
-      eager = true;
-    } else if (query.endsWith('&EAGER=true')) {
-      query = query.substring(0, query.length - 11);
-      eager = true;
+    // See [selectQueryDirectives]. The arguments passed to this method take
+    // precedence over the query `String` directives.
+    {
+      var extracted = _extractQueryDirective(query, 'EAGER');
+      query = extracted.query;
+      if (extracted.value == 'true') eager = true;
+    }
+
+    {
+      var extracted = _extractQueryDirective(query, 'LIMIT');
+      query = extracted.query;
+      limit ??= int.tryParse(extracted.value?.trim() ?? '');
+    }
+
+    {
+      var extracted = _extractQueryDirective(query, 'OFFSET');
+      query = extracted.query;
+      offset ??= int.tryParse(extracted.value?.trim() ?? '');
+    }
+
+    {
+      var extracted = _extractQueryDirective(query, 'PAGE');
+      query = extracted.query;
+      page ??= int.tryParse(extracted.value?.trim() ?? '');
+    }
+
+    {
+      var extracted = _extractQueryDirective(query, 'ORDER');
+      query = extracted.query;
+      orderDirection ??= OrderDirection.parse(extracted.value);
+    }
+
+    // Resolved here (and not by the repository) so an invalid `PAGE` becomes an
+    // error response instead of an uncaught `ArgumentError`:
+    try {
+      offset = resolveSelectOffset(page: page, offset: offset, limit: limit);
+    } on ArgumentError catch (e) {
+      return APIResponse.error(error: "Invalid pagination: ${e.message}");
     }
 
     eager ??= false;
 
+    // This endpoint has always returned ID-sorted entities, so the ordering
+    // defaults to `true` here (and not to the `offset != null` rule).
+    // It is now resolved by the DB instead of being sorted in Dart.
+    orderByID ??= true;
+
     _log.info(
       "APIDBModule[REQUEST]> select> "
       "table: `$table` ; "
-      "eager: $eager"
+      "eager: $eager ; "
+      "orderByID: $orderByID ; "
+      "orderDirection: ${OrderDirection.resolve(orderDirection).name}"
+      "${limit != null ? ' ; limit: $limit' : ''}"
+      "${offset != null ? ' ; offset: $offset' : ''}"
+      "${page != null ? ' ; page: $page' : ''}"
       "${query.isNotEmpty ? ' ; QUERY> $query' : ''}",
     );
 
@@ -311,35 +411,24 @@ class APIDBModule extends APIModule {
     if (query.isEmpty) {
       var selectAll = await entityRepository.selectAll(
         resolutionRules: resolutionRules,
+        limit: limit,
+        offset: offset,
+        orderByID: orderByID,
+        orderDirection: orderDirection,
       );
       list = selectAll.toList();
     } else {
       var selectByQuery = await entityRepository.selectByQuery(
         query,
         resolutionRules: resolutionRules,
+        limit: limit,
+        offset: offset,
+        orderByID: orderByID,
+        orderDirection: orderDirection,
       );
       list = selectByQuery.toList();
     }
 
-    list.sort((a, b) {
-      var id1 = entityRepository.getEntityID(a);
-      var id2 = entityRepository.getEntityID(b);
-
-      if (id1 == null && id2 == null) {
-        return 0;
-      } else if (id1 == null) {
-        return 1;
-      } else if (id2 == null) {
-        return -1;
-      } else if (id1 is num && id2 is num) {
-        return id1.compareTo(id2);
-      } else if (id1 is String && id2 is String) {
-        return id1.compareTo(id2);
-      } else {
-        return 0;
-      }
-    });
-
     if (json) {
       var entitiesJson = _entitiesToJsonMap(list);
       return APIResponse.ok(entitiesJson, mimeType: 'json');
diff --git a/lib/src/bones_api_entity.dart b/lib/src/bones_api_entity.dart
index 2799a8d..72a9d6c 100644
--- a/lib/src/bones_api_entity.dart
+++ b/lib/src/bones_api_entity.dart
@@ -3307,6 +3307,117 @@ mixin EntityFieldAccessor<O> {
 
 class EntityFieldAccessorGeneric<O> with EntityFieldAccessor<O> {}
 
+/// Compares 2 entity IDs, implementing the `orderByID` ordering of the
+/// `select*` methods.
+///
+/// - `null` IDs are ordered last (in [OrderDirection.ascending] order).
+/// - [num]s are compared numerically and [String]s lexicographically.
+/// - Any other pair of [Comparable]s of the same type is compared
+///   with [Comparable.compareTo]; otherwise returns `0` (undefined order).
+int compareEntityIDs(Object? id1, Object? id2) {
+  if (identical(id1, id2)) return 0;
+
+  if (id1 == null) return id2 == null ? 0 : 1;
+  if (id2 == null) return -1;
+
+  if (id1 is num && id2 is num) return id1.compareTo(id2);
+  if (id1 is String && id2 is String) return id1.compareTo(id2);
+
+  if (id1 is Comparable && id2 is Comparable) {
+    if (id1.runtimeType == id2.runtimeType) {
+      return id1.compareTo(id2);
+    }
+  }
+
+  return 0;
+}
+
+/// Resolves the effective `offset` of a `select*` operation from a 1-based
+/// [page], where [limit] is the page size.
+///
+/// Returns [offset] unchanged when [page] is `null`, otherwise
+/// `(page - 1) * limit`. A [page] of `1` resolves to an `offset` of `0`, which
+/// still activates the ordering (see [OrderDirection.resolveOrderByID]), so a
+/// paginated select is stable by default.
+///
+/// Throws an [ArgumentError] when:
+/// - [page] and [offset] are both defined: they are two spellings of the same
+///   thing, so passing both is a bug rather than a precedence question;
+/// - [page] is defined without a positive [limit]: a page has no meaning
+///   without a page size, and a `limit` of `0` means "no limit";
+/// - [page] is `< 1`: pages are numbered from `1`.
+int? resolveSelectOffset({int? page, int? offset, int? limit}) {
+  if (page == null) return offset;
+
+  if (offset != null) {
+    throw ArgumentError.value(
+      page,
+      'page',
+      "`page` and `offset` are mutually exclusive (offset: $offset)",
+    );
+  }
+
+  if (limit == null || limit <= 0) {
+    throw ArgumentError.value(
+      page,
+      'page',
+      '`page` requires a positive `limit` (the page size), got: $limit',
+    );
+  }
+
+  if (page < 1) {
+    throw ArgumentError.value(page, 'page', '`page` is 1-based, must be >= 1');
+  }
+
+  return (page - 1) * limit;
+}
+
+/// Applies the ordering and the pagination of a `select*` operation to [itr].
+///
+/// Orders the elements by ID (resolved through [idGetter]) when
+/// [OrderDirection.resolveOrderByID] resolves to `true`, then skips [offset]
+/// elements and takes [limit] of them — in that order, matching SQL semantics
+/// (`ORDER BY` → `OFFSET` → `LIMIT`).
+///
+/// Used by the [DBAdapter]s that can't delegate the ordering and the
+/// pagination to a DB engine, and by [IterableEntityRepository].
+///
+/// [zeroLimitIsUnlimited] selects how a `limit` of `0` is interpreted, since
+/// the pre-existing call sites disagree: the generated SQL treats it as "no
+/// `LIMIT` clause" (`true`), while the in-memory selects treat it as an empty
+/// result (`false`, the default). Only relevant for a [limit] of exactly `0`.
+Iterable<T> applySelectOrderAndPagination<T>(
+  Iterable<T> itr,
+  Object? Function(T o) idGetter, {
+  int? limit,
+  int? offset,
+  bool? orderByID,
+  OrderDirection? orderDirection,
+  bool zeroLimitIsUnlimited = false,
+}) {
+  if (OrderDirection.resolveOrderByID(orderByID, offset)) {
+    var descending = OrderDirection.resolve(orderDirection).isDescending;
+
+    var sorted = itr.toList();
+    sorted.sort(
+      descending
+          ? (a, b) => compareEntityIDs(idGetter(b), idGetter(a))
+          : (a, b) => compareEntityIDs(idGetter(a), idGetter(b)),
+    );
+    itr = sorted;
+  }
+
+  if (offset != null && offset > 0) {
+    itr = itr.skip(offset);
+  }
+
+  if (limit != null && (zeroLimitIsUnlimited ? limit > 0 : limit >= 0)) {
+    itr = itr.take(limit);
+  }
+
+  return itr;
+}
+
 abstract class EntityAccessor<O extends Object> {
   static String simplifiedName(String name) {
     name = name.trim().toLowerCase().replaceAll(RegExp(r'[\W_]+'), '').trim();
@@ -3381,20 +3492,51 @@ abstract class EntitySource<O extends Object> extends EntityAccessor<O> {
 
   final ConditionParseCache<O> _parseCache = ConditionParseCache.get<O>();
 
+  /// {@template bones_api.select_pagination}
+  /// Ordering and pagination:
+  /// - [limit]: the maximum number of returned entities. Also the page size
+  ///   of [page].
+  /// - [offset]: the return offset, for pagination.
+  /// - [page]: the 1-based page to return, an ergonomic alternative to
+  ///   [offset]: it resolves to `(page - 1) * limit`. Requires a positive
+  ///   [limit], and can't be combined with [offset].
+  ///   See [resolveSelectOffset].
+  /// - [orderByID]: if `true` the result is ordered by the table ID column,
+  ///   automatically resolved from the table scheme
+  ///   ([TableScheme.idFieldName]) or from [EntityHandler.idFieldName].
+  ///   Defaults to `true` when [offset] is defined, since a paginated select
+  ///   needs a stable order to be correct. Pass `false` to opt out.
+  /// - [orderDirection]: the [OrderDirection] of the ordering,
+  ///   [OrderDirection.ascending] by default.
+  ///   **Ignored while the ordering is not active** (see [orderByID]).
+  ///
+  /// Note that a query over a to-many relationship generates a `JOIN` without
+  /// a `DISTINCT`, so it can return the same entity more than once. Paginating
+  /// such a query is best-effort.
+  /// {@endtemplate}
   FutureOr<O?> selectFirstByQuery(
     String query, {
     Object? parameters,
     List? positionalParameters,
     Map<String, Object?>? namedParameters,
     Transaction? transaction,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
   }) => selectByQuery(
     query,
     parameters: parameters,
     namedParameters: namedParameters,
     transaction: transaction,
     limit: 1,
+    // The page size of a "first" select is 1, so `page: n` is the Nth entity:
+    offset: resolveSelectOffset(page: page, offset: offset, limit: 1),
+    orderByID: orderByID,
+    orderDirection: orderDirection,
   ).resolveMapped((result) => result.firstOrNull);
 
+  /// {@macro bones_api.select_pagination}
   FutureOr<Iterable<O>> selectByQuery(
     String query, {
     Object? parameters,
@@ -3402,6 +3544,10 @@ abstract class EntitySource<O extends Object> extends EntityAccessor<O> {
     Map<String, Object?>? namedParameters,
     Transaction? transaction,
     int? limit,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
   }) {
     var condition = _parseCache.parseQuery(query);
 
@@ -3412,9 +3558,13 @@ abstract class EntitySource<O extends Object> extends EntityAccessor<O> {
       namedParameters: namedParameters,
       transaction: transaction,
       limit: limit,
+      offset: resolveSelectOffset(page: page, offset: offset, limit: limit),
+      orderByID: orderByID,
+      orderDirection: orderDirection,
     );
   }
 
+  /// {@macro bones_api.select_pagination}
   FutureOr<Iterable<O>> select(
     EntityMatcher<O> matcher, {
     Object? parameters,
@@ -3422,9 +3572,14 @@ abstract class EntitySource<O extends Object> extends EntityAccessor<O> {
     Map<String, Object?>? namedParameters,
     Transaction? transaction,
     int? limit,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     EntityResolutionRules? resolutionRules,
   });
 
+  /// {@macro bones_api.select_pagination}
   FutureOr<Iterable<I>> selectIDsByQuery<I extends Object>(
     String query, {
     Object? parameters,
@@ -3432,6 +3587,10 @@ abstract class EntitySource<O extends Object> extends EntityAccessor<O> {
     Map<String, Object?>? namedParameters,
     Transaction? transaction,
     int? limit,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
   }) {
     var condition = _parseCache.parseQuery(query);
 
@@ -3442,9 +3601,13 @@ abstract class EntitySource<O extends Object> extends EntityAccessor<O> {
       namedParameters: namedParameters,
       transaction: transaction,
       limit: limit,
+      offset: resolveSelectOffset(page: page, offset: offset, limit: limit),
+      orderByID: orderByID,
+      orderDirection: orderDirection,
     );
   }
 
+  /// {@macro bones_api.select_pagination}
   FutureOr<Iterable<I>> selectIDsBy<I extends Object>(
     EntityMatcher<O> matcher, {
     Object? parameters,
@@ -3452,11 +3615,20 @@ abstract class EntitySource<O extends Object> extends EntityAccessor<O> {
     Map<String, Object?>? namedParameters,
     Transaction? transaction,
     int? limit,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
   });
 
+  /// {@macro bones_api.select_pagination}
   FutureOr<Iterable<O>> selectAll({
     Transaction? transaction,
     int? limit,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     EntityResolutionRules? resolutionRules,
   });
 
@@ -5463,6 +5635,7 @@ abstract class EntityRepository<O extends Object> extends EntityAccessor<O>
     );
   }
 
+  /// {@macro bones_api.select_pagination}
   @override
   FutureOr<O?> selectFirstByQuery(
     String query, {
@@ -5470,6 +5643,10 @@ abstract class EntityRepository<O extends Object> extends EntityAccessor<O>
     List? positionalParameters,
     Map<String, Object?>? namedParameters,
     Transaction? transaction,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     EntityResolutionRules? resolutionRules,
   }) => selectByQuery(
     query,
@@ -5477,9 +5654,14 @@ abstract class EntityRepository<O extends Object> extends EntityAccessor<O>
     namedParameters: namedParameters,
     transaction: transaction,
     limit: 1,
+    // The page size of a "first" select is 1, so `page: n` is the Nth entity:
+    offset: resolveSelectOffset(page: page, offset: offset, limit: 1),
+    orderByID: orderByID,
+    orderDirection: orderDirection,
     resolutionRules: resolutionRules,
   ).resolveMapped((result) => result.firstOrNull);
 
+  /// {@macro bones_api.select_pagination}
   @override
   FutureOr<Iterable<O>> selectByQuery(
     String query, {
@@ -5488,6 +5670,10 @@ abstract class EntityRepository<O extends Object> extends EntityAccessor<O>
     Map<String, Object?>? namedParameters,
     Transaction? transaction,
     int? limit,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     EntityResolutionRules? resolutionRules,
   }) {
     checkNotClosed();
@@ -5501,10 +5687,14 @@ abstract class EntityRepository<O extends Object> extends EntityAccessor<O>
       namedParameters: namedParameters,
       transaction: transaction,
       limit: limit,
+      offset: resolveSelectOffset(page: page, offset: offset, limit: limit),
+      orderByID: orderByID,
+      orderDirection: orderDirection,
       resolutionRules: resolutionRules,
     );
   }
 
+  /// {@macro bones_api.select_pagination}
   @override
   FutureOr<Iterable<I>> selectIDsByQuery<I extends Object>(
     String query, {
@@ -5513,6 +5703,10 @@ abstract class EntityRepository<O extends Object> extends EntityAccessor<O>
     Map<String, Object?>? namedParameters,
     Transaction? transaction,
     int? limit,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
   }) {
     checkNotClosed();
 
@@ -5525,6 +5719,9 @@ abstract class EntityRepository<O extends Object> extends EntityAccessor<O>
       namedParameters: namedParameters,
       transaction: transaction,
       limit: limit,
+      offset: resolveSelectOffset(page: page, offset: offset, limit: limit),
+      orderByID: orderByID,
+      orderDirection: orderDirection,
     );
   }
 
@@ -7427,6 +7624,10 @@ abstract class IterableEntityRepository<O extends Object>
     Map<String, Object?>? namedParameters,
     Transaction? transaction,
     int? limit,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     EntityResolutionRules? resolutionRules,
   }) {
     checkNotClosed();
@@ -7437,6 +7638,9 @@ abstract class IterableEntityRepository<O extends Object>
       positionalParameters: positionalParameters,
       namedParameters: namedParameters,
       limit: limit,
+      offset: resolveSelectOffset(page: page, offset: offset, limit: limit),
+      orderByID: orderByID,
+      orderDirection: orderDirection,
     );
 
     return trackEntities(os);
@@ -7450,6 +7654,10 @@ abstract class IterableEntityRepository<O extends Object>
     Map<String, Object?>? namedParameters,
     Transaction? transaction,
     int? limit,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
   }) {
     checkNotClosed();
 
@@ -7459,6 +7667,9 @@ abstract class IterableEntityRepository<O extends Object>
       positionalParameters: positionalParameters,
       namedParameters: namedParameters,
       limit: limit,
+      offset: resolveSelectOffset(page: page, offset: offset, limit: limit),
+      orderByID: orderByID,
+      orderDirection: orderDirection,
     );
 
     var ids = entityHandler.getIDs<I>(os);
@@ -7470,11 +7681,20 @@ abstract class IterableEntityRepository<O extends Object>
   FutureOr<Iterable<O>> selectAll({
     Transaction? transaction,
     int? limit,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     EntityResolutionRules? resolutionRules,
   }) {
     checkNotClosed();
 
-    var os = all(limit: limit);
+    var os = all(
+      limit: limit,
+      offset: resolveSelectOffset(page: page, offset: offset, limit: limit),
+      orderByID: orderByID,
+      orderDirection: orderDirection,
+    );
 
     return trackEntities(os);
   }
@@ -7871,12 +8091,16 @@ abstract class IterableEntityRepository<O extends Object>
     return del;
   }
 
+  /// {@macro bones_api.select_pagination}
   List<O> matches(
     EntityMatcher<dynamic> matcher, {
     Object? parameters,
     List? positionalParameters,
     Map<String, Object?>? namedParameters,
     int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
   }) {
     var itr = iterable().where((o) {
       return matcher.matchesEntity(
@@ -7888,22 +8112,47 @@ abstract class IterableEntityRepository<O extends Object>
       );
     });
 
-    if (limit != null && limit > 0) {
-      itr = itr.take(limit);
-    }
-
-    return itr.toList();
+    return _applyOrderAndPagination(
+      itr,
+      limit: limit,
+      offset: offset,
+      orderByID: orderByID,
+      orderDirection: orderDirection,
+    );
   }
 
-  List<O> all({int? limit}) {
-    var itr = iterable();
-
-    if (limit != null && limit > 0) {
-      itr = itr.take(limit);
-    }
+  /// {@macro bones_api.select_pagination}
+  List<O> all({
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
+  }) => _applyOrderAndPagination(
+    iterable(),
+    limit: limit,
+    offset: offset,
+    orderByID: orderByID,
+    orderDirection: orderDirection,
+  );
 
-    return itr.toList();
-  }
+  List<O> _applyOrderAndPagination(
+    Iterable<O> itr, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
+  }) =>
+      applySelectOrderAndPagination(
+        itr,
+        (o) => getID(o, entityHandler: entityHandler),
+        limit: limit,
+        offset: offset,
+        orderByID: orderByID,
+        orderDirection: orderDirection,
+        // Preserves the pre-existing behavior of this repository,
+        // where a `limit` of 0 means "no limit":
+        zeroLimitIsUnlimited: true,
+      ).toList();
 
   @override
   Map<String, dynamic> information({bool extended = false}) {
diff --git a/lib/src/bones_api_entity_db.dart b/lib/src/bones_api_entity_db.dart
index 3a06214..0b7beaa 100644
--- a/lib/src/bones_api_entity_db.dart
+++ b/lib/src/bones_api_entity_db.dart
@@ -603,18 +603,28 @@ abstract class DBAdapter<C extends Object> extends SchemeProvider
     PreFinishDBOperation<Map<String, dynamic>?, R?>? preFinish,
   });
 
+  /// {@macro bones_api.select_pagination}
   FutureOr<List<R>> doSelectByIDs<R>(
     TransactionOperation op,
     String entityName,
     String table,
     List<Object> ids, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     PreFinishDBOperation<Iterable<Map<String, dynamic>>, List<R>>? preFinish,
   });
 
+  /// {@macro bones_api.select_pagination}
   FutureOr<List<R>> doSelectAll<R>(
     TransactionOperation op,
     String entityName,
     String table, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     PreFinishDBOperation<Iterable<Map<String, dynamic>>, List<R>>? preFinish,
   });
 
@@ -1356,23 +1366,45 @@ class DBRepositoryAdapter<O> with Initializable {
     preFinish: preFinish,
   );
 
+  /// {@macro bones_api.select_pagination}
   FutureOr<List<R>> doSelectByIDs<R>(
     TransactionOperation op,
     List<Object> ids, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     PreFinishDBOperation<Iterable<Map<String, dynamic>>, List<R>>? preFinish,
   }) => databaseAdapter.doSelectByIDs<R>(
     op,
     name,
     tableName,
     ids,
+    limit: limit,
+    offset: offset,
+    orderByID: orderByID,
+    orderDirection: orderDirection,
     preFinish: preFinish,
   );
 
+  /// {@macro bones_api.select_pagination}
   FutureOr<List<R>> doSelectAll<R>(
     TransactionOperation op, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     PreFinishDBOperation<Iterable<Map<String, dynamic>>, List<R>>? preFinish,
-  }) =>
-      databaseAdapter.doSelectAll<R>(op, name, tableName, preFinish: preFinish);
+  }) => databaseAdapter.doSelectAll<R>(
+    op,
+    name,
+    tableName,
+    limit: limit,
+    offset: offset,
+    orderByID: orderByID,
+    orderDirection: orderDirection,
+    preFinish: preFinish,
+  );
 
   FutureOr<dynamic> doInsert(
     TransactionOperation op,
@@ -1639,6 +1671,12 @@ class DBEntityRepository<O extends Object> extends EntityRepository<O>
     }
   }
 
+  /// Resolves a single-row select against a requested [offset]: any positive
+  /// offset skips the only row there is.
+  List<O> _singleResult(O? res, int? offset) =>
+      res != null && (offset == null || offset <= 0) ? <O>[res] : <O>[];
+
+  /// {@macro bones_api.select_pagination}
   @override
   FutureOr<Iterable<O>> select(
     EntityMatcher matcher, {
@@ -1647,15 +1685,22 @@ class DBEntityRepository<O extends Object> extends EntityRepository<O>
     Map<String, Object?>? namedParameters,
     Transaction? transaction,
     int? limit,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     EntityResolutionRules? resolutionRules,
   }) {
+    offset = resolveSelectOffset(page: page, offset: offset, limit: limit);
+
     if (matcher is ConditionID) {
+      // A single row: only a positive `offset` can change the result.
       return _selectByID(
         transaction,
         matcher,
         parameters ?? namedParameters,
         resolutionRules,
-      ).resolveMapped((res) => res != null ? <O>[res] : <O>[]);
+      ).resolveMapped((res) => _singleResult(res, offset));
     }
 
     if (matcher is ConditionIdIN) {
@@ -1664,11 +1709,23 @@ class DBEntityRepository<O extends Object> extends EntityRepository<O>
         matcher,
         parameters ?? namedParameters,
         resolutionRules,
+        limit: limit,
+        offset: offset,
+        orderByID: orderByID,
+        orderDirection: orderDirection,
       );
     }
 
     if (matcher is ConditionANY) {
-      return _selectAll(transaction, matcher, resolutionRules);
+      return _selectAll(
+        transaction,
+        matcher,
+        resolutionRules,
+        limit: limit,
+        offset: offset,
+        orderByID: orderByID,
+        orderDirection: orderDirection,
+      );
     }
 
     if (matcher is KeyConditionEQ) {
@@ -1689,7 +1746,7 @@ class DBEntityRepository<O extends Object> extends EntityRepository<O>
               matcherID,
               parameters ?? namedParameters,
               resolutionRules,
-            ).resolveMapped((res) => res != null ? <O>[res] : <O>[]);
+            ).resolveMapped((res) => _singleResult(res, offset));
           }
         }
       }
@@ -1708,20 +1765,37 @@ class DBEntityRepository<O extends Object> extends EntityRepository<O>
     Map<String, Object?>? namedParameters,
     Transaction? transaction,
     int? limit,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
   }) {
+    offset = resolveSelectOffset(page: page, offset: offset, limit: limit);
+
     if (matcher is ConditionID) {
       var id = matcher.resolveIDValue(
         parameters: parameters ?? namedParameters,
       );
-      return existsID(
-        id,
-        transaction: transaction,
-      ).resolveMapped((exists) => exists ? [id] : []);
+      // A single ID: only a positive `offset` can change the result.
+      return existsID(transaction: transaction, id).resolveMapped(
+        (exists) => exists && (offset == null || offset <= 0) ? [id] : [],
+      );
     }
 
     if (matcher is ConditionIdIN) {
       var ids = matcher.idsValues.whereType<I>().toList();
-      return existIDs(ids, transaction: transaction);
+      // `existIDs` has no ordering/pagination hook, so it is applied here:
+      return existIDs(ids, transaction: transaction).resolveMapped(
+        (existing) =>
+            applySelectOrderAndPagination(
+              existing,
+              (id) => id,
+              limit: limit,
+              offset: offset,
+              orderByID: orderByID,
+              orderDirection: orderDirection,
+            ).toList(),
+      );
     }
 
     throw UnsupportedError(
@@ -1784,8 +1858,12 @@ class DBEntityRepository<O extends Object> extends EntityRepository<O>
     Transaction? transaction,
     ConditionIdIN matcher,
     Object? parameters,
-    EntityResolutionRules? resolutionRules,
-  ) {
+    EntityResolutionRules? resolutionRules, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
+  }) {
     var ids = matcher.idsValues.nonNulls.toList();
     if (ids.isEmpty) return <O>[];
 
@@ -1807,6 +1885,10 @@ class DBEntityRepository<O extends Object> extends EntityRepository<O>
       return repositoryAdapter.doSelectByIDs<O>(
         op,
         ids,
+        limit: limit,
+        offset: offset,
+        orderByID: orderByID,
+        orderDirection: orderDirection,
         preFinish: (results) {
           return resolveEntities(
             op.transaction,
@@ -1829,8 +1911,12 @@ class DBEntityRepository<O extends Object> extends EntityRepository<O>
   FutureOr<List<O>> _selectAll(
     Transaction? transaction,
     ConditionANY matcher,
-    EntityResolutionRules? resolutionRules,
-  ) {
+    EntityResolutionRules? resolutionRules, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
+  }) {
     final resolutionRulesResolved = resolveEntityResolutionRules(
       resolutionRules,
     );
@@ -1848,6 +1934,10 @@ class DBEntityRepository<O extends Object> extends EntityRepository<O>
     try {
       return repositoryAdapter.doSelectAll<O>(
         op,
+        limit: limit,
+        offset: offset,
+        orderByID: orderByID,
+        orderDirection: orderDirection,
         preFinish: (results) {
           return resolveEntities(
             op.transaction,
@@ -1870,8 +1960,22 @@ class DBEntityRepository<O extends Object> extends EntityRepository<O>
   FutureOr<Iterable<O>> selectAll({
     Transaction? transaction,
     int? limit,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     EntityResolutionRules? resolutionRules,
-  }) => select(ConditionANY(), limit: limit, resolutionRules: resolutionRules);
+    // NOTE: `transaction` is not forwarded, preserving the pre-existing
+    // behavior of this method.
+  }) => select(
+    ConditionANY(),
+    limit: limit,
+    offset: offset,
+    page: page,
+    orderByID: orderByID,
+    orderDirection: orderDirection,
+    resolutionRules: resolutionRules,
+  );
 
   @override
   bool hasReferencedEntities([EntityResolutionRulesResolved? resolutionRules]) {
diff --git a/lib/src/bones_api_entity_db_memory.dart b/lib/src/bones_api_entity_db_memory.dart
index c807544..b7b462c 100644
--- a/lib/src/bones_api_entity_db_memory.dart
+++ b/lib/src/bones_api_entity_db_memory.dart
@@ -877,10 +877,17 @@ class DBSQLMemoryAdapter extends DBSQLAdapter<DBSQLMemoryAdapterContext>
       });
     }
 
-    final limit = sql.limit;
-
+    // The `ORDER BY` must be applied before the `OFFSET`/`LIMIT`,
+    // which is what makes an offset-based pagination stable:
     var sel =
-        limit != null && limit >= 0 ? itr.take(limit).toList() : itr.toList();
+        applySelectOrderAndPagination(
+          itr,
+          (e) => e[tableScheme?.idFieldName ?? 'id'],
+          limit: sql.limit,
+          offset: sql.offset,
+          orderByID: sql.orderByID,
+          orderDirection: sql.orderDirection,
+        ).toList();
 
     return sel;
   }
diff --git a/lib/src/bones_api_entity_db_mysql.dart b/lib/src/bones_api_entity_db_mysql.dart
index 37f48ad..f08b113 100644
--- a/lib/src/bones_api_entity_db_mysql.dart
+++ b/lib/src/bones_api_entity_db_mysql.dart
@@ -109,6 +109,8 @@ class DBMySQLAdapter extends DBSQLAdapter<DBMySqlConnectionWrapper>
              acceptsTemporaryTableForReturning: true,
              acceptsInsertIgnore: true,
              createIndexIfNotExists: false,
+             // MySQL can't parse an `OFFSET` without a preceding `LIMIT`:
+             offsetRequiresLimit: true,
            ),
            transactions: true,
            transactionAbort: true,
diff --git a/lib/src/bones_api_entity_db_object_directory.dart b/lib/src/bones_api_entity_db_object_directory.dart
index b9bdd87..86283ea 100644
--- a/lib/src/bones_api_entity_db_object_directory.dart
+++ b/lib/src/bones_api_entity_db_object_directory.dart
@@ -17,6 +17,7 @@ import 'bones_api_entity_db_object.dart';
 import 'bones_api_entity_reference.dart';
 import 'bones_api_extension.dart';
 import 'bones_api_logging.dart';
+import 'bones_api_types.dart';
 
 final _log = logging.Logger('DBObjectDirectoryAdapter')..registerAsDbLogger();
 
@@ -485,6 +486,10 @@ class DBObjectDirectoryAdapter
     String entityName,
     String table,
     List<Object> ids, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     PreFinishDBOperation<List<Map<String, dynamic>>, List<R>>? preFinish,
   }) => executeTransactionOperation<List<R>>(
     op,
@@ -492,21 +497,36 @@ class DBObjectDirectoryAdapter
       table,
       ids,
       entityName,
+      limit: limit,
+      offset: offset,
+      orderByID: orderByID,
+      orderDirection: orderDirection,
     ).resolveMapped((res) => _finishOperation(op, res, preFinish)),
   );
 
   FutureOr<List<Map<String, dynamic>>> _doSelectByIDsImpl<R>(
     String table,
     List<Object> ids,
-    String entityName,
-  ) async {
+    String entityName, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
+  }) async {
     var tableDir = _resolveTableDirectory(table);
     if (!tableDir.existsSync()) return [];
 
     var entries =
         await ids.map((id) => _readObject(table, id)).resolveAllNotNull();
 
-    return entries;
+    return _applyOrderAndPagination(
+      table,
+      entries,
+      limit: limit,
+      offset: offset,
+      orderByID: orderByID,
+      orderDirection: orderDirection,
+    );
   }
 
   @override
@@ -514,19 +534,31 @@ class DBObjectDirectoryAdapter
     TransactionOperation op,
     String entityName,
     String table, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     PreFinishDBOperation<Iterable<Map<String, dynamic>>, List<R>>? preFinish,
   }) => executeTransactionOperation<List<R>>(
     op,
     (conn) => _doSelectAllImpl<R>(
       table,
       entityName,
+      limit: limit,
+      offset: offset,
+      orderByID: orderByID,
+      orderDirection: orderDirection,
     ).resolveMapped((res) => _finishOperation(op, res, preFinish)),
   );
 
   FutureOr<List<Map<String, dynamic>>> _doSelectAllImpl<R>(
     String table,
-    String entityName,
-  ) {
+    String entityName, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
+  }) {
     var tableDir = _resolveTableDirectory(table);
     if (!tableDir.existsSync()) return [];
 
@@ -539,7 +571,36 @@ class DBObjectDirectoryAdapter
           return _readObject(table, id);
         }).resolveAllNotNull();
 
-    return entries;
+    return entries.resolveMapped(
+      (entries) => _applyOrderAndPagination(
+        table,
+        entries,
+        limit: limit,
+        offset: offset,
+        orderByID: orderByID,
+        orderDirection: orderDirection,
+      ),
+    );
+  }
+
+  List<Map<String, dynamic>> _applyOrderAndPagination(
+    String table,
+    Iterable<Map<String, dynamic>> entries, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
+  }) {
+    var idField = _getTableIDFieldName(table);
+
+    return applySelectOrderAndPagination(
+      entries,
+      (e) => e[idField],
+      limit: limit,
+      offset: offset,
+      orderByID: orderByID,
+      orderDirection: orderDirection,
+    ).toList();
   }
 
   @override
diff --git a/lib/src/bones_api_entity_db_object_gcs.dart b/lib/src/bones_api_entity_db_object_gcs.dart
index e5f2c91..881f2a9 100644
--- a/lib/src/bones_api_entity_db_object_gcs.dart
+++ b/lib/src/bones_api_entity_db_object_gcs.dart
@@ -26,6 +26,7 @@ import 'bones_api_entity_reference.dart';
 import 'bones_api_extension.dart';
 import 'bones_api_extension_io.dart';
 import 'bones_api_logging.dart';
+import 'bones_api_types.dart';
 
 final _log = logging.Logger('DBObjectGCSAdapter')..registerAsDbLogger();
 
@@ -579,6 +580,10 @@ class DBObjectGCSAdapter extends DBObjectAdapter<DBObjectGCSAdapterContext> {
     String entityName,
     String table,
     List<Object> ids, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     PreFinishDBOperation<List<Map<String, dynamic>>, List<R>>? preFinish,
   }) => executeTransactionOperation<List<R>>(
     op,
@@ -586,18 +591,33 @@ class DBObjectGCSAdapter extends DBObjectAdapter<DBObjectGCSAdapterContext> {
       table,
       ids,
       entityName,
+      limit: limit,
+      offset: offset,
+      orderByID: orderByID,
+      orderDirection: orderDirection,
     ).resolveMapped((res) => _finishOperation(op, res, preFinish)),
   );
 
   FutureOr<List<Map<String, dynamic>>> _doSelectByIDsImpl<R>(
     String table,
     List<Object> ids,
-    String entityName,
-  ) async {
+    String entityName, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
+  }) async {
     var entries =
         await ids.map((id) => _readObject(table, id)).resolveAllNotNull();
 
-    return entries;
+    return _applyOrderAndPagination(
+      table,
+      entries,
+      limit: limit,
+      offset: offset,
+      orderByID: orderByID,
+      orderDirection: orderDirection,
+    );
   }
 
   @override
@@ -605,29 +625,68 @@ class DBObjectGCSAdapter extends DBObjectAdapter<DBObjectGCSAdapterContext> {
     TransactionOperation op,
     String entityName,
     String table, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     PreFinishDBOperation<Iterable<Map<String, dynamic>>, List<R>>? preFinish,
   }) => executeTransactionOperation<List<R>>(
     op,
     (conn) => _doSelectAllImpl<R>(
       table,
       entityName,
+      limit: limit,
+      offset: offset,
+      orderByID: orderByID,
+      orderDirection: orderDirection,
     ).resolveMapped((res) => _finishOperation(op, res, preFinish)),
   );
 
   Future<List<Map<String, dynamic>>> _doSelectAllImpl<R>(
     String table,
-    String entityName,
-  ) async {
+    String entityName, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
+  }) async {
     var files = await _listTableFiles(table);
 
     var entries =
-        files.map((f) {
+        await files.map((f) {
           var fileName = f.split('/').last;
           var id = pack_path.withoutExtension(fileName);
           return _readObject(table, id);
         }).resolveAllNotNull();
 
-    return entries;
+    return _applyOrderAndPagination(
+      table,
+      entries,
+      limit: limit,
+      offset: offset,
+      orderByID: orderByID,
+      orderDirection: orderDirection,
+    );
+  }
+
+  List<Map<String, dynamic>> _applyOrderAndPagination(
+    String table,
+    Iterable<Map<String, dynamic>> entries, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
+  }) {
+    var idField = _getTableIDFieldName(table);
+
+    return applySelectOrderAndPagination(
+      entries,
+      (e) => e[idField],
+      limit: limit,
+      offset: offset,
+      orderByID: orderByID,
+      orderDirection: orderDirection,
+    ).toList();
   }
 
   @override
diff --git a/lib/src/bones_api_entity_db_object_memory.dart b/lib/src/bones_api_entity_db_object_memory.dart
index e9a79d8..0aaf238 100644
--- a/lib/src/bones_api_entity_db_object_memory.dart
+++ b/lib/src/bones_api_entity_db_object_memory.dart
@@ -14,6 +14,7 @@ import 'bones_api_entity_db_object.dart';
 import 'bones_api_entity_reference.dart';
 import 'bones_api_extension.dart';
 import 'bones_api_logging.dart';
+import 'bones_api_types.dart';
 
 final _log = logging.Logger('DBObjectMemoryAdapter')..registerAsDbLogger();
 
@@ -533,6 +534,10 @@ class DBObjectMemoryAdapter
     String entityName,
     String table,
     List<Object> ids, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     PreFinishDBOperation<List<Map<String, dynamic>>, List<R>>? preFinish,
   }) => executeTransactionOperation<List<R>>(
     op,
@@ -540,14 +545,22 @@ class DBObjectMemoryAdapter
       table,
       ids,
       entityName,
+      limit: limit,
+      offset: offset,
+      orderByID: orderByID,
+      orderDirection: orderDirection,
     ).resolveMapped((res) => _finishOperation(op, res, preFinish)),
   );
 
   FutureOr<List<Map<String, dynamic>>> _doSelectByIDsImpl<R>(
     String table,
     List<Object> ids,
-    String entityName,
-  ) {
+    String entityName, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
+  }) {
     var map = _getTableMap(table, false);
     if (map == null) return [];
 
@@ -565,7 +578,14 @@ class DBObjectMemoryAdapter
             .nonNulls
             .toList();
 
-    return entries;
+    return _applyOrderAndPagination(
+      table,
+      entries,
+      limit: limit,
+      offset: offset,
+      orderByID: orderByID,
+      orderDirection: orderDirection,
+    );
   }
 
   @override
@@ -573,24 +593,62 @@ class DBObjectMemoryAdapter
     TransactionOperation op,
     String entityName,
     String table, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     PreFinishDBOperation<Iterable<Map<String, dynamic>>, List<R>>? preFinish,
   }) => executeTransactionOperation<List<R>>(
     op,
     (conn) => _doSelectAllImpl<R>(
       table,
       entityName,
+      limit: limit,
+      offset: offset,
+      orderByID: orderByID,
+      orderDirection: orderDirection,
     ).resolveMapped((res) => _finishOperation(op, res, preFinish)),
   );
 
   FutureOr<List<Map<String, dynamic>>> _doSelectAllImpl<R>(
     String table,
-    String entityName,
-  ) {
+    String entityName, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
+  }) {
     var map = _getTableMap(table, false);
     if (map == null) return [];
 
-    var entries = map.values.toList();
-    return entries;
+    return _applyOrderAndPagination(
+      table,
+      map.values,
+      limit: limit,
+      offset: offset,
+      orderByID: orderByID,
+      orderDirection: orderDirection,
+    );
+  }
+
+  List<Map<String, dynamic>> _applyOrderAndPagination(
+    String table,
+    Iterable<Map<String, dynamic>> entries, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
+  }) {
+    var idField = _getTableIDFieldName(table);
+
+    return applySelectOrderAndPagination(
+      entries,
+      (e) => e[idField],
+      limit: limit,
+      offset: offset,
+      orderByID: orderByID,
+      orderDirection: orderDirection,
+    ).toList();
   }
 
   @override
diff --git a/lib/src/bones_api_entity_db_relational.dart b/lib/src/bones_api_entity_db_relational.dart
index 790b93e..aa4f634 100644
--- a/lib/src/bones_api_entity_db_relational.dart
+++ b/lib/src/bones_api_entity_db_relational.dart
@@ -13,6 +13,7 @@ import 'bones_api_entity_reference.dart';
 import 'bones_api_entity_rules.dart';
 import 'bones_api_extension.dart';
 import 'bones_api_logging.dart';
+import 'bones_api_types.dart';
 import 'bones_api_utils.dart';
 
 final _log = logging.Logger('DBRelationalAdapter')..registerAsDbLogger();
@@ -135,6 +136,9 @@ abstract class DBRelationalAdapter<C extends Object> extends DBAdapter<C> {
     List? positionalParameters,
     Map<String, Object?>? namedParameters,
     int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     PreFinishDBOperation<Iterable<Map<String, dynamic>>, R>? preFinish,
   });
 
@@ -147,6 +151,9 @@ abstract class DBRelationalAdapter<C extends Object> extends DBAdapter<C> {
     List? positionalParameters,
     Map<String, Object?>? namedParameters,
     int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
   });
 
   FutureOr<bool> doInsertRelationship(
@@ -201,6 +208,9 @@ class DBRelationalRepositoryAdapter<O> extends DBRepositoryAdapter<O> {
     List? positionalParameters,
     Map<String, Object?>? namedParameters,
     int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     PreFinishDBOperation<Iterable<Map<String, dynamic>>, R>? preFinish,
   }) => databaseAdapter.doSelect<R>(
     op,
@@ -211,6 +221,9 @@ class DBRelationalRepositoryAdapter<O> extends DBRepositoryAdapter<O> {
     positionalParameters: positionalParameters,
     namedParameters: namedParameters,
     limit: limit,
+    offset: offset,
+    orderByID: orderByID,
+    orderDirection: orderDirection,
     preFinish: preFinish,
   );
 
@@ -221,6 +234,9 @@ class DBRelationalRepositoryAdapter<O> extends DBRepositoryAdapter<O> {
     List? positionalParameters,
     Map<String, Object?>? namedParameters,
     int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
   }) => databaseAdapter.doSelectIDsBy<I>(
     op,
     name,
@@ -230,6 +246,9 @@ class DBRelationalRepositoryAdapter<O> extends DBRepositoryAdapter<O> {
     positionalParameters: positionalParameters,
     namedParameters: namedParameters,
     limit: limit,
+    offset: offset,
+    orderByID: orderByID,
+    orderDirection: orderDirection,
   );
 
   FutureOr<bool> doInsertRelationship(
@@ -482,9 +501,15 @@ class DBRelationalEntityRepository<O extends Object>
     Map<String, Object?>? namedParameters,
     Transaction? transaction,
     int? limit,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
   }) {
     checkNotClosed();
 
+    offset = resolveSelectOffset(page: page, offset: offset, limit: limit);
+
     var op = TransactionOperationSelect(
       name,
       false,
@@ -501,6 +526,9 @@ class DBRelationalEntityRepository<O extends Object>
         positionalParameters: positionalParameters,
         namedParameters: namedParameters,
         limit: limit,
+        offset: offset,
+        orderByID: orderByID,
+        orderDirection: orderDirection,
       );
     } catch (e, s) {
       var message =
@@ -523,10 +551,16 @@ class DBRelationalEntityRepository<O extends Object>
     Map<String, Object?>? namedParameters,
     Transaction? transaction,
     int? limit,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     EntityResolutionRules? resolutionRules,
   }) {
     checkNotClosed();
 
+    offset = resolveSelectOffset(page: page, offset: offset, limit: limit);
+
     final resolutionRulesResolved = resolveEntityResolutionRules(
       resolutionRules,
     );
@@ -549,6 +583,9 @@ class DBRelationalEntityRepository<O extends Object>
         positionalParameters: positionalParameters,
         namedParameters: namedParameters,
         limit: limit,
+        offset: offset,
+        orderByID: orderByID,
+        orderDirection: orderDirection,
         preFinish: (results) {
           return resolveEntities(
             op.transaction,
@@ -574,8 +611,22 @@ class DBRelationalEntityRepository<O extends Object>
   FutureOr<Iterable<O>> selectAll({
     Transaction? transaction,
     int? limit,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     EntityResolutionRules? resolutionRules,
-  }) => select(ConditionANY(), limit: limit, resolutionRules: resolutionRules);
+    // NOTE: `transaction` is not forwarded, preserving the pre-existing
+    // behavior of this method.
+  }) => select(
+    ConditionANY(),
+    limit: limit,
+    offset: offset,
+    page: page,
+    orderByID: orderByID,
+    orderDirection: orderDirection,
+    resolutionRules: resolutionRules,
+  );
 
   @override
   bool isStored(O o, {Transaction? transaction}) {
diff --git a/lib/src/bones_api_entity_db_sql.dart b/lib/src/bones_api_entity_db_sql.dart
index 55ce120..8aadaba 100644
--- a/lib/src/bones_api_entity_db_sql.dart
+++ b/lib/src/bones_api_entity_db_sql.dart
@@ -167,6 +167,17 @@ class SQL implements SQLWrapper {
 
   final int? limit;
 
+  /// The return offset of this select (`OFFSET`), or `null` for no offset.
+  final int? offset;
+
+  /// If this select is ordered by the table ID column. `null` means unset,
+  /// resolved by [OrderDirection.resolveOrderByID] as `offset != null`.
+  final bool? orderByID;
+
+  /// The [OrderDirection] of the ordering.
+  /// Only applies while the ordering is active. See [orderByID].
+  final OrderDirection? orderDirection;
+
   final Map<String, String>? returnColumnsAliases;
 
   final String? mainTable;
@@ -216,6 +227,9 @@ class SQL implements SQLWrapper {
     this.returnColumns,
     this.returnColumnsAliases,
     this.limit,
+    this.offset,
+    this.orderByID,
+    this.orderDirection,
     required this.mainTable,
     this.relationship,
     this.tablesAliases,
@@ -240,6 +254,9 @@ class SQL implements SQLWrapper {
     returnColumns: returnColumns?.toSet(),
     returnColumnsAliases: returnColumnsAliases?.map((k, v) => MapEntry(k, v)),
     limit: limit,
+    offset: offset,
+    orderByID: orderByID,
+    orderDirection: orderDirection,
     mainTable: mainTable,
     relationship: relationship,
     tablesAliases: tablesAliases?.map((k, v) => MapEntry(k, v)),
@@ -2585,6 +2602,36 @@ abstract class DBSQLAdapter<C extends Object> extends DBRelationalAdapter<C>
     });
   }
 
+  /// Builds the ` ORDER BY ... LIMIT ... OFFSET ...` tail of a `SELECT`,
+  /// shared by [generateSelectSQL] and [generateSelectIDsSQL].
+  ///
+  /// The `ORDER BY` column is the ID column of the main table, already
+  /// resolved by [_generateSQLFrom] (through [TableScheme.idFieldName]) and
+  /// exposed as [EncodingContext.tableFieldID].
+  String _generateSelectTailSQL(
+    EncodingContext context,
+    String tableAlias, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
+  }) {
+    var tail = '';
+
+    if (OrderDirection.resolveOrderByID(orderByID, offset)) {
+      var tableFieldID = context.tableFieldID ?? 'id';
+      tail += dialect.orderBySQL(
+        tableAlias,
+        tableFieldID,
+        direction: orderDirection,
+      );
+    }
+
+    tail += dialect.limitOffsetSQL(limit: limit, offset: offset);
+
+    return tail;
+  }
+
   FutureOr<SQL> generateSelectSQL(
     Transaction transaction,
     String entityName,
@@ -2594,6 +2641,9 @@ abstract class DBSQLAdapter<C extends Object> extends DBRelationalAdapter<C>
     List? positionalParameters,
     Map<String, Object?>? namedParameters,
     int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
   }) {
     return _generateSQLFrom(
       transaction,
@@ -2604,11 +2654,21 @@ abstract class DBSQLAdapter<C extends Object> extends DBRelationalAdapter<C>
       positionalParameters: positionalParameters,
       namedParameters: namedParameters,
       limit: limit,
+      offset: offset,
+      orderByID: orderByID,
+      orderDirection: orderDirection,
       sqlBuilder: (String from, EncodingContext context) {
         var tableAlias = context.resolveEntityAlias(table);
         var q = dialect.elementQuote;
-        var limitStr = limit != null && limit > 0 ? ' LIMIT $limit' : '';
-        var sql = 'SELECT $q$tableAlias$q.* $from$limitStr';
+        var tail = _generateSelectTailSQL(
+          context,
+          tableAlias,
+          limit: limit,
+          offset: offset,
+          orderByID: orderByID,
+          orderDirection: orderDirection,
+        );
+        var sql = 'SELECT $q$tableAlias$q.* $from$tail';
         return sql;
       },
     );
@@ -2623,6 +2683,9 @@ abstract class DBSQLAdapter<C extends Object> extends DBRelationalAdapter<C>
     List? positionalParameters,
     Map<String, Object?>? namedParameters,
     int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
   }) {
     return _generateSQLFrom(
       transaction,
@@ -2633,13 +2696,23 @@ abstract class DBSQLAdapter<C extends Object> extends DBRelationalAdapter<C>
       positionalParameters: positionalParameters,
       namedParameters: namedParameters,
       limit: limit,
+      offset: offset,
+      orderByID: orderByID,
+      orderDirection: orderDirection,
       sqlBuilder: (String from, EncodingContext context) {
         var tableAlias = context.resolveEntityAlias(table);
         var tableFieldID = context.tableFieldID ?? 'id';
         var q = dialect.elementQuote;
-        var limitStr = limit != null && limit > 0 ? ' LIMIT $limit' : '';
+        var tail = _generateSelectTailSQL(
+          context,
+          tableAlias,
+          limit: limit,
+          offset: offset,
+          orderByID: orderByID,
+          orderDirection: orderDirection,
+        );
         var sql =
-            'SELECT $q$tableAlias$q.$q$tableFieldID$q as ${q}id$q $from$limitStr';
+            'SELECT $q$tableAlias$q.$q$tableFieldID$q as ${q}id$q $from$tail';
         return sql;
       },
     );
@@ -2654,6 +2727,9 @@ abstract class DBSQLAdapter<C extends Object> extends DBRelationalAdapter<C>
     List? positionalParameters,
     Map<String, Object?>? namedParameters,
     int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     required String Function(String from, EncodingContext context) sqlBuilder,
   }) {
     if (matcher is! Condition) {
@@ -2707,6 +2783,9 @@ abstract class DBSQLAdapter<C extends Object> extends DBRelationalAdapter<C>
           mainTable: table,
           tablesAliases: encodedSQL.tableAliases,
           limit: limit,
+          offset: offset,
+          orderByID: orderByID,
+          orderDirection: orderDirection,
         );
       } else {
         var joins = <_JoinEntry>[];
@@ -2905,6 +2984,9 @@ abstract class DBSQLAdapter<C extends Object> extends DBRelationalAdapter<C>
           mainTable: table,
           tablesAliases: encodedSQL.tableAliases,
           limit: limit,
+          offset: offset,
+          orderByID: orderByID,
+          orderDirection: orderDirection,
         );
       }
     });
@@ -3232,6 +3314,10 @@ abstract class DBSQLAdapter<C extends Object> extends DBRelationalAdapter<C>
     String entityName,
     String table,
     List<Object> ids, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     PreFinishDBOperation<Iterable<Map<String, dynamic>>, List<R>>? preFinish,
   }) {
     return generateSelectSQL(
@@ -3239,6 +3325,10 @@ abstract class DBSQLAdapter<C extends Object> extends DBRelationalAdapter<C>
       entityName,
       table,
       ConditionIdIN(ids),
+      limit: limit,
+      offset: offset,
+      orderByID: orderByID,
+      orderDirection: orderDirection,
     ).resolveMapped((sql) {
       return selectSQL(
         op,
@@ -3254,6 +3344,10 @@ abstract class DBSQLAdapter<C extends Object> extends DBRelationalAdapter<C>
     TransactionOperation op,
     String entityName,
     String table, {
+    int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     PreFinishDBOperation<Iterable<Map<String, dynamic>>, List<R>>? preFinish,
   }) {
     return generateSelectSQL(
@@ -3261,6 +3355,10 @@ abstract class DBSQLAdapter<C extends Object> extends DBRelationalAdapter<C>
       entityName,
       table,
       ConditionANY(),
+      limit: limit,
+      offset: offset,
+      orderByID: orderByID,
+      orderDirection: orderDirection,
     ).resolveMapped((sql) {
       return selectSQL(
         op,
@@ -3281,6 +3379,9 @@ abstract class DBSQLAdapter<C extends Object> extends DBRelationalAdapter<C>
     List? positionalParameters,
     Map<String, Object?>? namedParameters,
     int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     PreFinishDBOperation<Iterable<Map<String, dynamic>>, R>? preFinish,
   }) {
     return generateSelectSQL(
@@ -3292,6 +3393,9 @@ abstract class DBSQLAdapter<C extends Object> extends DBRelationalAdapter<C>
       positionalParameters: positionalParameters,
       namedParameters: namedParameters,
       limit: limit,
+      offset: offset,
+      orderByID: orderByID,
+      orderDirection: orderDirection,
     ).resolveMapped((sql) {
       return selectSQL(
         op,
@@ -3312,6 +3416,9 @@ abstract class DBSQLAdapter<C extends Object> extends DBRelationalAdapter<C>
     List? positionalParameters,
     Map<String, Object?>? namedParameters,
     int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
   }) {
     return generateSelectIDsSQL(
       op.transaction,
@@ -3322,6 +3429,9 @@ abstract class DBSQLAdapter<C extends Object> extends DBRelationalAdapter<C>
       positionalParameters: positionalParameters,
       namedParameters: namedParameters,
       limit: limit,
+      offset: offset,
+      orderByID: orderByID,
+      orderDirection: orderDirection,
     ).resolveMapped((sql) {
       return selectSQL(op, entityName, table, sql).resolveMapped(
         (r) => _finishSQLOperation(sql, op, r, (results) {
@@ -3768,6 +3878,9 @@ class DBSQLRepositoryAdapter<O> extends DBRelationalRepositoryAdapter<O> {
     List? positionalParameters,
     Map<String, Object?>? namedParameters,
     int? limit,
+    int? offset,
+    bool? orderByID,
+    OrderDirection? orderDirection,
   }) => databaseAdapter.generateSelectSQL(
     transaction,
     name,
@@ -3777,6 +3890,9 @@ class DBSQLRepositoryAdapter<O> extends DBRelationalRepositoryAdapter<O> {
     positionalParameters: positionalParameters,
     namedParameters: namedParameters,
     limit: limit,
+    offset: offset,
+    orderByID: orderByID,
+    orderDirection: orderDirection,
   );
 
   FutureOr<Iterable<Map<String, dynamic>>> selectSQL(
diff --git a/lib/src/bones_api_repository.dart b/lib/src/bones_api_repository.dart
index a9ec800..4e45ef6 100644
--- a/lib/src/bones_api_repository.dart
+++ b/lib/src/bones_api_repository.dart
@@ -5,6 +5,7 @@ import 'bones_api_condition.dart';
 import 'bones_api_entity.dart';
 import 'bones_api_entity_rules.dart';
 import 'bones_api_initializable.dart';
+import 'bones_api_types.dart';
 
 /// A entity repository API.
 abstract class APIRepository<O extends Object> with Initializable {
@@ -123,23 +124,37 @@ abstract class APIRepository<O extends Object> with Initializable {
     resolutionRules: resolutionRules,
   );
 
+  /// {@macro bones_api.select_pagination}
   FutureOr<Iterable<O>> selectAll({
     int? limit,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     Transaction? transaction,
     EntityResolutionRules? resolutionRules,
   }) => entityRepository.selectAll(
     limit: limit,
+    offset: offset,
+    page: page,
+    orderByID: orderByID,
+    orderDirection: orderDirection,
     transaction: transaction,
     resolutionRules: resolutionRules,
   );
 
   FutureOr<int> length() => entityRepository.length();
 
+  /// {@macro bones_api.select_pagination}
   FutureOr<O?> selectFirstByQuery(
     String query, {
     Object? parameters,
     List? positionalParameters,
     Map<String, Object?>? namedParameters,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     Transaction? transaction,
     EntityResolutionRules? resolutionRules,
   }) => entityRepository.selectFirstByQuery(
@@ -147,16 +162,25 @@ abstract class APIRepository<O extends Object> with Initializable {
     parameters: parameters,
     positionalParameters: positionalParameters,
     namedParameters: namedParameters,
+    offset: offset,
+    page: page,
+    orderByID: orderByID,
+    orderDirection: orderDirection,
     transaction: transaction,
     resolutionRules: resolutionRules,
   );
 
+  /// {@macro bones_api.select_pagination}
   FutureOr<Iterable<O>> selectByQuery(
     String query, {
     Object? parameters,
     List? positionalParameters,
     Map<String, Object?>? namedParameters,
     int? limit,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     Transaction? transaction,
     EntityResolutionRules? resolutionRules,
   }) => entityRepository.selectByQuery(
@@ -165,16 +189,25 @@ abstract class APIRepository<O extends Object> with Initializable {
     positionalParameters: positionalParameters,
     namedParameters: namedParameters,
     limit: limit,
+    offset: offset,
+    page: page,
+    orderByID: orderByID,
+    orderDirection: orderDirection,
     transaction: transaction,
     resolutionRules: resolutionRules,
   );
 
+  /// {@macro bones_api.select_pagination}
   FutureOr<Iterable<I>> selectIDsByQuery<I extends Object>(
     String query, {
     Object? parameters,
     List? positionalParameters,
     Map<String, Object?>? namedParameters,
     int? limit,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     Transaction? transaction,
   }) => entityRepository.selectIDsByQuery<I>(
     query,
@@ -182,15 +215,24 @@ abstract class APIRepository<O extends Object> with Initializable {
     positionalParameters: positionalParameters,
     namedParameters: namedParameters,
     limit: limit,
+    offset: offset,
+    page: page,
+    orderByID: orderByID,
+    orderDirection: orderDirection,
     transaction: transaction,
   );
 
+  /// {@macro bones_api.select_pagination}
   FutureOr<Iterable<I>> selectIDsBy<I extends Object>(
     EntityMatcher<O> matcher, {
     Object? parameters,
     List? positionalParameters,
     Map<String, Object?>? namedParameters,
     int? limit,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     Transaction? transaction,
   }) => entityRepository.selectIDsBy(
     matcher,
@@ -198,15 +240,24 @@ abstract class APIRepository<O extends Object> with Initializable {
     positionalParameters: positionalParameters,
     namedParameters: namedParameters,
     limit: limit,
+    offset: offset,
+    page: page,
+    orderByID: orderByID,
+    orderDirection: orderDirection,
     transaction: transaction,
   );
 
+  /// {@macro bones_api.select_pagination}
   FutureOr<Iterable<O>> select(
     EntityMatcher<O> matcher, {
     Object? parameters,
     List? positionalParameters,
     Map<String, Object?>? namedParameters,
     int? limit,
+    int? offset,
+    int? page,
+    bool? orderByID,
+    OrderDirection? orderDirection,
     Transaction? transaction,
     EntityResolutionRules? resolutionRules,
   }) => entityRepository.select(
@@ -215,6 +266,10 @@ abstract class APIRepository<O extends Object> with Initializable {
     positionalParameters: positionalParameters,
     namedParameters: namedParameters,
     limit: limit,
+    offset: offset,
+    page: page,
+    orderByID: orderByID,
+    orderDirection: orderDirection,
     transaction: transaction,
     resolutionRules: resolutionRules,
   );
diff --git a/lib/src/bones_api_sql_builder.dart b/lib/src/bones_api_sql_builder.dart
index 137a620..0b40bc9 100644
--- a/lib/src/bones_api_sql_builder.dart
+++ b/lib/src/bones_api_sql_builder.dart
@@ -111,6 +111,18 @@ class SQLDialect extends DBDialect {
   /// Whether the SQL dialect supports `IF NOT EXISTS` on `CREATE INDEX`.
   final bool createIndexIfNotExists;
 
+  /// If `true` this dialect can't parse an `OFFSET` clause that is not preceded
+  /// by a `LIMIT` clause (MySQL). See [offsetMaxLimitValue].
+  final bool offsetRequiresLimit;
+
+  /// The maximum row count accepted by a `LIMIT` clause of this dialect,
+  /// used as the `LIMIT` value when only an `offset` was requested and
+  /// [offsetRequiresLimit] is `true`.
+  ///
+  /// Declared as a [String] and not an [int] because MySQL's documented value
+  /// (`18446744073709551615`, 2^64-1) is out of range of a Dart [int].
+  final String offsetMaxLimitValue;
+
   const SQLDialect(
     super.name, {
     this.elementQuote = '',
@@ -123,8 +135,48 @@ class SQLDialect extends DBDialect {
     this.acceptsVarcharWithoutMaximumSize = false,
     this.foreignKeyCreatesImplicitIndex = true,
     this.createIndexIfNotExists = true,
+    this.offsetRequiresLimit = false,
+    this.offsetMaxLimitValue = '18446744073709551615',
   });
 
+  /// Builds the ` ORDER BY <tableAlias>.<column> ASC|DESC` clause
+  /// of this dialect.
+  String orderBySQL(
+    String tableAlias,
+    String column, {
+    OrderDirection? direction,
+  }) {
+    var q = elementQuote;
+    var keyword = OrderDirection.resolve(direction).sqlKeyword;
+    return ' ORDER BY $q$tableAlias$q.$q$column$q $keyword';
+  }
+
+  /// Builds the ` LIMIT <limit> OFFSET <offset>` clause of this dialect.
+  /// Returns an empty `String` when neither [limit] nor [offset] applies.
+  ///
+  /// Only positive values are emitted (`limit > 0` and `offset > 0`),
+  /// preserving the pre-existing `LIMIT` behavior.
+  ///
+  /// When only an [offset] applies and [offsetRequiresLimit] is `true`, emits
+  /// `LIMIT <offsetMaxLimitValue> OFFSET <offset>`, since such a dialect can't
+  /// parse a standalone `OFFSET`.
+  String limitOffsetSQL({int? limit, int? offset}) {
+    var hasLimit = limit != null && limit > 0;
+    var hasOffset = offset != null && offset > 0;
+
+    if (!hasOffset) {
+      return hasLimit ? ' LIMIT $limit' : '';
+    }
+
+    if (hasLimit) {
+      return ' LIMIT $limit OFFSET $offset';
+    }
+
+    return offsetRequiresLimit
+        ? ' LIMIT $offsetMaxLimitValue OFFSET $offset'
+        : ' OFFSET $offset';
+  }
+
   @override
   bool operator ==(Object other) =>
       identical(this, other) ||
@@ -147,7 +199,9 @@ class SQLDialect extends DBDialect {
         'acceptsInsertIgnore: $acceptsInsertIgnore, '
         'acceptsInsertOnConflict: $acceptsInsertOnConflict, '
         'foreignKeyCreatesImplicitIndex: $foreignKeyCreatesImplicitIndex, '
-        'createIndexIfNotExists: $createIndexIfNotExists'
+        'createIndexIfNotExists: $createIndexIfNotExists, '
+        'offsetRequiresLimit: $offsetRequiresLimit, '
+        'offsetMaxLimitValue: $offsetMaxLimitValue'
         '}';
   }
 }
diff --git a/lib/src/bones_api_types.dart b/lib/src/bones_api_types.dart
index a8809bf..fac65c0 100644
--- a/lib/src/bones_api_types.dart
+++ b/lib/src/bones_api_types.dart
@@ -6,6 +6,71 @@ import 'package:statistics/statistics.dart';
 
 import 'bones_api_utils.dart';
 
+/// The direction of the "order by" clause of a select operation.
+///
+/// Used by the `orderDirection` parameter of the `select*` methods.
+/// Only has effect while the ordering is active (see the `orderByID`
+/// parameter and [resolveOrderByID]).
+enum OrderDirection {
+  /// Ascending order (SQL `ASC`). The [defaultDirection].
+  ascending,
+
+  /// Descending order (SQL `DESC`).
+  descending;
+
+  /// The direction used when none is defined: [ascending].
+  static const OrderDirection defaultDirection = ascending;
+
+  /// Returns `true` if this is [ascending].
+  bool get isAscending => this == ascending;
+
+  /// Returns `true` if this is [descending].
+  bool get isDescending => this == descending;
+
+  /// The SQL keyword of this direction: `ASC` or `DESC`.
+  String get sqlKeyword => isDescending ? 'DESC' : 'ASC';
+
+  /// Resolves a nullable [direction] to a non-null one,
+  /// defaulting to [defaultDirection].
+  static OrderDirection resolve(OrderDirection? direction) =>
+      direction ?? defaultDirection;
+
+  /// Resolves if a select operation should order by the table ID column.
+  ///
+  /// Returns [orderByID] when defined. Otherwise returns `true` if an [offset]
+  /// is defined, since a paginated select needs a stable order to be correct.
+  static bool resolveOrderByID(bool? orderByID, int? offset) =>
+      orderByID ?? (offset != null);
+
+  /// Parses [o] to an [OrderDirection], or returns `null` if it can't
+  /// be resolved.
+  ///
+  /// Accepts (case-insensitive and trimmed): `asc`, `ascending`, `up`, `+`,
+  /// `desc`, `descending`, `down`, `-`. Also accepts an [OrderDirection].
+  static OrderDirection? parse(Object? o) {
+    if (o == null) return null;
+    if (o is OrderDirection) return o;
+
+    var s = o.toString().trim().toLowerCase();
+    if (s.isEmpty) return null;
+
+    switch (s) {
+      case 'asc':
+      case 'ascending':
+      case 'up':
+      case '+':
+        return ascending;
+      case 'desc':
+      case 'descending':
+      case 'down':
+      case '-':
+        return descending;
+      default:
+        return null;
+    }
+  }
+}
+
 /// A [Time] represents the time of the day,
 /// independently of the day of the year, timezone or [DateTime].
 class Time implements Comparable<Time> {
diff --git a/pubspec.yaml b/pubspec.yaml
index a4ad03a..f5c9c65 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,6 +1,6 @@
 name: bones_api
 description: Bones_API - A powerful API backend framework for Dart. It comes with a built-in HTTP Server, route handler, entity handler, SQL translator, and DB adapters.
-version: 1.10.0
+version: 1.11.0
 homepage: https://github.com/Colossus-Services/bones_api
 
 environment:
@@ -12,7 +12,7 @@ executables:
 dependencies:
   async_extension: ^1.2.22
   async_events: ^1.3.0
-  reflection_factory: ^2.7.5
+  reflection_factory: ^2.8.1
   statistics: ^1.2.1
   swiss_knife: ^3.3.14
   data_serializer: ^1.2.1
diff --git a/test/bones_api_db_module_test.dart b/test/bones_api_db_module_test.dart
new file mode 100644
index 0000000..304aab1
--- /dev/null
+++ b/test/bones_api_db_module_test.dart
@@ -0,0 +1,232 @@
+@TestOn('vm')
+@Tags(['entities'])
+// ignore_for_file: discarded_futures
+import 'package:bones_api/bones_api.dart';
+import 'package:statistics/statistics.dart' show Decimal;
+import 'package:test/test.dart';
+
+import 'bones_api_test_entities.dart';
+
+class _DBModuleTestProvider extends EntityRepositoryProvider {
+  late final DBSQLMemoryAdapter sqlAdapter;
+
+  late final DBSQLEntityRepository<Role> roleRepository;
+
+  _DBModuleTestProvider() {
+    sqlAdapter = DBSQLMemoryAdapter(parentRepositoryProvider: this)
+      ..addTableSchemes([
+        TableScheme(
+          'role',
+          idFieldName: 'id',
+          fieldsTypes: {
+            'id': int,
+            'type': String,
+            'enabled': bool,
+            'value': Decimal,
+          },
+        ),
+      ]);
+
+    roleRepository = DBSQLEntityRepository<Role>(
+      sqlAdapter,
+      'role',
+      roleEntityHandler,
+    )..ensureInitialized();
+  }
+}
+
+class _DBModuleTestAPIRoot extends APIRoot {
+  final _DBModuleTestProvider provider;
+
+  _DBModuleTestAPIRoot(this.provider)
+    : super(
+        'db-module-test',
+        '1.0',
+        apiConfig: APIConfig({'development': true}),
+      );
+
+  @override
+  Set<APIModule> loadModules() => {APIDBModule(this)};
+
+  @override
+  FutureOr<List<EntityRepositoryProvider>> loadEntityRepositoryProviders() => [
+    provider,
+  ];
+}
+
+void main() {
+  group('APIDBModule.select', () {
+    late final _DBModuleTestProvider provider;
+    late final _DBModuleTestAPIRoot apiRoot;
+
+    // The IDs of the 5 stored roles, in ascending order:
+    late final List<int> ids;
+
+    setUpAll(() async {
+      roleEntityHandler.ensureRegistered();
+
+      provider = _DBModuleTestProvider();
+      await provider.ensureInitialized();
+
+      var stored = <int>[];
+      for (var i = 1; i <= 5; ++i) {
+        var role = Role(i.isEven ? RoleType.admin : RoleType.guest);
+        stored.add((await provider.roleRepository.store(role)) as int);
+      }
+      ids = stored;
+      expect(ids, equals([1, 2, 3, 4, 5]));
+
+      apiRoot = _DBModuleTestAPIRoot(provider);
+      await apiRoot.ensureInitialized();
+    });
+
+    tearDownAll(() {
+      apiRoot.close();
+      provider.close();
+    });
+
+    /// Calls `/db/select/role/json` with the raw [query] `String`.
+    Future<List<Object?>> selectIDs([String query = '']) async {
+      var path = '/db/select/role/json';
+      var uri = Uri.parse(
+        'http://localhost$path${query.isEmpty ? '' : '?$query'}',
+      );
+
+      var response = await apiRoot.call(
+        APIRequest(APIRequestMethod.GET, path, requestedUri: uri),
+      );
+
+      expect(response.isOK, isTrue, reason: 'Response: $response');
+
+      var entities = response.payload as List;
+      return entities.map((e) => (e as Map)['id']).toList();
+    }
+
+    test('default: ID-ordered, resolved by the DB', () async {
+      // REGRESSION: this endpoint has always returned ID-sorted entities.
+      // The sort moved from Dart to the DB; the output must not change.
+      expect(await selectIDs(), equals(ids));
+    });
+
+    test('LIMIT', () async {
+      expect(await selectIDs('LIMIT=2'), equals([1, 2]));
+      expect(await selectIDs('LIMIT=5'), equals(ids));
+      expect(await selectIDs('LIMIT=100'), equals(ids));
+    });
+
+    test('OFFSET', () async {
+      expect(await selectIDs('OFFSET=3'), equals([4, 5]));
+      expect(await selectIDs('OFFSET=5'), isEmpty);
+    });
+
+    test('LIMIT and OFFSET', () async {
+      expect(await selectIDs('LIMIT=2&OFFSET=2'), equals([3, 4]));
+      expect(await selectIDs('OFFSET=2&LIMIT=2'), equals([3, 4]));
+    });
+
+    test('ORDER', () async {
+      expect(await selectIDs('ORDER=desc'), equals([5, 4, 3, 2, 1]));
+      expect(await selectIDs('ORDER=DESC&LIMIT=2'), equals([5, 4]));
+      expect(await selectIDs('ORDER=asc&LIMIT=2'), equals([1, 2]));
+      expect(
+        await selectIDs('ORDER=descending&LIMIT=2&OFFSET=1'),
+        equals([4, 3]),
+      );
+    });
+
+    test('PAGE', () async {
+      expect(await selectIDs('LIMIT=2&PAGE=1'), equals([1, 2]));
+      expect(await selectIDs('LIMIT=2&PAGE=2'), equals([3, 4]));
+      expect(await selectIDs('LIMIT=2&PAGE=3'), equals([5]));
+      expect(await selectIDs('LIMIT=2&PAGE=4'), isEmpty);
+
+      expect(await selectIDs('PAGE=2&LIMIT=2&ORDER=desc'), equals([3, 2]));
+
+      // `PAGE` is equivalent to the `OFFSET` it computes:
+      expect(
+        await selectIDs('LIMIT=2&PAGE=2'),
+        equals(await selectIDs('LIMIT=2&OFFSET=2')),
+      );
+    });
+
+    test('an invalid PAGE is an error response, not a crash', () async {
+      FutureOr<APIResponse> call(String query) => apiRoot.call(
+        APIRequest(
+          APIRequestMethod.GET,
+          '/db/select/role/json',
+          requestedUri: Uri.parse(
+            'http://localhost/db/select/role/json?$query',
+          ),
+        ),
+      );
+
+      // `PAGE` without a `LIMIT`:
+      var noLimit = await call('PAGE=2');
+      expect(noLimit.isOK, isFalse);
+      expect(noLimit.toString(), contains('Invalid pagination'));
+
+      // `PAGE` together with an `OFFSET`:
+      var withOffset = await call('LIMIT=2&PAGE=2&OFFSET=2');
+      expect(withOffset.isOK, isFalse);
+      expect(withOffset.toString(), contains('Invalid pagination'));
+
+      // `PAGE` below 1:
+      var zero = await call('LIMIT=2&PAGE=0');
+      expect(zero.isOK, isFalse);
+      expect(zero.toString(), contains('Invalid pagination'));
+
+      // An unparsable `PAGE` is ignored, like the other directives:
+      expect(await selectIDs('LIMIT=2&PAGE=abc'), equals([1, 2]));
+    });
+
+    test('paging through reassembles the full set exactly once', () async {
+      var pages = <List<Object?>>[];
+      for (var offset = 0; offset < ids.length; offset += 2) {
+        pages.add(await selectIDs('LIMIT=2&OFFSET=$offset'));
+      }
+
+      expect(pages.map((p) => p.length), equals([2, 2, 1]));
+      expect(pages.expand((p) => p).toList(), equals(ids));
+    });
+
+    test('EAGER=true still works, alone and with the new directives', () async {
+      // Backward-compat guard for the rewritten directive stripping:
+      expect(await selectIDs('EAGER=true'), equals(ids));
+      expect(await selectIDs('EAGER=true&LIMIT=2'), equals([1, 2]));
+      expect(await selectIDs('LIMIT=2&EAGER=true'), equals([1, 2]));
+      expect(await selectIDs('LIMIT=2&EAGER=true&ORDER=desc'), equals([5, 4]));
+    });
+
+    test('an entity query is preserved alongside the directives', () async {
+      // Roles 2 and 4 are `admin`; the rest are `guest`.
+      expect(await selectIDs('type == "admin"'), equals([2, 4]));
+
+      expect(await selectIDs('type == "admin"&LIMIT=1'), equals([2]));
+
+      expect(
+        await selectIDs('type == "admin"&LIMIT=1&ORDER=desc'),
+        equals([4]),
+      );
+
+      expect(await selectIDs('type == "guest"&OFFSET=1'), equals([3, 5]));
+
+      expect(
+        await selectIDs('EAGER=true&type == "admin"&OFFSET=1'),
+        equals([4]),
+      );
+    });
+
+    test('an unparsable directive value is ignored', () async {
+      expect(await selectIDs('LIMIT=abc'), equals(ids));
+      expect(await selectIDs('OFFSET=abc'), equals(ids));
+      expect(await selectIDs('ORDER=sideways'), equals(ids));
+    });
+
+    test('selectQueryDirectives', () {
+      expect(
+        APIDBModule.selectQueryDirectives,
+        equals(['EAGER', 'LIMIT', 'OFFSET', 'PAGE', 'ORDER']),
+      );
+    });
+  });
+}
diff --git a/test/bones_api_entity_db_sql_select_test.dart b/test/bones_api_entity_db_sql_select_test.dart
new file mode 100644
index 0000000..a5eb530
--- /dev/null
+++ b/test/bones_api_entity_db_sql_select_test.dart
@@ -0,0 +1,627 @@
+@Tags(['entities'])
+// ignore_for_file: discarded_futures
+import 'package:bones_api/bones_api.dart';
+import 'package:statistics/statistics.dart' show Decimal;
+import 'package:test/test.dart';
+
+import 'bones_api_test_entities.dart';
+
+/// A dedicated (non-singleton) provider with a single `role` table, so the
+/// ordering/pagination assertions below can't be disturbed by the entities
+/// stored by the other test files.
+class _SelectTestProvider extends EntityRepositoryProvider {
+  late final DBSQLMemoryAdapter sqlAdapter;
+
+  late final DBSQLEntityRepository<Role> roleRepository;
+
+  _SelectTestProvider() {
+    sqlAdapter = DBSQLMemoryAdapter(parentRepositoryProvider: this)
+      ..addTableSchemes([
+        TableScheme(
+          'role',
+          idFieldName: 'id',
+          fieldsTypes: {
+            'id': int,
+            'type': String,
+            'enabled': bool,
+            'value': Decimal,
+          },
+        ),
+        // A table whose ID column is NOT named `id`. Every entity of
+        // `bones_api_test_entities.dart` uses `id`, so without this the
+        // `orderByID` assertions would pass even if the column name were
+        // hardcoded instead of resolved from the `TableScheme`.
+        TableScheme(
+          'legacy_item',
+          idFieldName: 'item_code',
+          fieldsTypes: {'item_code': String, 'name': String},
+        ),
+      ]);
+
+    roleRepository = DBSQLEntityRepository<Role>(
+      sqlAdapter,
+      'role',
+      roleEntityHandler,
+    )..ensureInitialized();
+  }
+}
+
+void main() {
+  group('generateSelectSQL[memory]', () {
+    late final _SelectTestProvider provider;
+    late final DBSQLMemoryAdapter sqlAdapter;
+
+    setUpAll(() async {
+      roleEntityHandler.ensureRegistered();
+      provider = _SelectTestProvider();
+      await provider.ensureInitialized();
+      sqlAdapter = provider.sqlAdapter;
+    });
+
+    tearDownAll(() => provider.close());
+
+    FutureOr<SQL> selectSQL({
+      int? limit,
+      int? offset,
+      bool? orderByID,
+      OrderDirection? orderDirection,
+    }) => sqlAdapter.generateSelectSQL(
+      Transaction(),
+      'Role',
+      'role',
+      ConditionANY(),
+      limit: limit,
+      offset: offset,
+      orderByID: orderByID,
+      orderDirection: orderDirection,
+    );
+
+    // The `generic` dialect of `DBSQLMemoryAdapter` has an empty element quote:
+    const from = 'SELECT ro.* FROM role as ro';
+
+    test('baseline: no ordering and no pagination (unchanged SQL)', () async {
+      var sql = await selectSQL();
+      expect(sql.sql, equals(from));
+      expect(sql.offset, isNull);
+      expect(sql.orderByID, isNull);
+      expect(sql.orderDirection, isNull);
+    });
+
+    test('limit only (unchanged SQL)', () async {
+      expect((await selectSQL(limit: 2)).sql, equals('$from LIMIT 2'));
+    });
+
+    test('limit of 0 emits no clause', () async {
+      expect((await selectSQL(limit: 0)).sql, equals(from));
+    });
+
+    test('orderByID resolves the table ID column', () async {
+      expect(
+        (await selectSQL(orderByID: true)).sql,
+        equals('$from ORDER BY ro.id ASC'),
+      );
+    });
+
+    test('orderDirection', () async {
+      expect(
+        (await selectSQL(
+          orderByID: true,
+          orderDirection: OrderDirection.ascending,
+        )).sql,
+        equals('$from ORDER BY ro.id ASC'),
+      );
+
+      expect(
+        (await selectSQL(
+          orderByID: true,
+          orderDirection: OrderDirection.descending,
+        )).sql,
+        equals('$from ORDER BY ro.id DESC'),
+      );
+    });
+
+    test('orderDirection alone is ignored', () async {
+      expect(
+        (await selectSQL(orderDirection: OrderDirection.descending)).sql,
+        equals(from),
+      );
+    });
+
+    test('offset implies the ordering', () async {
+      expect(
+        (await selectSQL(offset: 3)).sql,
+        equals('$from ORDER BY ro.id ASC OFFSET 3'),
+      );
+
+      expect(
+        (await selectSQL(limit: 2, offset: 3)).sql,
+        equals('$from ORDER BY ro.id ASC LIMIT 2 OFFSET 3'),
+      );
+
+      expect(
+        (await selectSQL(
+          limit: 2,
+          offset: 3,
+          orderDirection: OrderDirection.descending,
+        )).sql,
+        equals('$from ORDER BY ro.id DESC LIMIT 2 OFFSET 3'),
+      );
+    });
+
+    test('orderByID: false opts out of the implied ordering', () async {
+      expect(
+        (await selectSQL(offset: 3, orderByID: false)).sql,
+        equals('$from OFFSET 3'),
+      );
+    });
+
+    test('the clauses are carried by the SQL and survive copy()', () async {
+      var sql = await selectSQL(
+        limit: 2,
+        offset: 3,
+        orderByID: true,
+        orderDirection: OrderDirection.descending,
+      );
+
+      expect(sql.limit, equals(2));
+      expect(sql.offset, equals(3));
+      expect(sql.orderByID, isTrue);
+      expect(sql.orderDirection, equals(OrderDirection.descending));
+
+      var copy = sql.copy();
+      expect(copy.sql, equals(sql.sql));
+      expect(copy.limit, equals(2));
+      expect(copy.offset, equals(3));
+      expect(copy.orderByID, isTrue);
+      expect(copy.orderDirection, equals(OrderDirection.descending));
+    });
+
+    test('with a WHERE condition', () async {
+      var sql = await sqlAdapter.generateSelectSQL(
+        Transaction(),
+        'Role',
+        'role',
+        ConditionParser().parse(' enabled == ? '),
+        parameters: {'enabled': true},
+        limit: 2,
+        offset: 1,
+      );
+
+      expect(
+        sql.sql,
+        equals(
+          'SELECT ro.* FROM role as ro WHERE ( ro.enabled = @enabled )'
+          ' ORDER BY ro.id ASC LIMIT 2 OFFSET 1',
+        ),
+      );
+    });
+
+    test('ORDER BY uses the resolved ID column, not a hardcoded `id`', () async {
+      // `legacy_item` declares `idFieldName: 'item_code'`. The ORDER BY column
+      // must come from the `TableScheme` (through
+      // `EncodingContext.tableFieldID`), which is the machinery this feature
+      // reuses. If it ever falls back to a literal `id`, this fails.
+      var sql = await sqlAdapter.generateSelectSQL(
+        Transaction(),
+        'LegacyItem',
+        'legacy_item',
+        ConditionANY(),
+        orderByID: true,
+      );
+
+      expect(
+        sql.sql,
+        equals(
+          'SELECT le.* FROM legacy_item as le'
+          ' ORDER BY le.item_code ASC',
+        ),
+      );
+      expect(sql.sql, isNot(contains('.id')));
+
+      var desc = await sqlAdapter.generateSelectSQL(
+        Transaction(),
+        'LegacyItem',
+        'legacy_item',
+        ConditionANY(),
+        limit: 2,
+        offset: 4,
+        orderDirection: OrderDirection.descending,
+      );
+
+      expect(
+        desc.sql,
+        equals(
+          'SELECT le.* FROM legacy_item as le'
+          ' ORDER BY le.item_code DESC LIMIT 2 OFFSET 4',
+        ),
+      );
+
+      // The IDs projection must also use it, for both the column and ORDER BY:
+      var ids = await sqlAdapter.generateSelectIDsSQL(
+        Transaction(),
+        'LegacyItem',
+        'legacy_item',
+        ConditionANY(),
+        orderByID: true,
+      );
+
+      expect(
+        ids.sql,
+        equals(
+          'SELECT le.item_code as id FROM legacy_item as le'
+          ' ORDER BY le.item_code ASC',
+        ),
+      );
+    });
+
+    test('generateSelectIDsSQL', () async {
+      var sql = await sqlAdapter.generateSelectIDsSQL(
+        Transaction(),
+        'Role',
+        'role',
+        ConditionANY(),
+        limit: 2,
+        offset: 1,
+        orderDirection: OrderDirection.descending,
+      );
+
+      expect(
+        sql.sql,
+        equals(
+          'SELECT ro.id as id FROM role as ro'
+          ' ORDER BY ro.id DESC LIMIT 2 OFFSET 1',
+        ),
+      );
+    });
+  });
+
+  group('generateSelectSQL[dialects]', () {
+    // `_generateSelectTailSQL` delegates the dialect-specific syntax to
+    // `SQLDialect`, so the per-dialect shape is asserted through it. The
+    // PostgreSQL and MySQL adapters can't be instantiated without a server.
+    const postgres = SQLDialect('PostgreSQL', elementQuote: '"');
+    const mysql = SQLDialect(
+      'MySQL',
+      elementQuote: '`',
+      offsetRequiresLimit: true,
+    );
+
+    test('PostgreSQL', () {
+      expect(
+        postgres.orderBySQL('ro', 'id') +
+            postgres.limitOffsetSQL(limit: 2, offset: 3),
+        equals(' ORDER BY "ro"."id" ASC LIMIT 2 OFFSET 3'),
+      );
+
+      // PostgreSQL accepts a standalone `OFFSET`:
+      expect(postgres.limitOffsetSQL(offset: 3), equals(' OFFSET 3'));
+    });
+
+    test('MySQL: an OFFSET requires a LIMIT', () {
+      expect(
+        mysql.orderBySQL('ro', 'id', direction: OrderDirection.descending) +
+            mysql.limitOffsetSQL(limit: 2, offset: 3),
+        equals(' ORDER BY `ro`.`id` DESC LIMIT 2 OFFSET 3'),
+      );
+
+      // MySQL can't parse a standalone `OFFSET`, so the maximum row count is
+      // used as the `LIMIT`:
+      expect(
+        mysql.limitOffsetSQL(offset: 3),
+        equals(' LIMIT 18446744073709551615 OFFSET 3'),
+      );
+    });
+  });
+
+  group('DBSQLEntityRepository[memory] ordering/pagination', () {
+    late final _SelectTestProvider provider;
+    late final DBSQLEntityRepository<Role> roleRepository;
+
+    // The IDs of the 5 stored roles, in ascending order:
+    late final List<int> ids;
+
+    setUpAll(() async {
+      roleEntityHandler.ensureRegistered();
+      provider = _SelectTestProvider();
+      await provider.ensureInitialized();
+      roleRepository = provider.roleRepository;
+
+      var stored = <int>[];
+      for (var i = 1; i <= 5; ++i) {
+        var role = Role(
+          i.isEven ? RoleType.admin : RoleType.guest,
+          enabled: i != 5,
+          value: Decimal.parse('$i.00'),
+        );
+        stored.add((await roleRepository.store(role)) as int);
+      }
+
+      ids = stored;
+      expect(ids.length, equals(5));
+      // The assertions below rely on the IDs being ascending:
+      expect(ids, orderedEquals([...ids]..sort()));
+    });
+
+    tearDownAll(() => provider.close());
+
+    Future<List<Object?>> selectIDs({
+      String? query,
+      Object? parameters,
+      int? limit,
+      int? offset,
+      int? page,
+      bool? orderByID,
+      OrderDirection? orderDirection,
+    }) async {
+      var sel = await roleRepository.selectByQuery(
+        query ?? ' id >= ? ',
+        parameters: parameters ?? [ids.first],
+        limit: limit,
+        offset: offset,
+        page: page,
+        orderByID: orderByID,
+        orderDirection: orderDirection,
+      );
+      return sel.map((e) => e.id).toList();
+    }
+
+    test('baseline: all 5 roles', () async {
+      expect(await selectIDs(), unorderedEquals(ids));
+    });
+
+    test('orderByID ascending/descending', () async {
+      expect(await selectIDs(orderByID: true), equals(ids));
+
+      expect(
+        await selectIDs(
+          orderByID: true,
+          orderDirection: OrderDirection.descending,
+        ),
+        equals(ids.reversed.toList()),
+      );
+    });
+
+    test('limit with the ordering', () async {
+      expect(await selectIDs(orderByID: true, limit: 2), equals(ids.take(2)));
+
+      expect(
+        await selectIDs(
+          orderByID: true,
+          limit: 2,
+          orderDirection: OrderDirection.descending,
+        ),
+        equals(ids.reversed.take(2)),
+      );
+    });
+
+    test('offset implies the ordering', () async {
+      expect(await selectIDs(offset: 2), equals(ids.skip(2)));
+      expect(await selectIDs(offset: 2, limit: 2), equals(ids.skip(2).take(2)));
+    });
+
+    test('paging through reassembles the full set exactly once', () async {
+      var pages = <List<Object?>>[];
+      for (var offset = 0; offset < ids.length; offset += 2) {
+        pages.add(await selectIDs(limit: 2, offset: offset));
+      }
+
+      expect(pages.map((p) => p.length), equals([2, 2, 1]));
+      expect(pages.expand((p) => p).toList(), equals(ids));
+    });
+
+    test('descending pagination', () async {
+      expect(
+        await selectIDs(
+          limit: 2,
+          offset: 1,
+          orderDirection: OrderDirection.descending,
+        ),
+        equals(ids.reversed.skip(1).take(2)),
+      );
+    });
+
+    test('offset past the end returns empty', () async {
+      expect(await selectIDs(offset: ids.length), isEmpty);
+      expect(await selectIDs(offset: 100), isEmpty);
+    });
+
+    test('orderDirection alone does not order', () async {
+      expect(
+        await selectIDs(orderDirection: OrderDirection.descending),
+        unorderedEquals(ids),
+      );
+    });
+
+    test('ordering and pagination with a WHERE condition', () async {
+      // Roles 1..4 are enabled; role 5 is not:
+      var enabled = await selectIDs(
+        query: ' enabled == ? ',
+        parameters: [true],
+        orderByID: true,
+      );
+      expect(enabled, equals(ids.take(4)));
+
+      expect(
+        await selectIDs(
+          query: ' enabled == ? ',
+          parameters: [true],
+          limit: 2,
+          offset: 1,
+        ),
+        equals(ids.take(4).skip(1).take(2)),
+      );
+    });
+
+    test('selectIDsByQuery', () async {
+      var sel = await roleRepository.selectIDsByQuery<int>(
+        ' id >= ? ',
+        parameters: [ids.first],
+        limit: 2,
+        offset: 2,
+      );
+      expect(sel.toList(), equals(ids.skip(2).take(2)));
+    });
+
+    test('selectFirstByQuery', () async {
+      var first = await roleRepository.selectFirstByQuery(
+        ' id >= ? ',
+        parameters: [ids.first],
+        orderByID: true,
+      );
+      expect(first?.id, equals(ids.first));
+
+      var last = await roleRepository.selectFirstByQuery(
+        ' id >= ? ',
+        parameters: [ids.first],
+        orderByID: true,
+        orderDirection: OrderDirection.descending,
+      );
+      expect(last?.id, equals(ids.last));
+
+      // `offset` implies the ordering, so this is the 2nd role:
+      var second = await roleRepository.selectFirstByQuery(
+        ' id >= ? ',
+        parameters: [ids.first],
+        offset: 1,
+      );
+      expect(second?.id, equals(ids[1]));
+    });
+
+    test('selectAll', () async {
+      var all = await roleRepository.selectAll(orderByID: true);
+      expect(all.map((e) => e.id).toList(), equals(ids));
+
+      var page = await roleRepository.selectAll(limit: 2, offset: 2);
+      expect(page.map((e) => e.id).toList(), equals(ids.skip(2).take(2)));
+
+      var desc = await roleRepository.selectAll(
+        orderByID: true,
+        orderDirection: OrderDirection.descending,
+      );
+      expect(desc.map((e) => e.id).toList(), equals(ids.reversed.toList()));
+    });
+
+    test('select with an EntityMatcher', () async {
+      var sel = await roleRepository.select(
+        ConditionANY(),
+        limit: 2,
+        offset: 1,
+      );
+      expect(sel.map((e) => e.id).toList(), equals(ids.skip(1).take(2)));
+    });
+
+    test('page: 1-based, computes the offset from the limit', () async {
+      expect(await selectIDs(limit: 2, page: 1), equals(ids.take(2)));
+      expect(await selectIDs(limit: 2, page: 2), equals(ids.skip(2).take(2)));
+      expect(await selectIDs(limit: 2, page: 3), equals(ids.skip(4).take(2)));
+
+      // Past the end:
+      expect(await selectIDs(limit: 2, page: 4), isEmpty);
+
+      // `page` is equivalent to the offset it computes:
+      expect(
+        await selectIDs(limit: 2, page: 2),
+        equals(await selectIDs(limit: 2, offset: 2)),
+      );
+    });
+
+    test('page implies the ordering, even on page 1', () async {
+      // Resolves to `offset: 0`, which still activates `orderByID`:
+      expect(await selectIDs(limit: 5, page: 1), equals(ids));
+
+      expect(
+        await selectIDs(
+          limit: 2,
+          page: 1,
+          orderDirection: OrderDirection.descending,
+        ),
+        equals(ids.reversed.take(2)),
+      );
+    });
+
+    test('page: descending', () async {
+      expect(
+        await selectIDs(
+          limit: 2,
+          page: 2,
+          orderDirection: OrderDirection.descending,
+        ),
+        equals(ids.reversed.skip(2).take(2)),
+      );
+    });
+
+    test('paging by page reassembles the full set exactly once', () async {
+      var pages = <List<Object?>>[];
+      for (var page = 1; page <= 3; ++page) {
+        pages.add(await selectIDs(limit: 2, page: page));
+      }
+
+      expect(pages.map((p) => p.length), equals([2, 2, 1]));
+      expect(pages.expand((p) => p).toList(), equals(ids));
+    });
+
+    test('page is rejected without a positive limit', () async {
+      expect(() => selectIDs(page: 2), throwsArgumentError);
+      expect(() => selectIDs(page: 2, limit: 0), throwsArgumentError);
+    });
+
+    test('page and offset are mutually exclusive', () async {
+      expect(
+        () => selectIDs(limit: 2, page: 2, offset: 2),
+        throwsArgumentError,
+      );
+    });
+
+    test('page must be >= 1', () async {
+      expect(() => selectIDs(limit: 2, page: 0), throwsArgumentError);
+      expect(() => selectIDs(limit: 2, page: -1), throwsArgumentError);
+    });
+
+    test('page on the other select methods', () async {
+      expect(
+        (await roleRepository.selectIDsByQuery<int>(
+          ' id >= ? ',
+          parameters: [ids.first],
+          limit: 2,
+          page: 2,
+        )).toList(),
+        equals(ids.skip(2).take(2)),
+      );
+
+      expect(
+        (await roleRepository.selectAll(
+          limit: 2,
+          page: 2,
+        )).map((e) => e.id).toList(),
+        equals(ids.skip(2).take(2)),
+      );
+
+      expect(
+        (await roleRepository.select(
+          ConditionANY(),
+          limit: 2,
+          page: 3,
+        )).map((e) => e.id).toList(),
+        equals(ids.skip(4).take(2)),
+      );
+
+      // `selectFirstByQuery` forces `limit: 1`, so `page: n` is the Nth entity:
+      expect(
+        (await roleRepository.selectFirstByQuery(
+          ' id >= ? ',
+          parameters: [ids.first],
+          page: 3,
+        ))?.id,
+        equals(ids[2]),
+      );
+    });
+
+    test('count is not affected by the ordering', () async {
+      expect(await roleRepository.length(), equals(ids.length));
+      expect(
+        await roleRepository.countByQuery(' enabled == ? ', parameters: [true]),
+        equals(4),
+      );
+    });
+  });
+}
diff --git a/test/bones_api_entity_db_tests_base.dart b/test/bones_api_entity_db_tests_base.dart
index afd0e2f..042b94a 100644
--- a/test/bones_api_entity_db_tests_base.dart
+++ b/test/bones_api_entity_db_tests_base.dart
@@ -2342,6 +2342,419 @@ Future<bool> runAdapterTests(
           }
         },
       );
+
+      test('generateSelectSQL: ORDER BY / LIMIT / OFFSET', () async {
+        var sqlAdapter = await entityRepositoryProvider.adapter;
+        // NOTE: not `cmdQuote` (the DDL quote asserted by
+        // `generateFullCreateTableSQLs`): the `generic` dialect of
+        // `DBSQLMemoryAdapter` has an empty element quote.
+        var q = sqlAdapter.dialect.elementQuote;
+
+        FutureOr<SQL> selectSQL({
+          int? limit,
+          int? offset,
+          bool? orderByID,
+          OrderDirection? orderDirection,
+        }) => sqlAdapter.generateSelectSQL(
+          Transaction(),
+          'Campaign',
+          'campaign',
+          ConditionANY(),
+          limit: limit,
+          offset: offset,
+          orderByID: orderByID,
+          orderDirection: orderDirection,
+        );
+
+        // The `ORDER BY` column is the table ID, resolved from the
+        // `TableScheme` of the DB:
+        final orderByIdAsc = ' ORDER BY ${q}ca$q.${q}id$q ASC';
+        final orderByIdDesc = ' ORDER BY ${q}ca$q.${q}id$q DESC';
+
+        // Baseline: the pre-existing SQL is unchanged.
+        expect((await selectSQL()).sql, isNot(contains('ORDER BY')));
+        expect((await selectSQL()).sql, isNot(contains('LIMIT')));
+        expect((await selectSQL()).sql, isNot(contains('OFFSET')));
+
+        expect((await selectSQL(limit: 2)).sql, endsWith(' LIMIT 2'));
+
+        // `orderDirection` alone is ignored:
+        expect(
+          (await selectSQL(orderDirection: OrderDirection.descending)).sql,
+          isNot(contains('ORDER BY')),
+        );
+
+        expect((await selectSQL(orderByID: true)).sql, endsWith(orderByIdAsc));
+
+        expect(
+          (await selectSQL(
+            orderByID: true,
+            orderDirection: OrderDirection.descending,
+          )).sql,
+          endsWith(orderByIdDesc),
+        );
+
+        // An `offset` implies the ordering, so the pagination is stable:
+        expect(
+          (await selectSQL(limit: 2, offset: 3)).sql,
+          endsWith('$orderByIdAsc LIMIT 2 OFFSET 3'),
+        );
+
+        expect(
+          (await selectSQL(offset: 3, orderByID: false)).sql,
+          isNot(contains('ORDER BY')),
+        );
+
+        // An `offset` with no `limit` is the dialect-specific case: MySQL can't
+        // parse a standalone `OFFSET`, so it gets the maximum row count as the
+        // `LIMIT` instead.
+        var offsetOnly = (await selectSQL(offset: 3)).sql;
+        if (sqlAdapter.dialect.offsetRequiresLimit) {
+          expect(
+            offsetOnly,
+            endsWith(
+              '$orderByIdAsc'
+              ' LIMIT ${sqlAdapter.dialect.offsetMaxLimitValue} OFFSET 3',
+            ),
+          );
+        } else {
+          expect(offsetOnly, endsWith('$orderByIdAsc OFFSET 3'));
+        }
+      });
+
+      test('Pagination: orderByID / orderDirection / offset / limit', () async {
+        final campaignRepo = entityRepositoryProvider.campaignAPIRepository;
+
+        // Store 5 campaigns and keep their (ascending) IDs. Every query below
+        // is scoped with ` id >= ? ` so the campaigns stored by the previous
+        // tests of this group can't leak into the assertions.
+        var ids = <int>[];
+        for (var i = 1; i <= 5; ++i) {
+          var id = await campaignRepo.store(Campaign('PAGE-0$i'));
+          expect(id, isNotNull);
+          ids.add(id as int);
+        }
+
+        expect(ids.length, equals(5));
+        expect(
+          ids,
+          orderedEquals([...ids]..sort()),
+          reason: "The stored IDs must be ascending: $ids",
+        );
+
+        final firstId = ids.first;
+
+        Future<List<Object?>> selectIDs({
+          int? limit,
+          int? offset,
+          int? page,
+          bool? orderByID,
+          OrderDirection? orderDirection,
+        }) async {
+          var sel = await campaignRepo.selectByQuery(
+            ' id >= ? ',
+            parameters: [firstId],
+            limit: limit,
+            offset: offset,
+            page: page,
+            orderByID: orderByID,
+            orderDirection: orderDirection,
+          );
+          return sel.map((e) => e.id).toList();
+        }
+
+        // Ordering:
+        expect(await selectIDs(orderByID: true), equals(ids));
+
+        expect(
+          await selectIDs(
+            orderByID: true,
+            orderDirection: OrderDirection.descending,
+          ),
+          equals(ids.reversed.toList()),
+        );
+
+        expect(
+          await selectIDs(orderByID: true, limit: 2),
+          equals(ids.take(2).toList()),
+        );
+
+        // `offset` implies `orderByID`:
+        expect(
+          await selectIDs(offset: 2, limit: 2),
+          equals(ids.skip(2).take(2).toList()),
+        );
+
+        // An `offset` with no `limit`: the MySQL
+        // `LIMIT <offsetMaxLimitValue> OFFSET n` path.
+        expect(await selectIDs(offset: 3), equals(ids.skip(3).toList()));
+
+        expect(
+          await selectIDs(
+            offset: 1,
+            limit: 2,
+            orderDirection: OrderDirection.descending,
+          ),
+          equals(ids.reversed.skip(1).take(2).toList()),
+        );
+
+        expect(await selectIDs(offset: ids.length), isEmpty);
+
+        // Paging through reassembles the full set exactly once:
+        var pages = <List<Object?>>[];
+        for (var offset = 0; offset < ids.length; offset += 2) {
+          pages.add(await selectIDs(limit: 2, offset: offset));
+        }
+        expect(pages.expand((p) => p).toList(), equals(ids));
+
+        // `orderDirection` alone is ignored (the order stays unspecified):
+        expect(
+          await selectIDs(orderDirection: OrderDirection.descending),
+          unorderedEquals(ids),
+        );
+
+        // `selectIDsByQuery`:
+        expect(
+          (await campaignRepo.selectIDsByQuery<int>(
+            ' id >= ? ',
+            parameters: [firstId],
+            offset: 2,
+            limit: 2,
+          )).toList(),
+          equals(ids.skip(2).take(2).toList()),
+        );
+
+        // `selectFirstByQuery`:
+        expect(
+          (await campaignRepo.selectFirstByQuery(
+            ' id >= ? ',
+            parameters: [firstId],
+            orderByID: true,
+            orderDirection: OrderDirection.descending,
+          ))?.id,
+          equals(ids.last),
+        );
+
+        // `selectAll` can't assert exact IDs (the previous tests of this group
+        // also stored campaigns), only that the pagination is applied:
+        expect(
+          (await campaignRepo.selectAll(limit: 2, orderByID: true)).length,
+          equals(2),
+        );
+
+        // `page` is 1-based and computes the offset from the `limit`:
+        expect(
+          await selectIDs(limit: 2, page: 1),
+          equals(ids.take(2).toList()),
+        );
+        expect(
+          await selectIDs(limit: 2, page: 2),
+          equals(ids.skip(2).take(2).toList()),
+        );
+        expect(
+          await selectIDs(limit: 2, page: 3),
+          equals(ids.skip(4).take(2).toList()),
+        );
+        expect(await selectIDs(limit: 2, page: 4), isEmpty);
+
+        expect(
+          await selectIDs(
+            limit: 2,
+            page: 2,
+            orderDirection: OrderDirection.descending,
+          ),
+          equals(ids.reversed.skip(2).take(2).toList()),
+        );
+
+        // Paging by `page` reassembles the full set exactly once:
+        var byPage = <List<Object?>>[];
+        for (var page = 1; page <= 3; ++page) {
+          byPage.add(await selectIDs(limit: 2, page: page));
+        }
+        expect(byPage.expand((p) => p).toList(), equals(ids));
+
+        // `page` is rejected without a positive `limit`, alongside an
+        // `offset`, or below 1:
+        expect(() => selectIDs(page: 2), throwsArgumentError);
+        expect(() => selectIDs(page: 2, limit: 0), throwsArgumentError);
+        expect(
+          () => selectIDs(page: 2, limit: 2, offset: 2),
+          throwsArgumentError,
+        );
+        expect(() => selectIDs(page: 0, limit: 2), throwsArgumentError);
+      });
+
+      test('Pagination: JOIN, eager resolution and stability', () async {
+        final campaignRepo = entityRepositoryProvider.campaignAPIRepository;
+        final campaignConfigRepo =
+            entityRepositoryProvider.campaignConfigAPIRepository;
+
+        var cfgId = await campaignConfigRepo.store(CampaignConfig(open: true));
+        expect(cfgId, isNotNull);
+
+        var ids = <int>[];
+        for (var i = 1; i <= 5; ++i) {
+          var id = await campaignRepo.store(
+            Campaign('JOIN-0$i', config: cfgId),
+          );
+          ids.add(id as int);
+        }
+        expect(ids, orderedEquals([...ids]..sort()));
+
+        // A condition over a referenced entity generates a `JOIN`. The
+        // `ORDER BY` must target the MAIN table's alias (`campaign`), not the
+        // joined one, otherwise the paging below would be ordered by the
+        // config's ID -- which is the same row for all 5 campaigns.
+        Future<List<Object?>> selectJoined({
+          int? limit,
+          int? offset,
+          bool? orderByID,
+          OrderDirection? orderDirection,
+          EntityResolutionRules? resolutionRules,
+        }) async {
+          var sel = await campaignRepo.selectByQuery(
+            ' config.open == ? && id >= ? ',
+            parameters: [true, ids.first],
+            limit: limit,
+            offset: offset,
+            orderByID: orderByID,
+            orderDirection: orderDirection,
+            resolutionRules: resolutionRules,
+          );
+          return sel.map((e) => e.id).toList();
+        }
+
+        expect(await selectJoined(orderByID: true), equals(ids));
+
+        expect(
+          await selectJoined(
+            orderByID: true,
+            orderDirection: OrderDirection.descending,
+          ),
+          equals(ids.reversed.toList()),
+        );
+
+        expect(
+          await selectJoined(limit: 2, offset: 2),
+          equals(ids.skip(2).take(2).toList()),
+        );
+
+        // Paging a JOIN query must still reassemble the full set:
+        var joinPages = <List<Object?>>[];
+        for (var offset = 0; offset < ids.length; offset += 2) {
+          joinPages.add(await selectJoined(limit: 2, offset: offset));
+        }
+        expect(joinPages.expand((p) => p).toList(), equals(ids));
+
+        // The ordering must survive the eager entity resolution, which
+        // re-reads the referenced entities after the select:
+        var eager = await selectJoined(
+          limit: 3,
+          offset: 1,
+          resolutionRules: EntityResolutionRules(allEager: true),
+        );
+        expect(eager, equals(ids.skip(1).take(3).toList()));
+
+        // Stability: the whole point of `offset` implying `orderByID` is that
+        // the same page is the same rows every time.
+        for (var i = 0; i < 3; ++i) {
+          expect(
+            await selectJoined(limit: 2, offset: 2),
+            equals(ids.skip(2).take(2).toList()),
+            reason: 'Unstable page on repetition #$i',
+          );
+        }
+
+        // A query matching nothing stays empty under every option:
+        Future<List<Object?>> selectNone({int? offset, int? limit}) async {
+          var sel = await campaignRepo.selectByQuery(
+            ' name == ? ',
+            parameters: ['JOIN-NO-SUCH-CAMPAIGN'],
+            limit: limit,
+            offset: offset,
+          );
+          return sel.map((e) => e.id).toList();
+        }
+
+        expect(await selectNone(), isEmpty);
+        expect(await selectNone(offset: 0), isEmpty);
+        expect(await selectNone(offset: 5, limit: 2), isEmpty);
+      });
+
+      test('Pagination [objectAdapter]: orderByID / offset / limit', () async {
+        final photoRepo = entityRepositoryProvider2.photoAPIRepository;
+
+        // `Photo` has a `String` ID, so this also covers the non-numeric
+        // branch of `compareEntityIDs`. Deliberately stored out of order:
+        var ids = ['PG-01', 'PG-02', 'PG-03', 'PG-04', 'PG-05'];
+        for (var id in [ids[2], ids[0], ids[4], ids[1], ids[3]]) {
+          var photo = Photo.fromData(base64.decode(png1PixelBase64), id: id);
+          expect(await photoRepo.store(photo), equals(id));
+        }
+
+        Future<List<String>> selectAllIDs({
+          int? limit,
+          int? offset,
+          bool? orderByID,
+          OrderDirection? orderDirection,
+        }) async {
+          var sel = await photoRepo.selectAll(
+            limit: limit,
+            offset: offset,
+            orderByID: orderByID,
+            orderDirection: orderDirection,
+          );
+          // The `setUpAll` of this group stores an extra photo (with a sha256
+          // ID), so only the ones created here are asserted:
+          return sel.map((e) => e.id).where(ids.contains).toList();
+        }
+
+        expect(await selectAllIDs(orderByID: true), equals(ids));
+
+        expect(
+          await selectAllIDs(
+            orderByID: true,
+            orderDirection: OrderDirection.descending,
+          ),
+          equals(ids.reversed.toList()),
+        );
+
+        // REGRESSION: `limit` was previously accepted and silently ignored by
+        // the object adapters, so this returned every photo.
+        var limited = await photoRepo.selectAll(limit: 2, orderByID: true);
+        expect(limited.length, equals(2));
+
+        // `offset` implies the ordering:
+        expect(
+          await selectAllIDs(offset: 1, limit: 2),
+          equals(ids.skip(1).take(2).toList()),
+        );
+
+        // `selectByIDs` -> `ConditionIdIN`, which is one of the
+        // `DBEntityRepository.select` fast paths that used to drop `limit`:
+        var byIDs = await photoRepo.entityRepository.select(
+          ConditionIdIN(ids),
+          offset: 1,
+          limit: 2,
+        );
+        expect(byIDs.map((e) => e.id).toList(), equals(ids.skip(1).take(2)));
+
+        // A single-row select: any positive offset skips the only row.
+        expect(
+          (await photoRepo.entityRepository.select(
+            ConditionID(ids.first),
+          )).map((e) => e.id),
+          equals([ids.first]),
+        );
+        expect(
+          await photoRepo.entityRepository.select(
+            ConditionID(ids.first),
+            offset: 1,
+          ),
+          isEmpty,
+        );
+      });
+
       test('populate', () async {
         var result = await entityRepositoryProvider.storeAllFromJson({
           'user': [
diff --git a/test/bones_api_entity_select_order_test.dart b/test/bones_api_entity_select_order_test.dart
new file mode 100644
index 0000000..2fde10e
--- /dev/null
+++ b/test/bones_api_entity_select_order_test.dart
@@ -0,0 +1,425 @@
+@Tags(['entities'])
+import 'package:bones_api/bones_api.dart';
+import 'package:test/test.dart';
+
+/// A minimal row, so [applySelectOrderAndPagination] is exercised over a type
+/// that is not a `Map` (as the object adapters use) nor an entity.
+class _Row {
+  final Object? id;
+
+  _Row(this.id);
+
+  @override
+  String toString() => 'Row($id)';
+}
+
+List<Object?> _ids(Iterable<_Row> rows) => rows.map((e) => e.id).toList();
+
+Iterable<_Row> _apply(
+  List<Object?> ids, {
+  int? limit,
+  int? offset,
+  bool? orderByID,
+  OrderDirection? orderDirection,
+  bool zeroLimitIsUnlimited = false,
+}) => applySelectOrderAndPagination(
+  ids.map(_Row.new),
+  (r) => r.id,
+  limit: limit,
+  offset: offset,
+  orderByID: orderByID,
+  orderDirection: orderDirection,
+  zeroLimitIsUnlimited: zeroLimitIsUnlimited,
+);
+
+void main() {
+  group('OrderDirection', () {
+    test('defaults', () {
+      expect(OrderDirection.defaultDirection, equals(OrderDirection.ascending));
+      expect(OrderDirection.resolve(null), equals(OrderDirection.ascending));
+      expect(
+        OrderDirection.resolve(OrderDirection.descending),
+        equals(OrderDirection.descending),
+      );
+    });
+
+    test('isAscending/isDescending/sqlKeyword', () {
+      expect(OrderDirection.ascending.isAscending, isTrue);
+      expect(OrderDirection.ascending.isDescending, isFalse);
+      expect(OrderDirection.ascending.sqlKeyword, equals('ASC'));
+
+      expect(OrderDirection.descending.isAscending, isFalse);
+      expect(OrderDirection.descending.isDescending, isTrue);
+      expect(OrderDirection.descending.sqlKeyword, equals('DESC'));
+    });
+
+    test('parse', () {
+      for (var s in ['asc', 'ASC', ' Ascending ', 'up', '+']) {
+        expect(
+          OrderDirection.parse(s),
+          equals(OrderDirection.ascending),
+          reason: 'parse($s)',
+        );
+      }
+
+      for (var s in ['desc', 'DESC', ' Descending ', 'down', '-']) {
+        expect(
+          OrderDirection.parse(s),
+          equals(OrderDirection.descending),
+          reason: 'parse($s)',
+        );
+      }
+
+      expect(OrderDirection.parse(null), isNull);
+      expect(OrderDirection.parse(''), isNull);
+      expect(OrderDirection.parse('   '), isNull);
+      expect(OrderDirection.parse('bogus'), isNull);
+
+      // Round-trip of an `OrderDirection` instance:
+      expect(
+        OrderDirection.parse(OrderDirection.descending),
+        equals(OrderDirection.descending),
+      );
+    });
+
+    test('resolveOrderByID', () {
+      // Unset and no offset: no ordering (the pre-existing behavior).
+      expect(OrderDirection.resolveOrderByID(null, null), isFalse);
+
+      // An `offset` implies the ordering, so the pagination is stable:
+      expect(OrderDirection.resolveOrderByID(null, 0), isTrue);
+      expect(OrderDirection.resolveOrderByID(null, 10), isTrue);
+
+      // An explicit value always wins:
+      expect(OrderDirection.resolveOrderByID(false, 10), isFalse);
+      expect(OrderDirection.resolveOrderByID(true, null), isTrue);
+    });
+  });
+
+  group('compareEntityIDs', () {
+    test('num', () {
+      expect(compareEntityIDs(1, 2), lessThan(0));
+      expect(compareEntityIDs(2, 1), greaterThan(0));
+      expect(compareEntityIDs(2, 2), equals(0));
+      expect(compareEntityIDs(1, 1.5), lessThan(0));
+    });
+
+    test('String', () {
+      expect(compareEntityIDs('a', 'b'), lessThan(0));
+      expect(compareEntityIDs('b', 'a'), greaterThan(0));
+      expect(compareEntityIDs('a', 'a'), equals(0));
+    });
+
+    test('null is ordered last', () {
+      expect(compareEntityIDs(null, null), equals(0));
+      expect(compareEntityIDs(null, 1), greaterThan(0));
+      expect(compareEntityIDs(1, null), lessThan(0));
+    });
+
+    test('mismatched types are undefined (0)', () {
+      expect(compareEntityIDs(1, 'a'), equals(0));
+      expect(compareEntityIDs('a', 1), equals(0));
+    });
+
+    test('sort round-trip', () {
+      var ids = <Object?>[3, null, 1, 2];
+      ids.sort(compareEntityIDs);
+      expect(ids, equals([1, 2, 3, null]));
+    });
+  });
+
+  group('resolveSelectOffset', () {
+    test('no page returns the offset unchanged', () {
+      expect(resolveSelectOffset(), isNull);
+      expect(resolveSelectOffset(offset: 40), equals(40));
+      expect(resolveSelectOffset(offset: 40, limit: 20), equals(40));
+      expect(resolveSelectOffset(offset: 0), equals(0));
+    });
+
+    test('page is 1-based', () {
+      expect(resolveSelectOffset(page: 1, limit: 20), equals(0));
+      expect(resolveSelectOffset(page: 2, limit: 20), equals(20));
+      expect(resolveSelectOffset(page: 3, limit: 20), equals(40));
+      expect(resolveSelectOffset(page: 10, limit: 3), equals(27));
+      expect(resolveSelectOffset(page: 2, limit: 1), equals(1));
+    });
+
+    test('page 1 resolves to offset 0, which activates the ordering', () {
+      var offset = resolveSelectOffset(page: 1, limit: 20);
+      expect(offset, equals(0));
+      // A paginated select must be stable even on the first page:
+      expect(OrderDirection.resolveOrderByID(null, offset), isTrue);
+    });
+
+    test('page requires a positive limit', () {
+      expect(
+        () => resolveSelectOffset(page: 3),
+        throwsA(
+          isA<ArgumentError>().having(
+            (e) => e.message,
+            'message',
+            contains('requires a positive `limit`'),
+          ),
+        ),
+      );
+
+      // No special case for page 1: the rule stays predictable.
+      expect(() => resolveSelectOffset(page: 1), throwsArgumentError);
+
+      // A `limit` of 0 means "no limit", so it is not a page size:
+      expect(() => resolveSelectOffset(page: 2, limit: 0), throwsArgumentError);
+      expect(
+        () => resolveSelectOffset(page: 2, limit: -1),
+        throwsArgumentError,
+      );
+    });
+
+    test('page and offset are mutually exclusive', () {
+      expect(
+        () => resolveSelectOffset(page: 3, offset: 100, limit: 20),
+        throwsA(
+          isA<ArgumentError>().having(
+            (e) => e.message,
+            'message',
+            contains('mutually exclusive'),
+          ),
+        ),
+      );
+
+      // Even when they would agree, and even for an offset of 0:
+      expect(
+        () => resolveSelectOffset(page: 3, offset: 40, limit: 20),
+        throwsArgumentError,
+      );
+      expect(
+        () => resolveSelectOffset(page: 1, offset: 0, limit: 20),
+        throwsArgumentError,
+      );
+    });
+
+    test('page must be >= 1', () {
+      expect(
+        () => resolveSelectOffset(page: 0, limit: 20),
+        throwsA(
+          isA<ArgumentError>().having(
+            (e) => e.message,
+            'message',
+            contains('1-based'),
+          ),
+        ),
+      );
+
+      expect(
+        () => resolveSelectOffset(page: -1, limit: 20),
+        throwsArgumentError,
+      );
+    });
+  });
+
+  group('applySelectOrderAndPagination', () {
+    // Deliberately unsorted, so an ordered result can't pass by accident:
+    final ids = <Object?>[3, 1, 5, 2, 4];
+
+    test('no ordering and no pagination is a pass-through', () {
+      expect(_ids(_apply(ids)), equals(ids));
+    });
+
+    test('orderDirection alone is ignored', () {
+      expect(
+        _ids(_apply(ids, orderDirection: OrderDirection.descending)),
+        equals(ids),
+      );
+    });
+
+    test('orderByID ascending/descending', () {
+      expect(_ids(_apply(ids, orderByID: true)), equals([1, 2, 3, 4, 5]));
+
+      expect(
+        _ids(
+          _apply(
+            ids,
+            orderByID: true,
+            orderDirection: OrderDirection.ascending,
+          ),
+        ),
+        equals([1, 2, 3, 4, 5]),
+      );
+
+      expect(
+        _ids(
+          _apply(
+            ids,
+            orderByID: true,
+            orderDirection: OrderDirection.descending,
+          ),
+        ),
+        equals([5, 4, 3, 2, 1]),
+      );
+    });
+
+    test('offset implies the ordering', () {
+      expect(_ids(_apply(ids, offset: 2)), equals([3, 4, 5]));
+
+      expect(
+        _ids(_apply(ids, offset: 1, orderDirection: OrderDirection.descending)),
+        equals([4, 3, 2, 1]),
+      );
+    });
+
+    test('orderByID: false opts out of the implied ordering', () {
+      // Skips 2 elements of the natural (unordered) sequence:
+      expect(_ids(_apply(ids, offset: 2, orderByID: false)), equals([5, 2, 4]));
+    });
+
+    test('offset + limit', () {
+      expect(_ids(_apply(ids, offset: 1, limit: 2)), equals([2, 3]));
+
+      expect(
+        _ids(
+          _apply(
+            ids,
+            offset: 1,
+            limit: 2,
+            orderDirection: OrderDirection.descending,
+          ),
+        ),
+        equals([4, 3]),
+      );
+    });
+
+    test('offset past the end returns empty', () {
+      expect(_ids(_apply(ids, offset: 5)), isEmpty);
+      expect(_ids(_apply(ids, offset: 100)), isEmpty);
+    });
+
+    test('limit greater than the length returns all', () {
+      expect(
+        _ids(_apply(ids, orderByID: true, limit: 100)),
+        equals([1, 2, 3, 4, 5]),
+      );
+    });
+
+    test('non-positive offset is ignored, but still implies the ordering', () {
+      expect(_ids(_apply(ids, offset: 0)), equals([1, 2, 3, 4, 5]));
+      expect(_ids(_apply(ids, offset: -1)), equals([1, 2, 3, 4, 5]));
+    });
+
+    test('zeroLimitIsUnlimited', () {
+      // In-memory selects: a `limit` of 0 returns an empty result.
+      expect(_ids(_apply(ids, limit: 0)), isEmpty);
+
+      // Generated SQL: a `limit` of 0 emits no `LIMIT` clause.
+      expect(
+        _ids(_apply(ids, limit: 0, zeroLimitIsUnlimited: true)),
+        equals(ids),
+      );
+    });
+
+    test('null IDs are ordered last', () {
+      expect(
+        _ids(_apply(<Object?>[2, null, 1], orderByID: true)),
+        equals([1, 2, null]),
+      );
+
+      expect(
+        _ids(
+          _apply(
+            <Object?>[2, null, 1],
+            orderByID: true,
+            orderDirection: OrderDirection.descending,
+          ),
+        ),
+        equals([null, 2, 1]),
+      );
+    });
+
+    test('String IDs', () {
+      expect(
+        _ids(_apply(<Object?>['c', 'a', 'b'], offset: 1)),
+        equals(['b', 'c']),
+      );
+    });
+  });
+
+  group('SQLDialect', () {
+    // The dialects actually declared by the adapters:
+    const generic = SQLDialect('generic');
+    const postgres = SQLDialect('PostgreSQL', elementQuote: '"');
+    const mysql = SQLDialect(
+      'MySQL',
+      elementQuote: '`',
+      offsetRequiresLimit: true,
+    );
+
+    test('defaults', () {
+      expect(generic.offsetRequiresLimit, isFalse);
+      expect(postgres.offsetRequiresLimit, isFalse);
+      expect(mysql.offsetRequiresLimit, isTrue);
+      expect(generic.offsetMaxLimitValue, equals('18446744073709551615'));
+    });
+
+    test('limitOffsetSQL: no clause', () {
+      for (var d in [generic, postgres, mysql]) {
+        expect(d.limitOffsetSQL(), equals(''), reason: d.name);
+        expect(
+          d.limitOffsetSQL(limit: 0, offset: 0),
+          equals(''),
+          reason: d.name,
+        );
+        expect(
+          d.limitOffsetSQL(limit: -1, offset: -1),
+          equals(''),
+          reason: d.name,
+        );
+      }
+    });
+
+    test('limitOffsetSQL: limit only', () {
+      for (var d in [generic, postgres, mysql]) {
+        expect(
+          d.limitOffsetSQL(limit: 10),
+          equals(' LIMIT 10'),
+          reason: d.name,
+        );
+      }
+    });
+
+    test('limitOffsetSQL: limit and offset', () {
+      for (var d in [generic, postgres, mysql]) {
+        expect(
+          d.limitOffsetSQL(limit: 10, offset: 20),
+          equals(' LIMIT 10 OFFSET 20'),
+          reason: d.name,
+        );
+      }
+    });
+
+    test('limitOffsetSQL: offset only', () {
+      expect(generic.limitOffsetSQL(offset: 20), equals(' OFFSET 20'));
+      expect(postgres.limitOffsetSQL(offset: 20), equals(' OFFSET 20'));
+
+      // MySQL can't parse a standalone `OFFSET`:
+      expect(
+        mysql.limitOffsetSQL(offset: 20),
+        equals(' LIMIT 18446744073709551615 OFFSET 20'),
+      );
+    });
+
+    test('orderBySQL', () {
+      expect(postgres.orderBySQL('u', 'id'), equals(' ORDER BY "u"."id" ASC'));
+
+      expect(
+        postgres.orderBySQL('u', 'id', direction: OrderDirection.descending),
+        equals(' ORDER BY "u"."id" DESC'),
+      );
+
+      expect(
+        mysql.orderBySQL('u', 'user_id'),
+        equals(' ORDER BY `u`.`user_id` ASC'),
+      );
+
+      // The `generic` dialect has no element quote:
+      expect(generic.orderBySQL('u', 'id'), equals(' ORDER BY u.id ASC'));
+    });
+  });
+}
diff --git a/test/bones_api_entity_test.dart b/test/bones_api_entity_test.dart
index f94db84..686ce07 100644
--- a/test/bones_api_entity_test.dart
+++ b/test/bones_api_entity_test.dart
@@ -1602,6 +1602,87 @@ void main() {
         expect(user, isNull);
       }
     });
+
+    test('SetEntityRepository: offset/orderByID/orderDirection', () async {
+      // A dedicated repository, so the group's shared ones are untouched:
+      var repository = SetEntityRepository<Role>('role', roleEntityHandler)
+        ..ensureInitialized();
+
+      addTearDown(repository.close);
+
+      var ids = <int>[];
+      for (var i = 1; i <= 5; ++i) {
+        var role = Role(i.isEven ? RoleType.admin : RoleType.guest);
+        ids.add((await repository.store(role)) as int);
+      }
+
+      expect(ids, equals([1, 2, 3, 4, 5]));
+
+      List<Object?> selectIDs({
+        int? limit,
+        int? offset,
+        bool? orderByID,
+        OrderDirection? orderDirection,
+      }) =>
+          repository
+              .select(
+                ConditionANY(),
+                limit: limit,
+                offset: offset,
+                orderByID: orderByID,
+                orderDirection: orderDirection,
+              )
+              .map((e) => e.id)
+              .toList();
+
+      // Baseline: unchanged, no ordering applied.
+      expect(selectIDs(), equals(ids));
+      expect(selectIDs(limit: 2), equals([1, 2]));
+
+      // `orderDirection` alone is ignored:
+      expect(selectIDs(orderDirection: OrderDirection.descending), equals(ids));
+
+      expect(selectIDs(orderByID: true), equals([1, 2, 3, 4, 5]));
+      expect(
+        selectIDs(orderByID: true, orderDirection: OrderDirection.descending),
+        equals([5, 4, 3, 2, 1]),
+      );
+
+      // `offset` implies the ordering:
+      expect(selectIDs(offset: 2), equals([3, 4, 5]));
+      expect(selectIDs(offset: 2, limit: 2), equals([3, 4]));
+      expect(
+        selectIDs(
+          offset: 1,
+          limit: 2,
+          orderDirection: OrderDirection.descending,
+        ),
+        equals([4, 3]),
+      );
+      expect(selectIDs(offset: 5), isEmpty);
+
+      // `selectIDsBy` and `selectAll` honor the same options:
+      expect(
+        repository.selectIDsBy<int>(ConditionANY(), offset: 2, limit: 2),
+        equals([3, 4]),
+      );
+
+      expect(
+        (await repository.selectAll(
+          orderByID: true,
+          orderDirection: OrderDirection.descending,
+        )).map((e) => e.id),
+        equals([5, 4, 3, 2, 1]),
+      );
+
+      expect(
+        (await repository.selectAll(offset: 3)).map((e) => e.id),
+        equals([4, 5]),
+      );
+
+      // A `limit` of 0 keeps meaning "no limit" for this repository:
+      expect(selectIDs(limit: 0), equals(ids));
+    });
   });
 
   group('SQLEntityRepository[memory]', () {
diff --git a/test/bones_api_test.reflection.g.dart b/test/bones_api_test.reflection.g.dart
index b094cb4..8eca443 100644
--- a/test/bones_api_test.reflection.g.dart
+++ b/test/bones_api_test.reflection.g.dart
@@ -1,6 +1,6 @@
 //
 // GENERATED CODE - DO NOT MODIFY BY HAND!
-// BUILDER: reflection_factory/2.7.5
+// BUILDER: reflection_factory/2.8.1
 // BUILD COMMAND: dart run build_runner build
 //
 
@@ -22,7 +22,7 @@ typedef __TI<T> = TypeInfo<T>;
 typedef __PR = ParameterReflection;
 
 mixin __ReflectionMixin {
-  static final Version _version = Version.parse('2.7.5');
+  static final Version _version = Version.parse('2.8.1');
 
   Version get reflectionFactoryVersion => _version;
 
diff --git a/test/bones_api_test_entities.reflection.g.dart b/test/bones_api_test_entities.reflection.g.dart
index b4775da..8924b8b 100644
--- a/test/bones_api_test_entities.reflection.g.dart
+++ b/test/bones_api_test_entities.reflection.g.dart
@@ -1,6 +1,6 @@
 //
 // GENERATED CODE - DO NOT MODIFY BY HAND!
-// BUILDER: reflection_factory/2.7.5
+// BUILDER: reflection_factory/2.8.1
 // BUILD COMMAND: dart run build_runner build
 //
 
@@ -22,7 +22,7 @@ typedef __TI<T> = TypeInfo<T>;
 typedef __PR = ParameterReflection;
 
 mixin __ReflectionMixin {
-  static final Version _version = Version.parse('2.7.5');
+  static final Version _version = Version.parse('2.8.1');
 
   Version get reflectionFactoryVersion => _version;
 
diff --git a/test/bones_api_test_entities_orders.reflection.g.dart b/test/bones_api_test_entities_orders.reflection.g.dart
index f64f1b2..818db5a 100644
--- a/test/bones_api_test_entities_orders.reflection.g.dart
+++ b/test/bones_api_test_entities_orders.reflection.g.dart
@@ -1,6 +1,6 @@
 //
 // GENERATED CODE - DO NOT MODIFY BY HAND!
-// BUILDER: reflection_factory/2.7.5
+// BUILDER: reflection_factory/2.8.1
 // BUILD COMMAND: dart run build_runner build
 //
 
@@ -22,7 +22,7 @@ typedef __TI<T> = TypeInfo<T>;
 typedef __PR = ParameterReflection;
 
 mixin __ReflectionMixin {
-  static final Version _version = Version.parse('2.7.5');
+  static final Version _version = Version.parse('2.8.1');
 
   Version get reflectionFactoryVersion => _version;
 
diff --git a/test/bones_api_test_modules.reflection.g.dart b/test/bones_api_test_modules.reflection.g.dart
index f2f8bc9..8bf90d8 100644
--- a/test/bones_api_test_modules.reflection.g.dart
+++ b/test/bones_api_test_modules.reflection.g.dart
@@ -1,6 +1,6 @@
 //
 // GENERATED CODE - DO NOT MODIFY BY HAND!
-// BUILDER: reflection_factory/2.7.5
+// BUILDER: reflection_factory/2.8.1
 // BUILD COMMAND: dart run build_runner build
 //
 
@@ -22,7 +22,7 @@ typedef __TI<T> = TypeInfo<T>;
 typedef __PR = ParameterReflection;
 
 mixin __ReflectionMixin {
-  static final Version _version = Version.parse('2.7.5');
+  static final Version _version = Version.parse('2.8.1');
 
   Version get reflectionFactoryVersion => _version;
 
diff --git a/test/bones_api_test_utils_test.reflection.g.dart b/test/bones_api_test_utils_test.reflection.g.dart
index 5333c9b..70524d9 100644
--- a/test/bones_api_test_utils_test.reflection.g.dart
+++ b/test/bones_api_test_utils_test.reflection.g.dart
@@ -1,6 +1,6 @@
 //
 // GENERATED CODE - DO NOT MODIFY BY HAND!
-// BUILDER: reflection_factory/2.7.5
+// BUILDER: reflection_factory/2.8.1
 // BUILD COMMAND: dart run build_runner build
 //
 
@@ -22,7 +22,7 @@ typedef __TI<T> = TypeInfo<T>;
 typedef __PR = ParameterReflection;
 
 mixin __ReflectionMixin {
-  static final Version _version = Version.parse('2.7.5');
+  static final Version _version = Version.parse('2.8.1');
 
   Version get reflectionFactoryVersion => _version;