@remit/web-client 0.0.231 → 0.0.233

package/src/hooks/calendar/agenda-window.test.ts

@@ -0,0 +1,235 @@
+/**
+ * The rolling range, and the busy time it is measured against.
+ *
+ * The strip never paginates, so the claims here are about continuity: reaching
+ * an end grows the run rather than replacing it, a day already held keeps the
+ * days either side of it, and a jump opens a window where it landed. The
+ * free-time half asserts that busy spans the strip did not draw still take the
+ * hours they cover — the rule itself is `@remit/ui`'s, and this only decides
+ * which spans a day gets.
+ */
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { freeStretchesFromSpans } from "@remit/ui";
+import {
+	busySpansByDate,
+	datesInRange,
+	extendRangeEnd,
+	extendRangeStart,
+	freeStretchesByDate,
+	LEAD_IN,
+	LEAD_OUT,
+	PAGE,
+	rangeAround,
+	rangeCovering,
+	weekKeyOf,
+	weekWindowsOver,
+} from "./agenda-window.js";
+import { calendarWindow, startOfDay } from "./window.js";
+
+const DATE = "2026-06-10";
+
+/** The offset this machine is on, so a fixture reads the same in any zone. */
+const offsetOn = (date: string): string => startOfDay(date).slice(19);
+
+const at = (date: string, time: string): string =>
+	`${date}T${time}:00${offsetOn(date)}`;
+
+const clocks = (
+	stretches: readonly { startMinute: number; endMinute: number }[],
+): string[] =>
+	stretches.map(
+		(stretch) =>
+			`${Math.floor(stretch.startMinute / 60)}–${Math.floor(stretch.endMinute / 60)}`,
+	);
+
+describe("the days the strip holds", () => {
+	it("opens further ahead than behind, because a diary is read forwards", () => {
+		const range = rangeAround(DATE);
+		assert.equal(range.from, "2026-05-31");
+		assert.equal(range.to, "2026-07-04");
+		assert.equal(datesInRange(range).length, LEAD_IN + LEAD_OUT + 1);
+	});
+
+	it("grows the run at whichever end was reached, keeping the other", () => {
+		const range = rangeAround(DATE);
+		assert.deepEqual(extendRangeStart(range), {
+			from: "2026-05-17",
+			to: range.to,
+		});
+		assert.deepEqual(extendRangeEnd(range), {
+			from: range.from,
+			to: "2026-07-18",
+		});
+		assert.equal(
+			datesInRange(extendRangeEnd(range)).length,
+			datesInRange(range).length + PAGE,
+		);
+	});
+
+	it("keeps the run a day is already in, so a scroll refetches nothing", () => {
+		const range = rangeAround(DATE);
+		for (const day of ["2026-05-31", DATE, "2026-06-28", "2026-07-04"]) {
+			assert.equal(rangeCovering(range, day), range, `${day} moved the run`);
+		}
+	});
+
+	it("opens a window where a jump landed rather than stretching to it", () => {
+		const range = rangeAround(DATE);
+		assert.deepEqual(
+			rangeCovering(range, "2026-11-02"),
+			rangeAround("2026-11-02"),
+		);
+		assert.deepEqual(
+			rangeCovering(range, "2026-01-05"),
+			rangeAround("2026-01-05"),
+		);
+	});
+});
+
+/**
+ * The range is not a window. A read may not cover more than a year
+ * (`CALENDAR_MAX_WINDOW_DAYS`), and the strip's range grows every time the
+ * reader reaches an end, so the range names weeks to fetch rather than being
+ * one request that eventually gets refused.
+ */
+describe("the weeks a range is fetched as", () => {
+	it("is the grid's own window for each week, once each", () => {
+		const windows = weekWindowsOver(datesInRange(rangeAround(DATE)));
+		for (const window of windows) {
+			assert.deepEqual(
+				window,
+				calendarWindow("week", window.from.slice(0, 10)),
+			);
+		}
+		assert.equal(new Set(windows.map((w) => w.from)).size, windows.length);
+	});
+
+	it("covers every day the strip holds and nothing before or after", () => {
+		const dates = datesInRange(rangeAround(DATE));
+		const held = new Set(weekWindowsOver(dates).map((window) => window.from));
+		for (const date of dates) assert.ok(held.has(weekKeyOf(date)));
+	});
+
+	it("names the week a day belongs to, Monday to Monday", () => {
+		// 2026-06-10 is a Wednesday; its week opens on the 8th.
+		assert.equal(weekKeyOf("2026-06-10"), startOfDay("2026-06-08"));
+		assert.equal(weekKeyOf("2026-06-08"), startOfDay("2026-06-08"));
+		assert.equal(weekKeyOf("2026-06-14"), startOfDay("2026-06-08"));
+		assert.equal(weekKeyOf("2026-06-15"), startOfDay("2026-06-15"));
+	});
+
+	it("asks for one week however far the reader scrolls", () => {
+		// Past the server's 366-day ceiling in both directions.
+		let range = rangeAround(DATE);
+		for (let reach = 0; reach < 30; reach += 1) {
+			range = extendRangeEnd(extendRangeStart(range));
+		}
+		const dates = datesInRange(range);
+		assert.ok(dates.length > 366, "the range never grew past the ceiling");
+
+		for (const window of weekWindowsOver(dates)) {
+			const days =
+				(Date.parse(window.to) - Date.parse(window.from)) / 86_400_000;
+			assert.equal(days, 7, `a window covered ${days} days`);
+		}
+	});
+
+	it("grows by adding weeks rather than by widening one", () => {
+		const opening = weekWindowsOver(datesInRange(rangeAround(DATE)));
+		const wider = weekWindowsOver(
+			datesInRange(extendRangeStart(rangeAround(DATE))),
+		);
+		const kept = new Set(wider.map((window) => window.from));
+		for (const window of opening) {
+			assert.ok(kept.has(window.from), `${window.from} was given up`);
+		}
+		assert.ok(wider.length > opening.length);
+	});
+});
+
+describe("busy time, split into the days it covers", () => {
+	const dates = ["2026-06-10", "2026-06-11", "2026-06-12"];
+
+	it("reads a span as minutes of the day it falls on", () => {
+		const byDate = busySpansByDate(dates, [
+			{ start: at("2026-06-10", "09:00"), end: at("2026-06-10", "10:30") },
+		]);
+		assert.deepEqual(byDate.get("2026-06-10"), [{ from: 540, to: 630 }]);
+		assert.equal(byDate.get("2026-06-11"), undefined);
+	});
+
+	it("gives a span crossing midnight one entry per day it touches", () => {
+		const byDate = busySpansByDate(dates, [
+			{ start: at("2026-06-10", "22:00"), end: at("2026-06-11", "02:00") },
+		]);
+		assert.deepEqual(byDate.get("2026-06-10"), [{ from: 1320, to: 1440 }]);
+		assert.deepEqual(byDate.get("2026-06-11"), [{ from: 0, to: 120 }]);
+	});
+
+	it("leaves no entry on the day a span merely ends at midnight of", () => {
+		const byDate = busySpansByDate(dates, [
+			{ start: at("2026-06-10", "22:00"), end: at("2026-06-11", "00:00") },
+		]);
+		assert.deepEqual(byDate.get("2026-06-10"), [{ from: 1320, to: 1440 }]);
+		assert.equal(byDate.get("2026-06-11"), undefined);
+	});
+
+	it("merges spans that run into each other into the hours they cover", () => {
+		const byDate = busySpansByDate(dates, [
+			{ start: at("2026-06-10", "11:00"), end: at("2026-06-10", "12:00") },
+			{ start: at("2026-06-10", "09:00"), end: at("2026-06-10", "11:30") },
+		]);
+		assert.deepEqual(byDate.get("2026-06-10"), [{ from: 540, to: 720 }]);
+	});
+
+	it("drops a span that is not a stretch of time at all", () => {
+		const byDate = busySpansByDate(dates, [
+			{ start: at("2026-06-10", "11:00"), end: at("2026-06-10", "11:00") },
+			{ start: "not a date", end: at("2026-06-10", "12:00") },
+		]);
+		assert.equal(byDate.size, 0);
+	});
+
+	it("ignores busy time outside the days on screen", () => {
+		const byDate = busySpansByDate(dates, [
+			{ start: at("2026-07-01", "09:00"), end: at("2026-07-01", "10:00") },
+		]);
+		assert.equal(byDate.size, 0);
+	});
+});
+
+describe("free time, off the spans the server merged", () => {
+	const dates = ["2026-06-10", "2026-06-11"];
+
+	it("answers every day the strip holds, including the untouched ones", () => {
+		const free = freeStretchesByDate(dates, []);
+		assert.deepEqual([...free.keys()], dates);
+		assert.equal(free.get("2026-06-11")?.[0].wholeDay, true);
+	});
+
+	/**
+	 * The reader unticked work, so the strip draws nothing on the 10th. They are
+	 * still in meetings all morning, and "Free all day" would be the one thing
+	 * this view must never say.
+	 */
+	it("takes hours out of a day the strip is drawing nothing on", () => {
+		const free = freeStretchesByDate(dates, [
+			{ start: at("2026-06-10", "09:00"), end: at("2026-06-10", "12:00") },
+			{ start: at("2026-06-10", "13:00"), end: at("2026-06-10", "16:00") },
+		]);
+		assert.deepEqual(clocks(free.get("2026-06-10") ?? []), ["16–22"]);
+		assert.equal(free.get("2026-06-10")?.[0].wholeDay, false);
+	});
+
+	it("is the rule `@remit/ui` states, applied to those spans", () => {
+		const spans = [{ from: 9 * 60, to: 12 * 60 }];
+		const free = freeStretchesByDate(dates, [
+			{ start: at("2026-06-10", "09:00"), end: at("2026-06-10", "12:00") },
+		]);
+		assert.deepEqual(
+			free.get("2026-06-10"),
+			freeStretchesFromSpans("2026-06-10", spans),
+		);
+	});
+});

package/src/hooks/calendar/agenda-window.ts

@@ -0,0 +1,183 @@
+/**
+ * The days the strip currently holds, and the arithmetic that grows them.
+ *
+ * The agenda never paginates. It holds one contiguous run of days around the
+ * day the address names and grows it at whichever end the reader reaches, so
+ * there are no page boundaries to lose a place at and no request that throws
+ * away what is already on screen. The range is the only thing a window is: what
+ * to ask `/calendar-events` and `/calendar-free-busy` for falls out of it.
+ *
+ * Nothing here reads a clock or a router. Every function takes the day it works
+ * from, which is what lets the rules be asserted without either.
+ */
+import {
+	type BusySpan,
+	type CalendarDay,
+	datesBetween,
+	type FreeStretch,
+	freeStretchesFromSpans,
+} from "@remit/ui";
+import { isoDate } from "@/lib/calendar-route";
+import { addDays, type CalendarWindow, calendarWindow } from "./window";
+
+/**
+ * Days held behind and ahead of the day the address opened on. More ahead than
+ * behind: a reader lands on a calendar to look forward, and the days behind are
+ * there so scrolling back a little does not immediately fetch.
+ */
+export const LEAD_IN = 10;
+export const LEAD_OUT = 24;
+
+/** What reaching an end adds to it. */
+export const PAGE = 14;
+
+export interface AgendaRange {
+	/** `YYYY-MM-DD`, inclusive. */
+	from: string;
+	/** `YYYY-MM-DD`, inclusive. */
+	to: string;
+}
+
+export const rangeAround = (date: string): AgendaRange => ({
+	from: addDays(date, -LEAD_IN),
+	to: addDays(date, LEAD_OUT),
+});
+
+export const extendRangeStart = (range: AgendaRange): AgendaRange => ({
+	...range,
+	from: addDays(range.from, -PAGE),
+});
+
+export const extendRangeEnd = (range: AgendaRange): AgendaRange => ({
+	...range,
+	to: addDays(range.to, PAGE),
+});
+
+/**
+ * The range that has a day in it. A day already held keeps the range it is in —
+ * identically, so a scroll that moved the address does not throw away the days
+ * either side of it and refetch them. A day outside it is a jump, and a jump
+ * opens a window around where it landed rather than stretching one across the
+ * months in between.
+ */
+export function rangeCovering(range: AgendaRange, date: string): AgendaRange {
+	if (date >= range.from && date <= range.to) return range;
+	return rangeAround(date);
+}
+
+/**
+ * The week each day of the range is served by, deduplicated and in order.
+ *
+ * The strip holds more days than one read may ask for — the server refuses a
+ * window over a year — so the range says which weeks to fetch rather than being
+ * a window itself. Reaching an end then adds a week to this list instead of
+ * widening a single request, which is what keeps the days already on screen
+ * where they are.
+ *
+ * The weeks are `calendarWindow("week", …)` exactly, so they are the grid's own
+ * cache entries: a reader who drops into the week grid and comes back out draws
+ * from what the strip fetched, and a week the grid has already read costs the
+ * strip nothing.
+ */
+export function weekWindowsOver(dates: readonly string[]): CalendarWindow[] {
+	const byStart = new Map<string, CalendarWindow>();
+	for (const date of dates) {
+		const week = calendarWindow("week", date);
+		if (!byStart.has(week.from)) byStart.set(week.from, week);
+	}
+	return [...byStart.values()];
+}
+
+/** The week window a day belongs to, named by its `from`. */
+export const weekKeyOf = (date: string): string =>
+	calendarWindow("week", date).from;
+
+const MINUTES_IN_DAY = 24 * 60;
+
+const minuteOfInstant = (instant: Date): number =>
+	instant.getHours() * 60 + instant.getMinutes();
+
+/**
+ * Busy spans as minutes of the days they cross, on the clock this device is
+ * reading. The API answers in UTC instants because a busy stretch is an
+ * interval rather than a civil date, so the split into days happens here, where
+ * the zone the strip is drawn in is known.
+ *
+ * A span crossing midnight becomes one entry per day it touches. Each day's
+ * entries come back sorted and merged, which is the shape the free-time rule
+ * takes.
+ */
+export function busySpansByDate(
+	dates: readonly string[],
+	spans: readonly { start: string; end: string }[],
+): Map<string, BusySpan[]> {
+	const held = new Set(dates);
+	const byDate = new Map<string, BusySpan[]>();
+
+	for (const span of spans) {
+		const start = new Date(span.start);
+		const end = new Date(span.end);
+		if (Number.isNaN(start.getTime()) || Number.isNaN(end.getTime())) continue;
+		if (end.getTime() <= start.getTime()) continue;
+
+		const firstDate = isoDate(start);
+		// The instant before the end, so a span ending at midnight belongs to the
+		// day it ran through rather than opening an empty entry on the next one.
+		const lastDate = isoDate(new Date(end.getTime() - 1));
+		for (let date = firstDate; date <= lastDate; date = addDays(date, 1)) {
+			if (!held.has(date)) continue;
+			const from = date === firstDate ? minuteOfInstant(start) : 0;
+			// Read off the end's own day rather than off the loop: a span ending at
+			// midnight belongs to the day it ran through, where its end is the end
+			// of that day and not minute zero of the next one.
+			const to = isoDate(end) === date ? minuteOfInstant(end) : MINUTES_IN_DAY;
+			if (to <= from) continue;
+			const day = byDate.get(date);
+			if (day) day.push({ from, to });
+			else byDate.set(date, [{ from, to }]);
+		}
+	}
+
+	for (const [date, day] of byDate) byDate.set(date, mergeSpans(day));
+	return byDate;
+}
+
+function mergeSpans(spans: BusySpan[]): BusySpan[] {
+	const sorted = [...spans].sort((a, b) => a.from - b.from);
+	const merged: BusySpan[] = [];
+	for (const span of sorted) {
+		const last = merged[merged.length - 1];
+		if (last && span.from <= last.to) {
+			last.to = Math.max(last.to, span.to);
+			continue;
+		}
+		merged.push({ ...span });
+	}
+	return merged;
+}
+
+/**
+ * The free time on every day the strip holds, out of the busy spans the server
+ * merged across every calendar. It is `freeStretchesFromSpans` and nothing
+ * else: the rule lives in `@remit/ui` beside the strip that draws it, so this
+ * only decides which spans a day gets.
+ */
+export function freeStretchesByDate(
+	dates: readonly string[],
+	spans: readonly { start: string; end: string }[],
+): Map<string, FreeStretch[]> {
+	const busy = busySpansByDate(dates, spans);
+	return new Map(
+		dates.map((date) => [
+			date,
+			freeStretchesFromSpans(date, busy.get(date) ?? []),
+		]),
+	);
+}
+
+/** The days a range names, in order. */
+export const datesInRange = (range: AgendaRange): string[] =>
+	datesBetween(range.from, range.to);
+
+/** How the strip asks a day what is still open on it. */
+export type FreeLookup = (day: CalendarDay) => FreeStretch[];

package/src/hooks/calendar/calendar-reads.render.test.ts

@@ -0,0 +1,265 @@
+/**
+ * What the calendar asks the server, and how often.
+ *
+ * Three things are pinned here, and all three are about the request rather than
+ * about the pixels: the window is the screenful the address names, the same
+ * week asked for twice is one request, and a step lands on a window that was
+ * already warmed. A grid that refetches on every navigation looks identical in
+ * a screenshot and is a different product to use.
+ *
+ * The tick list is the fourth: ticking nothing is every calendar, and an
+ * address naming a calendar that is gone shows the rest rather than a week that
+ * reads as empty.
+ */
+
+import assert from "node:assert/strict";
+import { afterEach, describe, it } from "node:test";
+import type {
+	RemitImapCalendarEventInstance,
+	RemitImapCalendarResponse,
+} from "@remit/api-http-client/types.gen.ts";
+import { createElement } from "react";
+import { type CalendarData, useCalendarData } from "@/hooks/useCalendarData";
+import { createDomHarness, type DomHarness } from "../../test-support/dom";
+import { type HttpMock, mockFetch } from "../../test-support/http";
+
+const WORK = "11111111-1111-4111-8111-111111111111";
+const HOME = "22222222-2222-4222-8222-222222222222";
+
+let harness: DomHarness | undefined;
+let http: HttpMock | undefined;
+let data: CalendarData | undefined;
+
+afterEach(() => {
+	harness?.close();
+	harness = undefined;
+	http?.restore();
+	http = undefined;
+	data = undefined;
+});
+
+const calendar = (
+	calendarId: string,
+	displayName: string,
+): RemitImapCalendarResponse =>
+	({
+		calendarId,
+		accountConfigId: "cfg-1",
+		urlSegment: displayName.toLowerCase(),
+		displayName,
+		color: "Cal1",
+		componentSet: "VeventOnly",
+		source: "UserCreated",
+		timezone: "Europe/Amsterdam",
+		syncSequence: 1,
+		createdAt: 0,
+		updatedAt: 0,
+	}) as RemitImapCalendarResponse;
+
+const instance = (
+	over: Partial<RemitImapCalendarEventInstance>,
+): RemitImapCalendarEventInstance =>
+	({
+		calendarId: WORK,
+		calendarObjectId: "obj-1",
+		recurrenceId: "",
+		icalUid: "uid-1",
+		summary: "Roadmap review",
+		start: "2026-06-10T10:00:00+02:00",
+		end: "2026-06-10T11:30:00+02:00",
+		allDay: false,
+		status: "Confirmed",
+		transparency: "Opaque",
+		zoneCertainty: "Explicit",
+		etag: "etag-1",
+		hasRecurrence: false,
+		...over,
+	}) as RemitImapCalendarEventInstance;
+
+function Probe({
+	date,
+	calendarIds,
+}: {
+	date: string;
+	calendarIds: readonly string[];
+}) {
+	data = useCalendarData({ view: "week", date, calendarIds });
+	return null;
+}
+
+const mount = async (
+	date: string,
+	calendarIds: readonly string[],
+	instances: RemitImapCalendarEventInstance[] = [],
+	calendars: RemitImapCalendarResponse[] = [
+		calendar(WORK, "Work"),
+		calendar(HOME, "Home"),
+	],
+) => {
+	http = mockFetch((call) =>
+		call.path.endsWith("/calendars")
+			? { items: calendars }
+			: { items: instances },
+	);
+	harness = createDomHarness();
+	harness.renderApp(createElement(Probe, { date, calendarIds }));
+	await harness.flush();
+	await harness.wait(20);
+	await harness.flush();
+};
+
+const rerender = async (date: string, calendarIds: readonly string[]) => {
+	harness?.renderApp(createElement(Probe, { date, calendarIds }));
+	await harness?.flush();
+	await harness?.wait(20);
+	await harness?.flush();
+};
+
+/** Event listings whose window starts on a given day. */
+const windowsFrom = (day: string): string[] =>
+	(http?.to("/calendar-events") ?? [])
+		.map((call) => call.url)
+		.filter((url) => url.includes(`from=${encodeURIComponent(day)}`));
+
+describe("the window the grid asks for", () => {
+	it("is the week the address names, not the day", async () => {
+		await mount("2026-06-10", []);
+		const asked = windowsFrom("2026-06-08");
+		assert.equal(asked.length, 1, "the visible week was asked for once");
+		assert.ok(
+			asked[0].includes(`to=${encodeURIComponent("2026-06-15")}`),
+			`the window ends on the next Monday: ${asked[0]}`,
+		);
+	});
+
+	it("warms the week either side, so a step is not a wait", async () => {
+		await mount("2026-06-10", []);
+		assert.equal(windowsFrom("2026-06-01").length, 1);
+		assert.equal(windowsFrom("2026-06-15").length, 1);
+	});
+});
+
+describe("moving around inside a week already read", () => {
+	it("asks nothing again", async () => {
+		await mount("2026-06-08", []);
+		await rerender("2026-06-11", []);
+		assert.equal(
+			windowsFrom("2026-06-08").length,
+			1,
+			"every day of one week shares the window that was already fetched",
+		);
+	});
+
+	it("steps onto a week the prefetch already holds", async () => {
+		await mount("2026-06-10", []);
+		const before = windowsFrom("2026-06-15").length;
+		await rerender("2026-06-17", []);
+		assert.equal(
+			windowsFrom("2026-06-15").length,
+			before,
+			"the next week was warmed, so stepping onto it fetches nothing",
+		);
+	});
+});
+
+describe("the calendars the address ticked", () => {
+	it("names none when the reader has ticked none", async () => {
+		await mount("2026-06-10", []);
+		assert.ok(
+			windowsFrom("2026-06-08").every((url) => !url.includes("calendarId=")),
+			"ticking nothing off is every calendar, which the API takes as no filter",
+		);
+	});
+
+	it("names the one the address ticked", async () => {
+		await mount("2026-06-10", [WORK]);
+		const asked = windowsFrom("2026-06-08");
+		assert.equal(asked.length, 1);
+		assert.ok(asked[0].includes(`calendarId=${WORK}`));
+		assert.ok(!asked[0].includes(`calendarId=${HOME}`));
+	});
+
+	it("shows the rest when the address names a calendar that is gone", async () => {
+		await mount("2026-06-10", ["33333333-3333-4333-8333-333333333333"]);
+		assert.ok(
+			windowsFrom("2026-06-08").every((url) => !url.includes("calendarId=")),
+			"an address pointing at nothing shows the calendar, not an empty week",
+		);
+	});
+});
+
+/**
+ * The zone every write is built in, so it has to be one the server will take.
+ *
+ * The server checks a TZID against `Intl.supportedValuesOf("timeZone")` — the
+ * canonical IANA list, which holds no spelling of UTC at all — and refuses
+ * anything absent from it. A collection naming no zone therefore cannot be
+ * answered with a substitute, and above all not with the reader's own: a
+ * browser on a UTC machine resolves that to "UTC", and every event written
+ * from one was refused for a zone nobody had chosen.
+ */
+describe("the zone a collection is read on", () => {
+	const RESOLVABLE = new Set(Intl.supportedValuesOf("timeZone"));
+
+	it("is one the server will take, or none at all", async () => {
+		await mount(
+			"2026-06-10",
+			[],
+			[],
+			[
+				{
+					...calendar(WORK, "Work"),
+					timezone: "",
+				} as RemitImapCalendarResponse,
+			],
+		);
+		const zone = data?.timeZoneByCalendarId[WORK];
+		assert.ok(
+			zone === "" || RESOLVABLE.has(zone ?? ""),
+			`"${zone}" is neither absent nor a zone the server accepts as a TZID`,
+		);
+	});
+
+	it("is the collection's own where it has one", async () => {
+		await mount("2026-06-10", []);
+		assert.equal(data?.timeZoneByCalendarId[WORK], "Europe/Amsterdam");
+	});
+});
+
+describe("what the grid is handed", () => {
+	it("draws the occurrences the server expanded", async () => {
+		await mount(
+			"2026-06-10",
+			[],
+			[
+				instance({ calendarObjectId: "obj-1" }),
+				instance({
+					calendarObjectId: "obj-2",
+					recurrenceId: "2026-06-11T07:15:00Z",
+					summary: "Standup",
+					hasRecurrence: true,
+				}),
+			],
+		);
+		assert.deepEqual(
+			data?.events.map((event) => event.id),
+			["obj-1", "obj-2#2026-06-11T07:15:00Z"],
+		);
+		assert.equal(data?.events[1].title, "Standup");
+	});
+
+	it("leaves a cancelled occurrence off rather than drawing it as confirmed", async () => {
+		await mount(
+			"2026-06-10",
+			[],
+			[
+				instance({ calendarObjectId: "obj-1" }),
+				instance({ calendarObjectId: "obj-3", status: "Cancelled" }),
+			],
+		);
+		assert.deepEqual(
+			data?.events.map((event) => event.id),
+			["obj-1"],
+		);
+	});
+});