snapback4 0.0.7 → 0.0.9

package/README.md

@@ -300,8 +300,11 @@ flips the link.
 
 ## 5. Development
 
-- **`snapback4 dev [--port N] [--no-watch]`** serves `snapback/*.q` on
-  `127.0.0.1:4400`, recompiling and re-adopting on every save. Personas
+- **`snapback4 dev [--port N] [--no-watch] [--fresh]`** serves
+  `snapback/*.q` on `127.0.0.1:4400`, recompiling and re-adopting on every
+  save; the store lives in `.snapback4/` and persists across runs, and
+  `--fresh` uses one in memory that dies with the process (acceptance
+  scripts start from nothing). Personas
   (`use personas ..`) sign requests from the same machine with the
   `x-snapback-persona: alice` header (the client's `persona: "alice"`),
   acting as `dev:alice`.

package/dist/local.js

@@ -40,6 +40,7 @@ export async function createLocalClient(options) {
     const viewer = (options.persona ? `dev:${options.persona}` : session.principal);
     const principal = viewer;
     let sessionDead = false;
+    let partitionDenied = null;
     const refusedSession = async (denied) => {
         if (session && !sessionDead && denied?.code === "E_AUTH") {
             sessionDead = true;
@@ -87,13 +88,24 @@ export async function createLocalClient(options) {
         async sync(from, limit) {
             try {
                 const response = await doFetch(`${base}/sync?from=${from}&limit=${limit}`, { headers });
-                if (response.status >= 500)
+                if (response.status === 503)
                     return { denied: offline() };
                 const page = (await response.json());
                 if (page.denied) {
                     await refusedSession(page.denied);
+                    if (!page.denied.retryable) {
+                        // The server refuses this device's partition (a schema the store
+                        // cannot serve, a dead session): every read says so, once
+                        // loudly here, and until the next successful sync.
+                        if (!partitionDenied)
+                            console.error(`snapback4: the server refused the partition: ${page.denied.code}: ${page.denied.message}`);
+                        partitionDenied = page.denied;
+                        for (const watch of watches.values())
+                            void rerun(watch);
+                    }
                     return { denied: page.denied };
                 }
+                partitionDenied = null;
                 if (link !== "online")
                     setLink("online");
                 if (page.watermark > seq)
@@ -147,6 +159,8 @@ export async function createLocalClient(options) {
         const program = backend.programs[op.name];
         if (!program)
             return { read: { denied: { code: "E_OP", family: "op", message: `unknown query ${op.name}` } }, tables: new Set() };
+        if (partitionDenied)
+            return { read: { denied: partitionDenied }, tables: new Set(Object.keys(backend.schema.tables)) };
         try {
             const outcome = await store.read((tx) => new Interpreter(tx, backend.schema, { viewer: principal, args: args, now: Date.now(), newIds: [], mint: mintId }, "query").run(program));
             const read = { data: outcome.data, complete: outcome.complete, fresh: link === "online" && replica.isCaughtUp, next: outcome.next, ...(link === "online" && replica.isCaughtUp ? {} : { since: lastSyncAt }) };
@@ -190,11 +204,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 +258,6 @@ export async function createLocalClient(options) {
                         void rerun(watch);
             }
         }
-        finally {
-            flushing = false;
-        }
     }
     const settled = new Map();
     const client = {

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))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snapback4",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "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.7"
+    "snapback4-darwin-arm64": "0.0.9"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",