slopkit 0.1.2 → 0.3.0

package/dist/conformance/legacy/replica-012.js

@@ -0,0 +1,403 @@
+/* oxlint-disable anti-slop/no-unknown-parameters, anti-slop/no-runtime-typeof, anti-slop/no-reflect-get -- frozen released storage boundary, not a new decoder */
+// Released 0.1.2 adapter and commit decision, kept unchanged for cross-release read/write checks.
+/**
+ * The sync engine's storage port over IndexedDB: the replica (one store per table, out-of-line keys, and a checkpoint)
+ * and the outbox (one record per command, keyed by client and number), in one database shared by every tab.
+ *
+ * - A commit is decided inside its own read-write transaction from the checkpoint the disk holds (`commitPlan`): a
+ *   stale tab can't make the disk go back, and a patch whose base the disk never reached is written as the whole
+ *   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.
+ * - 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
+ *   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.
+ * - A newer version opening in another tab closes this page's connection; its writes then fail as `Replaced`.
+ *
+ * `factory` is the browser's `indexedDB`, or any implementation of the same API (the headless simulation passes an
+ * 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 { committed, openDatabase, request } from "../../web/idb.js";
+function commitPlan(stored, commit) {
+    const same = stored.dataset === commit.dataset;
+    if (!same && stored.dataset !== null && stored.dataset !== commit.replaces) {
+        return "stale";
+    }
+    if (same && stored.revision >= commit.revision) {
+        return "skip";
+    }
+    if (!commit.reset && same && stored.revision >= commit.base) {
+        return "delta";
+    }
+    return "whole";
+}
+export function indexedReplica(options) {
+    const names = options.tables.map((lens) => lens.name);
+    const shapes = options.tables.map((lens) => lens.shape).join("\n");
+    /** 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. */
+    let discarded = null;
+    /**
+     * The checkpoint this page loaded, as written: a copy under other row shapes is this page's to replace only while it
+     * is still that one. Once another release's tab writes its own, that release owns the copy on this device.
+     */
+    let loaded;
+    let opened;
+    /** The generation this page loaded; undefined until it has. */
+    let generation;
+    /** A newer version took the database over: this page must reload. */
+    let superseded = false;
+    /**
+     * The version to open: `version`, or past what the browser has when that lacks a store these tables need (a table
+     * added without a bump) or is already newer (another release's tab moved it): the layout follows the tables, so a
+     * forgotten bump can't leave the copy unopenable.
+     */
+    const layout = async () => {
+        const probe = await new Promise((resolve, reject) => {
+            const opening = options.factory.open(options.name);
+            opening.onsuccess = () => resolve(opening.result);
+            opening.onerror = () => reject(opening.error ?? new Error(`can't open ${options.name}`));
+        });
+        const missing = [...names, "meta", "outbox"].some((name) => !probe.objectStoreNames.contains(name));
+        const current = probe.version;
+        probe.close();
+        if (current >= options.version && !missing) {
+            return current;
+        }
+        return Math.max(current + (missing ? 1 : 0), options.version);
+    };
+    const open = () => {
+        opened ??= layout()
+            .then((version) => openDatabase(options.factory, options.name, version, (database, _from, upgrade) => {
+            // Replica tables start over (the server has them); every other store an earlier version kept may hold work
+            // nobody else has, so its records move into the outbox: converted by `legacy`, else kept as they were under
+            // their own key, counted unreadable. Nothing is dropped unseen.
+            const legacy = options.legacy;
+            const own = new Set(["meta", "outbox"]);
+            if (!database.objectStoreNames.contains("outbox")) {
+                database.createObjectStore("outbox");
+            }
+            if (database.objectStoreNames.contains("meta")) {
+                upgrade.objectStore("meta").delete("checkpoint");
+            }
+            else {
+                database.createObjectStore("meta");
+            }
+            const outbox = upgrade.objectStore("outbox");
+            // A snapshot: deleting a store changes the live list being walked.
+            const existing = [...database.objectStoreNames];
+            for (const name of existing) {
+                if (own.has(name)) {
+                    continue;
+                }
+                if (names.includes(name)) {
+                    database.deleteObjectStore(name);
+                    continue;
+                }
+                const cursor = upgrade.objectStore(name).openCursor();
+                let at = 0;
+                cursor.onsuccess = () => {
+                    const current = cursor.result;
+                    if (current === null) {
+                        database.deleteObjectStore(name);
+                        return;
+                    }
+                    const value = current.value;
+                    const command = legacy?.store === name ? legacy.convert(value) : undefined;
+                    if (command === undefined) {
+                        outbox.put(value, ["legacy", name, at++]);
+                    }
+                    else {
+                        outbox.put(command, [command.client, command.id]);
+                    }
+                    current.continue();
+                };
+            }
+            for (const name of names) {
+                database.createObjectStore(name);
+            }
+        }))
+            .then((database) => {
+            // The browser closed it under us (iOS Safari, cleared site data): the next call opens it again.
+            database.onclose = () => {
+                opened = undefined;
+            };
+            database.onversionchange = () => {
+                superseded = true;
+                database.close();
+            };
+            return database;
+        });
+        // A failed open may succeed later (a blocked upgrade): try again next time.
+        opened.catch(() => (opened = undefined));
+        return opened;
+    };
+    const db = async () => {
+        if (superseded) {
+            throw new Replaced();
+        }
+        return await open();
+    };
+    /** Inside a write transaction: refuse if the database was forgotten since this page loaded. */
+    async function guard(transaction) {
+        const stored = await request(transaction.objectStore("meta").get("generation"));
+        if ((typeof stored === "number" ? stored : 0) !== (generation ?? 0)) {
+            transaction.abort();
+            throw new Replaced();
+        }
+    }
+    /** The checkpoint on disk as this version may trust it: one of other row shapes (or none) holds nothing. */
+    const checkpointOf = (value) => {
+        if (typeof value !== "object" || value === null) {
+            return { dataset: null, revision: 0 };
+        }
+        const dataset = Reflect.get(value, "dataset");
+        const revision = Reflect.get(value, "revision");
+        if (Reflect.get(value, "shapes") !== shapes) {
+            return { dataset: null, revision: 0 };
+        }
+        const at = {
+            dataset: typeof dataset === "string" ? dataset : null,
+            revision: typeof revision === "number" ? revision : 0,
+        };
+        if (damaged !== undefined &&
+            damaged.dataset === at.dataset &&
+            damaged.revision === at.revision) {
+            return { dataset: null, revision: 0 };
+        }
+        return at;
+    };
+    return {
+        async load() {
+            const database = await db();
+            const transaction = database.transaction([...names, "meta", "outbox"], "readonly");
+            const entries = (name) => Promise.all([
+                request(transaction.objectStore(name).getAllKeys()),
+                request(transaction.objectStore(name).getAll()),
+            ]).then(([keys, rows]) => keys.flatMap((key, at) => typeof key === "string" || typeof key === "number" ? [{ key, row: rows[at] }] : []));
+            const [stored, point, outbox, ...tables] = await Promise.all([
+                request(transaction.objectStore("meta").get("generation")),
+                request(transaction.objectStore("meta").get("checkpoint")),
+                request(transaction.objectStore("outbox").getAll()),
+                ...names.map(entries),
+            ]);
+            generation = typeof stored === "number" ? stored : 0;
+            // A tap kept before taps recorded their copy's revision was made on the copy beside it on the disk: it takes
+            // that checkpoint's revision now, before the rows can be discarded (other row shapes, rows that don't parse),
+            // so a copy started over never makes it look like it was made on nothing.
+            const disk = typeof point === "object" && point !== null ? Reflect.get(point, "revision") : 0;
+            const commands = outbox.flatMap((each) => {
+                const parsed = check(options.pending, each);
+                if (!parsed.ok) {
+                    return [];
+                }
+                return [
+                    parsed.value.since === undefined && typeof disk === "number" && disk > 0
+                        ? { ...parsed.value, since: disk }
+                        : parsed.value,
+                ];
+            });
+            const unreadable = outbox.length - commands.length;
+            const empty = {
+                dataset: null,
+                revision: 0,
+                tables: options.empty,
+                server: null,
+            };
+            const at = checkpointOf(point);
+            const raw = typeof point === "object" && point !== null ? Reflect.get(point, "dataset") : null;
+            discarded = typeof raw === "string" && raw !== at.dataset ? raw : null;
+            loaded =
+                typeof point === "object" && point !== null
+                    ? {
+                        dataset: raw,
+                        revision: disk,
+                        shapes: Reflect.get(point, "shapes"),
+                    }
+                    : undefined;
+            const server = typeof point === "object" && point !== null
+                ? check(options.server, Reflect.get(point, "server"))
+                : undefined;
+            let restored = options.empty;
+            for (const [index, lens] of options.tables.entries()) {
+                restored = restored === undefined ? undefined : lens.restore(restored, tables[index] ?? []);
+            }
+            // Rows written under other shapes, or that no longer fit: start over rather than show wrong data, and let the
+            // next commit rewrite the disk. The server's facts are not rows (every pull brings them again), so facts an
+            // older page kept that no longer fit wait for the next pull instead of costing the copy.
+            if (restored === undefined && at.dataset !== null) {
+                damaged = at;
+                discarded = at.dataset;
+            }
+            if (restored === undefined || at.dataset === null) {
+                return { replica: empty, commands, unreadable };
+            }
+            return {
+                replica: {
+                    dataset: at.dataset,
+                    revision: at.revision,
+                    tables: restored,
+                    server: server?.ok === true ? server.value : null,
+                },
+                commands,
+                unreadable,
+            };
+        },
+        async commit(commit) {
+            const database = await db();
+            const transaction = database.transaction([...names, "meta"], "readwrite");
+            const done = committed(transaction);
+            const meta = transaction.objectStore("meta");
+            const target = {
+                dataset: commit.replica.dataset,
+                revision: commit.replica.revision,
+                server: commit.replica.server,
+                shapes,
+            };
+            try {
+                await guard(transaction);
+                const point = await request(meta.get("checkpoint"));
+                // The disk holds another dataset this page never saw (the server replaced the one it is on): refused,
+                // whatever row shapes wrote it, so a tab of another release can't write a replaced dataset back.
+                const held = typeof point === "object" && point !== null ? Reflect.get(point, "dataset") : null;
+                if (typeof held === "string" &&
+                    held !== commit.replica.dataset &&
+                    held !== commit.replaces &&
+                    held !== discarded) {
+                    transaction.abort();
+                    throw new Replaced();
+                }
+                const stored = checkpointOf(point);
+                const plan = commitPlan(stored, {
+                    ...target,
+                    reset: commit.reset,
+                    base: commit.base,
+                    replaces: commit.replaces,
+                });
+                // The disk holds a dataset this page never saw: the server replaced the one this page is on.
+                if (plan === "stale") {
+                    transaction.abort();
+                    throw new Replaced();
+                }
+                const revision = typeof point === "object" && point !== null ? Reflect.get(point, "revision") : 0;
+                const written = typeof point === "object" && point !== null ? Reflect.get(point, "shapes") : undefined;
+                // 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 &&
+                    (loaded === undefined ||
+                        loaded.dataset !== held ||
+                        loaded.revision !== revision ||
+                        loaded.shapes !== written)) {
+                    transaction.abort();
+                    throw new Replaced();
+                }
+                // The copy this page loaded and couldn't read (other row shapes, rows that don't parse) still fences it: never
+                // rewritten below its revision. The page catches up from the server and writes it then.
+                if (plan === "whole" &&
+                    held === commit.replica.dataset &&
+                    typeof revision === "number" &&
+                    revision > commit.replica.revision) {
+                    transaction.abort();
+                    throw new Error("this device holds a newer copy than this page");
+                }
+                const write = (ops) => {
+                    for (const op of ops) {
+                        if ("drop" in op) {
+                            transaction.objectStore(op.table).delete(op.key);
+                        }
+                        else {
+                            transaction.objectStore(op.table).put(op.row, op.key);
+                        }
+                    }
+                };
+                if (plan === "delta") {
+                    write(commit.ops);
+                }
+                if (plan === "whole") {
+                    for (const name of names) {
+                        transaction.objectStore(name).clear();
+                    }
+                    for (const lens of options.tables) {
+                        write(lens.snapshot(commit.replica.tables));
+                    }
+                }
+                // 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;
+                if (plan !== "skip" || facts) {
+                    meta.put(target, "checkpoint");
+                }
+                options.interfere?.("commit", transaction);
+                await done;
+                if (plan === "whole") {
+                    damaged = undefined;
+                    discarded = null;
+                    loaded = undefined;
+                }
+                const now = plan === "skip" ? stored : target;
+                if (now.dataset === null) {
+                    throw new Error("the replica has no dataset");
+                }
+                return { dataset: now.dataset, revision: now.revision };
+            }
+            catch (error) {
+                await done.catch(() => undefined);
+                throw error;
+            }
+        },
+        async keep(pending) {
+            const database = await db();
+            const transaction = database.transaction(["meta", "outbox"], "readwrite");
+            const done = committed(transaction);
+            try {
+                await guard(transaction);
+                transaction.objectStore("outbox").put(pending, [pending.client, pending.id]);
+                options.interfere?.("keep", transaction);
+                await done;
+            }
+            catch (error) {
+                await done.catch(() => undefined);
+                throw error;
+            }
+        },
+        async drop(keys) {
+            const database = await db();
+            const transaction = database.transaction(["meta", "outbox"], "readwrite");
+            const done = committed(transaction);
+            try {
+                await guard(transaction);
+                for (const key of keys) {
+                    transaction.objectStore("outbox").delete([key.client, key.id]);
+                }
+                options.interfere?.("drop", 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();
+            const transaction = database.transaction([...names, "meta", "outbox"], "readwrite");
+            const done = committed(transaction);
+            const meta = transaction.objectStore("meta");
+            const stored = await request(meta.get("generation"));
+            for (const name of [...names, "outbox"]) {
+                transaction.objectStore(name).clear();
+            }
+            meta.delete("checkpoint");
+            meta.put((typeof stored === "number" ? stored : 0) + 1, "generation");
+            await done;
+        },
+    };
+}

package/dist/conformance/outbox-bound.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/conformance/outbox-bound.test.js

@@ -0,0 +1,268 @@
+import { expect, test } from "vitest";
+import { createClient } from "../client.js";
+import * as syncApi from "../sync.js";
+import { createSync } from "../sync.js";
+import { database, deferred, pending, rowsLens } from "./fixtures.js";
+function bounded(max = 3, joins = false) {
+    return createSync({
+        tables: [rowsLens],
+        empty: { rows: new Map() },
+        onlineOnly: () => false,
+        refused: (_command, reason) => ({ kind: "failed", reason }),
+        outboxMax: max,
+        joins: (waiting, next) => joins && waiting.value === next.value,
+    });
+}
+const offline = {
+    pull: async () => ({ ok: false, failure: { kind: "offline", message: "offline" } }),
+    push: async () => {
+        throw new Error("no offline intent may be sent");
+    },
+};
+function client(stored, id, max = 3, joins = false) {
+    const answers = [];
+    const runtime = createClient({
+        sync: bounded(max, joins),
+        client: id,
+        ports: {
+            storage: stored.port,
+            network: offline,
+            now: () => 0,
+            fingerprint: async () => "",
+            answered: (answer) => {
+                answers.push(answer);
+            },
+        },
+    });
+    return { runtime, answers };
+}
+test("outbox has a shared default of 500 at the storage boundary", async () => {
+    const stored = database();
+    await stored.port.load();
+    const results = await Promise.all(Array.from({ length: 501 }, (_, at) => stored.port.keep(pending("page", at + 1))));
+    expect(results.slice(0, 500)).toStrictEqual(Array.from({ length: 500 }, () => undefined));
+    expect(results[500]).toStrictEqual({ kind: "full", waiting: 500, finished: 0, max: 500 });
+    expect((await stored.port.load()).commands).toHaveLength(500);
+    expect(syncApi.OUTBOX_MAX).toBe(500);
+});
+test("outboxMax must be a positive safe integer", () => {
+    for (const max of [0, -1, 1.5, Number.NaN]) {
+        expect(() => bounded(max)).toThrow(/outboxMax must be a positive integer/);
+    }
+});
+test("keep admits and counts in one transaction, but always permits an existing key's outcome", async () => {
+    const stored = database();
+    await stored.port.load();
+    const first = pending("page", 1);
+    expect(await stored.port.keep(first, 1)).toBeUndefined();
+    expect(await stored.port.keep(pending("page", 2), 1)).toStrictEqual({
+        kind: "full",
+        waiting: 1,
+        finished: 0,
+        max: 1,
+    });
+    expect(await stored.port.keep({ ...first, state: { kind: "done", outcome: { kind: "ok", resource: "r1" }, revision: 0 } }, 1)).toBeUndefined();
+    expect(await stored.port.keep(pending("page", 3), 1)).toStrictEqual({
+        kind: "full",
+        waiting: 0,
+        finished: 1,
+        max: 1,
+    });
+    expect((await stored.port.load()).commands).toHaveLength(1);
+});
+test("two offline clients share one transactional admission bound; every unadmitted tap is answered without a record", async () => {
+    const a = database();
+    const b = database({ factory: a.factory, name: a.name });
+    const ca = client(a, "tab-a");
+    const cb = client(b, "tab-b");
+    ca.runtime.start();
+    cb.runtime.start();
+    await Promise.all([ca.runtime.settle(), cb.runtime.settle()]);
+    // Neither page has heard of the other's taps. All six keeps overlap before either page gets an acknowledgement.
+    for (const value of [1, 2, 3]) {
+        ca.runtime.command({ name: "put", value });
+        cb.runtime.command({ name: "put", value: value + 10 });
+    }
+    await Promise.all([ca.runtime.settle(), cb.runtime.settle()]);
+    const disk = await a.port.load();
+    const models = [...ca.runtime.model().commands, ...cb.runtime.model().commands];
+    const refused = [...ca.answers, ...cb.answers];
+    expect(disk.commands).toHaveLength(3);
+    expect(models).toHaveLength(3);
+    expect(new Set(disk.commands.map((each) => `${each.client}:${each.id}`)).size).toBe(3);
+    expect(models
+        .map((each) => `${each.client}:${each.id}`)
+        .toSorted((left, right) => left.localeCompare(right))).toStrictEqual(disk.commands
+        .map((each) => `${each.client}:${each.id}`)
+        .toSorted((left, right) => left.localeCompare(right)));
+    expect(refused).toHaveLength(3);
+    for (const answer of refused) {
+        expect(answer.state).toMatchObject({
+            kind: "done",
+            revision: 0,
+            outcome: { kind: "failed" },
+        });
+        if (answer.state.kind !== "done" || answer.state.outcome.kind !== "failed") {
+            throw new Error("not a refused tap");
+        }
+        expect(answer.state.outcome.reason).toMatch(/outbox.*full/i);
+        expect(models).not.toContainEqual(answer);
+        expect(disk.commands.some((each) => each.client === answer.client && each.id === answer.id)).toBe(false);
+    }
+    expect(ca.runtime.model().storage.kind).toBe("ok");
+    expect(cb.runtime.model().storage.kind).toBe("ok");
+    expect([...ca.runtime.faults, ...cb.runtime.faults]).toStrictEqual([]);
+    const denied = ca.answers.length > 0 ? ca : cb;
+    expect(syncApi.deriveOutboxState(denied.runtime.model())).toStrictEqual({
+        kind: "full",
+        waiting: 3,
+        finished: 0,
+        max: 3,
+    });
+});
+test("a full outbox leaves model and disk unchanged; joins coalesces before admission", async () => {
+    const stored = database();
+    const app = client(stored, "page", 1, true);
+    app.runtime.start();
+    await app.runtime.settle();
+    app.runtime.command({ name: "put", value: 1 });
+    await app.runtime.settle();
+    const before = (await stored.port.load()).commands;
+    app.runtime.command({ name: "put", value: 1 });
+    await app.runtime.settle();
+    expect(app.answers).toStrictEqual([]);
+    app.runtime.command({ name: "put", value: 2 });
+    await app.runtime.settle();
+    expect(app.runtime.model().commands).toHaveLength(1);
+    expect((await stored.port.load()).commands).toStrictEqual(before);
+    expect(app.answers).toHaveLength(1);
+    expect(app.runtime.model().storage.kind).toBe("ok");
+});
+test("a late load plus concurrent keeps obeys the disk count, not the page's pre-load count", async () => {
+    const stored = database();
+    const old = client(stored, "old");
+    old.runtime.start();
+    await old.runtime.settle();
+    for (const value of [1, 2, 3]) {
+        old.runtime.command({ name: "put", value });
+    }
+    await old.runtime.settle();
+    const loaded = deferred();
+    const answers = [];
+    const late = createClient({
+        sync: bounded(),
+        client: "late",
+        ports: {
+            storage: { ...stored.port, load: () => loaded.promise },
+            network: offline,
+            now: () => 3001,
+            fingerprint: async () => "",
+            answered: (answer) => {
+                answers.push(answer);
+            },
+        },
+    });
+    late.start();
+    late.dispatch({ type: "tick", now: 6002 });
+    late.command({ name: "put", value: 4 });
+    loaded.resolve(await stored.port.load());
+    await late.settle();
+    expect((await stored.port.load()).commands.map((each) => each.command.value)).toStrictEqual([
+        1, 2, 3,
+    ]);
+    expect(late.model().commands.map((each) => each.command.value)).toStrictEqual([1, 2, 3]);
+    expect(answers).toHaveLength(1);
+});
+test("grandfathered records are never dropped; outcomes update at capacity and dismissal permits a new admission", async () => {
+    const stored = database();
+    const old = client(stored, "old", 4);
+    old.runtime.start();
+    await old.runtime.settle();
+    for (const value of [1, 2, 3, 4]) {
+        old.runtime.command({ name: "put", value });
+    }
+    await old.runtime.settle();
+    const reopened = database({ factory: stored.factory, name: stored.name });
+    const app = client(reopened, "new", 3);
+    app.runtime.start();
+    await app.runtime.settle();
+    // A late receipt is an update of an existing key, even when the current bound is below the existing count.
+    app.runtime.dispatch({
+        type: "pushed",
+        client: "old",
+        ids: [1],
+        revision: 0,
+        receipts: [{ id: 1, outcome: { kind: "ok", resource: "r1" }, revision: 0 }],
+        now: 0,
+    });
+    await app.runtime.settle();
+    expect((await stored.port.load()).commands).toHaveLength(4);
+    expect((await stored.port.load()).commands[0]?.state).toStrictEqual({
+        kind: "done",
+        outcome: { kind: "ok", resource: "r1" },
+        revision: 0,
+    });
+    app.runtime.command({ name: "put", value: 5 });
+    await app.runtime.settle();
+    expect((await stored.port.load()).commands).toHaveLength(4);
+    expect(syncApi.deriveOutboxState(app.runtime.model())).toStrictEqual({
+        kind: "full",
+        waiting: 3,
+        finished: 1,
+        max: 3,
+    });
+    // The count must be below max, not merely equal to max.
+    app.runtime.dispatch({ type: "dismiss", client: "old", id: 1, now: 0 });
+    await app.runtime.settle();
+    app.runtime.command({ name: "put", value: 6 });
+    await app.runtime.settle();
+    expect((await stored.port.load()).commands).toHaveLength(3);
+    app.runtime.dispatch({
+        type: "pushed",
+        client: "old",
+        ids: [2],
+        revision: 0,
+        receipts: [{ id: 2, outcome: { kind: "ok", resource: "r2" }, revision: 0 }],
+        now: 0,
+    });
+    await app.runtime.settle();
+    app.runtime.dispatch({ type: "dismiss", client: "old", id: 2, now: 0 });
+    await app.runtime.settle();
+    app.runtime.command({ name: "put", value: 7 });
+    await app.runtime.settle();
+    expect((await stored.port.load()).commands.map((each) => each.command.value).toSorted((a, b) => a - b)).toStrictEqual([3, 4, 7]);
+    expect(app.runtime.faults).toStrictEqual([]);
+});
+test("the outbox subject distinguishes waiting work from finished work needing dismissal", async () => {
+    const stored = database();
+    const app = client(stored, "page", 1);
+    app.runtime.start();
+    await app.runtime.settle();
+    expect(syncApi.deriveOutboxState(app.runtime.model())).toStrictEqual({ kind: "ok" });
+    app.runtime.command({ name: "put", value: 1 });
+    await app.runtime.settle();
+    expect(syncApi.deriveOutboxState(app.runtime.model())).toStrictEqual({
+        kind: "full",
+        waiting: 1,
+        finished: 0,
+        max: 1,
+    });
+    app.runtime.dispatch({
+        type: "pushed",
+        client: "page",
+        ids: [1],
+        revision: 0,
+        receipts: [{ id: 1, outcome: { kind: "ok", resource: "r1" }, revision: 0 }],
+        now: 0,
+    });
+    await app.runtime.settle();
+    expect(syncApi.deriveOutboxState(app.runtime.model())).toStrictEqual({
+        kind: "full",
+        waiting: 0,
+        finished: 1,
+        max: 1,
+    });
+    app.runtime.dispatch({ type: "dismiss", client: "page", id: 1, now: 0 });
+    await app.runtime.settle();
+    expect(syncApi.deriveOutboxState(app.runtime.model())).toStrictEqual({ kind: "ok" });
+});

package/dist/conformance/paging-budget.test.d.ts

@@ -0,0 +1 @@
+export {};