@shortlink-org/portolan 0.1.0

package/src/lib/pins.test.ts

@@ -0,0 +1,139 @@
+import { describe, expect, it } from "vitest";
+import {
+  PIN_CAP,
+  addPin,
+  isPinned,
+  movePin,
+  parsePins,
+  removePin,
+  serializePins,
+} from "./pins";
+import type { Pin } from "./pins";
+
+const pin = (n: number): Pin => ({ kind: "event", id: `e${n}` });
+const many = (n: number): Pin[] => Array.from({ length: n }, (_, i) => pin(i));
+
+describe("what can be pinned", () => {
+  it("keeps a context and a store, which have pages of their own", () => {
+    const raw = JSON.stringify([
+      { kind: "context", id: "shop" },
+      { kind: "store", id: "shop.oms.pg" },
+      { kind: "column", id: "shop.oms.pg.orders.id" },
+    ]);
+    expect(parsePins(raw)).toEqual([
+      { kind: "context", id: "shop" },
+      { kind: "store", id: "shop.oms.pg" },
+    ]);
+  });
+});
+
+describe("addPin", () => {
+  it("appends, so the newest pin is the one at the bottom", () => {
+    const { pins } = addPin([pin(0)], pin(1));
+    expect(pins.map((p) => p.id)).toEqual(["e0", "e1"]);
+  });
+
+  it("pins the same thing once, whatever a second click means", () => {
+    const start = [pin(0)];
+    expect(addPin(start, pin(0)).pins).toBe(start);
+  });
+
+  it("tells the two kinds of the same id apart", () => {
+    const { pins } = addPin(
+      [{ kind: "event", id: "x" }],
+      { kind: "table", id: "x" },
+    );
+    expect(pins).toHaveLength(2);
+  });
+
+  it("drops the oldest at the cap rather than refusing the new one", () => {
+    const full = many(PIN_CAP);
+    const { pins, evicted } = addPin(full, pin(99));
+    expect(pins).toHaveLength(PIN_CAP);
+    expect(evicted).toEqual(pin(0));
+    expect(pins[0]).toEqual(pin(1));
+    expect(pins[PIN_CAP - 1]).toEqual(pin(99));
+  });
+
+  it("evicts nothing while there is still room", () => {
+    expect(addPin(many(PIN_CAP - 1), pin(99)).evicted).toBeNull();
+  });
+});
+
+describe("removePin", () => {
+  it("takes one out and leaves the order of the rest alone", () => {
+    expect(removePin(many(3), pin(1)).map((p) => p.id)).toEqual(["e0", "e2"]);
+  });
+});
+
+describe("movePin", () => {
+  it("moves a pin down, closing the gap behind it", () => {
+    expect(movePin(many(4), 0, 2).map((p) => p.id)).toEqual([
+      "e1",
+      "e2",
+      "e0",
+      "e3",
+    ]);
+  });
+
+  it("moves a pin up", () => {
+    expect(movePin(many(4), 3, 1).map((p) => p.id)).toEqual([
+      "e0",
+      "e3",
+      "e1",
+      "e2",
+    ]);
+  });
+
+  it("leaves the list untouched for a drop that goes nowhere", () => {
+    const start = many(3);
+    expect(movePin(start, 1, 1)).toBe(start);
+    expect(movePin(start, -1, 0)).toBe(start);
+    expect(movePin(start, 0, 9)).toBe(start);
+  });
+});
+
+describe("parsePins", () => {
+  it("round-trips what it wrote", () => {
+    const pins = many(3);
+    expect(parsePins(serializePins(pins))).toEqual(pins);
+  });
+
+  it("treats anything that is not a pin list as no pins at all", () => {
+    expect(parsePins(null)).toEqual([]);
+    expect(parsePins("")).toEqual([]);
+    expect(parsePins("{not json")).toEqual([]);
+    expect(parsePins('{"kind":"event"}')).toEqual([]);
+  });
+
+  it("drops entries an older build wrote and this one cannot draw", () => {
+    const raw = JSON.stringify([
+      { kind: "event", id: "e0" },
+      { kind: "column", id: "c1" }, // a kind that is no longer pinnable
+      { kind: "event" }, // no id
+      { kind: "event", id: "" }, // empty id
+      null,
+      "flow.checkout",
+      { kind: "adr", id: "shop.oms.0007" },
+    ]);
+    expect(parsePins(raw)).toEqual([
+      { kind: "event", id: "e0" },
+      { kind: "adr", id: "shop.oms.0007" },
+    ]);
+  });
+
+  it("de-duplicates and holds the cap, whatever storage says", () => {
+    const raw = JSON.stringify([...many(PIN_CAP + 4), pin(0)]);
+    const parsed = parsePins(raw);
+    expect(parsed).toHaveLength(PIN_CAP);
+    expect(new Set(parsed.map((p) => `${p.kind}:${p.id}`)).size).toBe(PIN_CAP);
+  });
+});
+
+describe("isPinned", () => {
+  it("matches on kind and id together", () => {
+    const pins: Pin[] = [{ kind: "flow", id: "flow.checkout" }];
+    expect(isPinned(pins, { kind: "flow", id: "flow.checkout" })).toBe(true);
+    expect(isPinned(pins, { kind: "adr", id: "flow.checkout" })).toBe(false);
+  });
+});

package/src/lib/pins.ts

@@ -0,0 +1,130 @@
+// What the reader keeps at the top of the tree.
+//
+// A pin is a reader's own answer to "where do I keep coming back to", so it is
+// stored as nothing but a kind and a catalog id: the name, the icon and the
+// route are all read back out of the catalog at render time. A pin taken
+// against a build that no longer has that event therefore goes quiet rather
+// than pointing at a page that is not there.
+//
+// Order is the reader's, not the catalog's - pins are dragged into the order
+// they think in - so the list is a sequence and never re-sorted.
+
+/**
+ * What can be pinned. Not every kind: a column, a shared type or a value
+ * object is read inside the thing that holds it, and a pin that lands on a
+ * panel three levels deep is a bookmark to a scroll position.
+ */
+export type PinKind =
+  /** A context is a page and the top of a tree; keeping it at the top is a way in. */
+  | "context"
+  | "flow"
+  | "event"
+  | "adr"
+  | "service"
+  | "aggregate"
+  | "table"
+  /** A store has a page of its own, so it can be kept at the top like one. */
+  | "store"
+  /** A module has a page of its own, so it can be kept at the top like one. */
+  | "module";
+
+const PIN_KINDS: readonly PinKind[] = [
+  "context",
+  "flow",
+  "event",
+  "adr",
+  "service",
+  "aggregate",
+  "table",
+  "store",
+  "module",
+] as const;
+
+function isPinKind(value: string): value is PinKind {
+  return (PIN_KINDS as readonly string[]).includes(value);
+}
+
+export interface Pin {
+  kind: PinKind;
+  /** The catalog id, spelled the way the catalog spells it. */
+  id: string;
+}
+
+/**
+ * How many pins a reader may keep. Twelve is the last count that still reads
+ * as a shortlist above the tree rather than as a second tree; past it the
+ * pinned block would push FLOWS off the first screen, which is exactly the
+ * harm pinning was meant to undo.
+ */
+export const PIN_CAP = 12;
+
+function samePin(a: Pin, b: Pin): boolean {
+  return a.kind === b.kind && a.id === b.id;
+}
+
+export function isPinned(pins: Pin[], pin: Pin): boolean {
+  return pins.some((p) => samePin(p, pin));
+}
+
+/**
+ * Pin something, at the end of the list. At the cap the OLDEST pin goes, not
+ * the new one: a reader who pins a thirteenth thing has said what they want on
+ * screen, and refusing them would make the cap look like a bug. `evicted` is
+ * what they lost, so the caller can say so out loud.
+ */
+export function addPin(
+  pins: Pin[],
+  pin: Pin,
+): { pins: Pin[]; evicted: Pin | null } {
+  if (isPinned(pins, pin)) return { pins, evicted: null };
+  const next = [...pins, pin];
+  if (next.length <= PIN_CAP) return { pins: next, evicted: null };
+  const evicted = next[0] ?? null;
+  return { pins: next.slice(next.length - PIN_CAP), evicted };
+}
+
+export function removePin(pins: Pin[], pin: Pin): Pin[] {
+  return pins.filter((p) => !samePin(p, pin));
+}
+
+/** Move the pin at `from` so that it sits at `to`, closing the gap behind it. */
+export function movePin(pins: Pin[], from: number, to: number): Pin[] {
+  if (from === to) return pins;
+  if (from < 0 || from >= pins.length) return pins;
+  if (to < 0 || to >= pins.length) return pins;
+  const next = [...pins];
+  const [moved] = next.splice(from, 1);
+  if (!moved) return pins;
+  next.splice(to, 0, moved);
+  return next;
+}
+
+/**
+ * Whatever is in storage, read as a pin list. Anything that is not a pin is
+ * dropped rather than repaired: what comes back was written by an older build
+ * or by hand, and a half-understood entry is worse than one that is gone.
+ */
+export function parsePins(raw: string | null): Pin[] {
+  if (!raw) return [];
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) return [];
+  const out: Pin[] = [];
+  for (const entry of parsed) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const { kind, id } = entry as { kind?: unknown; id?: unknown };
+    if (typeof kind !== "string" || typeof id !== "string") continue;
+    if (!isPinKind(kind) || id === "") continue;
+    const pin = { kind, id };
+    if (!isPinned(out, pin)) out.push(pin);
+  }
+  return out.slice(0, PIN_CAP);
+}
+
+export function serializePins(pins: Pin[]): string {
+  return JSON.stringify(pins);
+}

package/src/lib/problems.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, it } from "vitest";
+import { catalog } from "../data";
+import { contextStats, edgeCount, problems } from "./derive";
+import type { Catalog } from "../catalog";
+
+describe("problems", () => {
+  it("finds every unresolved edge and nothing else", () => {
+    for (const problem of problems(catalog)) {
+      const context = catalog.contexts.find((c) => c.id === problem.context);
+      const service = context?.services.find((s) => s.id === problem.service);
+      expect(
+        service,
+        `${problem.id} names a service not in the catalog`,
+      ).toBeDefined();
+
+      if (problem.kind === "rpc") {
+        const call = service?.consumes.find((c) => c.id === problem.id);
+        expect(call?.status).toBe("unresolved");
+        expect(call?.peer).toBe(problem.peer);
+      } else {
+        const event = service?.aggregates
+          .flatMap((a) => a.events)
+          .find((e) => e.id === problem.id);
+        const consumer = event?.consumers.find(
+          (c) => c.service === problem.peer,
+        );
+        expect(consumer?.status).toBe("unresolved");
+      }
+    }
+  });
+
+  it("agrees with the per-context counts the overview prints", () => {
+    // The overview card and the problems page must never disagree about how
+    // much is broken - they are two renderings of one number.
+    const found = problems(catalog);
+    for (const context of catalog.contexts) {
+      const mine = found.filter((p) => p.context === context.id);
+      expect(mine.length, `context ${context.id}`).toBe(
+        contextStats(context).unresolved,
+      );
+    }
+  });
+
+  it("says nothing at all about a clean catalog", () => {
+    const clean: Catalog = {
+      ...catalog,
+      contexts: catalog.contexts.map((context) => ({
+        ...context,
+        services: context.services.map((service) => ({
+          ...service,
+          consumes: service.consumes.map((c) => ({
+            ...c,
+            status: "verified" as const,
+          })),
+          aggregates: service.aggregates.map((aggregate) => ({
+            ...aggregate,
+            events: aggregate.events.map((event) => ({
+              ...event,
+              consumers: event.consumers.map((c) => ({
+                ...c,
+                status: "verified" as const,
+              })),
+            })),
+          })),
+        })),
+      })),
+    };
+    expect(problems(clean)).toEqual([]);
+  });
+});
+
+describe("edgeCount", () => {
+  it("counts every call and consumer, resolved or not", () => {
+    const byHand = catalog.contexts
+      .flatMap((c) => c.services)
+      .reduce(
+        (n, s) =>
+          n +
+          s.consumes.length +
+          s.aggregates.reduce(
+            (m, a) =>
+              m + a.events.reduce((k, e) => k + e.consumers.length, 0),
+            0,
+          ),
+        0,
+      );
+    expect(edgeCount(catalog)).toBe(byHand);
+    expect(edgeCount(catalog)).toBeGreaterThanOrEqual(problems(catalog).length);
+  });
+
+  it("is zero for a catalog whose services are not wired together", () => {
+    const bare: Catalog = {
+      ...catalog,
+      contexts: catalog.contexts.map((context) => ({
+        ...context,
+        services: context.services.map((service) => ({
+          ...service,
+          consumes: [],
+          aggregates: service.aggregates.map((aggregate) => ({
+            ...aggregate,
+            events: aggregate.events.map((event) => ({
+              ...event,
+              consumers: [],
+            })),
+          })),
+        })),
+      })),
+    };
+    expect(edgeCount(bare)).toBe(0);
+    expect(problems(bare)).toEqual([]);
+  });
+});

package/src/lib/project-preview.ts

@@ -0,0 +1,5 @@
+declare const __PROJECT_PREVIEW__: boolean | undefined;
+
+/** True only for the temporary site served from an isolated onboarding trial. */
+export const projectPreview =
+  typeof __PROJECT_PREVIEW__ === "undefined" ? false : __PROJECT_PREVIEW__;

package/src/lib/proto-problems.test.ts

@@ -0,0 +1,121 @@
+import { describe, expect, it } from "vitest";
+import { buildIndex, type Catalog, type Service } from "../catalog";
+import { protoProblems } from "./proto-problems";
+
+function service(id: string, overrides: Partial<Service> = {}): Service {
+  const slug = id.slice(id.indexOf(".") + 1);
+
+  return {
+    id,
+    slug,
+    name: slug,
+    repo: "",
+    path: "",
+    readme: "",
+    provides: [],
+    consumes: [],
+    aggregates: [],
+    ...overrides,
+  };
+}
+
+function catalogWith(services: Service[]): Catalog {
+  return {
+    generatedAt: "2024-01-01T00:00:00Z",
+    commit: "abc1234",
+    contexts: [
+      {
+        id: "shop",
+        slug: "shop",
+        name: "Shop",
+        summary: "",
+        services,
+      },
+    ],
+    defs: {},
+    flows: [],
+    adrs: [],
+  };
+}
+
+const pricing = () =>
+  service("shop.pricing", {
+    provides: [
+      {
+        id: "pricing.v1.Pricing",
+        methods: [{ name: "GetQuote" }],
+        source: "proto/pricing/v1/pricing.proto:7",
+      },
+    ],
+  });
+
+const calling = (id: string, status: "declared" | "unresolved" = "declared") =>
+  service("shop.oms", {
+    consumes: [
+      {
+        id,
+        peer: "shop.pricing",
+        status,
+        source: "internal/infrastructure/pricing/pricing.proto:10",
+      },
+    ],
+  });
+
+function found(catalog: Catalog) {
+  return protoProblems(catalog, buildIndex(catalog));
+}
+
+describe("protoProblems", () => {
+  it("reports a call whose provider answers on no such method", () => {
+    const problems = found(
+      catalogWith([pricing(), calling("pricing.v1.Pricing/ListPriceLists")]),
+    );
+
+    expect(problems).toHaveLength(1);
+    expect(problems[0]?.kind).toBe("proto-missing");
+    expect(problems[0]?.severity).toBe("error");
+    // The near end is the CALLER: that is the copy to go and look at.
+    expect(problems[0]?.service).toBe("shop.oms");
+    expect(problems[0]?.id).toBe("pricing.v1.Pricing/ListPriceLists");
+  });
+
+  it("says nothing about a call the provider does declare", () => {
+    expect(
+      found(catalogWith([pricing(), calling("pricing.v1.Pricing/GetQuote")])),
+    ).toEqual([]);
+  });
+
+  // An unresolved call already has a problem of its own from problems(), and
+  // one edge under two headings makes the page look worse than the estate is.
+  it("leaves an unresolved call to the report that already covers it", () => {
+    expect(
+      found(
+        catalogWith([
+          pricing(),
+          calling("pricing.v1.Pricing/ListPriceLists", "unresolved"),
+        ]),
+      ),
+    ).toEqual([]);
+  });
+
+  // A call to something outside the estate is a fact, not a defect - and it is
+  // the `rpc` problem's business, not this one's.
+  it("says nothing when the peer is not in the catalog at all", () => {
+    const outside = service("shop.oms", {
+      consumes: [
+        {
+          id: "psp.v2.Charges/Create",
+          peer: "psp",
+          status: "declared",
+          source: "internal/infrastructure/psp/psp.proto:9",
+        },
+      ],
+    });
+
+    expect(found(catalogWith([outside]))).toEqual([]);
+  });
+
+  it("finds nothing in a catalog where nobody calls anybody", () => {
+    expect(found(catalogWith([pricing()]))).toEqual([]);
+  });
+});

package/src/lib/proto-problems.ts

@@ -0,0 +1,65 @@
+// Where a call and the interface it names disagree.
+//
+// docs/adr/org.0001.md promises this: producers publish their schema, consumers
+// keep a narrowed copy, and "a field, method or enum value that differs between
+// the two is reported against the consuming service". This is the first half of
+// that promise - a call naming a method no provider declares.
+//
+// It is deliberately NOT done in the merge. src/merge.ts is documented as
+// union-by-id plus first-non-empty and nothing else, and teaching it to compare
+// shapes would put a semantic judgement in the one place that has none. The
+// comparison belongs here, over the merged catalog, on the page where the rest
+// of that judgement already lives.
+//
+// This is also NOT the same finding as derive.ts's `rpc` problem. That one is
+// about the PEER: a call whose other end is nobody the catalog knows. This one
+// is about a call whose peer is known and whose METHOD is not - the copy is
+// stale, or the producer removed something, and the two are different repairs.
+
+import type { Catalog, CatalogIndex } from "../catalog";
+import type { Problem } from "./derive";
+
+/**
+ * Every call that names a method no interface in the catalog declares.
+ *
+ * An unresolved call is skipped: it already has a problem of its own from
+ * `problems()`, and reporting the same edge twice under two headings would make
+ * the page look worse than the estate is.
+ */
+export function protoProblems(
+  catalog: Catalog,
+  index: CatalogIndex,
+): Problem[] {
+  const out: Problem[] = [];
+
+  for (const context of catalog.contexts) {
+    for (const service of context.services) {
+      for (const call of service.consumes) {
+        if (call.status === "unresolved") continue;
+
+        // The peer has to be a service in the catalog before the method is
+        // worth asking about. A call to something outside the estate is a fact,
+        // not a defect.
+        if (!index.serviceById.has(call.peer)) continue;
+
+        if (index.rpcProviderByMethod.has(call.id)) continue;
+
+        out.push({
+          kind: "proto-missing",
+          // An error, not a staleness warning: the peer is in the catalog and
+          // does not answer on this. Either the copy is behind or the method is
+          // gone, and both are a call that will fail.
+          severity: "error",
+          context: context.id,
+          service: service.id,
+          id: call.id,
+          peer: call.peer,
+          note: call.note,
+          source: call.source,
+        });
+      }
+    }
+  }
+
+  return out;
+}

package/src/lib/queries.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, it } from "vitest";
+import type { Catalog } from "../catalog";
+import type { ForgeRef, ForgeRepo } from "./github-catalog";
+import {
+  comparisonQuery,
+  comparisonSide,
+  forgeKeys,
+  forgeRefsQuery,
+  localStatusQuery,
+  sourceCodeQuery,
+  sourceKeys,
+} from "./queries";
+import type { RemoteSourceLocation, SourceLocation } from "./source-link";
+
+const REPO: ForgeRepo = {
+  provider: "github",
+  owner: "acme",
+  repo: "portolan",
+  webUrl: "https://github.com/acme/portolan",
+};
+const OTHER: ForgeRepo = { ...REPO, repo: "shop", webUrl: "https://github.com/acme/shop" };
+const SHA = "a".repeat(40);
+const OTHER_SHA = "b".repeat(40);
+const REFS: ForgeRef[] = [
+  { name: "main", commit: SHA, protected: true, kind: "branch" },
+  { name: "feature", commit: OTHER_SHA, protected: false, kind: "branch" },
+];
+const bundled = { name: "main", sha: SHA, catalog: { contexts: [] } as unknown as Catalog };
+
+const remote: RemoteSourceLocation = {
+  kind: "remote",
+  provider: "github",
+  origin: "https://github.com",
+  repositoryUrl: "https://github.com/acme/shop",
+  ref: SHA,
+  path: "internal/cart/cart.go",
+  line: 3,
+  href: `https://github.com/acme/shop/blob/${SHA}/internal/cart/cart.go#L3`,
+};
+const local: SourceLocation = { kind: "local", path: "internal/cart/cart.go", line: 1, href: null };
+
+describe("forgeRefsQuery", () => {
+  it("is disabled without a repository and keyed under the forge prefix", () => {
+    expect(forgeRefsQuery(null, "").enabled).toBe(false);
+    expect(forgeRefsQuery(REPO, "").enabled).toBe(true);
+    expect(forgeRefsQuery(REPO, "").queryKey.slice(0, forgeKeys.all.length)).toEqual(forgeKeys.all);
+  });
+
+  // A token makes the answer the token's: a different key, so a reader who
+  // connects never sees the anonymous listing, and one who disconnects never
+  // keeps the authenticated one.
+  it("keys by repository and by token", () => {
+    expect(forgeRefsQuery(REPO, "").queryKey).not.toEqual(forgeRefsQuery(OTHER, "").queryKey);
+    expect(forgeRefsQuery(REPO, "").queryKey).not.toEqual(forgeRefsQuery(REPO, "secret").queryKey);
+    expect(forgeRefsQuery(REPO, "secret").queryKey).toEqual(forgeRefsQuery(REPO, "secret").queryKey);
+  });
+});
+
+describe("comparisonSide", () => {
+  it("resolves the current branch to the bundled catalog without a lookup", () => {
+    expect(comparisonSide("main", [], bundled)).toEqual({ name: "main", sha: SHA, catalog: bundled.catalog });
+  });
+
+  it("resolves other names through the forge refs, and unknown names to null", () => {
+    expect(comparisonSide("feature", REFS, bundled)).toEqual({ name: "feature", sha: OTHER_SHA, catalog: null });
+    expect(comparisonSide("gone", REFS, bundled)).toBeNull();
+  });
+});
+
+describe("comparisonQuery", () => {
+  const base = comparisonSide("main", REFS, bundled);
+  const head = comparisonSide("feature", REFS, bundled);
+
+  it("waits until both sides are resolved", () => {
+    expect(comparisonQuery(REPO, "", base, null).enabled).toBe(false);
+    expect(comparisonQuery(null, "", base, head).enabled).toBe(false);
+    expect(comparisonQuery(REPO, "", base, head).enabled).toBe(true);
+  });
+
+  // Two names that point at the same commits are the same comparison; the
+  // key is the commits, so a renamed branch does not fetch twice.
+  it("keys by the resolved commits, not the names", () => {
+    const renamed = { ...head!, name: "feature-renamed" };
+    expect(comparisonQuery(REPO, "", base, head).queryKey).toEqual(comparisonQuery(REPO, "", base, renamed).queryKey);
+    expect(comparisonQuery(REPO, "", base, head).queryKey).not.toEqual(comparisonQuery(REPO, "", head, base).queryKey);
+    expect(comparisonQuery(REPO, "", base, head).queryKey.slice(0, forgeKeys.all.length)).toEqual(forgeKeys.all);
+  });
+});
+
+describe("sourceCodeQuery", () => {
+  it("keys remote files by forge, repository, commit, path and token", () => {
+    const key = sourceCodeQuery(remote, "").queryKey;
+    expect(key.slice(0, sourceKeys.all.length)).toEqual(sourceKeys.all);
+    expect(key).not.toEqual(sourceCodeQuery({ ...remote, ref: OTHER_SHA }, "").queryKey);
+    expect(key).not.toEqual(sourceCodeQuery({ ...remote, path: "go.mod" }, "").queryKey);
+    expect(key).not.toEqual(sourceCodeQuery(remote, "secret").queryKey);
+  });
+
+  it("keys local files by path alone, under the same prefix", () => {
+    const key = sourceCodeQuery(local, "").queryKey;
+    expect(key.slice(0, sourceKeys.all.length)).toEqual(sourceKeys.all);
+    expect(key).toEqual(sourceCodeQuery(local, "ignored").queryKey);
+    expect(key).not.toEqual(sourceCodeQuery(remote, "").queryKey);
+  });
+});
+
+describe("localStatusQuery", () => {
+  // Settings is where a reader learns whether a local server is up, and the
+  // server may have been started since the last visit.
+  it("is stale at once so every visit asks again", () => {
+    expect(localStatusQuery().staleTime).toBe(0);
+  });
+});