slopkit 0.2.0 → 0.3.0

package/dist/web/replica.js

@@ -7,7 +7,9 @@
  *   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
@@ -26,7 +28,7 @@
  */
 import { Replaced } from "../client.js";
 import { check, literal, nullable, number, object, string } from "../schema.js";
-import { commitPlan } from "../sync.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 });
@@ -374,15 +376,31 @@ export function indexedReplica(options) {
                 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);
@@ -406,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.2.0",
+  "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",