@byollm/relay 0.1.0-alpha.9 → 0.1.0-alpha.91

package/dist/store-contract.js

@@ -0,0 +1,712 @@
+import {
+  AWAITING_PAYLOAD_MS,
+  routeKey
+} from "./chunk-4ISUXCIO.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, advance } = 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("hands one pair at most two unsealed grants at a time", async () => {
+      const { store, done } = await make();
+      for (const id of ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]) {
+        await store.enqueue({ id, siteId: SITE, stub: stub(id) });
+      }
+      const granted = await store.claim(claimArgs());
+      expect(granted).toHaveLength(2);
+      await done();
+    });
+    it("counts the cap per owner, not per site", async () => {
+      const { store, done } = await make();
+      for (const id of ["a1", "a2", "a3"]) {
+        await store.enqueue({ id, siteId: SITE, stub: stub(id, "alice") });
+      }
+      for (const id of ["b1", "b2", "b3"]) {
+        await store.enqueue({ id, siteId: SITE, stub: stub(id, "bob") });
+      }
+      const forAlice = await store.claim(claimArgs());
+      const forBob = await store.claim(
+        claimArgs({ owner: "bob", owners: ["bob"], runnerId: "runner_2" })
+      );
+      expect(forAlice, "alice gets her two").toHaveLength(2);
+      expect(
+        forBob,
+        "and bob gets his own two, rather than what is left of a site-wide pair"
+      ).toHaveLength(2);
+      await done();
+    });
+    it("re-offers an abandoned grant only to the device that abandoned it", async () => {
+      const { store, done } = await make();
+      if (advance === void 0) {
+        await done();
+        return;
+      }
+      await store.enqueue({ id: "a", siteId: SITE, stub: stub("a") });
+      const first = await store.claim(claimArgs());
+      expect(first).toHaveLength(1);
+      await advance(store, AWAITING_PAYLOAD_MS + 1e3);
+      const stranger = await store.claim(claimArgs({ runnerId: "runner_2" }));
+      expect(stranger, "a device that never held it gets nothing").toEqual([]);
+      const again = await store.claim(claimArgs());
+      expect(again, "its first claimant gets it back").toHaveLength(1);
+      await done();
+    });
+    it("leaves an unabandoned job free for whoever asks", async () => {
+      const { store, done } = await make();
+      await store.enqueue({ id: "a", siteId: SITE, stub: stub("a") });
+      const other = await store.claim(claimArgs({ runnerId: "runner_9" }));
+      expect(other).toHaveLength(1);
+      await done();
+    });
+    it("lets a sealing site keep working, which is every honest one", async () => {
+      const { store, done } = await make();
+      for (const id of ["a", "b", "c", "d"]) {
+        await store.enqueue({ id, siteId: SITE, stub: stub(id) });
+      }
+      const first = await store.claim(claimArgs());
+      expect(first).toHaveLength(2);
+      for (const job of first) {
+        await store.seal({
+          siteId: SITE,
+          jobId: job.id,
+          envelope: ENVELOPE
+        });
+      }
+      const next = await store.claim(claimArgs());
+      expect(next, "the slots came back").toHaveLength(2);
+      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("reports what a sweep removed, not only what it requeued \u2014 B096", async () => {
+      const { store, done } = await make();
+      await store.enqueue({
+        id: "expired",
+        siteId: SITE,
+        stub: { ...stub("expired"), deadlineAt: Date.now() - 1e3 }
+      });
+      await store.enqueue({ id: "alive", siteId: SITE, stub: stub("alive") });
+      const swept = await store.sweep();
+      expect(
+        swept.map((job) => job.id),
+        "a sweep removed a job and reported nothing about it"
+      ).toContain("expired");
+      expect(swept.map((job) => job.id)).not.toContain("alive");
+      expect(await store.job(SITE, "alive")).toBeDefined();
+      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