@reventlessdev/reventless-local 3.0.0-alpha.224 → 3.0.0-alpha.226

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/DcbEventLogStorageSqliteTest.res

@@ -94,7 +94,7 @@ describe("DcbEventLogStorage_Sqlite", () => {
   // Backend contract: an empty tag value (an absent composite-partition member) is
   // legitimate — it appends, is recorded verbatim, and keeps matching through both
   // the partition read and a composite read. Held identically by the in-memory and
-  // DynamoDB backends. See docs/plans/dcb-empty-tag-values-break-append.md.
+  // DynamoDB backends. See docs/plans/done/dcb-empty-tag-values-break-append.md.
   testPromise("an empty tag value appends and stays readable", async () => {
     await runUnderSqlite(async () => {
       module TestBus = LocalBus.Make()

package/tests/adapter/DcbEventLogStorageTest.res

@@ -145,7 +145,7 @@ describe("DcbEventLogStorage_InMemory", () => {
     // An empty tag value is a legitimate model state — an absent member of a
     // composite partition key. Every backend must accept it, record it verbatim,
     // and keep matching the event through its partition and composite reads. See
-    // docs/plans/dcb-empty-tag-values-break-append.md.
+    // docs/plans/done/dcb-empty-tag-values-break-append.md.
     testPromise("an empty tag value appends and stays readable", async () => {
       let storage = makeStorage()
       let ops = await storage.operations->TestRunner.resolve

package/tests/adapter/EventLogSnapshotParityTest.res

@@ -1,5 +1,5 @@
 // Backend-parity tests for the EventLog snapshot ops
-// (docs/plans/aggregate-snapshotting.md): the in-memory and SQLite backends
+// (docs/plans/done/aggregate-snapshotting.md): the in-memory and SQLite backends
 // must behave identically for latestSnapshot / writeSnapshot (keep-one) and
 // the replayStream ~fromSeq delta read, so GWT/local tests of
 // snapshot-enabled aggregates give the same results under either backend.

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

package/tests/adapter/QueryDbListPushdownParityTest.res.mjs

@@ -36,13 +36,16 @@ let capability = {
   sortFields: capability_sortFields
 };
 
-function mk(id, status, name, qty, owner) {
+function mk(id, status, name, qty, owner, archived) {
   let o = {};
   o["id"] = id;
   o["status"] = status;
   o["name"] = name;
   o["qty"] = qty;
   o["owner"] = owner;
+  if (archived !== undefined) {
+    o["archived"] = archived;
+  }
   return o;
 }
 
@@ -52,35 +55,40 @@ let rows = [
     "active",
     "Charlie",
     3,
-    "u-a"
+    "u-a",
+    false
   ],
   [
     "p-2",
     "active",
     "Alpha",
     1,
-    "u-b"
+    "u-b",
+    true
   ],
   [
     "p-3",
     "inactive",
     "Echo",
     5,
-    "u-a"
+    "u-a",
+    false
   ],
   [
     "p-4",
     "active",
     "Bravo",
     2,
-    "u-c"
+    "u-c",
+    true
   ],
   [
     "p-5",
     "inactive",
     "Delta",
     4,
-    "u-a"
+    "u-a",
+    undefined
   ]
 ];
 
@@ -96,7 +104,7 @@ async function build() {
   for (let i = 0, i_finish = rows.length; i < i_finish; ++i) {
     let match = rows[i];
     let id = match[0];
-    await ops.save(id, mk(id, match[1], match[2], match[3], match[4]), "Any", undefined);
+    await ops.save(id, mk(id, match[1], match[2], match[3], match[4], match[5]), "Any", undefined);
   }
   return {
     listPage: Stdlib_Option.getOrThrow(TestBus.getQueryDbListPage("items"), undefined),
@@ -148,11 +156,11 @@ function orderBy(f, dir) {
   ]);
 }
 
-async function checkPushed(label, ownerScope, args) {
+async function checkPushed(label, ownerScope, retiredScope, args) {
   let s = await build();
   let argsDict = Object.fromEntries(args);
-  let expected = norm(QueryDbListQuery$ReventlessCore.run(s.fullScan(), argsDict, capability, "name", param => {}, ownerScope));
-  let actual = s.listPage(argsDict, capability, "name", ownerScope);
+  let expected = norm(QueryDbListQuery$ReventlessCore.run(s.fullScan(), argsDict, capability, "name", param => {}, ownerScope, retiredScope));
+  let actual = s.listPage(argsDict, capability, "name", ownerScope, retiredScope);
   if (actual !== undefined) {
     globalThis.expect(norm(actual)).toEqual(expected);
   } else {
@@ -162,7 +170,20 @@ async function checkPushed(label, ownerScope, args) {
 
 async function checkFallback(args) {
   let s = await build();
-  globalThis.expect(Stdlib_Option.isSome(s.listPage(Object.fromEntries(args), capability, "name", undefined))).toBe(false);
+  globalThis.expect(Stdlib_Option.isSome(s.listPage(Object.fromEntries(args), capability, "name", undefined, undefined))).toBe(false);
+}
+
+async function liveIds(args) {
+  let s = await build();
+  let conn = s.listPage(Object.fromEntries(args), capability, "name", undefined, {
+    field: "archived",
+    values: undefined
+  });
+  if (conn !== undefined) {
+    return norm(conn).edges.map(e => e.id);
+  } else {
+    return [];
+  }
 }
 
 async function scopedIds(owner, args) {
@@ -170,7 +191,7 @@ async function scopedIds(owner, args) {
   let conn = s.listPage(Object.fromEntries(args), capability, "name", [
     "owner",
     owner
-  ]);
+  ], undefined);
   if (conn !== undefined) {
     return norm(conn).edges.map(e => e.id);
   } else {
@@ -179,12 +200,12 @@ async function scopedIds(owner, args) {
 }
 
 globalThis.describe("QueryDb list push-down parity (SQLite ≡ QueryDbListQuery spec)", () => {
-  globalThis.test("bare page", () => checkPushed("bare", undefined, []));
-  globalThis.test("first:2", () => checkPushed("first", undefined, [[
+  globalThis.test("bare page", () => checkPushed("bare", undefined, undefined, []));
+  globalThis.test("first:2", () => checkPushed("first", undefined, undefined, [[
       "first",
       2
     ]]));
-  globalThis.test("first:2 + after", () => checkPushed("after", undefined, [
+  globalThis.test("first:2 + after", () => checkPushed("after", undefined, undefined, [
     [
       "first",
       2
@@ -194,14 +215,14 @@ globalThis.describe("QueryDb list push-down parity (SQLite ≡ QueryDbListQuery
       QueryDbListQuery$ReventlessCore.encodeCursor("p-2")
     ]
   ]));
-  globalThis.test("statusEq active", () => checkPushed("eq", undefined, [[
+  globalThis.test("statusEq active", () => checkPushed("eq", undefined, undefined, [[
       "filter",
       Object.fromEntries([[
           "statusEq",
           "active"
         ]])
     ]]));
-  globalThis.test("statusEq active + first:2", () => checkPushed("eq+first", undefined, [
+  globalThis.test("statusEq active + first:2", () => checkPushed("eq+first", undefined, undefined, [
     [
       "filter",
       Object.fromEntries([[
@@ -214,15 +235,15 @@ globalThis.describe("QueryDb list push-down parity (SQLite ≡ QueryDbListQuery
       2
     ]
   ]));
-  globalThis.test("orderBy name ASC", () => checkPushed("order-asc", undefined, [[
+  globalThis.test("orderBy name ASC", () => checkPushed("order-asc", undefined, undefined, [[
       "orderBy",
       orderBy("name", "ASC")
     ]]));
-  globalThis.test("orderBy name DESC", () => checkPushed("order-desc", undefined, [[
+  globalThis.test("orderBy name DESC", () => checkPushed("order-desc", undefined, undefined, [[
       "orderBy",
       orderBy("name", "DESC")
     ]]));
-  globalThis.test("orderBy name DESC + first:2 + after", () => checkPushed("order-desc-after", undefined, [
+  globalThis.test("orderBy name DESC + first:2 + after", () => checkPushed("order-desc-after", undefined, undefined, [
     [
       "orderBy",
       orderBy("name", "DESC")
@@ -236,11 +257,11 @@ globalThis.describe("QueryDb list push-down parity (SQLite ≡ QueryDbListQuery
       QueryDbListQuery$ReventlessCore.encodeCursor("Delta")
     ]
   ]));
-  globalThis.test("orderBy status ASC (tiebreak by id)", () => checkPushed("order-tiebreak", undefined, [[
+  globalThis.test("orderBy status ASC (tiebreak by id)", () => checkPushed("order-tiebreak", undefined, undefined, [[
       "orderBy",
       orderBy("status", "ASC")
     ]]));
-  globalThis.test("qty range From/To (numeric-as-string)", () => checkPushed("range", undefined, [[
+  globalThis.test("qty range From/To (numeric-as-string)", () => checkPushed("range", undefined, undefined, [[
       "filter",
       Object.fromEntries([
         [
@@ -253,7 +274,7 @@ globalThis.describe("QueryDb list push-down parity (SQLite ≡ QueryDbListQuery
         ]
       ])
     ]]));
-  globalThis.test("orderBy qty ASC (numeric-as-string sort)", () => checkPushed("order-qty", undefined, [[
+  globalThis.test("orderBy qty ASC (numeric-as-string sort)", () => checkPushed("order-qty", undefined, undefined, [[
       "orderBy",
       orderBy("qty", "ASC")
     ]]));
@@ -288,22 +309,70 @@ globalThis.describe("QueryDb list push-down parity (SQLite ≡ QueryDbListQuery
       QueryDbListQuery$ReventlessCore.encodeCursor("p-4")
     ]
   ]));
+  globalThis.describe("retirement narrowing", () => {
+    globalThis.test("bare page, narrowed", () => checkPushed("retired-bare", undefined, {
+      field: "archived",
+      values: undefined
+    }, []));
+    globalThis.test("narrowed + orderBy", () => checkPushed("retired-order", undefined, {
+      field: "archived",
+      values: undefined
+    }, [[
+        "orderBy",
+        orderBy("name", "DESC")
+      ]]));
+    globalThis.test("narrowed + the caller's own filter", () => checkPushed("retired-filter", undefined, {
+      field: "archived",
+      values: undefined
+    }, [[
+        "filter",
+        Object.fromEntries([[
+            "statusEq",
+            "active"
+          ]])
+      ]]));
+    globalThis.test("narrowed + owner-scoped together", () => checkPushed("retired-owner", [
+      "owner",
+      "u-a"
+    ], {
+      field: "archived",
+      values: undefined
+    }, []));
+    globalThis.test("drops the archived rows and keeps the one with no flag", async () => {
+      let ids = await liveIds([]);
+      globalThis.expect(ids).toEqual([
+        "p-1",
+        "p-3",
+        "p-5"
+      ]);
+    });
+    globalThis.test("a page of first:2 is two live rows, not two rows minus the archived", async () => {
+      let ids = await liveIds([[
+          "first",
+          2
+        ]]);
+      globalThis.expect(ids).toEqual([
+        "p-1",
+        "p-3"
+      ]);
+    });
+  });
   globalThis.describe("owner scoping", () => {
     globalThis.test("bare page, scoped", () => checkPushed("owner-bare", [
       "owner",
       "u-a"
-    ], []));
+    ], undefined, []));
     globalThis.test("scoped + orderBy", () => checkPushed("owner-order", [
       "owner",
       "u-a"
-    ], [[
+    ], undefined, [[
         "orderBy",
         orderBy("name", "DESC")
       ]]));
     globalThis.test("scoped + client filter compose", () => checkPushed("owner-and-filter", [
       "owner",
       "u-a"
-    ], [[
+    ], undefined, [[
         "filter",
         Object.fromEntries([[
             "statusEq",
@@ -361,6 +430,7 @@ export {
   cur,
   checkPushed,
   checkFallback,
+  liveIds,
   scopedIds,
 }
 /*  Not a pure module */

package/tests/adapter/QueryDbListResolverTest.res

@@ -37,10 +37,11 @@ let rowStateSchemaWithAnnotations =
       scanSort: ["name"],
       semantic: [],
       metric: [],
-      status: None,
+      lifecycle: None,
       groupBy: None,
       visibility: None,
       live: None,
+      retired: None,
     },
   )