slopkit 0.1.2 → 0.3.0

package/dist/web/replica.js

@@ -7,11 +7,17 @@
  *   replica instead, so the checkpoint never covers rows the disk doesn't have.
  * - Every write checks the database's generation, read at load: after a forget in another tab this page's writes
  *   fail as `Replaced` instead of bringing the forgotten copy back.
- * - The outbox is written per command, never replaced whole, so tabs can't overwrite each other's intents.
+ * - The outbox is written per command, never replaced whole, so tabs can't overwrite each other's intents. A new
+ *   command is admitted inside its own write's transaction, from the store's count, so every tab shares one bound;
+ *   a kept one always updates, and nothing kept is dropped for room.
  * - Rows are read back only under the row shapes that wrote them (each table's name and schema `shape`, kept with the
  *   checkpoint): any change to a table or its schema starts the rows over, with no number to bump by hand. The next
  *   commit then writes the whole replica, so the disk is repaired, not just the memory. Rows that don't parse are
- *   treated the same. The server's facts are not rows: facts an older page kept that no longer fit load as null and
+ *   treated the same.
+ * - A partial copy (a first copy still paging in) keeps its history in the checkpoint, written in the same transaction
+ *   as its rows, and marks its row shapes as partial: a release from before paging reads it as another release's copy,
+ *   so it never takes part of a history for all of it. A delta takes the patch's history only when the disk is at the
+ *   cursor the patch moved from, and a complete copy at a revision is never narrowed to a partial one. The server's facts are not rows: facts an older page kept that no longer fit load as null and
  *   never cost the copy; facts that change at the same revision are written too.
  * - A version upgrade starts the replica over (it comes back from the server) but keeps the outbox and the generation:
  *   an intent on disk is never erased by an upgrade. One this version can't read stays on disk and is counted.
@@ -21,12 +27,24 @@
  * in-memory one). `interfere` is for tests: it sees each write transaction before it commits and may abort it.
  */
 import { Replaced } from "../client.js";
-import { check } from "../schema.js";
-import { commitPlan } from "../sync.js";
+import { check, literal, nullable, number, object, string } from "../schema.js";
+import { commitPlan, OUTBOX_MAX } from "../sync.js";
 import { committed, openDatabase, request } from "./idb.js";
+const COMPLETE = { kind: "complete" };
+const count = () => number({ integer: true, min: 0 });
+const partialSchema = object({
+    kind: literal("partial"),
+    next: string(),
+    through: nullable(string()),
+    held: count(),
+    total: count(),
+});
 export function indexedReplica(options) {
     const names = options.tables.map((lens) => lens.name);
     const shapes = options.tables.map((lens) => lens.shape).join("\n");
+    /** A partial copy's row shapes: foreign to a release from before paging. */
+    const partialShapes = `${shapes}\npartial`;
+    const ours = (written) => written === shapes || written === partialShapes;
     /** The checkpoint a load found whose rows didn't parse: the next commit at it rewrites the whole replica. */
     let damaged;
     /** The dataset of a copy this page loaded but couldn't read (other row shapes, rows that don't parse): its own to replace. */
@@ -142,22 +160,26 @@ export function indexedReplica(options) {
     }
     /** The checkpoint on disk as this version may trust it: one of other row shapes (or none) holds nothing. */
     const checkpointOf = (value) => {
+        const none = { dataset: null, revision: 0, history: COMPLETE };
         if (typeof value !== "object" || value === null) {
-            return { dataset: null, revision: 0 };
+            return none;
         }
         const dataset = Reflect.get(value, "dataset");
         const revision = Reflect.get(value, "revision");
-        if (Reflect.get(value, "shapes") !== shapes) {
-            return { dataset: null, revision: 0 };
+        const written = Reflect.get(value, "shapes");
+        const partial = check(partialSchema, Reflect.get(value, "history"));
+        if (written !== shapes && (written !== partialShapes || !partial.ok)) {
+            return none;
         }
         const at = {
             dataset: typeof dataset === "string" ? dataset : null,
             revision: typeof revision === "number" ? revision : 0,
+            history: written === partialShapes && partial.ok ? partial.value : COMPLETE,
         };
         if (damaged !== undefined &&
             damaged.dataset === at.dataset &&
             damaged.revision === at.revision) {
-            return { dataset: null, revision: 0 };
+            return none;
         }
         return at;
     };
@@ -197,6 +219,7 @@ export function indexedReplica(options) {
                 revision: 0,
                 tables: options.empty,
                 server: null,
+                history: COMPLETE,
             };
             const at = checkpointOf(point);
             const raw = typeof point === "object" && point !== null ? Reflect.get(point, "dataset") : null;
@@ -232,6 +255,7 @@ export function indexedReplica(options) {
                     revision: at.revision,
                     tables: restored,
                     server: server?.ok === true ? server.value : null,
+                    history: at.history,
                 },
                 commands,
                 unreadable,
@@ -246,7 +270,6 @@ export function indexedReplica(options) {
                 dataset: commit.replica.dataset,
                 revision: commit.replica.revision,
                 server: commit.replica.server,
-                shapes,
             };
             try {
                 await guard(transaction);
@@ -267,6 +290,7 @@ export function indexedReplica(options) {
                     reset: commit.reset,
                     base: commit.base,
                     replaces: commit.replaces,
+                    ...(commit.from === undefined ? {} : { from: commit.from }),
                 });
                 // The disk holds a dataset this page never saw: the server replaced the one this page is on.
                 if (plan === "stale") {
@@ -278,7 +302,7 @@ export function indexedReplica(options) {
                 // Another release's tab wrote this dataset under its own row shapes since this page loaded: that release owns
                 // the copy now, at any revision, and this page stops writing until it reloads.
                 if (held === commit.replica.dataset &&
-                    written !== shapes &&
+                    !ours(written) &&
                     (loaded === undefined ||
                         loaded.dataset !== held ||
                         loaded.revision !== revision ||
@@ -305,7 +329,7 @@ export function indexedReplica(options) {
                         }
                     }
                 };
-                if (plan === "delta") {
+                if (plan === "delta" || plan === "adopt") {
                     write(commit.ops);
                 }
                 if (plan === "whole") {
@@ -318,8 +342,16 @@ export function indexedReplica(options) {
                 }
                 // At the same revision the rows are already there, but the server's facts may have moved: they are kept too.
                 const facts = plan === "skip" && stored.revision === target.revision;
+                // A delta keeps the disk's history; a whole write or a delta from the disk's own cursor takes the page's.
+                const history = plan === "whole" || plan === "adopt"
+                    ? (commit.replica.history ?? COMPLETE)
+                    : stored.history;
+                const checkpoint = {
+                    ...target,
+                    ...(history.kind === "partial" ? { history, shapes: partialShapes } : { shapes }),
+                };
                 if (plan !== "skip" || facts) {
-                    meta.put(target, "checkpoint");
+                    meta.put(checkpoint, "checkpoint");
                 }
                 options.interfere?.("commit", transaction);
                 await done;
@@ -328,26 +360,47 @@ export function indexedReplica(options) {
                     discarded = null;
                     loaded = undefined;
                 }
-                const now = plan === "skip" ? stored : target;
+                const now = plan === "skip" ? stored : checkpoint;
                 if (now.dataset === null) {
                     throw new Error("the replica has no dataset");
                 }
-                return { dataset: now.dataset, revision: now.revision };
+                // A delta under the disk's own history leaves out rows of this page's copy: said, so a failed write stays owed.
+                return {
+                    dataset: now.dataset,
+                    revision: now.revision,
+                    ...(plan === "delta" && stored.history.kind === "partial" ? { whole: false } : {}),
+                };
             }
             catch (error) {
                 await done.catch(() => undefined);
                 throw error;
             }
         },
-        async keep(pending) {
+        async keep(pending, max = OUTBOX_MAX) {
             const database = await db();
             const transaction = database.transaction(["meta", "outbox"], "readwrite");
             const done = committed(transaction);
+            const outbox = transaction.objectStore("outbox");
+            const key = [pending.client, pending.id];
             try {
                 await guard(transaction);
-                transaction.objectStore("outbox").put(pending, [pending.client, pending.id]);
+                // Admission is decided here, from the store's own count, so every tab shares one bound. A kept key always
+                // updates; records already past the bound (an older release, a larger one) stay, and keep new ones out.
+                if ((await request(outbox.count(key))) === 0 &&
+                    (await request(outbox.count())) >= max) {
+                    const kept = await request(outbox.getAll());
+                    // Unreadable records take room too: counted as waiting, since what they hold is unknown.
+                    const finished = kept.filter((each) => {
+                        const parsed = check(options.pending, each);
+                        return parsed.ok && parsed.value.state.kind === "done";
+                    }).length;
+                    await done;
+                    return { kind: "full", waiting: kept.length - finished, finished, max };
+                }
+                outbox.put(pending, key);
                 options.interfere?.("keep", transaction);
                 await done;
+                return undefined;
             }
             catch (error) {
                 await done.catch(() => undefined);
@@ -371,6 +424,30 @@ export function indexedReplica(options) {
                 throw error;
             }
         },
+        async mark(keys) {
+            const database = await db();
+            const transaction = database.transaction(["meta", "outbox"], "readwrite");
+            const done = committed(transaction);
+            const outbox = transaction.objectStore("outbox");
+            try {
+                await guard(transaction);
+                const kept = await Promise.all(keys.map((key) => request(outbox.get([key.client, key.id]))));
+                // A push's commands, in flight, in one write: only records kept already, so nothing is admitted here.
+                for (const [at, record] of kept.entries()) {
+                    const key = keys[at];
+                    if (key !== undefined && typeof record === "object" && record !== null) {
+                        outbox.put({ ...record, state: { kind: "sending" } }, [key.client, key.id]);
+                    }
+                }
+                // An outbox write, as a keep is.
+                options.interfere?.("keep", transaction);
+                await done;
+            }
+            catch (error) {
+                await done.catch(() => undefined);
+                throw error;
+            }
+        },
         /** Drop this device's copy and its outbox, and move to a new generation so no open tab writes it back. */
         async forget() {
             const database = await db();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slopkit",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "Opinionated standards and libraries for fast, local-first personal software: state machines, exhaustive state tables, sync, a command ledger, jobs, a guarded server, and the conformance suite that proves them",
   "keywords": [
     "conformance",
@@ -82,6 +82,10 @@
       "types": "./dist/server/jobs.d.ts",
       "default": "./dist/server/jobs.js"
     },
+    "./server/pull": {
+      "types": "./dist/server/pull.d.ts",
+      "default": "./dist/server/pull.js"
+    },
     "./server/web": {
       "types": "./dist/server/web.d.ts",
       "default": "./dist/server/web.js"
@@ -118,6 +122,18 @@
       "types": "./dist/conformance/fixtures.d.ts",
       "default": "./dist/conformance/fixtures.js"
     },
+    "./conformance/legacy/replica-012": {
+      "types": "./dist/conformance/legacy/replica-012.d.ts",
+      "default": "./dist/conformance/legacy/replica-012.js"
+    },
+    "./conformance/paging-fixtures": {
+      "types": "./dist/conformance/paging-fixtures.d.ts",
+      "default": "./dist/conformance/paging-fixtures.js"
+    },
+    "./conformance/pull": {
+      "types": "./dist/conformance/pull.d.ts",
+      "default": "./dist/conformance/pull.js"
+    },
     "./package.json": "./package.json"
   },
   "dependencies": {