@reventlessdev/rescript-pulumi-aws 3.0.0-alpha.4 → 3.0.0-alpha.5

package/CHANGELOG.md

@@ -3,6 +3,13 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.5 (2026-08-23)
+
+### Bug Fixes
+
+* **querydb:** serve the previous page instead of refusing it ([48341c9](https://github.com/ReventlessDev/reventless-core/commit/48341c9f61b5155b441deeb0edc9abf461948346))
+
+
 # 3.0.0-alpha.4 (2026-08-23)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/rescript-pulumi-aws",
-  "version": "3.0.0-alpha.4",
+  "version": "3.0.0-alpha.5",
   "description": "ReScript bindings for @pulumi/aws",
   "license": "Apache-2.0",
   "jest": {

package/src/AppSync/AppSync_Resolver_Functions.res

@@ -563,6 +563,18 @@ saying whether a filter was pushed down.
 let pageWindowBudget = (~filtered: string) =>
   `(${filtered} ? (_first > 1000 ? _first : 1000) : _first + _from)`
 
+/**
+The same budget for the full-list door, which may also read backward.
+
+A backward page is the slice `[_from, _upTo)` of the window, so the read has to
+reach `_upTo` rows into it — `_first + _from` would stop short and hand back a
+page with its tail missing.
+*/
+let listPageWindowBudget = {
+  let need = "(_backward ? _upTo : _first + _from)"
+  `(parts.length > 0 ? (${need} > 1000 ? ${need} : 1000) : ${need})`
+}
+
 /**
 Decodes `after` into the window it names (`t`, the token opening it) and the row's
 index among that window's matches (`n`). Pre-window cursors carried
@@ -597,21 +609,74 @@ let cursorPathGuard = `
     util.error('This cursor belongs to a different read of this list; restart from the first page.', 'CursorPathMismatch');
   }`
 
+/**
+The full-list door's cursor decode, which unlike `cursorDecode` may run backward.
+
+A `{t, n}` cursor names a position INSIDE a read window, and a window is re-read
+from its own token — which forward paging already relies on to resume mid-window.
+Backward is the same move in the other direction: re-read the window `before`
+names and cut the page that ends at `n`, `[n - first, n)`. No new cursor shape, no
+index, and no assumption forward paging does not already make.
+
+What it cannot do is cross into an EARLIER window: DynamoDB's continuation chain
+walks one way, so a window cannot name the one before it. `_upTo <= 0` with a
+non-null window is that case, and it is the only one still refused.
+
+Declares `_first` (the response's slicing needs it before `connectionPageResponse`
+would have declared it, so that one omits it here).
+*/
+let listCursorPreamble = `
+  const _first = ctx.args.first ?? 50;
+  let _window = null;
+  let _from = 0;
+  let _cursorPath = null;
+  let _backward = false;
+  let _upTo = -1;
+  if (ctx.args.before != null && ctx.args.before !== '') {
+    const _c = JSON.parse(util.base64Decode(ctx.args.before));
+    _window = (_c.t !== undefined ? _c.t : _c.token) ?? null;
+    _cursorPath = _c.p ?? 's';
+    _backward = true;
+    _upTo = _c.n !== undefined ? _c.n : 0;
+    _from = (_upTo - _first) > 0 ? (_upTo - _first) : 0;
+  } else if (ctx.args.after != null && ctx.args.after !== '') {
+    const _c = JSON.parse(util.base64Decode(ctx.args.after));
+    _window = (_c.t !== undefined ? _c.t : _c.token) ?? null;
+    _from = _c.n !== undefined ? _c.n + 1 : 0;
+    _cursorPath = _c.p ?? 's';
+  }`
+
 /**
 Cuts the requested page out of the returned window. Expects `items` (sorted, if the
 door sorts) plus `_window` / `_from` from `cursorDecode`. `pathExpr` is the JS
 expression naming which read minted these cursors, for a door that has two.
+
+`bidirectional` is the full-list door, whose page may have been cut backward: it
+reads `_backward` / `_upTo` from `listCursorPreamble` and takes `_first` from
+there rather than declaring its own.
 */
-let connectionPageResponse = (~pathExpr: option<string>=?) => {
+let connectionPageResponse = (~pathExpr: option<string>=?, ~bidirectional: bool=false) => {
   let tag = switch pathExpr {
   | None => ""
   | Some(e) => `, p: ${e}`
   }
-  `
-  const _first = ctx.args.first ?? 50;
+  let firstDecl = bidirectional ? "" : "\n  const _first = ctx.args.first ?? 50;"
+  let slice = bidirectional
+    ? `
+  const _rest = _backward ? items.slice(_from, _upTo) : items.slice(_from);
+  const _page = _backward ? _rest : _rest.slice(0, _first);
+  // A backward page was cut from ahead, so a next page provably exists — the one
+  // the caller came from — whatever this window's tail looks like.
+  const _more = _backward ? true : _rest.length > _first;`
+    : `
   const _rest = items.slice(_from);
   const _page = _rest.slice(0, _first);
-  const _more = _rest.length > _first;
+  const _more = _rest.length > _first;`
+  // Only what the door can actually serve. `!!ctx.args.after` said "a page
+  // precedes this one", which is a different claim: at a window boundary one does
+  // and this door cannot reach it, so the client drew a Prev that always errored.
+  let hasPrevious = bidirectional ? "_from > 0" : "!!ctx.args.after"
+  `${firstDecl}${slice}
   const _next = ctx.result?.nextToken ?? null;
   const _lastIndex = _page.length - 1;
   // A row's cursor names its own position. The last row of a page that closes its
@@ -632,7 +697,7 @@ let connectionPageResponse = (~pathExpr: option<string>=?) => {
     edges,
     pageInfo: {
       hasNextPage: _more || !!_next,
-      hasPreviousPage: !!ctx.args.after,
+      hasPreviousPage: ${hasPrevious},
       startCursor: edges.length > 0 ? edges[0].cursor : _boundary,
       endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : _boundary,
     },
@@ -1039,7 +1104,7 @@ ${switch retiredValues {
   const req = _exempt
     ? {
         operation: 'Scan',
-        limit: ${pageWindowBudget(~filtered="parts.length > 0")},
+        limit: ${listPageWindowBudget},
         nextToken: _window,
       }
     : {
@@ -1050,14 +1115,14 @@ ${switch retiredValues {
           expressionNames: { '#owner': '${field}' },
           expressionValues: { ':owner': util.dynamodb.toDynamoDB(_sub) },
         },
-        limit: ${pageWindowBudget(~filtered="parts.length > 0")},
+        limit: ${listPageWindowBudget},
         nextToken: _window,
         scanIndexForward: !(_indexOrdered && ctx.args.orderBy.direction === 'DESC'),
       };`
   | _ => `
   const req = {
     operation: 'Scan',
-    limit: ${pageWindowBudget(~filtered="parts.length > 0")},
+    limit: ${listPageWindowBudget},
     nextToken: _window,
   };`
   }
@@ -1070,16 +1135,18 @@ ${switch retiredValues {
   const _indexOrdered = ${indexOrderedExpr};`
   }
   let pageResponse = switch ownerIndex {
-  | None => connectionPageResponse()
-  | Some(_) => connectionPageResponse(~pathExpr="_path")
+  | None => connectionPageResponse(~bidirectional=true)
+  | Some(_) => connectionPageResponse(~pathExpr="_path", ~bidirectional=true)
   }
   `${importUtil}
 export function request(ctx) {
-  // Scan cannot page backward (ScanIndexForward is Query-only). Fail loud rather than
-  // silently returning the forward page. The ordered {single}Items connection
-  // (queryItemsWithSortConditions) supports last/before — direct backward callers there.
-  if (ctx.args.before != null || ctx.args.last != null) {
-    util.error('Backward pagination (last/before) is not supported on full-list connections; use first/after.', 'UnsupportedPagination');
+  // 'before' IS served — the page is cut backward out of the window the cursor
+  // names. 'last' is not: "the last N rows of the list" needs the end of the
+  // list, which a forward-only Scan cursor cannot reach. The ordered
+  // {single}Items connection (queryItemsWithSortConditions) has a real keyset
+  // cursor and honours both — direct callers who need 'last' there.
+  if (ctx.args.last != null) {
+    util.error('last is not supported on full-list connections; page backward with first and before.', 'UnsupportedPagination');
   }
   const filter = ctx.args.filter ?? {};
   const names = {};
@@ -1104,8 +1171,14 @@ export function request(ctx) {
     });
     parts.push('#id IN (' + placeholders.join(', ') + ')');
   }${filterClauses}${rangeClauses}${requireAttributeClause}${ownerClause}${retiredClause}
-${cursorDecode(~args="ctx.args")}${requestPathGuard}
-  const _first = ctx.args.first ?? 50;${requestOperation}
+${listCursorPreamble}${requestPathGuard}
+  // The one page a cursor cannot reach: it begins in an earlier window, and a
+  // continuation token cannot name the one before it. Refused by itself rather
+  // than folded into the 'last' guard, because the two are different limits and a
+  // caller can act on this one (page forward from the start).
+  if (_backward && _upTo <= 0 && _window !== null) {
+    util.error('The previous page begins in an earlier read window, which this cursor cannot name; page forward from the start.', 'UnsupportedPagination');
+  }${requestOperation}
   if (parts.length > 0) {
     req.filter = {
       expression: parts.join(' AND '),
@@ -1117,9 +1190,7 @@ ${cursorDecode(~args="ctx.args")}${requestPathGuard}
 }
 export function response(ctx) {
   if (ctx.error) util.error(ctx.error.message, ctx.error.type);
-  let items = ctx.result?.items ?? [];${responsePathPreamble}${sortBlock}${cursorDecode(
-      ~args="ctx.args",
-    )}${pageResponse}
+  let items = ctx.result?.items ?? [];${responsePathPreamble}${sortBlock}${listCursorPreamble}${pageResponse}
 }
 `->Pulumi.Input.make
 }

package/src/AppSync/AppSync_Resolver_Functions.res.mjs

@@ -392,6 +392,10 @@ function pageWindowBudget(filtered) {
   return `(` + filtered + ` ? (_first > 1000 ? _first : 1000) : _first + _from)`;
 }
 
+let need = "(_backward ? _upTo : _first + _from)";
+
+let listPageWindowBudget = `(parts.length > 0 ? (` + need + ` > 1000 ? ` + need + ` : 1000) : ` + need + `)`;
+
 function cursorDecode(args) {
   return `
   let _window = null;
@@ -410,13 +414,42 @@ let cursorPathGuard = `
     util.error('This cursor belongs to a different read of this list; restart from the first page.', 'CursorPathMismatch');
   }`;
 
-function connectionPageResponse(pathExpr) {
-  let tag = pathExpr !== undefined ? `, p: ` + pathExpr : "";
-  return `
+let listCursorPreamble = `
   const _first = ctx.args.first ?? 50;
+  let _window = null;
+  let _from = 0;
+  let _cursorPath = null;
+  let _backward = false;
+  let _upTo = -1;
+  if (ctx.args.before != null && ctx.args.before !== '') {
+    const _c = JSON.parse(util.base64Decode(ctx.args.before));
+    _window = (_c.t !== undefined ? _c.t : _c.token) ?? null;
+    _cursorPath = _c.p ?? 's';
+    _backward = true;
+    _upTo = _c.n !== undefined ? _c.n : 0;
+    _from = (_upTo - _first) > 0 ? (_upTo - _first) : 0;
+  } else if (ctx.args.after != null && ctx.args.after !== '') {
+    const _c = JSON.parse(util.base64Decode(ctx.args.after));
+    _window = (_c.t !== undefined ? _c.t : _c.token) ?? null;
+    _from = _c.n !== undefined ? _c.n + 1 : 0;
+    _cursorPath = _c.p ?? 's';
+  }`;
+
+function connectionPageResponse(pathExpr, bidirectionalOpt) {
+  let bidirectional = bidirectionalOpt !== undefined ? bidirectionalOpt : false;
+  let tag = pathExpr !== undefined ? `, p: ` + pathExpr : "";
+  let firstDecl = bidirectional ? "" : "\n  const _first = ctx.args.first ?? 50;";
+  let slice = bidirectional ? `
+  const _rest = _backward ? items.slice(_from, _upTo) : items.slice(_from);
+  const _page = _backward ? _rest : _rest.slice(0, _first);
+  // A backward page was cut from ahead, so a next page provably exists — the one
+  // the caller came from — whatever this window's tail looks like.
+  const _more = _backward ? true : _rest.length > _first;` : `
   const _rest = items.slice(_from);
   const _page = _rest.slice(0, _first);
-  const _more = _rest.length > _first;
+  const _more = _rest.length > _first;`;
+  let hasPrevious = bidirectional ? "_from > 0" : "!!ctx.args.after";
+  return firstDecl + slice + `
   const _next = ctx.result?.nextToken ?? null;
   const _lastIndex = _page.length - 1;
   // A row's cursor names its own position. The last row of a page that closes its
@@ -437,7 +470,7 @@ function connectionPageResponse(pathExpr) {
     edges,
     pageInfo: {
       hasNextPage: _more || !!_next,
-      hasPreviousPage: !!ctx.args.after,
+      hasPreviousPage: ` + hasPrevious + `,
       startCursor: edges.length > 0 ? edges[0].cursor : _boundary,
       endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : _boundary,
     },
@@ -447,7 +480,7 @@ function connectionPageResponse(pathExpr) {
 let indexConnectionResponseCode = `
 export function response(ctx) {
   if (ctx.error) util.error(ctx.error.message, ctx.error.type);
-  const items = ctx.result?.items ?? [];` + cursorDecode("ctx.args") + connectionPageResponse(undefined) + `
+  const items = ctx.result?.items ?? [];` + cursorDecode("ctx.args") + connectionPageResponse(undefined, undefined) + `
 }`;
 
 let indexBackwardPagingGuard = `
@@ -686,7 +719,7 @@ function listAllItemsConnection(labelField, filterFieldsOpt, rangeFieldsOpt, sor
   const req = _exempt
     ? {
         operation: 'Scan',
-        limit: ` + (`(` + "parts.length > 0" + ` ? (_first > 1000 ? _first : 1000) : _first + _from)`) + `,
+        limit: ` + listPageWindowBudget + `,
         nextToken: _window,
       }
     : {
@@ -697,33 +730,35 @@ function listAllItemsConnection(labelField, filterFieldsOpt, rangeFieldsOpt, sor
           expressionNames: { '#owner': '` + ownerField + `' },
           expressionValues: { ':owner': util.dynamodb.toDynamoDB(_sub) },
         },
-        limit: ` + (`(` + "parts.length > 0" + ` ? (_first > 1000 ? _first : 1000) : _first + _from)`) + `,
+        limit: ` + listPageWindowBudget + `,
         nextToken: _window,
         scanIndexForward: !(_indexOrdered && ctx.args.orderBy.direction === 'DESC'),
       };` : `
   const req = {
     operation: 'Scan',
-    limit: ` + (`(` + "parts.length > 0" + ` ? (_first > 1000 ? _first : 1000) : _first + _from)`) + `,
+    limit: ` + listPageWindowBudget + `,
     nextToken: _window,
   };`
     ) : `
   const req = {
     operation: 'Scan',
-    limit: ` + (`(` + "parts.length > 0" + ` ? (_first > 1000 ? _first : 1000) : _first + _from)`) + `,
+    limit: ` + listPageWindowBudget + `,
     nextToken: _window,
   };`;
   let requestPathGuard = Stdlib_Option.isSome(ownerIndex$1) ? cursorPathGuard : "";
   let responsePathPreamble = ownerIndex$1 !== undefined ? ownerIdentityPreamble + `
   const _path = _exempt ? 's' : 'q';
   const _indexOrdered = ` + indexOrderedExpr + `;` : "";
-  let pageResponse = ownerIndex$1 !== undefined ? connectionPageResponse("_path") : connectionPageResponse(undefined);
+  let pageResponse = ownerIndex$1 !== undefined ? connectionPageResponse("_path", true) : connectionPageResponse(undefined, true);
   return importUtil + `
 export function request(ctx) {
-  // Scan cannot page backward (ScanIndexForward is Query-only). Fail loud rather than
-  // silently returning the forward page. The ordered {single}Items connection
-  // (queryItemsWithSortConditions) supports last/before — direct backward callers there.
-  if (ctx.args.before != null || ctx.args.last != null) {
-    util.error('Backward pagination (last/before) is not supported on full-list connections; use first/after.', 'UnsupportedPagination');
+  // 'before' IS served — the page is cut backward out of the window the cursor
+  // names. 'last' is not: "the last N rows of the list" needs the end of the
+  // list, which a forward-only Scan cursor cannot reach. The ordered
+  // {single}Items connection (queryItemsWithSortConditions) has a real keyset
+  // cursor and honours both — direct callers who need 'last' there.
+  if (ctx.args.last != null) {
+    util.error('last is not supported on full-list connections; page backward with first and before.', 'UnsupportedPagination');
   }
   const filter = ctx.args.filter ?? {};
   const names = {};
@@ -748,8 +783,14 @@ export function request(ctx) {
     });
     parts.push('#id IN (' + placeholders.join(', ') + ')');
   }` + filterClauses + rangeClauses + requireAttributeClause + ownerClause + retiredClause + `
-` + cursorDecode("ctx.args") + requestPathGuard + `
-  const _first = ctx.args.first ?? 50;` + requestOperation + `
+` + listCursorPreamble + requestPathGuard + `
+  // The one page a cursor cannot reach: it begins in an earlier window, and a
+  // continuation token cannot name the one before it. Refused by itself rather
+  // than folded into the 'last' guard, because the two are different limits and a
+  // caller can act on this one (page forward from the start).
+  if (_backward && _upTo <= 0 && _window !== null) {
+    util.error('The previous page begins in an earlier read window, which this cursor cannot name; page forward from the start.', 'UnsupportedPagination');
+  }` + requestOperation + `
   if (parts.length > 0) {
     req.filter = {
       expression: parts.join(' AND '),
@@ -761,7 +802,7 @@ export function request(ctx) {
 }
 export function response(ctx) {
   if (ctx.error) util.error(ctx.error.message, ctx.error.type);
-  let items = ctx.result?.items ?? [];` + responsePathPreamble + sortBlock + cursorDecode("ctx.args") + pageResponse + `
+  let items = ctx.result?.items ?? [];` + responsePathPreamble + sortBlock + listCursorPreamble + pageResponse + `
 }
 `;
 }
@@ -1289,8 +1330,10 @@ export {
   queryByIndexDeletable,
   queryByIndexSort,
   pageWindowBudget,
+  listPageWindowBudget,
   cursorDecode,
   cursorPathGuard,
+  listCursorPreamble,
   connectionPageResponse,
   indexConnectionResponseCode,
   indexBackwardPagingGuard,

package/tests/AppSync_Resolver_FunctionsTest.mjs

@@ -209,6 +209,11 @@ describe('listAllItemsConnection', () => {
       expect(req2.nextToken).toBe('TOK1')
     })
 
+    // `hasPreviousPage` reports what this door can SERVE, not what exists. This
+    // cursor opens a new window at position 0, so the page before it lies in the
+    // previous window — real, and unreachable, because a continuation token
+    // cannot name the one before it. Claiming it is what drew a Prev button that
+    // always errored.
     test('final page (nextToken null) closes the connection', () => {
       const after = util.base64Encode(JSON.stringify({ t: 'TOK1', n: -1 }))
       const r = response(makeCtx({
@@ -216,7 +221,7 @@ describe('listAllItemsConnection', () => {
         result: { items: [{ id: 'z' }], nextToken: null },
       }))
       expect(r.pageInfo.hasNextPage).toBe(false)
-      expect(r.pageInfo.hasPreviousPage).toBe(true)
+      expect(r.pageInfo.hasPreviousPage).toBe(false)
     })
 
     // A filtered Scan can return an empty page while nextToken is still set. The
@@ -239,15 +244,55 @@ describe('listAllItemsConnection', () => {
       expect(r.pageInfo.hasNextPage).toBe(false)
     })
 
-    // Scan cannot page backward; last/before must error, not mislead.
-    test('request rejects backward pagination (before)', () => {
-      expect(() => request(makeCtx({ args: { before: 'x' } }))).toThrow(
-        'Backward pagination',
+    // `before` is served by re-reading the window the cursor names and cutting
+    // the page that ends at it. `last` is not: the last N rows of the list needs
+    // the END of the list, which a forward-only cursor cannot reach.
+    test('request rejects `last`, which needs the end of the list', () => {
+      expect(() => request(makeCtx({ args: { last: 5 } }))).toThrow('last is not supported')
+    })
+
+    test('a backward page is the page that precedes it, exactly', () => {
+      const items = Array.from({ length: 25 }, (_, i) => ({ id: 'r' + i }))
+      const page1 = response(makeCtx({ args: { first: 10 }, result: { items, nextToken: null } }))
+      const fwd = { args: { first: 10, after: page1.pageInfo.endCursor } }
+      const page2 = response(makeCtx({ ...fwd, result: { items, nextToken: null } }))
+      expect(page2.edges.map(e => e.node.id)).toEqual(items.slice(10, 20).map(i => i.id))
+
+      const back = { args: { first: 10, before: page2.pageInfo.startCursor } }
+      const prev = response(makeCtx({ ...back, result: { items, nextToken: null } }))
+      expect(prev.edges.map(e => e.node.id)).toEqual(page1.edges.map(e => e.node.id))
+      // Cut from ahead, so a next page provably exists — the one we came from.
+      expect(prev.pageInfo.hasNextPage).toBe(true)
+      expect(prev.pageInfo.hasPreviousPage).toBe(false)
+    })
+
+    // The read must reach `_upTo` rows into the window, not `first + from`, or the
+    // backward slice comes back with its tail missing.
+    test('a backward read examines the window as deep as the page it cuts', () => {
+      const before = util.base64Encode(JSON.stringify({ t: null, n: 30 }))
+      expect(request(makeCtx({ args: { first: 10, before } })).limit).toBe(30)
+    })
+
+    test('the window a backward cursor names is the one re-read', () => {
+      const before = util.base64Encode(JSON.stringify({ t: 'W7', n: 30 }))
+      expect(request(makeCtx({ args: { first: 10, before } })).nextToken).toBe('W7')
+    })
+
+    // The one page still out of reach, and the only case left refused.
+    test('a previous page in an earlier window is refused, and says which limit', () => {
+      const before = util.base64Encode(JSON.stringify({ t: 'W2', n: 0 }))
+      expect(() => request(makeCtx({ args: { first: 10, before } }))).toThrow(
+        'earlier read window',
       )
     })
 
-    test('request rejects backward pagination (last)', () => {
-      expect(() => request(makeCtx({ args: { last: 5 } }))).toThrow('Backward pagination')
+    // At the very start there is no earlier window to be unable to name, so a
+    // short backward page is served rather than refused.
+    test('a backward page at the start of the first window is served, not refused', () => {
+      const items = Array.from({ length: 10 }, (_, i) => ({ id: 'r' + i }))
+      const before = util.base64Encode(JSON.stringify({ t: null, n: 3 }))
+      const r = response(makeCtx({ args: { first: 10, before }, result: { items, nextToken: null } }))
+      expect(r.edges.map(e => e.node.id)).toEqual(['r0', 'r1', 'r2'])
     })
 
     // Cursors minted before the read window existed named the following window.
@@ -1025,16 +1070,37 @@ describe('listAllItemsConnection — owner scoping', () => {
     })
   })
 
-  // Backward paging stays refused on both branches: a Query can walk backward,
-  // but the `{t, n}` cursor is DynamoDB's forward-only continuation token, and a
-  // door must not advertise what its cursor cannot honour.
+  // Backward paging works the same way on both branches, and for the same reason:
+  // it re-reads the window the cursor names and cuts the page ending at it, which
+  // is operation-agnostic. `last` stays refused on both — it needs the end of the
+  // list, which neither a Scan nor this Query's cursor can reach.
   test.each([['scoped', asUser('cust-a')], ['exempt', asUser('ops-1', ['Admin'])]])(
-    'a %s caller is still refused backward paging',
+    'a %s caller is still refused `last`',
     (_, identity) => {
       const { request } = indexed()
-      expect(() => request(makeCtx({ args: { last: 5 }, identity }))).toThrow('Backward pagination')
+      expect(() => request(makeCtx({ args: { last: 5 }, identity }))).toThrow(
+        'last is not supported',
+      )
     },
   )
+
+  // The path tag has to survive the direction change: a backward cursor still
+  // names the read that minted it, and replaying it on the other branch is the
+  // same mistake as replaying a forward one.
+  test('a backward cursor is path-checked like a forward one', () => {
+    const { request, response } = indexed()
+    const scopedPage = response(makeCtx({
+      args: { first: 10 },
+      identity: asUser('cust-a'),
+      result: { items: Array.from({ length: 10 }, (_, i) => ({ id: 'r' + i })), nextToken: null },
+    }))
+    expect(() =>
+      request(makeCtx({
+        args: { first: 10, before: scopedPage.pageInfo.endCursor },
+        identity: asUser('ops-1', ['Admin']),
+      })),
+    ).toThrow('different read of this list')
+  })
 })
 
 // ---------------------------------------------------------------------------