slopkit 0.1.1 → 0.2.0

package/dist/web/replica.js

@@ -11,7 +11,11 @@
  * - 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 +25,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 { check, literal, nullable, number, object, string } from "../schema.js";
 import { commitPlan } 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 +158,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 +217,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 +253,7 @@ export function indexedReplica(options) {
                     revision: at.revision,
                     tables: restored,
                     server: server?.ok === true ? server.value : null,
+                    history: at.history,
                 },
                 commands,
                 unreadable,
@@ -246,7 +268,6 @@ export function indexedReplica(options) {
                 dataset: commit.replica.dataset,
                 revision: commit.replica.revision,
                 server: commit.replica.server,
-                shapes,
             };
             try {
                 await guard(transaction);
@@ -267,6 +288,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 +300,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 +327,7 @@ export function indexedReplica(options) {
                         }
                     }
                 };
-                if (plan === "delta") {
+                if (plan === "delta" || plan === "adopt") {
                     write(commit.ops);
                 }
                 if (plan === "whole") {
@@ -318,8 +340,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,11 +358,16 @@ 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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slopkit",
-  "version": "0.1.1",
+  "version": "0.2.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": {