@reventlessdev/reventless-local 3.0.0-alpha.223 → 3.0.0-alpha.225

package/src/adapter/QueryDb/QueryDbStorage_InMemory.res.mjs

@@ -167,11 +167,11 @@ function Make(Bus) {
     };
     let publishSaved = (changeKind, id, state) => {
       let subKey = getSubKey(state, subIdField);
-      let descriptor = LocalStateChangeDescriptor$ReventlessLocal.make(changeKind, entityKeyFor(id, subKey), state, LocalStateChangeDescriptor$ReventlessLocal.nextSequence());
+      let descriptor = LocalStateChangeDescriptor$ReventlessLocal.make(changeKind, entityKeyFor(id, subKey), state, LocalStateChangeDescriptor$ReventlessLocal.nextSequence(), Stdlib_Option.map(LocalStateChangeDescriptor$ReventlessLocal.retiredSpecFor(name), r => r.field), Stdlib_Option.flatMap(LocalStateChangeDescriptor$ReventlessLocal.retiredSpecFor(name), r => r.values));
       Bus.publishStateChange(name, descriptor);
     };
     let publishRemoved = (id, subKey) => {
-      let descriptor = LocalStateChangeDescriptor$ReventlessLocal.make("Removed", entityKeyFor(id, subKey), undefined, LocalStateChangeDescriptor$ReventlessLocal.nextSequence());
+      let descriptor = LocalStateChangeDescriptor$ReventlessLocal.make("Removed", entityKeyFor(id, subKey), undefined, LocalStateChangeDescriptor$ReventlessLocal.nextSequence(), undefined, undefined);
       Bus.publishStateChange(name, descriptor);
     };
     let save = async (id, state, _saveMode, ttl) => {

package/src/adapter/QueryDb/QueryDbStorage_Sqlite.res

@@ -147,6 +147,7 @@ type busCallbacks = {
       ~capability: GraphQL_FragmentGenerator.serverCapability,
       ~labelField: string,
       ~ownerScope: (string, string)=?,
+      ~retiredScope: Reventless.OwnerScope.retiredScope=?,
     ) => option<JSON.t>,
   ) => unit,
 }
@@ -263,6 +264,8 @@ let makeStorage = (
       ~id=entityKeyFor(id, subKey),
       ~state=Some(state),
       ~seq=LocalStateChangeDescriptor.nextSequence(),
+      ~retiredField=?LocalStateChangeDescriptor.retiredSpecFor(name)->Option.map(r => r.field),
+      ~retiredValues=?LocalStateChangeDescriptor.retiredSpecFor(name)->Option.flatMap(r => r.values),
     )
     bus.publishStateChange(~name, ~descriptor)
   }
@@ -428,6 +431,7 @@ let makeStorage = (
     ~capability: GraphQL_FragmentGenerator.serverCapability,
     ~labelField as _,
     ~ownerScope: option<(string, string)>=?,
+    ~retiredScope: option<Reventless.OwnerScope.retiredScope>=?,
   ): option<JSON.t> => {
     let filterDict =
       argsDict->Dict.get("filter")->Option.flatMap(JSON.Decode.object)->Option.getOr(Dict.make())
@@ -451,6 +455,39 @@ let makeStorage = (
         params->Array.push(JSON.Encode.string(required))
       | None => ()
       }
+      // `IS NOT 1`, not `= 0`, and on the raw extraction rather than through
+      // `jsonText`. SQLite renders a JSON true as the integer 1 and a missing
+      // path as NULL, and `IS NOT` is the comparison that treats NULL as a value
+      // rather than poisoning the predicate. Three cases have to land the way the
+      // in-memory spec lands them: absent keeps the row (a row written before the
+      // annotation is not retired), false keeps it, and a value that is not a
+      // JSON boolean keeps it too — which `= 0` would get wrong, since a string
+      // `'true'` compares unequal to 0 and the row would vanish on this backend
+      // only. `QueryDbListPushdownParityTest` is what holds the two together.
+      //
+      // The state form compares against the states' text instead of 1, and the
+      // three cases land identically: absent is NULL, a state outside the set
+      // compares unequal to every member, and a non-string value is none of them
+      // either.
+      //
+      // Written as a conjunction of `IS NOT` rather than as `NOT IN`: `IN` is
+      // ordinary equality, so a NULL path makes the predicate NULL and the row
+      // vanishes — the absent case, which has to keep the row. `IS NOT` is the
+      // comparison that treats NULL as a value, and it does not have an `IN`
+      // spelling. A set naming nothing pushes no predicate down, which is the
+      // same answer `isRetiredValue` gives it.
+      switch retiredScope {
+      | Some(scope) =>
+        let path = `json_extract(item, '$.${scope.field->String.replaceAll("'", "''")}')`
+        switch scope.values {
+        | None => whereParts->Array.push(`${path} IS NOT 1`)
+        | Some(states) =>
+          states->Array.forEach(state =>
+            whereParts->Array.push(`${path} IS NOT '${state->String.replaceAll("'", "''")}'`)
+          )
+        }
+      | None => ()
+      }
       let valString = v =>
         switch v->JSON.Decode.string {
         | Some(s) => Some(s)

package/src/adapter/QueryDb/QueryDbStorage_Sqlite.res.mjs

@@ -194,7 +194,7 @@ function makeStorage(db, bus, name, indexes, subIdField) {
   };
   let publishSaved = (changeKind, id, state) => {
     let subKey = computeSubKey(state, subIdField);
-    let descriptor = LocalStateChangeDescriptor$ReventlessLocal.make(changeKind, entityKeyFor(id, subKey), state, LocalStateChangeDescriptor$ReventlessLocal.nextSequence());
+    let descriptor = LocalStateChangeDescriptor$ReventlessLocal.make(changeKind, entityKeyFor(id, subKey), state, LocalStateChangeDescriptor$ReventlessLocal.nextSequence(), Stdlib_Option.map(LocalStateChangeDescriptor$ReventlessLocal.retiredSpecFor(name), r => r.field), Stdlib_Option.flatMap(LocalStateChangeDescriptor$ReventlessLocal.retiredSpecFor(name), r => r.values));
     bus.publishStateChange(name, descriptor);
   };
   let saveKind = (id, state) => {
@@ -209,7 +209,7 @@ function makeStorage(db, bus, name, indexes, subIdField) {
     }
   };
   let publishRemoved = (id, subKey) => {
-    let descriptor = LocalStateChangeDescriptor$ReventlessLocal.make("Removed", entityKeyFor(id, subKey), undefined, LocalStateChangeDescriptor$ReventlessLocal.nextSequence());
+    let descriptor = LocalStateChangeDescriptor$ReventlessLocal.make("Removed", entityKeyFor(id, subKey), undefined, LocalStateChangeDescriptor$ReventlessLocal.nextSequence(), undefined, undefined);
     bus.publishStateChange(name, descriptor);
   };
   let rowKeysForPartition = id => SqliteDriver$ReventlessLocal.all(selectByPartitionStmt, [id]).map(row => {
@@ -337,7 +337,7 @@ function makeStorage(db, bus, name, indexes, subIdField) {
   };
   let jsonText = field => `CAST(json_extract(item, '$.` + field.replaceAll("'", "''") + `') AS TEXT)`;
   let idExpr = "COALESCE(json_extract(item, '$.id'), partition_key)";
-  let listPage = (argsDict, capability, param, ownerScope) => {
+  let listPage = (argsDict, capability, param, ownerScope, retiredScope) => {
     let filterDict = Stdlib_Option.getOr(Stdlib_Option.flatMap(argsDict["filter"], Stdlib_JSON.Decode.object), {});
     let strNonEmpty = k => Stdlib_Option.mapOr(Stdlib_Option.flatMap(filterDict[k], Stdlib_JSON.Decode.string), false, s => s.length > 0);
     let hasIds = Stdlib_Option.mapOr(Stdlib_Option.flatMap(filterDict["ids"], Stdlib_JSON.Decode.array), false, a => a.length !== 0);
@@ -352,6 +352,17 @@ function makeStorage(db, bus, name, indexes, subIdField) {
       whereParts.push(jsonText(ownerScope[0]) + ` = ?`);
       params.push(ownerScope[1]);
     }
+    if (retiredScope !== undefined) {
+      let path = `json_extract(item, '$.` + retiredScope.field.replaceAll("'", "''") + `')`;
+      let states = retiredScope.values;
+      if (states !== undefined) {
+        states.forEach(state => {
+          whereParts.push(path + ` IS NOT '` + state.replaceAll("'", "''") + `'`);
+        });
+      } else {
+        whereParts.push(path + ` IS NOT 1`);
+      }
+    }
     let valString = v => {
       let s = Stdlib_JSON.Decode.string(v);
       if (s !== undefined) {

package/src/reset/LocalSeedReset.res

@@ -11,9 +11,20 @@
 //     unlink leaves it on the orphaned inode still serving every row it had, the
 //     delete looks like it worked, and the seed then fails against the untouched
 //     server with "the target store is not empty". Deleting ROWS through a second
-//     connection is visible to the running server immediately (its reads go to
-//     these tables; there is no in-process cache), so a reset needs no restart and
-//     no stopping of the platform.
+//     connection is what works instead — a query issued after the delete reads
+//     the emptied tables, so the platform need not be STOPPED for the reset.
+//
+//     It does need RESTARTING before the re-seed, and this comment claimed
+//     otherwise for a while on the strength of "there is no in-process cache".
+//     There is: a DCB slice's decision state is held per partition in the
+//     running process, and a delete behind its back does not invalidate it. The
+//     slice goes on refusing writes for ids whose state it still remembers, so
+//     the re-seed fails with `…AlreadyExists` naming rows the store visibly does
+//     not hold — verified by the same id being refused before a restart and
+//     accepted after, against byte-identical tables.
+//
+//     So: reset with the platform up, then restart it, then seed. Emptying the
+//     store and emptying the process are two steps, and only the first is here.
 //
 //   • It is SCOPED. Wiping domain data leaves the plugin registry intact, so a
 //     re-seed just works — the same reason the deployed default is `domain`.
@@ -543,15 +554,21 @@ let run = (~dbPath: option<string>=?): unit => {
         if total(plan) == 0 {
           Console.log("Nothing to do.")
         } else {
+          // Set at all ⇒ it is the answer, affirmative or not. Falling through to
+          // the prompt on an unrecognised value would ask for a TTY the runs this
+          // variable exists for do not have, so `SEED_RESET_CONFIRM=no` would
+          // throw where it plainly means "don't". Both arms read the reply
+          // through one predicate, which is what keeps the typed `y` and the
+          // env var speaking the same language.
           let confirmed = switch Seed.Prompt.envValue("SEED_RESET_CONFIRM") {
-          | Some("1") | Some("yes") => true
-          | _ =>
+          | Some(answer) => Seed.Prompt.isAffirmative(answer)
+          | None =>
             let answer = await Seed.Prompt.ask(
               `Empty ${total(
                   plan,
                 )->Int.toString} row(s)/object(s) in the "${plan.scope->scopeLabel}" scope? [y/N]: `,
             )
-            answer->String.trim->String.toLowerCase == "y"
+            Seed.Prompt.isAffirmative(answer)
           }
           if confirmed {
             execute(db, plan)

package/src/reset/LocalSeedReset.res.mjs

@@ -499,25 +499,8 @@ function run(dbPath) {
       if (total(plan) === 0) {
         console.log("Nothing to do.");
       } else {
-        let match$1 = Seed_Prompt$ReventlessSeed.envValue("SEED_RESET_CONFIRM");
-        let confirmed;
-        let exit = 0;
-        if (match$1 !== undefined) {
-          switch (match$1) {
-            case "1" :
-            case "yes" :
-              confirmed = true;
-              break;
-            default:
-              exit = 1;
-          }
-        } else {
-          exit = 1;
-        }
-        if (exit === 1) {
-          let answer = await Seed_Prompt$ReventlessSeed.ask(`Empty ` + total(plan).toString() + ` row(s)/object(s) in the "` + scopeLabel(plan.scope) + `" scope? [y/N]: `);
-          confirmed = answer.trim().toLowerCase() === "y";
-        }
+        let answer = Seed_Prompt$ReventlessSeed.envValue("SEED_RESET_CONFIRM");
+        let confirmed = answer !== undefined ? Seed_Prompt$ReventlessSeed.isAffirmative(answer) : Seed_Prompt$ReventlessSeed.isAffirmative(await Seed_Prompt$ReventlessSeed.ask(`Empty ` + total(plan).toString() + ` row(s)/object(s) in the "` + scopeLabel(plan.scope) + `" scope? [y/N]: `));
         if (confirmed) {
           execute(db, plan);
           console.log(`Reset complete — the "` + scopeLabel(plan.scope) + `" scope reads empty and is re-seedable.`);

package/tests/adapter/GraphQL_SchemaInspectorTest.res

@@ -109,10 +109,11 @@ let indexedStateSchemaWithAnnotations = indexedStateSchema->S.Metadata.set(
     scanSort: [],
     semantic: [],
     metric: [],
-    status: None,
+    lifecycle: None,
     groupBy: None,
     visibility: None,
     live: None,
+    retired: None,
   },
 )
 
@@ -139,10 +140,11 @@ let orderedStateSchemaWithAnnotations = orderedStateSchema->S.Metadata.set(
     scanSort: [],
     semantic: [],
     metric: [],
-    status: None,
+    lifecycle: None,
     groupBy: None,
     visibility: None,
     live: None,
+    retired: None,
   },
 )
 
@@ -170,10 +172,11 @@ let scanStateSchemaWithAnnotations = scanStateSchema->S.Metadata.set(
     scanSort: ["name"],
     semantic: [],
     metric: [],
-    status: None,
+    lifecycle: None,
     groupBy: None,
     visibility: None,
     live: None,
+    retired: None,
   },
 )
 
@@ -429,7 +432,7 @@ describe("GraphQL_SchemaInspector", () => {
       // Query field should use filter + first/after/last/before args (Phase 4)
       expect(
         sdl->String.includes(
-          "Relay_Products(filter: RelayProductFilter, first: Int, after: String, last: Int, before: String): RelayProductConnection!",
+          "Relay_Products(filter: RelayProductFilter, first: Int, after: String, last: Int, before: String, includeRetired: Boolean): RelayProductConnection!",
         ),
       )->toBe(true)
       // Connection filter input with search/searchPrefix/ids

package/tests/adapter/GraphQL_SchemaInspectorTest.res.mjs

@@ -114,10 +114,11 @@ let indexedStateSchemaWithAnnotations = S.Metadata.set(indexedStateSchema, State
   scanSort: [],
   semantic: [],
   metric: [],
-  status: undefined,
+  lifecycle: undefined,
   groupBy: undefined,
   visibility: undefined,
-  live: undefined
+  live: undefined,
+  retired: undefined
 });
 
 let orderedStateSchema = S.schema(s => ({
@@ -141,10 +142,11 @@ let orderedStateSchemaWithAnnotations = S.Metadata.set(orderedStateSchema, State
   scanSort: [],
   semantic: [],
   metric: [],
-  status: undefined,
+  lifecycle: undefined,
   groupBy: undefined,
   visibility: undefined,
-  live: undefined
+  live: undefined,
+  retired: undefined
 });
 
 let scanStateSchema = S.schema(s => ({
@@ -169,10 +171,11 @@ let scanStateSchemaWithAnnotations = S.Metadata.set(scanStateSchema, StateAnnota
   scanSort: ["name"],
   semantic: [],
   metric: [],
-  status: undefined,
+  lifecycle: undefined,
   groupBy: undefined,
   visibility: undefined,
-  live: undefined
+  live: undefined,
+  retired: undefined
 });
 
 globalThis.describe("GraphQL_SchemaInspector", () => {
@@ -350,7 +353,7 @@ globalThis.describe("GraphQL_SchemaInspector", () => {
       globalThis.expect(sdl.includes("edges: [RelayProductEdge!]!")).toBe(true);
       globalThis.expect(sdl.includes("pageInfo: PageInfo!")).toBe(true);
       globalThis.expect(sdl.includes("totalCount")).toBe(false);
-      globalThis.expect(sdl.includes("Relay_Products(filter: RelayProductFilter, first: Int, after: String, last: Int, before: String): RelayProductConnection!")).toBe(true);
+      globalThis.expect(sdl.includes("Relay_Products(filter: RelayProductFilter, first: Int, after: String, last: Int, before: String, includeRetired: Boolean): RelayProductConnection!")).toBe(true);
       globalThis.expect(sdl.includes("input RelayProductFilter")).toBe(true);
       globalThis.expect(sdl.includes("search: String")).toBe(true);
       globalThis.expect(sdl.includes("searchPrefix: String")).toBe(true);

package/tests/adapter/GraphQL_SubscriptionResolversTest.res.mjs

@@ -69,7 +69,7 @@ globalThis.describe("LocalGraphQL_SubscriptionResolvers", () => {
           "2026-05-19T12:00:00Z"
         ]
       ]);
-      let descriptor = LocalStateChangeDescriptor$ReventlessLocal.make("Updated", "prod-1", state, LocalStateChangeDescriptor$ReventlessLocal.nextSequence());
+      let descriptor = LocalStateChangeDescriptor$ReventlessLocal.make("Updated", "prod-1", state, LocalStateChangeDescriptor$ReventlessLocal.nextSequence(), undefined, undefined);
       TestBus.publishStateChange("Product", descriptor);
       let received = await consumerPromise;
       if (received !== null) {
@@ -88,7 +88,7 @@ globalThis.describe("LocalGraphQL_SubscriptionResolvers", () => {
       let foreignDescriptor = LocalStateChangeDescriptor$ReventlessLocal.make("Updated", "cat-1", Object.fromEntries([[
           "id",
           "cat-1"
-        ]]), LocalStateChangeDescriptor$ReventlessLocal.nextSequence());
+        ]]), LocalStateChangeDescriptor$ReventlessLocal.nextSequence(), undefined, undefined);
       TestBus.publishStateChange("Category", foreignDescriptor);
       let received = await consumerPromise;
       globalThis.expect(received === null ? undefined : Primitive_option.some(received)).toEqual(undefined);

package/tests/adapter/QueryDbListPushdownParityTest.res

@@ -21,13 +21,21 @@ let capability: ReventlessCore.GraphQL_FragmentGenerator.serverCapability = {
   sortFields: ["name", "qty", "status"],
 }
 
-let mk = (id, status, name, qty, owner) => {
+let mk = (id, status, name, qty, owner, archived) => {
   let o = Dict.make()
   o->Dict.set("id", JSON.Encode.string(id))
   o->Dict.set("status", JSON.Encode.string(status))
   o->Dict.set("name", JSON.Encode.string(name))
   o->Dict.set("qty", JSON.Encode.int(qty))
   o->Dict.set("owner", JSON.Encode.string(owner))
+  // `archived` is absent on p-5, not false. A row written before the annotation
+  // existed has no such attribute, and "absent means not retired" is the rule
+  // both the spec and every push-down have to land on — get it wrong and the
+  // view empties the day someone adds `@retired`.
+  switch archived {
+  | Some(b) => o->Dict.set("archived", JSON.Encode.bool(b))
+  | None => ()
+  }
   JSON.Encode.object(o)
 }
 
@@ -40,11 +48,11 @@ let mk = (id, status, name, qty, owner) => {
 // to work on a field the client-visible filter surface does not admit, which is
 // the normal case and the reason the predicate travels separately.
 let rows = [
-  ("p-1", "active", "Charlie", 3, "u-a"),
-  ("p-2", "active", "Alpha", 1, "u-b"),
-  ("p-3", "inactive", "Echo", 5, "u-a"),
-  ("p-4", "active", "Bravo", 2, "u-c"),
-  ("p-5", "inactive", "Delta", 4, "u-a"),
+  ("p-1", "active", "Charlie", 3, "u-a", Some(false)),
+  ("p-2", "active", "Alpha", 1, "u-b", Some(true)),
+  ("p-3", "inactive", "Echo", 5, "u-a", Some(false)),
+  ("p-4", "active", "Bravo", 2, "u-c", Some(true)),
+  ("p-5", "inactive", "Delta", 4, "u-a", None),
 ]
 
 type setup = {
@@ -53,6 +61,7 @@ type setup = {
     ~capability: ReventlessCore.GraphQL_FragmentGenerator.serverCapability,
     ~labelField: string,
     ~ownerScope: (string, string)=?,
+    ~retiredScope: Reventless.OwnerScope.retiredScope=?,
   ) => option<JSON.t>,
   fullScan: unit => array<JSON.t>,
 }
@@ -66,8 +75,13 @@ let build = async (): setup => {
   let s = Storage.make(~name="items", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
   let ops = await s.operations->TestRunner.resolve
   for i in 0 to rows->Array.length - 1 {
-    let (id, status, name, qty, owner) = rows->Array.getUnsafe(i)
-    let _ = await ops.save(id, mk(id, status, name, qty, owner), ReventlessCore.QueryDb.Any, None)
+    let (id, status, name, qty, owner, archived) = rows->Array.getUnsafe(i)
+    let _ = await ops.save(
+      id,
+      mk(id, status, name, qty, owner, archived),
+      ReventlessCore.QueryDb.Any,
+      None,
+    )
   }
   {
     listPage: TestBus.getQueryDbListPage("items")->Option.getOrThrow,
@@ -118,7 +132,7 @@ let orderBy = (f, dir) =>
 let cur = ReventlessCore.QueryDbListQuery.encodeCursor
 
 // Assert the push-down serves this shape AND matches the spec exactly.
-let checkPushed = async (~label, ~ownerScope=?, args) => {
+let checkPushed = async (~label, ~ownerScope=?, ~retiredScope=?, args) => {
   let s = await build()
   let argsDict = argsOf(args)
   let expected =
@@ -129,8 +143,9 @@ let checkPushed = async (~label, ~ownerScope=?, args) => {
       ~labelField="name",
       ~decodeLocalId=_ => None,
       ~ownerScope?,
+      ~retiredScope?,
     )->norm
-  switch s.listPage(~argsDict, ~capability, ~labelField="name", ~ownerScope?) {
+  switch s.listPage(~argsDict, ~capability, ~labelField="name", ~ownerScope?, ~retiredScope?) {
   | Some(actual) => expect(actual->norm)->toEqual(expected)
   | None => expect("push-down for " ++ label)->toBe("returned None")
   }
@@ -142,6 +157,15 @@ let checkFallback = async args => {
   expect(s.listPage(~argsDict=argsOf(args), ~capability, ~labelField="name")->Option.isSome)->toBe(false)
 }
 
+// The ids a retirement-narrowed read returns, from the push-down.
+let liveIds = async args => {
+  let s = await build()
+  switch s.listPage(~argsDict=argsOf(args), ~capability, ~labelField="name", ~retiredScope={field: "archived", values: None}) {
+  | Some(conn) => (conn->norm).edges->Array.map(e => e.id)
+  | None => []
+  }
+}
+
 // The ids a scoped read actually returns, from the push-down.
 let scopedIds = async (~owner, args) => {
   let s = await build()
@@ -218,6 +242,54 @@ describe("QueryDb list push-down parity (SQLite ≡ QueryDbListQuery spec)", ()
     checkFallback([("last", JSON.Encode.int(2)), ("before", JSON.Encode.string(cur("p-4")))])
   )
 
+  // ── Retirement narrowing ──────────────────────────────────────────────────
+  // Same parity argument as owner scoping below: the push-down is the path a
+  // deployment takes and the spec is the path the tests reach, so a predicate
+  // implemented in one of them is a hole every fallback-based test calls green.
+  describe("retirement narrowing", () => {
+    testPromise("bare page, narrowed", () =>
+      checkPushed(~label="retired-bare", ~retiredScope={field: "archived", values: None}, [])
+    )
+    testPromise("narrowed + orderBy", () =>
+      checkPushed(
+        ~label="retired-order",
+        ~retiredScope={field: "archived", values: None},
+        [("orderBy", orderBy("name", "DESC"))],
+      )
+    )
+    testPromise("narrowed + the caller's own filter", () =>
+      checkPushed(
+        ~label="retired-filter",
+        ~retiredScope={field: "archived", values: None},
+        [("filter", filterOf([("statusEq", JSON.Encode.string("active"))]))],
+      )
+    )
+    testPromise("narrowed + owner-scoped together", () =>
+      checkPushed(
+        ~label="retired-owner",
+        ~ownerScope=("owner", "u-a"),
+        ~retiredScope={field: "archived", values: None},
+        [],
+      )
+    )
+
+    // The rows, not just the parity: p-2 and p-4 are archived, p-5 carries no
+    // flag at all. Parity alone would pass if BOTH implementations were wrong
+    // the same way.
+    testPromise("drops the archived rows and keeps the one with no flag", async () => {
+      let ids = await liveIds([])
+      expect(ids)->toEqual(["p-1", "p-3", "p-5"])
+    })
+
+    // The reason the predicate is pushed into the SQL rather than applied to the
+    // page: `first: 2` must yield two LIVE rows, not two rows of which some were
+    // filtered away afterwards.
+    testPromise("a page of first:2 is two live rows, not two rows minus the archived", async () => {
+      let ids = await liveIds([("first", JSON.Encode.int(2))])
+      expect(ids)->toEqual(["p-1", "p-3"])
+    })
+  })
+
   // ── Owner scoping ─────────────────────────────────────────────────────────
   // Parity matters more here than anywhere else in this file. The push-down is
   // the path a deployment actually takes; the spec is the path the tests most