@antelopejs/dms 0.7.1 → 0.7.2

package/frontend-vue/layers/dms-ui/app/composables/chart/useChartFetch.ts

@@ -1,6 +1,5 @@
 import {
   computed,
-  onBeforeUnmount,
   onMounted,
   ref,
   watch,
@@ -12,12 +11,11 @@ import {
   usePeriodScope,
 } from "../../../../dms-core/app/composables/period/usePeriodScope";
 import type { PeriodState } from "../../../../dms-core/app/composables/period/types";
-import { useRealtimeTopic } from "../../../../dms-core/app/composables/realtime/useRealtimeTopic";
 import {
   hasUrlVariables,
   resolveUrlVariables,
 } from "../../build/utils/urlVariables";
-import { onPageBlocksRefresh } from "../../utils/blockRefresh";
+import { useRefreshTriggers } from "../../build/composables/blocks/useRefreshTriggers";
 
 export interface UseChartFetchOptions<T> {
   /**
@@ -132,20 +130,6 @@ function readStaticData<T>(
   return source ?? null;
 }
 
-function subscribeRealtimeTopics(
-  topic: string | string[] | undefined,
-  onEvent: () => void,
-): void {
-  if (!topic) return;
-  const topics = Array.isArray(topic) ? topic : [topic];
-  for (const entry of topics) {
-    useRealtimeTopic(entry, (event) => {
-      if (!("type" in event)) return;
-      onEvent();
-    });
-  }
-}
-
 /**
  * The URL to request: `fetchUrl` with its tokens filled, or `undefined` while
  * one has no value. Only a URL naming a token reads the route.
@@ -164,16 +148,6 @@ function useResolvedFetchUrl<T>(
   );
 }
 
-// Mounted only: the page refresh is a browser event, and a block the server
-// renders has nothing to refetch.
-function subscribePageRefresh(onRefresh: () => void): void {
-  let unsubscribe: (() => void) | undefined;
-  onMounted(() => {
-    unsubscribe = onPageBlocksRefresh(onRefresh);
-  });
-  onBeforeUnmount(() => unsubscribe?.());
-}
-
 export function useChartFetch<T>(
   options: UseChartFetchOptions<T>,
 ): UseChartFetchReturn<T> {
@@ -290,8 +264,7 @@ export function useChartFetch<T>(
       scheduleRefresh,
     );
     onMounted(fetchOnMount);
-    subscribeRealtimeTopics(options.realtimeTopic, refreshSameInputs);
-    subscribePageRefresh(refreshSameInputs);
+    useRefreshTriggers(options.realtimeTopic, refreshSameInputs);
   } else if (typeof options.staticData === "function") {
     watch(
       () => readStaticData(options.staticData),

package/frontend-vue/layers/dms-ui/app/composables/form/useForm.ts

@@ -13,6 +13,7 @@ import {
   type ReplaceUrlVariablesContext,
   hasUrlVariables,
   replaceUrlVariables,
+  resolveTextVariables,
   resolveUrlVariables,
 } from "../../build/utils/urlVariables";
 
@@ -347,7 +348,7 @@ export function resolveSubmitDefaults(
   const resolved: Record<string, unknown> = {};
   for (const [key, value] of Object.entries(submitDefaults)) {
     if (typeof value === "string" && hasUrlVariables(value)) {
-      const replaced = resolveUrlVariables(value, context);
+      const replaced = resolveTextVariables(value, context);
       if (replaced === undefined) continue;
       resolved[key] = replaced;
     } else {

package/frontend-vue/layers/dms-ui/app/composables/tab/types/props.ts

@@ -29,6 +29,8 @@ export interface TabProps extends TabComponentProps {
    * names, read in one request and again when a watch action fires.
    */
   badgesUrl?: string;
+  /** Topics whose events make the tab set read `badgesUrl` again. */
+  realtimeTopic?: string | string[];
 }
 
 /** The badges `badgesUrl` answers with, by tab slot. */

package/frontend-vue/layers/dms-ui/app/composables/table-view/types/action-target.ts

@@ -1,9 +1,13 @@
+import type { DrawerDirection } from "../../containers/types";
+
 export type ActionTarget =
   | {
       type: "drawer";
       component: ComponentInfo;
       title?: string;
       description?: string;
+      /** Edge the drawer slides in from (`bottom` by default). */
+      direction?: DrawerDirection;
     }
   | {
       type: "modal";

package/frontend-vue/layers/dms-ui/app/utils/blockRefresh.ts

@@ -1,7 +1,7 @@
 /**
  * The window event a data block (StatGroup, KeyValueList, NavCardGrid,
- * ActivityFeed, KPI, top list, meter, chart, a tab set's badges) re-fetches
- * on, keeping its values on screen until the new answer lands.
+ * ActivityFeed, KPI, top list, meter, chart, a tab set's badges, table view)
+ * re-fetches on, keeping its values on screen until the new answer lands.
  */
 export const BLOCK_REFRESH_EVENT = "DmsComponent.Block.Refresh";
 

package/frontend-vue/layers/dms-ui/i18n/locales/ui-en-GB.json

@@ -25,6 +25,7 @@
       "edit_item_description": "Change its fields, then save.",
       "edit_item_in": "Changes are saved to {caption}.",
       "search_placeholder": "Search...",
+      "search_open": "Open search",
       "options_title": "Table options",
       "filters_title": "Filters",
       "columns_title": "Columns",

package/frontend-vue/layers/dms-ui/i18n/locales/ui-fr-FR.json

@@ -25,6 +25,7 @@
       "edit_item_description": "Modifiez ses champs, puis enregistrez.",
       "edit_item_in": "Les modifications sont enregistrées dans « {caption} ».",
       "search_placeholder": "Rechercher...",
+      "search_open": "Ouvrir la recherche",
       "options_title": "Options de la table",
       "filters_title": "Filtres",
       "columns_title": "Colonnes",

package/frontend-vue/package.json

@@ -11,7 +11,7 @@
   "license": "Apache-2.0",
   "packageManager": "pnpm@10.6.5",
   "engines": {
-    "@antelopejs/dms-frontend": ">=0.5.1 <0.6.0"
+    "@antelopejs/dms-frontend": ">=0.5.2 <0.6.0"
   },
   "scripts": {
     "typecheck": "ajs dms verify-source --layer \"$PWD\" --local-package @antelopejs/dms=.. --local-package @antelopejs/interface-dms=../../interface-dms",
@@ -73,7 +73,7 @@
   },
   "devDependencies": {
     "@antelopejs/core": ">=1.13.4 <2",
-    "@antelopejs/dms-frontend": ">=0.5.1 <0.6.0",
+    "@antelopejs/dms-frontend": ">=0.5.2 <0.6.0",
     "@eslint/js": "^8.57.0",
     "@inertiajs/vue3": "^3.7.0",
     "@nuxt/ui": "4.10.0",

package/frontend-vue/pnpm-lock.yaml

@@ -157,8 +157,8 @@ importers:
         specifier: '>=1.13.4 <2'
         version: 1.13.5
       '@antelopejs/dms-frontend':
-        specifier: '>=0.5.1 <0.6.0'
-        version: 0.5.1(@antelopejs/core@1.13.5)
+        specifier: '>=0.5.2 <0.6.0'
+        version: 0.5.2(@antelopejs/core@1.13.5)
       '@eslint/js':
         specifier: ^8.57.0
         version: 8.57.0
@@ -234,8 +234,8 @@ packages:
     engines: {node: '>=20.19'}
     hasBin: true
 
-  '@antelopejs/dms-frontend@0.5.1':
-    resolution: {integrity: sha512-ykrqlHfYF+BqNy+h4FuZBbqAW6UjviauCiI8cQCW1M55MzIxk2Ar3ZnMH1VKH8QsfDBBNapDik5rd/AMLQ33dw==}
+  '@antelopejs/dms-frontend@0.5.2':
+    resolution: {integrity: sha512-0kChPedSTpKES7aN/gLj5tAe4WRaU+FrwaRKpOyvo3fvvRPfDTvlTYjjdUpabsF150d3+V/AksXstZ5eb36QwQ==}
     engines: {node: '>=20.12.0'}
     hasBin: true
     peerDependencies:
@@ -4205,7 +4205,7 @@ snapshots:
       semver: 7.8.5
       typescript: 5.9.3
 
-  '@antelopejs/dms-frontend@0.5.1(@antelopejs/core@1.13.5)':
+  '@antelopejs/dms-frontend@0.5.2(@antelopejs/core@1.13.5)':
     dependencies:
       '@antelopejs/core': 1.13.5
       chokidar: 4.0.3

package/frontend-vue/tests/activity-feed-days.test.ts

@@ -3,6 +3,7 @@ import {
   formatActivityTime,
   formatShortDate,
   groupActivityByDay,
+  activityText,
   resolveActivityParams,
   relativeDayBucket,
 } from "../layers/dms-ui/app/build/components/activity-feed/activityFeedDays";
@@ -87,25 +88,38 @@ describe("activity feed day groups", () => {
 });
 
 describe("resolveActivityParams", () => {
-  // Echoes the key and its values, so assertions read the whole text.
-  const translate = (key: string, params?: Record<string, string> | null) =>
-    `${key}(${JSON.stringify(params ?? {})})`;
-
-  it("translates a $ value with the entry's literal values", () => {
+  it("makes a $ value a text of its own, with the entry's other values", () => {
+    const count = { type: "count", value: 2 } as const;
     expect(
-      resolveActivityParams(
-        { device: "$activity.device", browser: "Chrome", os: "Windows" },
-        translate,
-      ),
+      resolveActivityParams({
+        device: "$activity.device",
+        browser: "Chrome",
+        count,
+      }),
     ).toEqual({
-      device: '$activity.device({"browser":"Chrome","os":"Windows"})',
+      device: {
+        key: "$activity.device",
+        params: { browser: "Chrome", count },
+      },
       browser: "Chrome",
-      os: "Windows",
+      count,
     });
   });
 
   it("gives nothing for an entry without values", () => {
-    expect(resolveActivityParams(undefined, translate)).toBeNull();
+    expect(resolveActivityParams(undefined)).toBeUndefined();
+  });
+});
+
+describe("activityText", () => {
+  it("gives a $ title the entry's values and leaves other texts alone", () => {
+    expect(activityText("$a.title", { name: "Léa" })).toEqual({
+      key: "$a.title",
+      params: { name: "Léa" },
+    });
+    expect(activityText("Plain", { name: "Léa" })).toBe("Plain");
+    const composed = { key: "a.composed" };
+    expect(activityText(composed, { name: "Léa" })).toBe(composed);
   });
 });
 

package/frontend-vue/tests/banner-block-fetch.test.ts

@@ -0,0 +1,162 @@
+// @vitest-environment jsdom
+/**
+ * A Banner with a `fetchUrl` draws what its route answers, over its static
+ * options field by field; draws nothing while the first answer is on its way
+ * or when the route answers no banner (`null`, `{}`, a 204); reads its route
+ * again on a page refresh; and runs the button targets the route answers.
+ */
+import { createApp, defineComponent, h, reactive, ref } from "vue";
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { refreshPageBlocks } from "../layers/dms-ui/app/utils/blockRefresh";
+
+const requests: string[] = [];
+let answer: unknown = null;
+const pressed: unknown[] = [];
+
+vi.stubGlobal("useAuthFetch", () => ({
+  $authFetch: async (url: string) => {
+    requests.push(url);
+    return answer;
+  },
+}));
+vi.stubGlobal("useDmsRoute", () => reactive({ query: {} }));
+vi.stubGlobal("useDmsCookie", () => ref<string[]>([]));
+vi.stubGlobal("useTranslation", () => ({ processI18n: String }));
+vi.stubGlobal("useApiError", () => {});
+vi.stubGlobal("useI18n", () => ({ t: String, locale: ref("en") }));
+
+vi.mock("../layers/dms-core/app/composables/watch/useWatch", () => ({
+  useWatch: () => ({ state: ref({}) }),
+}));
+vi.mock(
+  "../layers/dms-ui/app/build/composables/actions/useActionTargets",
+  () => ({
+    useActionTargets: () => ({
+      handleCustomButton: (button: unknown) => pressed.push(button),
+    }),
+  }),
+);
+vi.mock("../layers/dms-ui/app/components/banner/Banner.vue", () => ({
+  default: defineComponent({
+    props: {
+      title: { type: String, default: undefined },
+      description: { type: String, default: undefined },
+      tone: { type: String, default: undefined },
+      icon: { type: String, default: undefined },
+    },
+    setup:
+      (props, { slots }) =>
+      () =>
+        h("section", { "data-banner": JSON.stringify(props) }, [
+          slots.actions?.(),
+        ]),
+  }),
+}));
+
+const { default: BannerBlock } = await import(
+  "../layers/dms-ui/app/components/blocks/BannerBlock.vue"
+);
+
+// useChartFetch debounces every refresh past the first by 180ms.
+const SETTLE_MS = 250;
+const settle = () => new Promise((resolve) => setTimeout(resolve, SETTLE_MS));
+const FETCH_URL = "/api/ws/{{params.id}}/health";
+
+const UButton = defineComponent({
+  props: { label: { type: String, default: undefined } },
+  setup:
+    (props, { attrs }) =>
+    () =>
+      h("button", { onClick: attrs.onClick }, props.label),
+});
+
+const mounted: Array<{ unmount: () => void }> = [];
+
+function mountBanner(props: Record<string, unknown>) {
+  const root = document.createElement("div");
+  const app = createApp(BannerBlock, {
+    componentId: "health",
+    pageId: "ws",
+    routeParams: { id: "ws-1" },
+    fetchUrl: FETCH_URL,
+    ...props,
+  });
+  app.component("UButton", UButton);
+  app.mount(root);
+  mounted.push(app);
+  return {
+    root,
+    read: () => {
+      const banner = root.querySelector("[data-banner]");
+      return banner ? JSON.parse(banner.getAttribute("data-banner")!) : null;
+    },
+  };
+}
+
+beforeEach(() => {
+  requests.length = 0;
+  pressed.length = 0;
+  answer = null;
+});
+
+afterEach(() => {
+  mounted.splice(0).forEach((app) => app.unmount());
+});
+
+it("draws the fetched props over the static options", async () => {
+  answer = { tone: "error", title: "Provider down" };
+  const banner = mountBanner({ title: "Static", description: "Kept" });
+  expect(banner.read()).toBeNull();
+  await settle();
+
+  expect(requests).toEqual(["/api/ws/ws-1/health"]);
+  expect(banner.read()).toMatchObject({
+    tone: "error",
+    title: "Provider down",
+    description: "Kept",
+    icon: "i-ph-warning-circle",
+  });
+});
+
+it.each([
+  ["null", null],
+  ["an empty object", {}],
+  ["no content (204)", undefined],
+])("draws nothing when the route answers %s", async (_name, response) => {
+  answer = response;
+  const banner = mountBanner({ title: "Static" });
+  await settle();
+  expect(requests).toHaveLength(1);
+  expect(banner.root.innerHTML).toBe("<!--v-if-->");
+});
+
+it("follows a page refresh, appearing and going away", async () => {
+  const banner = mountBanner({});
+  await settle();
+  expect(banner.read()).toBeNull();
+
+  answer = { title: "Degraded" };
+  refreshPageBlocks();
+  await settle();
+  expect(banner.read()).toMatchObject({ title: "Degraded" });
+
+  answer = null;
+  refreshPageBlocks();
+  await settle();
+  expect(banner.read()).toBeNull();
+  expect(requests).toHaveLength(3);
+});
+
+it("runs a button target the route answers", async () => {
+  const replay = {
+    label: "Replay",
+    target: { type: "api", url: "/api/replay", successMessage: "Replayed" },
+    confirm: { title: "Replay the queue?" },
+  };
+  answer = { title: "Outage", actions: [replay] };
+  const banner = mountBanner({});
+  await settle();
+
+  banner.root.querySelector("button")!.click();
+  expect(pressed).toEqual([replay]);
+});

package/frontend-vue/tests/block-fetch-options-forwarding.test.ts

@@ -0,0 +1,100 @@
+/**
+ * Every block reading its data through useChartFetch hands it the period
+ * scope and the realtime topics of its options: a block that dropped them
+ * would silently stop following its PeriodSelector or its topics.
+ */
+import { type Component, createSSRApp, defineComponent, h, ref } from "vue";
+import { renderToString } from "vue/server-renderer";
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import type { UseChartFetchOptions } from "../layers/dms-ui/app/composables/chart/useChartFetch";
+
+const fetchOptions: Array<UseChartFetchOptions<unknown>> = [];
+
+vi.mock("../layers/dms-ui/app/composables/chart/useChartFetch", () => ({
+  useChartFetch: (options: UseChartFetchOptions<unknown>) => {
+    fetchOptions.push(options);
+    return {
+      data: ref(null),
+      isLoading: ref(false),
+      error: ref(null),
+      refresh: async () => {},
+    };
+  },
+}));
+vi.mock("../layers/dms-core/app/composables/watch/useWatch", () => ({
+  useWatch: () => ({ state: ref({}) }),
+}));
+vi.mock(
+  "../layers/dms-core/app/composables/components/useComponentEvent",
+  () => ({ useComponentEvent: () => ({}) }),
+);
+// The frames around the blocks are not under test here.
+vi.mock("../layers/dms-ui/app/components/card/Card.vue", () => ({
+  default: defineComponent({ setup: () => () => h("div") }),
+}));
+vi.mock(
+  "#dms-layout/app/build/composables/navigation/useCategoryNavCards",
+  () => ({
+    useCategoryNavCards: () => ({ cards: ref([]) }),
+    usePreviewEntryVeil: () => ({}),
+  }),
+);
+
+const BLOCKS: Record<string, string> = {
+  StatGroupBlock: "../layers/dms-ui/app/components/blocks/StatGroupBlock.vue",
+  KeyValueListBlock:
+    "../layers/dms-ui/app/components/blocks/KeyValueListBlock.vue",
+  NavCardGridBlock:
+    "../layers/dms-ui/app/components/blocks/NavCardGridBlock.vue",
+  ActivityFeed:
+    "../layers/dms-ui/app/components/activity-feed/ActivityFeed.vue",
+  MeterBlock: "../layers/dms-ui/app/components/meter/MeterBlock.vue",
+};
+const GLOBAL_COMPONENTS = ["DmsCard", "UIcon", "USkeleton", "UButton", "ULink"];
+const SCOPE = "dashboard";
+const TOPICS = ["stats:first", "stats:second"];
+
+const Slot = defineComponent({
+  setup:
+    (_, { slots }) =>
+    () =>
+      h("div", slots.default?.()),
+});
+
+async function render(block: Component): Promise<void> {
+  const app = createSSRApp({
+    render: () =>
+      h(block, {
+        componentId: "block",
+        pageId: "page",
+        fetchUrl: "/api/data",
+        periodScope: SCOPE,
+        realtimeTopic: TOPICS,
+      }),
+  });
+  for (const name of GLOBAL_COMPONENTS) app.component(name, Slot);
+  await renderToString(app);
+}
+
+beforeEach(() => {
+  fetchOptions.length = 0;
+  vi.stubGlobal("useI18n", () => ({ locale: ref("en-GB"), t: String }));
+  vi.stubGlobal("useTranslation", () => ({ processI18n: String }));
+  vi.stubGlobal("useDmsCookie", () => ref<string[]>([]));
+});
+
+afterEach(() => vi.unstubAllGlobals());
+
+it.each(Object.keys(BLOCKS))(
+  "%s forwards periodScope and realtimeTopic",
+  async (name) => {
+    const block = (await import(BLOCKS[name])).default as Component;
+    await render(block);
+    expect(fetchOptions).toHaveLength(1);
+    expect(fetchOptions[0]).toMatchObject({
+      fetchUrl: "/api/data",
+      periodScope: SCOPE,
+      realtimeTopic: TOPICS,
+    });
+  },
+);

package/frontend-vue/tests/block-items-period-realtime.test.ts

@@ -0,0 +1,147 @@
+// @vitest-environment jsdom
+/**
+ * A list block reading its items from a route follows a PeriodSelector like
+ * a KPI card (the period goes with every request, and a new period reads the
+ * route again) and reads the route again on each event of its realtime
+ * topics, keeping its items on screen until the answer lands.
+ */
+import { createApp, defineComponent, h, nextTick, reactive, ref } from "vue";
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import type { RealtimeTopicHandler } from "../layers/dms-core/app/composables/realtime/useUserRealtime";
+
+const requests: string[] = [];
+let revision = 1;
+const topicHandlers = new Map<string, RealtimeTopicHandler>();
+
+vi.stubGlobal("useAuthFetch", () => ({
+  $authFetch: async (url: string) => {
+    requests.push(url);
+    return { items: [{ revision }] };
+  },
+}));
+vi.stubGlobal("useDmsRoute", () => reactive({ query: {} }));
+
+vi.mock("../layers/dms-core/app/composables/watch/useWatch", () => ({
+  useWatch: () => ({ state: ref({}) }),
+}));
+vi.mock(
+  "../layers/dms-core/app/composables/components/useComponentEvent",
+  () => ({ useComponentEvent: () => ({}) }),
+);
+vi.mock("../layers/dms-core/app/composables/realtime/useRealtimeTopic", () => ({
+  useRealtimeTopic: (topic: string, handler: RealtimeTopicHandler) => {
+    topicHandlers.set(topic, handler);
+  },
+}));
+
+const { usePeriod } = await import(
+  "../layers/dms-core/app/composables/period/usePeriod"
+);
+const { registerPeriodScope } = await import(
+  "../layers/dms-core/app/composables/period/usePeriodScope"
+);
+const { useBlockItems } = await import(
+  "../layers/dms-ui/app/build/composables/blocks/useBlockItems"
+);
+
+const SCOPE = "block-items-period";
+const STATS_URL = "/api/stats";
+const FACTS_TOPICS = ["facts:first", "facts:second"];
+// useChartFetch debounces every refresh past the first by 180ms.
+const SETTLE_MS = 250;
+const settle = () => new Promise((resolve) => setTimeout(resolve, SETTLE_MS));
+
+interface ItemsProbe {
+  items?: { value: unknown[] };
+  isPending?: { value: boolean };
+}
+
+interface SelectedPeriod {
+  period?: ReturnType<typeof usePeriod>;
+}
+
+const mounted: Array<{ unmount: () => void }> = [];
+
+function mountPeriodPage() {
+  const selected: SelectedPeriod = {};
+  const Selector = defineComponent({
+    setup() {
+      const period = usePeriod({ defaultPreset: "last-7-days" });
+      registerPeriodScope(SCOPE, period.state);
+      selected.period = period;
+      return () => h("div");
+    },
+  });
+  const Block = defineComponent({
+    setup() {
+      useBlockItems({
+        items: () => [],
+        fetchUrl: STATS_URL,
+        periodScope: SCOPE,
+      });
+      return () => h("div");
+    },
+  });
+  const app = createApp({ render: () => h("main", [h(Selector), h(Block)]) });
+  app.mount(document.createElement("div"));
+  mounted.push(app);
+  return selected;
+}
+
+function mountRealtimeBlock(probe: ItemsProbe) {
+  const Block = defineComponent({
+    setup() {
+      const { items, isPending } = useBlockItems({
+        items: () => [],
+        fetchUrl: STATS_URL,
+        realtimeTopic: FACTS_TOPICS,
+      });
+      probe.items = items;
+      probe.isPending = isPending;
+      return () => h("div");
+    },
+  });
+  const app = createApp(Block);
+  app.mount(document.createElement("div"));
+  mounted.push(app);
+}
+
+beforeEach(() => {
+  requests.length = 0;
+  revision = 1;
+  topicHandlers.clear();
+});
+
+afterEach(() => {
+  mounted.splice(0).forEach((app) => app.unmount());
+});
+
+it("requests the items with the period of its scope, again when it changes", async () => {
+  const selected = mountPeriodPage();
+  await settle();
+  expect(requests).toHaveLength(1);
+  expect(requests[0]).toMatch(/^\/api\/stats\?from=.*&preset=last-7-days/);
+
+  selected.period?.setPreset("last-30-days");
+  await nextTick();
+  await settle();
+  expect(requests).toHaveLength(2);
+  expect(requests[1]).toContain("preset=last-30-days");
+});
+
+it("reads the route again on each event of any of its topics", async () => {
+  const probe: ItemsProbe = {};
+  mountRealtimeBlock(probe);
+  await settle();
+  expect([...topicHandlers.keys()]).toEqual(FACTS_TOPICS);
+  expect(probe.items?.value).toEqual([{ revision: 1 }]);
+
+  revision = 2;
+  topicHandlers.get("facts:second")?.({ type: "facts.update" } as never);
+  expect(probe.isPending?.value).toBe(false);
+  expect(probe.items?.value).toEqual([{ revision: 1 }]);
+  await settle();
+
+  expect(requests).toEqual([STATS_URL, STATS_URL]);
+  expect(probe.items?.value).toEqual([{ revision: 2 }]);
+});