@byollm/relay 0.1.0-alpha.8 → 0.1.0-alpha.80

package/dist/store-contract.d.ts

@@ -0,0 +1,67 @@
+import { R as RoutingStore } from './store-DPCLO12l.js';
+import '@byollm/protocol';
+
+/**
+ * The routing store's behaviour, written once and run against every
+ * implementation — cloud_008 finding 54.
+ *
+ * There were two copies. This package tested `RelayState`; `byollm-cloud`
+ * tested `ValkeyRoutingStore` with a file that opened by explaining it was
+ * "written once and parameterised… a second copy of the scenario is a second
+ * place for two implementations to quietly diverge" — and was itself the
+ * second copy. It had drifted to sixteen cases against the eighteen in the
+ * ledger, which is exactly the divergence the sentence predicted, happening
+ * to the sentence.
+ *
+ * So the contract lives here, in the package that declares `RoutingStore`,
+ * and both repositories import it. A store that cannot pass this is not a
+ * routing store, whatever it implements.
+ *
+ * ## Why this ships in the published package
+ *
+ * Because the implementation that matters most is in another repository. A
+ * contract only the author can run is a description; one a third party runs
+ * against their own implementation is a contract. `@byollm/relay/store-contract`
+ * is a subpath export so nothing that imports the relay itself pulls in a
+ * test framework.
+ *
+ * ## What this cannot prove
+ *
+ * `CLAIM_ATOMIC` is a MUST and every case here would pass against a store
+ * that read, decided and wrote in three steps — in one process there is
+ * nothing to interleave. Concurrency belongs with the implementation that
+ * has a network in it, and `byollm-cloud`'s suite runs it against Valkey with
+ * many connections. Named here so the omission is a decision rather than an
+ * oversight.
+ */
+/** The control-plane site id these cases route under. */
+declare const CONTRACT_SITE = "site_store";
+interface StoreContractOptions {
+    /**
+     * A fresh, empty store, and how to dispose of it.
+     *
+     * Arrow-typed rather than a method, because the caller passes these
+     * around: a method signature lets `this` travel with the call, and a
+     * factory read off an options object is exactly where that goes wrong.
+     */
+    readonly make: () => Promise<{
+        store: RoutingStore;
+        done: () => Promise<void>;
+    }>;
+    /**
+     * Whether this store writes stubs as bytes and reads them back.
+     *
+     * An in-process store holds typed objects and cannot hold a stub it cannot
+     * parse; a serialising one can, because what it wrote may have been written
+     * by a previous version. The case that covers it is skipped rather than
+     * hidden — a reader should know which half of this contract each store is
+     * proving (cloud_008 §2.1a).
+     */
+    readonly serialising?: boolean;
+    /** Write a stub's raw bytes, bypassing serialisation. */
+    readonly writeRawStub?: (store: RoutingStore, id: string, raw: string) => Promise<void>;
+}
+/** Run the contract. Call inside a suite; it declares its own `describe`. */
+declare function describeStoreContract(name: string, options: StoreContractOptions): void;
+
+export { CONTRACT_SITE, type StoreContractOptions, describeStoreContract };

package/dist/store-contract.js

@@ -0,0 +1,625 @@
+import {
+  routeKey
+} from "./chunk-OB6LPEEE.js";
+
+// src/store-contract.ts
+import { generateKeys, publicIdentityOf } from "@byollm/protocol";
+import { describe, expect, it } from "vitest";
+var CONTRACT_SITE = "site_store";
+var SITE_KEY_ID = "BYOLLM-TEST-SITE-KEY-ID";
+var SITE = CONTRACT_SITE;
+var stub = (id, owner = "alice") => ({
+  id,
+  kind: "llm.generate",
+  owner,
+  site: SITE_KEY_ID,
+  audience: "private",
+  sizeClass: "small",
+  streaming: false,
+  deadlineAt: 41024448e5
+});
+var capability = (model) => ({
+  kind: "llm.generate",
+  service: model,
+  backendId: "ollama",
+  backendClass: "process",
+  model,
+  offerScope: "private"
+});
+var ENVELOPE = {
+  ciphertext: "AAAA",
+  recipientKeyId: "r",
+  senderKeyId: "s",
+  direction: "payload",
+  deadlineAt: 41024448e5
+};
+var claimArgs = (over = {}) => {
+  const { owners = ["alice"], sites = [SITE], ...rest } = over;
+  return {
+    runnerId: "runner_1",
+    owner: "alice",
+    device: publicIdentityOf(generateKeys(Date.now())),
+    kinds: /* @__PURE__ */ new Set(["llm.generate"]),
+    routes: new Set(
+      sites.flatMap((site) => owners.map((owner) => routeKey(site, owner)))
+    ),
+    max: 10,
+    leaseMs: 6e4,
+    ...rest
+  };
+};
+function describeStoreContract(name, options) {
+  const { make, serialising, writeRawStub } = options;
+  describe(`the routing store \u2014 ${name}`, () => {
+    it("is idempotent by job id", async () => {
+      const { store, done } = await make();
+      await store.enqueue({ id: "a", siteId: SITE, stub: stub("a") });
+      await store.claim(claimArgs());
+      await store.enqueue({ id: "a", siteId: SITE, stub: stub("a") });
+      expect((await store.job(SITE, "a"))?.state).toBe("awaiting-payload");
+      await done();
+    });
+    it("gives two sites the same id without either seeing the other", async () => {
+      const { store, done } = await make();
+      await store.enqueue({ id: "shared", siteId: SITE, stub: stub("shared") });
+      await store.enqueue({
+        id: "shared",
+        siteId: "site_other",
+        stub: stub("shared", "bob")
+      });
+      expect((await store.job(SITE, "shared"))?.stub.owner).toBe("alice");
+      expect((await store.job("site_other", "shared"))?.stub.owner).toBe("bob");
+      const granted = await store.claim(claimArgs());
+      expect(granted.map((job) => job.id)).toEqual(["shared"]);
+      expect(granted[0]?.owner).toBe("alice");
+      const replay = await store.enqueue({
+        id: "shared",
+        siteId: SITE,
+        stub: stub("shared")
+      });
+      expect(replay).toEqual(await store.job(SITE, "shared"));
+      await done();
+    });
+    it("grants only what the owners set allows", async () => {
+      const { store, done } = await make();
+      await store.enqueue({ id: "mine", siteId: SITE, stub: stub("mine") });
+      await store.enqueue({
+        id: "theirs",
+        siteId: SITE,
+        stub: stub("theirs", "mallory")
+      });
+      const granted = await store.claim(claimArgs());
+      expect(granted.map((job) => job.id)).toEqual(["mine"]);
+      await done();
+    });
+    it("refuses a stale lease and honours the current one", async () => {
+      const { store, done } = await make();
+      await store.enqueue({ id: "a", siteId: SITE, stub: stub("a") });
+      const [granted] = await store.claim(claimArgs());
+      await store.seal({ jobId: "a", siteId: SITE, envelope: ENVELOPE });
+      expect(
+        await store.takePayload({
+          jobId: "a",
+          runnerId: "runner_1",
+          leaseId: "an-older-grant"
+        })
+      ).toEqual({ refused: "stale-lease" });
+      expect(
+        await store.takePayload({
+          jobId: "a",
+          runnerId: "runner_1",
+          leaseId: granted.lease.id
+        })
+      ).toEqual({ envelope: ENVELOPE });
+      await done();
+    });
+    it("will not answer for one job with another job's lease", async () => {
+      const { store, done } = await make();
+      await store.enqueue({ id: "mine", siteId: SITE, stub: stub("mine") });
+      await store.enqueue({ id: "other", siteId: SITE, stub: stub("other") });
+      const granted = await store.claim(claimArgs());
+      const mine = granted.find((job) => job.id === "mine");
+      const other = granted.find((job) => job.id === "other");
+      await store.seal({ jobId: "other", siteId: SITE, envelope: ENVELOPE });
+      expect(
+        await store.takePayload({
+          jobId: "other",
+          runnerId: "runner_1",
+          leaseId: mine.lease.id
+        })
+      ).toEqual({ refused: "stale-lease" });
+      expect(
+        await store.takePayload({
+          jobId: "other",
+          runnerId: "runner_1",
+          leaseId: other.lease.id
+        })
+      ).toEqual({ envelope: ENVELOPE });
+      await done();
+    });
+    it("renews a grant it still holds, and extends the sweep with it", async () => {
+      const { store, done } = await make();
+      await store.enqueue({ id: "a", siteId: SITE, stub: stub("a") });
+      const [granted] = await store.claim(claimArgs({ leaseMs: 1e3 }));
+      const renewed = await store.renewLeases({
+        runnerId: "runner_1",
+        leases: [{ jobId: "a", leaseId: granted.lease.id }],
+        leaseMs: 6e4
+      });
+      expect(renewed.lost).toEqual([]);
+      expect(renewed.renewed.map((r) => r.jobId)).toEqual(["a"]);
+      expect(renewed.renewed[0].expiresAt).toBeGreaterThan(
+        granted.lease.expiresAt
+      );
+      expect((await store.job(SITE, "a"))?.claimedBy?.leaseExpiresAt).toBe(
+        renewed.renewed[0].expiresAt
+      );
+      await done();
+    });
+    it("reports a lease the runner no longer holds as lost, and renews nothing", async () => {
+      const { store, done } = await make();
+      await store.enqueue({ id: "a", siteId: SITE, stub: stub("a") });
+      const [granted] = await store.claim(claimArgs({ leaseMs: 1e3 }));
+      const before = (await store.job(SITE, "a"))?.claimedBy?.leaseExpiresAt;
+      const renewed = await store.renewLeases({
+        runnerId: "runner_1",
+        leases: [{ jobId: "a", leaseId: "a-grant-that-ended" }],
+        leaseMs: 6e4
+      });
+      expect(renewed.renewed).toEqual([]);
+      expect(renewed.lost).toEqual([
+        { jobId: "a", leaseId: "a-grant-that-ended" }
+      ]);
+      expect((await store.job(SITE, "a"))?.claimedBy?.leaseExpiresAt).toBe(
+        before
+      );
+      expect((await store.job(SITE, "a"))?.claimedBy?.leaseId).toBe(
+        granted.lease.id
+      );
+      await done();
+    });
+    it("does not hand out a stub it cannot parse", async () => {
+      const { store, done } = await make();
+      if (!serialising || writeRawStub === void 0) {
+        await done();
+        return;
+      }
+      await store.enqueue({ id: "good", siteId: SITE, stub: stub("good") });
+      await store.enqueue({ id: "old", siteId: SITE, stub: stub("old") });
+      const legacy = { ...stub("old") };
+      delete legacy["site"];
+      await writeRawStub(store, "old", JSON.stringify(legacy));
+      const granted = await store.claim(claimArgs({ max: 10 }));
+      expect(granted.map((job) => job.id)).toEqual(["good"]);
+      expect((await store.job(SITE, "old"))?.state).toBe("queued");
+      await done();
+    });
+    it("honours a self job's audience", async () => {
+      const { store, done } = await make();
+      await store.enqueue({
+        id: "private",
+        siteId: SITE,
+        stub: { ...stub("private", "alice"), audience: "private" }
+      });
+      const granted = await store.claim(
+        claimArgs({ owner: "owner", owners: ["owner", "alice"] })
+      );
+      expect(granted).toEqual([]);
+      expect((await store.job(SITE, "private"))?.state).toBe("queued");
+      await done();
+    });
+    it("still offers that job to its owner's own machine", async () => {
+      const { store, done } = await make();
+      await store.enqueue({
+        id: "private",
+        siteId: SITE,
+        stub: { ...stub("private", "alice"), audience: "private" }
+      });
+      const granted = await store.claim(
+        claimArgs({ owner: "alice", owners: ["alice"] })
+      );
+      expect(granted.map((job) => job.id)).toEqual(["private"]);
+      await done();
+    });
+    it("does not offer a job back to the runner that refused it", async () => {
+      const { store, done } = await make();
+      await store.enqueue({ id: "a", siteId: SITE, stub: stub("a") });
+      const [granted] = await store.claim(claimArgs());
+      await store.releaseLeases({
+        runnerId: "runner_1",
+        leases: [{ jobId: "a", leaseId: granted.lease.id }],
+        reason: "refused"
+      });
+      expect(await store.claim(claimArgs())).toEqual([]);
+      expect((await store.job(SITE, "a"))?.state).toBe("queued");
+      expect(
+        (await store.claim(claimArgs({ runnerId: "runner_2" }))).map(
+          (j) => j.id
+        )
+      ).toEqual(["a"]);
+      await done();
+    });
+    it("does not offer a job back to a runner before its not-before", async () => {
+      const { store, done } = await make();
+      await store.enqueue({ id: "a", siteId: SITE, stub: stub("a") });
+      const [granted] = await store.claim(claimArgs());
+      await store.releaseLeases({
+        runnerId: "runner_1",
+        leases: [{ jobId: "a", leaseId: granted.lease.id }],
+        retryAfter: Date.now() + 6e5
+      });
+      expect(await store.claim(claimArgs())).toEqual([]);
+      expect((await store.job(SITE, "a"))?.state).toBe("queued");
+      expect(
+        (await store.claim(claimArgs({ runnerId: "runner_2" }))).map(
+          (j) => j.id
+        )
+      ).toEqual(["a"]);
+      await done();
+    });
+    it("offers it again once the not-before has passed", async () => {
+      const { store, done } = await make();
+      await store.enqueue({ id: "a", siteId: SITE, stub: stub("a") });
+      const [granted] = await store.claim(claimArgs());
+      await store.releaseLeases({
+        runnerId: "runner_1",
+        leases: [{ jobId: "a", leaseId: granted.lease.id }],
+        retryAfter: Date.now() - 1e3
+      });
+      expect((await store.claim(claimArgs())).map((j) => j.id)).toEqual(["a"]);
+      await done();
+    });
+    it("will not un-finish a job that is already done", async () => {
+      const { store, done } = await make();
+      await store.enqueue({ id: "a", siteId: SITE, stub: stub("a") });
+      const [granted] = await store.claim(claimArgs());
+      const lease = granted.lease.id;
+      await store.takePayload({
+        jobId: "a",
+        runnerId: "runner_1",
+        leaseId: lease
+      });
+      await store.complete({
+        jobId: "a",
+        runnerId: "runner_1",
+        leaseId: lease,
+        envelope: ENVELOPE,
+        disposition: "ok"
+      });
+      const released = await store.releaseLeases({
+        runnerId: "runner_1",
+        leases: [{ jobId: "a", leaseId: lease }],
+        reason: "shutdown"
+      });
+      expect(released).toEqual([]);
+      expect((await store.job(SITE, "a"))?.state).toBe("done");
+      expect((await store.finished(SITE)).map((j) => j.id)).toEqual(["a"]);
+      expect(await store.claim(claimArgs({ runnerId: "runner_2" }))).toEqual(
+        []
+      );
+      await done();
+    });
+    it("keeps a job claimable by a runner that only went away", async () => {
+      const { store, done } = await make();
+      await store.enqueue({ id: "a", siteId: SITE, stub: stub("a") });
+      const [granted] = await store.claim(claimArgs());
+      await store.releaseLeases({
+        runnerId: "runner_1",
+        leases: [{ jobId: "a", leaseId: granted.lease.id }],
+        reason: "shutdown"
+      });
+      expect((await store.claim(claimArgs())).map((j) => j.id)).toEqual(["a"]);
+      await done();
+    });
+    it("stops offering a job past its deadline, and drops the ciphertext", async () => {
+      const { store, done } = await make();
+      await store.enqueue({
+        id: "late",
+        siteId: SITE,
+        stub: { ...stub("late"), deadlineAt: Date.now() - 1e3 }
+      });
+      expect(await store.claim(claimArgs())).toEqual([]);
+      expect(await store.job(SITE, "late")).toBeUndefined();
+      await done();
+    });
+    it("names a cancelled job to the device holding it, and offers it to nobody", async () => {
+      const { store, done } = await make();
+      await store.enqueue({ id: "a", siteId: SITE, stub: stub("a") });
+      await store.claim(claimArgs());
+      expect(await store.cancel({ jobId: "a", siteId: SITE })).toBe(true);
+      const held = (await store.job(SITE, "a"))?.claimedBy?.leaseId;
+      expect(await store.cancelRequests("runner_1")).toEqual([
+        { jobId: "a", leaseId: held }
+      ]);
+      expect(await store.cancel({ jobId: "a", siteId: "someone_else" })).toBe(
+        false
+      );
+      await done();
+    });
+    it("records a result once", async () => {
+      const { store, done } = await make();
+      await store.enqueue({ id: "a", siteId: SITE, stub: stub("a") });
+      const [granted] = await store.claim(claimArgs());
+      const first = await store.complete({
+        jobId: "a",
+        runnerId: "runner_1",
+        leaseId: granted.lease.id,
+        envelope: ENVELOPE,
+        disposition: "ok"
+      });
+      const replay = await store.complete({
+        jobId: "a",
+        runnerId: "runner_1",
+        leaseId: granted.lease.id,
+        envelope: { ...ENVELOPE, ciphertext: "different" },
+        disposition: "error"
+      });
+      expect(first).toEqual({ accepted: true, state: "done" });
+      expect(replay).toEqual({
+        accepted: false,
+        duplicate: true,
+        state: "done"
+      });
+      expect((await store.job(SITE, "a"))?.disposition).toBe("ok");
+      await done();
+    });
+    it("answers the device that finished it with `duplicate`", async () => {
+      const { store, done } = await make();
+      await store.enqueue({ id: "a", siteId: SITE, stub: stub("a") });
+      const [granted] = await store.claim(claimArgs());
+      const first = await store.complete({
+        jobId: "a",
+        runnerId: "runner_1",
+        leaseId: granted.lease.id,
+        envelope: ENVELOPE,
+        disposition: "ok"
+      });
+      expect(first).toEqual({ accepted: true, state: "done" });
+      const replay = await store.complete({
+        jobId: "a",
+        runnerId: "runner_1",
+        leaseId: granted.lease.id,
+        envelope: { ...ENVELOPE, ciphertext: "a-different-result" },
+        disposition: "error"
+      });
+      expect(replay).toEqual({
+        accepted: false,
+        duplicate: true,
+        state: "done"
+      });
+      const stranger = await store.complete({
+        jobId: "a",
+        runnerId: "runner_2",
+        leaseId: granted.lease.id,
+        envelope: ENVELOPE,
+        disposition: "ok"
+      });
+      expect(stranger).toEqual({ refused: "not-holder" });
+      expect((await store.job(SITE, "a"))?.disposition).toBe("ok");
+      await done();
+    });
+    it("refuses a result produced under a grant that ended", async () => {
+      const { store, done } = await make();
+      await store.enqueue({ id: "a", siteId: SITE, stub: stub("a") });
+      await store.claim(claimArgs());
+      const late = await store.complete({
+        jobId: "a",
+        runnerId: "runner_1",
+        leaseId: "a-grant-that-ended",
+        envelope: ENVELOPE,
+        disposition: "ok"
+      });
+      expect(late).toEqual({ refused: "stale-lease" });
+      expect((await store.job(SITE, "a"))?.state).toBe("awaiting-payload");
+      expect((await store.job(SITE, "a"))?.result).toBeUndefined();
+      await done();
+    });
+    it("refuses a payload for a job that already finished [V1-6]", async () => {
+      const { store, done } = await make();
+      await store.enqueue({ id: "a", siteId: SITE, stub: stub("a") });
+      const [granted] = await store.claim(claimArgs());
+      await store.seal({ jobId: "a", siteId: SITE, envelope: ENVELOPE });
+      await store.takePayload({
+        jobId: "a",
+        runnerId: "runner_1",
+        leaseId: granted.lease.id
+      });
+      await store.complete({
+        jobId: "a",
+        runnerId: "runner_1",
+        leaseId: granted.lease.id,
+        envelope: ENVELOPE,
+        disposition: "ok"
+      });
+      const replay = await store.takePayload({
+        jobId: "a",
+        runnerId: "runner_1",
+        leaseId: granted.lease.id
+      });
+      expect(replay).toEqual({ refused: "terminal" });
+      expect((await store.job(SITE, "a"))?.state).toBe("done");
+      await done();
+    });
+    it("tells a runner nothing about another site's job id [V1-8]", async () => {
+      const { store, done } = await make();
+      await store.enqueue({
+        id: "secret",
+        siteId: "site_somebody_else",
+        stub: stub("secret")
+      });
+      await store.enqueue({ id: "mine", siteId: SITE, stub: stub("mine") });
+      const granted = await store.claim(claimArgs());
+      const mine = granted.find((job) => job.id === "mine");
+      const other = await store.takePayload({
+        jobId: "secret",
+        runnerId: "runner_1",
+        leaseId: mine.lease.id
+      });
+      const absent = await store.takePayload({
+        jobId: "no-such-job-anywhere",
+        runnerId: "runner_1",
+        leaseId: mine.lease.id
+      });
+      expect(other).toEqual(absent);
+      expect(other).toEqual({ refused: "not-found" });
+      await done();
+    });
+    it("offers a job to any device that serves its kind", async () => {
+      const { store, done } = await make();
+      await store.enqueue({ id: "a", siteId: SITE, stub: stub("a") });
+      const claimed = await store.claim(
+        claimArgs({ runnerId: "runner_any", kinds: /* @__PURE__ */ new Set(["llm.generate"]) })
+      );
+      expect(claimed.map((j) => j.id)).toEqual(["a"]);
+      await done();
+    });
+    it("does not offer a job to a device that serves a different kind", async () => {
+      const { store, done } = await make();
+      await store.enqueue({ id: "a", siteId: SITE, stub: stub("a") });
+      const claimed = await store.claim(
+        claimArgs({ runnerId: "runner_chat", kinds: /* @__PURE__ */ new Set(["llm.chat"]) })
+      );
+      expect(claimed).toEqual([]);
+      await done();
+    });
+    it("remembers a device, and what it says it can run", async () => {
+      const { store, done } = await make();
+      const device = publicIdentityOf(generateKeys(3e12));
+      await store.seen({
+        runnerId: "runner_1",
+        owner: "alice",
+        device,
+        capabilities: [capability("llama3")],
+        withheld: []
+      });
+      const known = await store.presence("runner_1");
+      expect(known?.owner).toBe("alice");
+      expect(known?.device.identity).toBe(device.identity);
+      expect(known?.capabilities.map((row) => row.model)).toEqual(["llama3"]);
+      await done();
+    });
+    it("replaces the matrix rather than merging it", async () => {
+      const { store, done } = await make();
+      const device = publicIdentityOf(generateKeys(3000000000001));
+      const seen = { runnerId: "runner_2", owner: "alice", device };
+      await store.seen({
+        ...seen,
+        capabilities: [capability("llama3")],
+        withheld: []
+      });
+      await store.seen({
+        ...seen,
+        capabilities: [capability("mistral")],
+        withheld: []
+      });
+      const known = await store.presence("runner_2");
+      expect(known?.capabilities.map((row) => row.model)).toEqual(["mistral"]);
+      await done();
+    });
+    it("keeps an empty matrix, because empty is an answer", async () => {
+      const { store, done } = await make();
+      const device = publicIdentityOf(generateKeys(3000000000002));
+      const seen = { runnerId: "runner_3", owner: "alice", device };
+      await store.seen({
+        ...seen,
+        capabilities: [capability("llama3")],
+        withheld: []
+      });
+      await store.seen({ ...seen, capabilities: [], withheld: [] });
+      expect((await store.presence("runner_3"))?.capabilities).toEqual([]);
+      await done();
+    });
+    it("remembers which kinds are withheld, and drops them when resolved", async () => {
+      const { store, done } = await make();
+      const device = publicIdentityOf(generateKeys(3000000000004));
+      const seen = { runnerId: "runner_withheld", owner: "alice", device };
+      await store.seen({
+        ...seen,
+        capabilities: [],
+        withheld: [
+          {
+            kind: "llm.generate",
+            claimants: [
+              { service: "ollama", offer: "team" },
+              { service: "mlx", offer: "private" }
+            ]
+          }
+        ]
+      });
+      const held = await store.presence("runner_withheld");
+      expect(held?.withheld.map((row) => row.kind)).toEqual(["llm.generate"]);
+      expect(held?.withheld[0]?.claimants.map((c) => c.service)).toEqual([
+        "ollama",
+        "mlx"
+      ]);
+      await store.seen({
+        ...seen,
+        capabilities: [capability("llama3")],
+        withheld: []
+      });
+      expect((await store.presence("runner_withheld"))?.withheld).toEqual([]);
+      await done();
+    });
+    it("stamps presence from its own clock, and moves it on the next beat", async () => {
+      const { store, done } = await make();
+      const device = publicIdentityOf(generateKeys(3000000000003));
+      const seen = { runnerId: "runner_4", owner: "alice", device };
+      const before = await store.now();
+      const first = await store.seen({
+        ...seen,
+        capabilities: [],
+        withheld: []
+      });
+      expect(first.lastSeenAt).toBeGreaterThanOrEqual(before);
+      const later = await store.seen({
+        ...seen,
+        capabilities: [],
+        withheld: []
+      });
+      expect(later.lastSeenAt).toBeGreaterThanOrEqual(first.lastSeenAt);
+      await done();
+    });
+    it("lists everyone it has seen", async () => {
+      const { store, done } = await make();
+      await store.seen({
+        runnerId: "runner_5",
+        owner: "alice",
+        device: publicIdentityOf(generateKeys(3000000000004)),
+        capabilities: [],
+        withheld: []
+      });
+      await store.seen({
+        runnerId: "runner_6",
+        owner: "bob",
+        device: publicIdentityOf(generateKeys(3000000000005)),
+        capabilities: [],
+        withheld: []
+      });
+      const everyone = await store.everyone();
+      const ids = everyone.map((row) => row.runnerId);
+      expect(ids).toContain("runner_5");
+      expect(ids).toContain("runner_6");
+      await done();
+    });
+    it("does not know a runner it has never seen", async () => {
+      const { store, done } = await make();
+      expect(await store.presence("runner_never")).toBeUndefined();
+      await done();
+    });
+    it("stamps deadlines from its own clock", async () => {
+      const { store, done } = await make();
+      await store.enqueue({ id: "a", siteId: SITE, stub: stub("a") });
+      const before = await store.now();
+      const [granted] = await store.claim(claimArgs({ leaseMs: 45e3 }));
+      const after = await store.now();
+      expect(granted.lease.expiresAt).toBeGreaterThanOrEqual(before + 45e3);
+      expect(granted.lease.expiresAt).toBeLessThanOrEqual(after + 45e3);
+      await done();
+    });
+  });
+}
+export {
+  CONTRACT_SITE,
+  describeStoreContract
+};
+//# sourceMappingURL=store-contract.js.map