slopkit 0.1.0 → 0.1.2

package/DEPS.md

@@ -29,7 +29,7 @@ seeded network's PRNG and scheduler.
 ## Budgets
 
 - **Kit client core**, gated by `pack:check` on the packed package: `schema`, `contract`, `sync`, `client`, `machine`,
-  `money`, `digest`, `states` and `web/replica`, minified and gzipped together, ≤ 10,730 bytes (10,668 measured).
+  `money`, `digest`, `states` and `web/replica`, minified and gzipped together, ≤ 10,730 bytes (10,726 measured).
   `cron` is browser-safe but outside the core; an app that ships it counts it in its own budget. The budget grows only
   with a new entry or guarantee, by its measured size.
 - **Hello app** (preact, signals, and `sync`, `client`, `web/replica`, `schema`, `contract`, `states`): ≤ 17 KB gzip

package/dist/conformance/push-batch.test.d.ts

@@ -0,0 +1,2 @@
+/** A push carries at most `PUSH_MAX` commands, so a long outbox drains through a push endpoint bounded the same way. */
+export {};

package/dist/conformance/push-batch.test.js

@@ -0,0 +1,66 @@
+/** A push carries at most `PUSH_MAX` commands, so a long outbox drains through a push endpoint bounded the same way. */
+import { expect, test } from "vitest";
+import { createClient } from "../client.js";
+import { createSync, PUSH_MAX } from "../sync.js";
+import { copy, database, patch, pending, sync } from "./fixtures.js";
+test("120 kept commands go out as pushes of 50, 50 and 20, each once, and all reach an outcome", async () => {
+    const stored = database();
+    await stored.port.load();
+    await stored.port.commit({
+        replica: copy(29, []),
+        reset: true,
+        base: 0,
+        replaces: "dataset-a",
+        ops: [],
+    });
+    for (let id = 1; id <= 120; id++) {
+        await stored.port.keep({ ...pending("older-page", id, id), since: 29 });
+    }
+    const reopened = database({ factory: stored.factory, name: stored.name });
+    const pushes = [];
+    const runtime = createClient({
+        sync,
+        client: "newer-page",
+        ports: {
+            storage: reopened.port,
+            network: {
+                pull: async () => ({ ok: true, value: { patch: patch(29, []), receipts: [] } }),
+                push: async (request) => {
+                    pushes.push(request.commands.map((each) => each.id));
+                    // The server's contract: a push of more than 50 commands is refused before anything acts.
+                    if (request.commands.length > 50) {
+                        return { ok: false, failure: { kind: "invalid", message: "commands: at most 50" } };
+                    }
+                    return {
+                        ok: true,
+                        value: {
+                            receipts: request.commands.map((each) => ({
+                                id: each.id,
+                                outcome: { kind: "ok", resource: `r${each.id}` },
+                                revision: 29,
+                            })),
+                            revision: 29,
+                        },
+                    };
+                },
+            },
+            now: () => 0,
+            fingerprint: async () => "fixture-fingerprint",
+        },
+    });
+    runtime.start();
+    await runtime.settle();
+    expect(pushes.map((each) => each.length)).toStrictEqual([50, 50, 20]);
+    expect(pushes.flat()).toStrictEqual(Array.from({ length: 120 }, (_, at) => at + 1));
+    expect(runtime
+        .model()
+        .commands.filter((each) => each.state.kind === "done")
+        .map((each) => each.id)).toHaveLength(120);
+    expect(runtime.faults).toStrictEqual([]);
+    expect(PUSH_MAX).toBe(50);
+});
+test("a push bound that isn't a positive integer is refused when sync is made", () => {
+    for (const pushMax of [0, -1, 1.5, Number.NaN]) {
+        expect(() => createSync({ tables: [], empty: {}, onlineOnly: () => false, refused: () => null, pushMax })).toThrow(/pushMax must be a positive integer/);
+    }
+});

package/dist/sync.d.ts

@@ -378,6 +378,8 @@ export type Spec<T, P, S, C, O> = {
      * until it resolves or the person dismisses it. Default: every outcome is resolved.
      */
     resolved?: (pending: Pending<C, O>, model: Model<T, S, C, O>) => boolean;
+    /** The most commands one push carries: the push endpoint's own bound. Default `PUSH_MAX`. */
+    pushMax?: number;
 };
 /** The socket must be heard this often (the server pokes every 20 s); quieter, the page polls. */
 export declare const SOCKET_DEADLINE_MS = 45000;
@@ -385,6 +387,8 @@ export declare const SOCKET_DEADLINE_MS = 45000;
 export declare const POLL_MS = 4000;
 /** Storage gets this long to load, or to keep an intent, before the page goes on without it. */
 export declare const STORAGE_DEADLINE_MS = 3000;
+/** Commands per push unless the spec says otherwise; the rest wait for the next push. */
+export declare const PUSH_MAX = 50;
 /** Settled commands stay drawn this long. */
 export declare const DONE_KEEP_MS = 60000;
 /** Whether the server can be asked now. */

package/dist/sync.js

@@ -47,6 +47,8 @@ export const POLL_MS = 4000;
 const BACKOFF_MAX_MS = 30_000;
 /** Storage gets this long to load, or to keep an intent, before the page goes on without it. */
 export const STORAGE_DEADLINE_MS = 3000;
+/** Commands per push unless the spec says otherwise; the rest wait for the next push. */
+export const PUSH_MAX = 50;
 /** Settled commands stay drawn this long. */
 export const DONE_KEEP_MS = 60_000;
 /** Whether the server can be asked now. */
@@ -114,6 +116,10 @@ function failedConnection(connection, failure) {
     }
 }
 export function createSync(spec) {
+    const pushMax = spec.pushMax ?? PUSH_MAX;
+    if (!Number.isSafeInteger(pushMax) || pushMax < 1) {
+        throw new Error(`sync: pushMax must be a positive integer, got ${pushMax}`);
+    }
     const emptyReplica = () => ({
         dataset: null,
         revision: 0,
@@ -212,12 +218,14 @@ export function createSync(spec) {
             const first = next.commands.find((each) => each.state.kind === "queued" || each.state.kind === "unknown");
             if (first !== undefined) {
                 // One push per client, dataset and tapped-against revision: the server judges each by what it was made on.
+                // At most `pushMax`, oldest first; the rest go in the next push.
                 const tapped = (each) => each.since ?? next.replica.revision;
                 const ids = new Set(next.commands
                     .filter((each) => each.client === first.client &&
                     each.dataset === first.dataset &&
                     tapped(each) === tapped(first) &&
                     (each.state.kind === "queued" || each.state.kind === "unknown"))
+                    .slice(0, pushMax)
                     .map((each) => each.id));
                 const mine = (each) => each.client === first.client && ids.has(each.id);
                 out.push({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slopkit",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "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",