@antelopejs/dms 0.9.2 → 0.9.3

package/frontend-vue/tests/period-hydration-now.test.ts

@@ -1,185 +0,0 @@
-// @vitest-environment jsdom
-/**
- * A relative preset (`last-24h`) in a server render and in the browser that
- * hydrates it, through the runtime's real async data: both resolve the period
- * from the instant the server rendered at, so the browser hydrates the same
- * bounds, key and card data without asking again, whatever time it is when
- * it hydrates. Anywhere else, the period follows the browser's clock.
- */
-import {
-  createApp,
-  createSSRApp,
-  defineComponent,
-  h,
-  nextTick,
-  onBeforeUnmount,
-  type App,
-  type Component,
-} from "vue";
-import { renderToString } from "vue/server-renderer";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import {
-  browserTimeZone,
-  setReaderTimeZoneSource,
-} from "../layers/dms-core/app/utils/regional";
-
-const engine = await import("#dms/frontend-module");
-vi.stubGlobal("useDmsAsyncData", engine.useDmsAsyncData);
-vi.stubGlobal("useDmsFetch", engine.useDmsFetch);
-vi.stubGlobal("useDmsState", engine.useDmsState);
-vi.stubGlobal("useDmsCookie", engine.useDmsCookie);
-
-const requests: string[] = [];
-vi.stubGlobal("useAuthFetch", () => ({
-  $authFetch: async (url: string) => {
-    requests.push(url);
-    return {
-      value: new URL(url, "http://dms.local").searchParams.get("to"),
-    };
-  },
-}));
-
-const { useApiData } = await import(
-  "../layers/dms-core/app/composables/auth/useApiData"
-);
-vi.stubGlobal("useApiData", useApiData);
-const { usePeriod } = await import(
-  "../layers/dms-core/app/composables/period/usePeriod"
-);
-const { registerPeriodScope } = await import(
-  "../layers/dms-core/app/composables/period/usePeriodScope"
-);
-const { TIME_ZONE_COOKIE, useTimeZoneCookie } = await import(
-  "../layers/dms-core/app/composables/period/periodTimeZone"
-);
-setReaderTimeZoneSource(() => useTimeZoneCookie().value);
-const ZONE_COOKIE = `${TIME_ZONE_COOKIE}=${encodeURIComponent(JSON.stringify(browserTimeZone()))}`;
-// jsdom's `document` stays while the server renders: its cookies are the ones
-// read then, as the request's would be.
-document.cookie = ZONE_COOKIE;
-const { useChartFetch } = await import(
-  "../layers/dms-ui/app/composables/chart/useChartFetch"
-);
-
-const SCOPE = "ops";
-const SERVER_NOW = new Date("2026-10-15T10:00:30.000Z");
-// The browser hydrates a minute and a half later, past a minute boundary.
-const HYDRATION_DELAY_MS = 90_000;
-
-const Selector = defineComponent({
-  setup() {
-    const period = usePeriod({ defaultPreset: "last-24h" });
-    onBeforeUnmount(registerPeriodScope(SCOPE, period.state));
-    return () => h("i", period.state.value.key);
-  },
-});
-
-const Card = defineComponent({
-  setup() {
-    const { data, isLoading } = useChartFetch<{ value: string }>({
-      fetchUrl: "/api/errors",
-      periodScope: SCOPE,
-    });
-    return () =>
-      h("p", isLoading.value ? "SKELETON" : `to:${data.value?.value}`);
-  },
-});
-
-const Page: Component = {
-  render: () => h("main", [h(Selector), h(Card)]),
-};
-
-const mounted: App[] = [];
-
-beforeEach(() => {
-  requests.length = 0;
-  vi.useFakeTimers({ toFake: ["Date"] });
-  vi.setSystemTime(SERVER_NOW);
-});
-
-afterEach(() => {
-  mounted.splice(0).forEach((app) => app.unmount());
-  vi.useRealTimers();
-});
-
-async function serverRender() {
-  const runtime = engine.createDmsFrontendRuntime(
-    undefined,
-    {},
-    true,
-    ZONE_COOKIE,
-  );
-  const app = createSSRApp(Page);
-  engine.provideDmsFrontendRuntime(app, runtime);
-  engine.setDmsServerRuntimeResolver(() => runtime);
-  // What the server sees: no `window`.
-  const browserWindow = globalThis.window;
-  vi.stubGlobal("window", undefined);
-  try {
-    const html = await renderToString(app);
-    return { html, payload: engine.serializeDmsPayload(runtime) };
-  } finally {
-    vi.stubGlobal("window", browserWindow);
-  }
-}
-
-async function hydrate(html: string, payload: unknown) {
-  const browser = engine.createDmsFrontendRuntime(undefined, {});
-  engine.restoreDmsPayload(
-    browser,
-    structuredClone(payload) as Parameters<typeof engine.restoreDmsPayload>[1],
-  );
-  const container = document.createElement("div");
-  container.innerHTML = html;
-  const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-  const error = vi.spyOn(console, "error").mockImplementation(() => {});
-  const app = createSSRApp(Page);
-  engine.provideDmsFrontendRuntime(app, browser);
-  app.mount(container);
-  mounted.push(app);
-  await nextTick();
-  await new Promise((done) => setTimeout(done, 300));
-  const mismatches = [...warn.mock.calls, ...error.mock.calls].filter((call) =>
-    /hydration/i.test(String(call[0])),
-  );
-  warn.mockRestore();
-  error.mockRestore();
-  return { container, mismatches };
-}
-
-describe("a relative preset across a server render and its hydration", () => {
-  it("renders the card's data with the server's instant", async () => {
-    const { html } = await serverRender();
-
-    expect(html).toContain(`to:${SERVER_NOW.toISOString()}`);
-    expect(html).toContain(`|${SERVER_NOW.toISOString()}|`);
-    expect(requests).toHaveLength(1);
-  });
-
-  it("hydrates the same bounds later on: no request, no mismatch", async () => {
-    const { html, payload } = await serverRender();
-    requests.length = 0;
-    vi.setSystemTime(SERVER_NOW.getTime() + HYDRATION_DELAY_MS);
-
-    const { container, mismatches } = await hydrate(html, payload);
-
-    expect(mismatches).toEqual([]);
-    expect(requests).toEqual([]);
-    expect(container.innerHTML).toBe(html);
-  });
-
-  it("follows the browser's clock on a client mount", async () => {
-    const later = SERVER_NOW.getTime() + HYDRATION_DELAY_MS;
-    vi.setSystemTime(later);
-    const app = createApp(Selector);
-    engine.provideDmsFrontendRuntime(
-      app,
-      engine.createDmsFrontendRuntime(undefined, {}),
-    );
-    const root = document.createElement("div");
-    app.mount(root);
-    mounted.push(app);
-
-    expect(root.textContent).toContain(`|${new Date(later).toISOString()}|`);
-  });
-});

package/frontend-vue/tests/period-live-pause.test.ts

@@ -1,110 +0,0 @@
-// @vitest-environment jsdom
-/**
- * A rolling period (`last-hour`, `last-24h`) slides every minute, and every
- * block reading it refetches. On a paused live page the period holds still,
- * so nothing refetches on the clock; a period the user picks still applies at
- * once, and resuming catches the skipped minutes up in one read.
- */
-import { createApp, defineComponent, h, ref } from "vue";
-import { afterEach, beforeEach, expect, it, vi } from "vitest";
-import { useRealDataEngine } from "./fixtures/dataEngine";
-import { createPageLiveController } from "../layers/dms-ui/app/build/composables/live/pageLiveController";
-import { setCurrentPageLive } from "../layers/dms-ui/app/build/composables/live/currentPageLive";
-import { usePageLive } from "../layers/dms-ui/app/composables/live/usePageLive";
-import {
-  usePeriod,
-  type UsePeriodReturn,
-} from "../layers/dms-core/app/composables/period/usePeriod";
-import { registerPeriodScope } from "../layers/dms-core/app/composables/period/usePeriodScope";
-
-const requests: string[] = [];
-
-vi.stubGlobal("useAuthFetch", () => ({
-  $authFetch: async (url: string) => {
-    requests.push(url);
-    return { value: requests.length };
-  },
-}));
-vi.stubGlobal("useDmsRoute", () => ({ query: {} }));
-vi.stubGlobal("ref", ref);
-
-const { useChartFetch } = await import(
-  "../layers/dms-ui/app/composables/chart/useChartFetch"
-);
-
-const SCOPE = "live-period";
-const MINUTE_MS = 60_000;
-const apps: Array<() => void> = [];
-
-function mountPageWithChart(): UsePeriodReturn {
-  let period: UsePeriodReturn | undefined;
-  const app = createApp(
-    defineComponent({
-      setup() {
-        const { isPaused } = usePageLive();
-        // As the PeriodSelector wires it.
-        period = usePeriod({
-          defaultPreset: "last-hour",
-          holdClock: () => isPaused.value,
-        });
-        registerPeriodScope(SCOPE, period.state);
-        useChartFetch({ fetchUrl: "/api/chart", periodScope: SCOPE });
-        return () => h("div");
-      },
-    }),
-  );
-  app.mount(document.createElement("div"));
-  apps.push(() => app.unmount());
-  return period!;
-}
-
-beforeEach(() => useRealDataEngine());
-
-beforeEach(() => {
-  vi.useFakeTimers();
-  requests.length = 0;
-  window.localStorage.clear();
-});
-
-afterEach(() => {
-  apps.splice(0).forEach((unmount) => unmount());
-  setCurrentPageLive(null);
-  vi.useRealTimers();
-});
-
-it("slides and refetches every minute in Direct", async () => {
-  setCurrentPageLive(createPageLiveController("api.overview", {}));
-  mountPageWithChart();
-  await vi.advanceTimersByTimeAsync(1000);
-  expect(requests).toHaveLength(1);
-
-  await vi.advanceTimersByTimeAsync(2 * MINUTE_MS);
-  expect(requests).toHaveLength(3);
-});
-
-it("holds the period while paused, but follows the user's pick", async () => {
-  const live = createPageLiveController("api.overview", {});
-  setCurrentPageLive(live);
-  const period = mountPageWithChart();
-  await vi.advanceTimersByTimeAsync(1000);
-  expect(requests).toHaveLength(1);
-
-  live.pause();
-  const heldKey = period.state.value.key;
-  await vi.advanceTimersByTimeAsync(3 * MINUTE_MS);
-  expect(requests).toHaveLength(1);
-  expect(period.state.value.key).toBe(heldKey);
-
-  period.setPreset("last-24h");
-  await vi.advanceTimersByTimeAsync(1000);
-  expect(requests).toHaveLength(2);
-  expect(requests[1]).toContain("preset=last-24h");
-
-  await vi.advanceTimersByTimeAsync(2 * MINUTE_MS);
-  expect(requests).toHaveLength(2);
-
-  live.resume();
-  await vi.advanceTimersByTimeAsync(1000);
-  expect(requests).toHaveLength(3);
-  expect(period.state.value.key).not.toBe(heldKey);
-});

package/frontend-vue/tests/period-max-days.test.ts

@@ -1,114 +0,0 @@
-// @vitest-environment jsdom
-/**
- * `maxDays` caps the custom range a PeriodSelector lets the user pick: the
- * calendar disables the days past it once a start day is picked, and a range
- * from the date fields or a long preset is cut to it.
- */
-import { CalendarDate } from "@internationalized/date";
-import { createApp, defineComponent, h, nextTick, type App } from "vue";
-import { afterEach, describe, expect, it } from "vitest";
-import PeriodRangeCalendar from "../layers/dms-ui/app/build/components/period/PeriodRangeCalendar.vue";
-import {
-  calendarRangeDays,
-  isBeyondMaxDays,
-  limitCalendarRange,
-} from "../layers/dms-ui/app/build/composables/period/periodDisplay";
-
-const OCTOBER_FIRST = new CalendarDate(2026, 10, 1);
-const OCTOBER_LAST = new CalendarDate(2026, 10, 31);
-
-describe("limitCalendarRange", () => {
-  const october = { start: OCTOBER_FIRST, end: OCTOBER_LAST };
-
-  it("keeps a range within the limit", () => {
-    expect(limitCalendarRange(october, 31, "start")).toBe(october);
-    expect(limitCalendarRange(october, undefined, "start")).toBe(october);
-  });
-
-  it("moves the end when the start is kept", () => {
-    const limited = limitCalendarRange(october, 7, "start");
-    expect(limited.start.toString()).toBe("2026-10-01");
-    expect(limited.end.toString()).toBe("2026-10-07");
-    expect(calendarRangeDays(limited)).toBe(7);
-  });
-
-  it("moves the start when the end is kept", () => {
-    const limited = limitCalendarRange(october, 7, "end");
-    expect(limited.start.toString()).toBe("2026-10-25");
-    expect(limited.end.toString()).toBe("2026-10-31");
-  });
-});
-
-describe("isBeyondMaxDays", () => {
-  it("allows exactly maxDays days on either side of the picked day", () => {
-    const picked = new CalendarDate(2026, 10, 10);
-    expect(isBeyondMaxDays(picked.add({ days: 6 }), picked, 7)).toBe(false);
-    expect(isBeyondMaxDays(picked.add({ days: 7 }), picked, 7)).toBe(true);
-    expect(isBeyondMaxDays(picked.subtract({ days: 6 }), picked, 7)).toBe(
-      false,
-    );
-    expect(isBeyondMaxDays(picked.subtract({ days: 7 }), picked, 7)).toBe(true);
-    expect(isBeyondMaxDays(picked.add({ days: 400 }), picked, undefined)).toBe(
-      false,
-    );
-  });
-});
-
-describe("the range calendar with maxDays", () => {
-  let app: App | undefined;
-
-  afterEach(() => {
-    app?.unmount();
-    app = undefined;
-  });
-
-  function mountCalendar(maxDays?: number): HTMLElement {
-    const host = document.createElement("div");
-    document.body.appendChild(host);
-    app = createApp(
-      defineComponent({
-        setup: () => () =>
-          h(PeriodRangeCalendar, {
-            modelValue: {
-              start: new CalendarDate(2026, 9, 1),
-              end: new CalendarDate(2026, 9, 2),
-            },
-            locale: "en-US",
-            numberOfMonths: 1,
-            maxDays,
-          }),
-      }),
-    );
-    app.config.globalProperties.$t = (_key: string, fallback: string) =>
-      fallback;
-    app.component(
-      "UButton",
-      defineComponent({ setup: () => () => h("button") }),
-    );
-    app.mount(host);
-    return host;
-  }
-
-  function day(host: HTMLElement, value: string): HTMLElement {
-    const cell = host.querySelector<HTMLElement>(`[data-value="${value}"]`);
-    if (!cell) throw new Error(`No day ${value}`);
-    return cell;
-  }
-
-  it("disables the days past the limit once a start day is picked", async () => {
-    const host = mountCalendar(7);
-    expect(day(host, "2026-09-20").hasAttribute("data-disabled")).toBe(false);
-    day(host, "2026-09-10").click();
-    await nextTick();
-    expect(day(host, "2026-09-16").hasAttribute("data-disabled")).toBe(false);
-    expect(day(host, "2026-09-17").hasAttribute("data-disabled")).toBe(true);
-    expect(day(host, "2026-09-03").hasAttribute("data-disabled")).toBe(true);
-  });
-
-  it("leaves every day enabled without a limit", async () => {
-    const host = mountCalendar();
-    day(host, "2026-09-10").click();
-    await nextTick();
-    expect(day(host, "2026-09-30").hasAttribute("data-disabled")).toBe(false);
-  });
-});

package/frontend-vue/tests/period-presets.test.ts

@@ -1,108 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { resolvePresetRange } from "../layers/dms-core/app/composables/period/presetResolvers";
-import { resolveComparisonRange } from "../layers/dms-core/app/composables/period/compareResolvers";
-import {
-  MS_PER_DAY,
-  MS_PER_HOUR,
-  type PeriodRange,
-} from "../layers/dms-core/app/composables/period/types";
-
-const NOW = new Date(2026, 6, 28, 14, 37, 12, 500);
-const FALLBACK: PeriodRange = {
-  from: new Date(2026, 0, 1),
-  to: new Date(2026, 0, 31),
-};
-
-function durationOf(range: PeriodRange): number {
-  return range.to.getTime() - range.from.getTime();
-}
-
-function isStartOfDay(date: Date): boolean {
-  return (
-    date.getHours() === 0 &&
-    date.getMinutes() === 0 &&
-    date.getSeconds() === 0 &&
-    date.getMilliseconds() === 0
-  );
-}
-
-describe("relative presets", () => {
-  it("keeps last-hour on instant bounds ending now", () => {
-    const range = resolvePresetRange("last-hour", NOW, FALLBACK);
-    expect(range.to).toEqual(NOW);
-    expect(durationOf(range)).toBe(MS_PER_HOUR);
-    expect(isStartOfDay(range.from)).toBe(false);
-  });
-
-  it("keeps last-24h on instant bounds ending now", () => {
-    const range = resolvePresetRange("last-24h", NOW, FALLBACK);
-    expect(range.to).toEqual(NOW);
-    expect(durationOf(range)).toBe(MS_PER_DAY);
-  });
-
-  it("snaps last-90-days to calendar day boundaries, today included", () => {
-    const range = resolvePresetRange("last-90-days", NOW, FALLBACK);
-    expect(isStartOfDay(range.from)).toBe(true);
-    expect(range.to.getDate()).toBe(NOW.getDate());
-    expect(range.to.getHours()).toBe(23);
-    expect(Math.round(durationOf(range) / MS_PER_DAY)).toBe(90);
-  });
-
-  it("resolves the same day-count family consistently", () => {
-    const lengths = (
-      ["last-7-days", "last-30-days", "last-90-days"] as const
-    ).map((preset) =>
-      Math.round(
-        durationOf(resolvePresetRange(preset, NOW, FALLBACK)) / MS_PER_DAY,
-      ),
-    );
-    expect(lengths).toEqual([7, 30, 90]);
-  });
-});
-
-describe("previous-period comparison", () => {
-  it("returns the equal-length span immediately before a day range", () => {
-    const range = resolvePresetRange("last-7-days", NOW, FALLBACK);
-    const compare = resolveComparisonRange("previous-period", range, null);
-    expect(compare).not.toBeNull();
-    expect(durationOf(compare!)).toBe(durationOf(range));
-    expect(compare!.to.getTime()).toBe(range.from.getTime() - 1);
-  });
-
-  it("does not overlap the primary range", () => {
-    const range = resolvePresetRange("this-month", NOW, FALLBACK);
-    const compare = resolveComparisonRange("previous-period", range, null);
-    expect(compare!.to.getTime()).toBeLessThan(range.from.getTime());
-  });
-
-  it("compares an intraday range to the hour right before it", () => {
-    const range = resolvePresetRange("last-hour", NOW, FALLBACK);
-    const compare = resolveComparisonRange("previous-period", range, null);
-    expect(durationOf(compare!)).toBe(MS_PER_HOUR);
-    expect(range.from.getTime() - compare!.to.getTime()).toBe(1);
-  });
-
-  it("keeps whole-day comparisons on midnight across a DST change", () => {
-    // October 2026 holds the European DST change (Oct 25); the previous
-    // 31 days must still start at local midnight.
-    const range = {
-      from: new Date(2026, 9, 1),
-      to: new Date(new Date(2026, 10, 1).getTime() - 1),
-    };
-    const compare = resolveComparisonRange("previous-period", range, null);
-    expect(compare!.from).toEqual(new Date(2026, 7, 31));
-    expect(compare!.to.getTime()).toBe(range.from.getTime() - 1);
-  });
-
-  it("keeps previous-year on the same calendar dates", () => {
-    const range = resolvePresetRange("last-30-days", NOW, FALLBACK);
-    const compare = resolveComparisonRange("previous-year", range, null);
-    expect(compare!.from.getFullYear()).toBe(range.from.getFullYear() - 1);
-    expect(compare!.from.getDate()).toBe(range.from.getDate());
-  });
-
-  it("returns null when comparison is none", () => {
-    const range = resolvePresetRange("today", NOW, FALLBACK);
-    expect(resolveComparisonRange("none", range, null)).toBeNull();
-  });
-});

package/frontend-vue/tests/period-reader-zone.test.ts

@@ -1,137 +0,0 @@
-/**
- * A server render resolves periods and writes dates in the time zone of the
- * browser it renders for (its `dms-time-zone` cookie), whatever the server's
- * own: the same bounds and the same text as the browser's, so hydration
- * matches. Without the cookie, or in the server's own zone, nothing changes.
- */
-import { afterEach, describe, expect, it } from "vitest";
-import {
-  browserTimeZone,
-  regionalDateTimeFormat,
-  regionalDayKey,
-  setReaderTimeZoneSource,
-} from "../layers/dms-core/app/utils/regional";
-import {
-  localClock,
-  zonedClock,
-} from "../layers/dms-core/app/composables/period/periodClock";
-import { resolvePresetRange } from "../layers/dms-core/app/composables/period/presetResolvers";
-import { resolveComparisonRange } from "../layers/dms-core/app/composables/period/compareResolvers";
-import {
-  formatPeriodDate,
-  parsePeriodDate,
-} from "../layers/dms-ui/app/build/composables/period/periodQuery";
-import { formatPeriodRange } from "../layers/dms-ui/app/build/composables/period/periodDisplay";
-
-// A zone far from any CI's, and one with a daylight saving change.
-const READER_ZONE =
-  browserTimeZone() === "Pacific/Kiritimati"
-    ? "Etc/GMT+12"
-    : "Pacific/Kiritimati";
-const NEW_YORK = "America/New_York";
-const NOW = new Date("2026-10-14T21:30:00.000Z");
-const FALLBACK = { from: NOW, to: NOW };
-
-function readFor(zone: string | null): void {
-  setReaderTimeZoneSource(() => zone);
-}
-
-function inZone(zone: string, date: Date) {
-  const { year, month, day, hours, minutes } = zonedClock(zone).wall(date);
-  return `${year}-${month + 1}-${day} ${hours}:${minutes}`;
-}
-
-afterEach(() => readFor(null));
-
-describe("the clock a period is resolved in", () => {
-  it("reads and builds wall times in a zone, across a daylight saving change", () => {
-    const clock = zonedClock(NEW_YORK);
-    // 8 March 2026: New York moves from UTC-5 to UTC-4 at 2:00.
-    const midnight = clock.instant({
-      year: 2026,
-      month: 2,
-      day: 8,
-      hours: 0,
-      minutes: 0,
-      seconds: 0,
-      milliseconds: 0,
-    });
-    expect(midnight.toISOString()).toBe("2026-03-08T05:00:00.000Z");
-    const evening = clock.instant({ ...clock.wall(midnight), hours: 23 });
-    expect(evening.toISOString()).toBe("2026-03-09T03:00:00.000Z");
-    // Day 0 rolls back to the last day of the month before, as Date's does.
-    const rolled = clock.wall(
-      clock.instant({ ...clock.wall(midnight), month: 3, day: 0 }),
-    );
-    expect([rolled.month, rolled.day]).toEqual([2, 31]);
-  });
-
-  it("matches Date's own calendar in the zone the code runs in", () => {
-    const local = zonedClock(browserTimeZone());
-    expect(local.wall(NOW)).toEqual(localClock.wall(NOW));
-    const wall = { ...localClock.wall(NOW), day: 40, hours: 0 };
-    expect(local.instant(wall).getTime()).toBe(
-      localClock.instant(wall).getTime(),
-    );
-  });
-});
-
-describe("a server render for a browser in another zone", () => {
-  it("resolves presets and comparisons on the browser's calendar days", () => {
-    readFor(READER_ZONE);
-    const range = resolvePresetRange("this-month", NOW, FALLBACK)!;
-    const reader = zonedClock(READER_ZONE);
-    expect(inZone(READER_ZONE, range.from)).toMatch(/-1 0:0$/);
-    expect(reader.wall(range.to).hours).toBe(23);
-    expect(reader.wall(range.to).month).toBe(reader.wall(range.from).month);
-    const previous = resolveComparisonRange("previous-year", range, null)!;
-    expect(reader.wall(previous.from).year).toBe(
-      reader.wall(range.from).year - 1,
-    );
-    expect(inZone(READER_ZONE, previous.from)).toMatch(/-1 0:0$/);
-  });
-
-  it("reads and writes the URL's days as the browser's", () => {
-    readFor(READER_ZONE);
-    const from = parsePeriodDate("2026-10-01", "start")!;
-    expect(inZone(READER_ZONE, from)).toBe("2026-10-1 0:0");
-    expect(formatPeriodDate(from, "start")).toBe("2026-10-01");
-    expect(parsePeriodDate("2026-02-30", "start")).toBeNull();
-  });
-
-  it("writes the period's label and other dates in the browser's zone", () => {
-    readFor(READER_ZONE);
-    const range = resolvePresetRange("this-month", NOW, FALLBACK)!;
-    const expected = new Intl.DateTimeFormat("en", {
-      month: "short",
-      day: "numeric",
-      timeZone: READER_ZONE,
-    }).format(range.from);
-    expect(formatPeriodRange(range, "en")).toContain(expected);
-    expect(
-      regionalDateTimeFormat("en", { dateStyle: "medium" }).format(NOW),
-    ).toBe(
-      new Intl.DateTimeFormat("en", {
-        dateStyle: "medium",
-        timeZone: READER_ZONE,
-      }).format(NOW),
-    );
-  });
-
-  it("files dates under the browser's calendar days", () => {
-    readFor(READER_ZONE);
-    const { year, month, day } = zonedClock(READER_ZONE).wall(NOW);
-    const pad = (value: number) => String(value).padStart(2, "0");
-    expect(regionalDayKey(NOW)).toBe(`${year}-${pad(month + 1)}-${pad(day)}`);
-  });
-
-  it("changes nothing without the browser's zone, or in the server's own", () => {
-    for (const zone of [null, browserTimeZone()]) {
-      readFor(zone);
-      const range = resolvePresetRange("this-month", NOW, FALLBACK)!;
-      expect(range.from).toEqual(
-        new Date(NOW.getFullYear(), NOW.getMonth(), 1),
-      );
-    }
-  });
-});