snapback4 0.0.6 → 0.0.8

package/README.md

@@ -206,7 +206,11 @@ The horizon `last N by index` bounds what a device acquires per group;
 older rows are online-only, and a device's read past them says
 `complete: false`. Joining a group delivers its rows; leaving it delivers
 one scope tombstone, and the table's `retain` says what the device keeps.
-A table without `sync` is online-only: its queries run on the server.
+What it keeps under `delivered-history` it can still read locally through
+a query without a membership `require` (the server refuses the same query
+once the membership is gone, so a "history" query answers on the device
+and is empty online). A table without `sync` is online-only: its queries
+run on the server.
 
 ## 4. The client
 
@@ -308,7 +312,8 @@ flips the link.
 - **`snapback4 run <op> '<json args>' --as alice [--json]`** runs one
   operation against the local store and prints the result and the meter.
 - **`snapback4 test [--fixture dir] [--as persona]`** loads a fixture
-  (one `<table>.jsonl` per table), runs every query as each persona with
+  (one `<table>.jsonl` per table) into a fresh store in memory (without a
+  fixture, the project's dev store), runs every query as each persona with
   arguments derived from the data (a reference is the table's first row,
   a principal the persona, a text the shortest that fits), prints the
   meters beside the ceilings and the arguments it used, and names any

package/dist/local.js

@@ -190,11 +190,27 @@ export async function createLocalClient(options) {
         return store.read(async (tx) => (await tx.side("outbox").all()).map((e) => e.value).sort((a, b) => (a.id < b.id ? -1 : 1)));
     }
     let flushing = false;
+    let flushAgain = false;
     async function flush() {
-        if (flushing)
+        // A write queued while a flush runs is flushed by the same flush, on
+        // its next pass: nothing waits for the next link change.
+        if (flushing) {
+            flushAgain = true;
             return;
+        }
         flushing = true;
         try {
+            do {
+                flushAgain = false;
+                await flushOnce();
+            } while (flushAgain && link === "online" && !closed);
+        }
+        finally {
+            flushing = false;
+        }
+    }
+    async function flushOnce() {
+        {
             for (const entry of await queued()) {
                 if (link !== "online")
                     return;
@@ -228,9 +244,6 @@ export async function createLocalClient(options) {
                         void rerun(watch);
             }
         }
-        finally {
-            flushing = false;
-        }
     }
     const settled = new Map();
     const client = {

package/dist/replica/interpreter.d.ts

@@ -91,7 +91,12 @@ export declare class Interpreter {
      * counted. */
     private visibility;
     private ruleTrue;
-    /** The read rule for one row, with probes over the replica. */
+    /** Whether the viewer may read a held row. A synced table's rows are
+     * the partition: the server delivered each under the read rule and
+     * withdrew what it revoked, so what the device holds it may read — and
+     * what `retain delivered-history` kept after a leave stays readable here
+     * even though the server now refuses it. Only an online-only table's
+     * rows (none, unless predicted) meet the rule on the device. */
     readable(table: string, row: Row): Promise<boolean>;
     private rule;
     private permitted;

package/dist/replica/interpreter.js

@@ -625,7 +625,9 @@ export class Interpreter {
                     this.env.set(lane.binding, source);
                 await this.statements(lane.setup ?? [], merge.site);
                 this.pageDepth++;
-                const rows = await this.scan(lane.scan);
+                // One row past the page per lane, so a lane that alone fills the
+                // page still shows there is more (as on the server).
+                const rows = await this.scan({ ...lane.scan, take: { Literal: take + 1 } });
                 this.pageDepth = depth;
                 for (const row of rows) {
                     if (seen.has(row.id))
@@ -703,9 +705,17 @@ export class Interpreter {
             default: return false;
         }
     }
-    /** The read rule for one row, with probes over the replica. */
+    /** Whether the viewer may read a held row. A synced table's rows are
+     * the partition: the server delivered each under the read rule and
+     * withdrew what it revoked, so what the device holds it may read — and
+     * what `retain delivered-history` kept after a leave stays readable here
+     * even though the server now refuses it. Only an online-only table's
+     * rows (none, unless predicted) meet the rule on the device. */
     async readable(table, row) {
-        const rule = this.schema.tables[table].rules.read;
+        const definition = this.schema.tables[table];
+        if (definition?.sync)
+            return true;
+        const rule = definition.rules.read;
         return this.rule(rule, undefined, row, false);
     }
     async rule(rule, old, next, insert) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snapback4",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "type": "module",
   "description": "Snapback 4: the card (contract), the online and local-first clients (IndexedDB, SQLite), React hooks, sign-in, a labelled mock, and the `snapback4` CLI. LLP 3000.",
   "bin": {
@@ -42,7 +42,7 @@
     "README.md"
   ],
   "optionalDependencies": {
-    "snapback4-darwin-arm64": "0.0.6"
+    "snapback4-darwin-arm64": "0.0.8"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",