@remit/web-client 0.0.229 → 0.0.231

package/src/lib/calendar-density.ts

@@ -0,0 +1,34 @@
+/**
+ * How much of a day this device shows at once.
+ *
+ * A phone on a train and a monitor on a desk want different amounts of the
+ * same week, and the answer belongs to the screen rather than to the calendar:
+ * it is not a fact about the view, so it is in no tier of the address, and a
+ * link shared from one device must not resize the day on another. Stored the
+ * way the intelligence rail's preference is (`lib/intelligence-pref.ts`), and
+ * a storage failure falls back to the default rather than crashing.
+ */
+import type { Density } from "@remit/ui";
+
+export const CALENDAR_DENSITY_KEY = "remit:calendar-density";
+
+/** Roomy enough to read a title at a glance, which is the common case. */
+export const DEFAULT_CALENDAR_DENSITY: Density = "comfortable";
+
+export function readCalendarDensity(): Density {
+	try {
+		return localStorage.getItem(CALENDAR_DENSITY_KEY) === "compact"
+			? "compact"
+			: DEFAULT_CALENDAR_DENSITY;
+	} catch {
+		return DEFAULT_CALENDAR_DENSITY;
+	}
+}
+
+export function writeCalendarDensity(density: Density): void {
+	try {
+		localStorage.setItem(CALENDAR_DENSITY_KEY, density);
+	} catch {
+		// Storage unavailable — the in-memory default stands.
+	}
+}

package/src/lib/calendar-fixtures.ts

@@ -0,0 +1,207 @@
+/**
+ * A week of invented calendar, so the routes and the grid can be walked before
+ * the REST layer exists. Every name here is made up and every event is
+ * generated from the day being looked at, which is what keeps the grid full
+ * wherever the reader navigates instead of only in June 2026.
+ *
+ * Stage A.3 deletes this file: `hooks/useCalendarData` swaps its body for the
+ * query hooks and nothing that renders a calendar changes.
+ */
+import type {
+	CalendarColorId,
+	CalendarDescriptor,
+	CalendarEventData,
+} from "@remit/ui";
+
+export const workCalendarId = "fixture-work";
+export const personalCalendarId = "fixture-personal";
+export const teamCalendarId = "fixture-team";
+
+export const fixtureCalendars: CalendarDescriptor[] = [
+	{
+		id: workCalendarId,
+		accountId: "fixture-account-work",
+		accountLabel: "Work",
+		name: "Work",
+		color: "cal-1",
+	},
+	{
+		id: teamCalendarId,
+		accountId: "fixture-account-work",
+		accountLabel: "Work",
+		name: "Team",
+		color: "cal-6",
+	},
+	{
+		id: personalCalendarId,
+		accountId: "fixture-account-personal",
+		accountLabel: "Personal",
+		name: "Personal",
+		color: "cal-4",
+	},
+];
+
+export const fixtureColorByCalendarId: Record<string, CalendarColorId> =
+	Object.fromEntries(
+		fixtureCalendars.map((calendar) => [calendar.id, calendar.color]),
+	);
+
+const pad = (value: number): string => String(value).padStart(2, "0");
+
+/** The Monday of the week a day falls in; the grid starts its weeks there. */
+function weekStart(date: string): Date {
+	const [year, month, day] = date.split("-").map(Number);
+	const instant = new Date(Date.UTC(year, month - 1, day));
+	const weekday = (instant.getUTCDay() + 6) % 7;
+	instant.setUTCDate(instant.getUTCDate() - weekday);
+	return instant;
+}
+
+function dayOffsetFrom(start: Date, days: number): string {
+	const instant = new Date(start);
+	instant.setUTCDate(instant.getUTCDate() + days);
+	return `${instant.getUTCFullYear()}-${pad(instant.getUTCMonth() + 1)}-${pad(
+		instant.getUTCDate(),
+	)}`;
+}
+
+/** The zone the device is on, which is the only clock a fixture can honestly use. */
+export const fixtureTimeZone = (): string =>
+	Intl.DateTimeFormat().resolvedOptions().timeZone;
+
+/** An ISO instant carrying the device's own offset for that day. */
+function at(date: string, hour: number, minute: number): string {
+	const local = new Date(`${date}T${pad(hour)}:${pad(minute)}:00`);
+	const offset = -local.getTimezoneOffset();
+	const sign = offset < 0 ? "-" : "+";
+	const size = Math.abs(offset);
+	return `${date}T${pad(hour)}:${pad(minute)}:00${sign}${pad(
+		Math.floor(size / 60),
+	)}:${pad(size % 60)}`;
+}
+
+const template: CalendarEventData = {
+	id: "",
+	calendarId: workCalendarId,
+	title: "",
+	start: "",
+	end: "",
+	allDay: false,
+	location: "",
+	notes: "",
+	attendees: [],
+	myRsvp: "accepted",
+	threadId: "",
+	threadSubject: "",
+	timeZone: "",
+	zoneCertainty: "explicit",
+	recurrenceRule: "",
+	seriesId: "",
+	seriesException: false,
+	status: "confirmed",
+};
+
+interface FixtureSpec {
+	dayOffset: number;
+	startHour: number;
+	startMinute: number;
+	endHour: number;
+	endMinute: number;
+	title: string;
+	calendarId: string;
+	location: string;
+	recurrenceRule: string;
+	seriesId: string;
+}
+
+const spec = (
+	dayOffset: number,
+	title: string,
+	startHour: number,
+	endHour: number,
+	over: Partial<FixtureSpec> = {},
+): FixtureSpec => ({
+	dayOffset,
+	startHour,
+	startMinute: 0,
+	endHour,
+	endMinute: 0,
+	title,
+	calendarId: workCalendarId,
+	location: "",
+	recurrenceRule: "",
+	seriesId: "",
+	...over,
+});
+
+/**
+ * One made-up week: a daily standup, a couple of long blocks, an overlap on
+ * Wednesday and something on a Saturday, so every band the grid draws has
+ * something in it.
+ */
+const WEEK: FixtureSpec[] = [
+	spec(0, "Standup", 9, 9, {
+		startMinute: 15,
+		endMinute: 30,
+		recurrenceRule: "Every weekday, 09:15",
+		seriesId: "fixture-standup",
+	}),
+	spec(0, "Roadmap review", 11, 12, { calendarId: teamCalendarId }),
+	spec(1, "Standup", 9, 9, {
+		startMinute: 15,
+		endMinute: 30,
+		recurrenceRule: "Every weekday, 09:15",
+		seriesId: "fixture-standup",
+	}),
+	spec(1, "Supplier call", 14, 15, {
+		calendarId: teamCalendarId,
+		location: "Meet",
+	}),
+	spec(2, "Standup", 9, 9, {
+		startMinute: 15,
+		endMinute: 30,
+		recurrenceRule: "Every weekday, 09:15",
+		seriesId: "fixture-standup",
+	}),
+	spec(2, "Design review", 10, 12, { calendarId: teamCalendarId }),
+	spec(2, "Dentist", 11, 12, {
+		calendarId: personalCalendarId,
+		location: "Kerkstraat 4",
+	}),
+	spec(3, "Standup", 9, 9, {
+		startMinute: 15,
+		endMinute: 30,
+		recurrenceRule: "Every weekday, 09:15",
+		seriesId: "fixture-standup",
+	}),
+	spec(3, "One to one", 15, 16, { location: "Room 2" }),
+	spec(4, "Standup", 9, 9, {
+		startMinute: 15,
+		endMinute: 30,
+		recurrenceRule: "Every weekday, 09:15",
+		seriesId: "fixture-standup",
+	}),
+	spec(4, "Retro", 16, 17, { calendarId: teamCalendarId }),
+	spec(5, "Climbing", 10, 12, { calendarId: personalCalendarId }),
+];
+
+/** The invented week around a day, in the zone the device is running on. */
+export function fixtureEventsAround(date: string): CalendarEventData[] {
+	const start = weekStart(date);
+	const timeZone = fixtureTimeZone();
+	return WEEK.map((entry) => {
+		const day = dayOffsetFrom(start, entry.dayOffset);
+		return {
+			...template,
+			id: `fixture-${day}-${entry.title.toLowerCase().replace(/\s+/g, "-")}`,
+			calendarId: entry.calendarId,
+			title: entry.title,
+			start: at(day, entry.startHour, entry.startMinute),
+			end: at(day, entry.endHour, entry.endMinute),
+			location: entry.location,
+			timeZone,
+			recurrenceRule: entry.recurrenceRule,
+			seriesId: entry.seriesId,
+		};
+	});
+}

package/src/lib/calendar-format.ts

@@ -0,0 +1,29 @@
+/**
+ * The words a calendar surface puts a time in. Every component in `@remit/ui`
+ * takes its text already formatted and owns no clock, so the formatting lives
+ * on this side of the seam.
+ */
+import type { CalendarEventData } from "@remit/ui";
+
+const DAY = new Intl.DateTimeFormat(undefined, {
+	weekday: "short",
+	day: "numeric",
+	month: "long",
+});
+
+const CLOCK = new Intl.DateTimeFormat(undefined, {
+	hour: "2-digit",
+	minute: "2-digit",
+	hour12: false,
+});
+
+/** "Wed 10 June, 10:00 – 11:00", or the day alone when it runs all of it. */
+export function formatEventWhen(event: CalendarEventData): string {
+	const start = new Date(event.start);
+	const end = new Date(event.end);
+	const day = DAY.format(start);
+	if (event.allDay) return `${day}, all day`;
+	const sameDay = DAY.format(end) === day;
+	if (sameDay) return `${day}, ${CLOCK.format(start)} – ${CLOCK.format(end)}`;
+	return `${day}, ${CLOCK.format(start)} – ${DAY.format(end)}, ${CLOCK.format(end)}`;
+}

package/src/lib/calendar-route.test.ts

@@ -0,0 +1,210 @@
+/**
+ * The calendar's address, rule by rule — which tier holds which fact, what a
+ * segment the calendar cannot read resolves to, and what a query string it did
+ * not write is allowed to say.
+ */
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { CALENDAR_DENSITY_KEY } from "./calendar-density.js";
+import {
+	calendarSearchSchema,
+	calendarViewMountsGrid,
+	calendarViews,
+	canonicalCalendarParams,
+	DEFAULT_CALENDAR_VIEW,
+	isoDate,
+	parseCalendarDate,
+	parseCalendarView,
+	readCalendarIds,
+	stepCalendarDate,
+} from "./calendar-route.js";
+
+const TODAY = "2026-06-10";
+
+describe("parseCalendarView", () => {
+	it("reads every zoom the ladder has", () => {
+		for (const view of calendarViews) {
+			assert.equal(parseCalendarView(view), view);
+		}
+	});
+
+	it("reads a segment that names no zoom as none", () => {
+		assert.equal(parseCalendarView("fortnight"), undefined);
+		assert.equal(parseCalendarView("Week"), undefined);
+		assert.equal(parseCalendarView(""), undefined);
+	});
+});
+
+describe("parseCalendarDate", () => {
+	it("reads a day the calendar has", () => {
+		assert.equal(parseCalendarDate("2026-06-10"), "2026-06-10");
+		assert.equal(parseCalendarDate("2024-02-29"), "2024-02-29");
+	});
+
+	it("refuses a day the calendar does not have", () => {
+		assert.equal(parseCalendarDate("2026-02-30"), undefined);
+		assert.equal(parseCalendarDate("2026-13-01"), undefined);
+		assert.equal(parseCalendarDate("2025-02-29"), undefined);
+	});
+
+	it("refuses anything that is not the one spelling", () => {
+		assert.equal(parseCalendarDate("2026-6-10"), undefined);
+		assert.equal(parseCalendarDate("10-06-2026"), undefined);
+		assert.equal(parseCalendarDate("2026-06-10T09:30"), undefined);
+		assert.equal(parseCalendarDate("today"), undefined);
+		assert.equal(parseCalendarDate(""), undefined);
+	});
+});
+
+describe("canonicalCalendarParams", () => {
+	it("leaves an address it can read alone", () => {
+		assert.deepEqual(
+			canonicalCalendarParams({ view: "day", date: "2026-06-10" }, TODAY),
+			{ view: "day", date: "2026-06-10" },
+		);
+	});
+
+	it("keeps the half it could read", () => {
+		assert.deepEqual(
+			canonicalCalendarParams({ view: "fortnight", date: "2026-06-10" }, TODAY),
+			{ view: DEFAULT_CALENDAR_VIEW, date: "2026-06-10" },
+		);
+		assert.deepEqual(
+			canonicalCalendarParams({ view: "day", date: "yesterday" }, TODAY),
+			{ view: "day", date: TODAY },
+		);
+	});
+
+	it("sends an address it can read nothing of to this week", () => {
+		assert.deepEqual(canonicalCalendarParams({ view: "", date: "" }, TODAY), {
+			view: DEFAULT_CALENDAR_VIEW,
+			date: TODAY,
+		});
+	});
+});
+
+describe("calendarViewMountsGrid", () => {
+	it("draws the week and the day", () => {
+		assert.equal(calendarViewMountsGrid("week"), true);
+		assert.equal(calendarViewMountsGrid("day"), true);
+	});
+
+	it("has the other three still to come", () => {
+		assert.equal(calendarViewMountsGrid("year"), false);
+		assert.equal(calendarViewMountsGrid("month"), false);
+		assert.equal(calendarViewMountsGrid("agenda"), false);
+	});
+});
+
+describe("stepCalendarDate", () => {
+	it("steps a screenful in the view's own unit", () => {
+		assert.equal(stepCalendarDate("2026-06-10", "day", 1), "2026-06-11");
+		assert.equal(stepCalendarDate("2026-06-10", "week", 1), "2026-06-17");
+		assert.equal(stepCalendarDate("2026-06-10", "agenda", 1), "2026-06-17");
+		assert.equal(stepCalendarDate("2026-06-10", "month", 1), "2026-07-10");
+		assert.equal(stepCalendarDate("2026-06-10", "year", 1), "2027-06-10");
+	});
+
+	it("steps back the same distance it steps forward", () => {
+		for (const view of calendarViews) {
+			const forward = stepCalendarDate("2026-06-10", view, 1);
+			assert.equal(stepCalendarDate(forward, view, -1), "2026-06-10");
+		}
+	});
+
+	it("crosses a month, a year and a leap day", () => {
+		assert.equal(stepCalendarDate("2026-12-31", "day", 1), "2027-01-01");
+		assert.equal(stepCalendarDate("2026-01-01", "day", -1), "2025-12-31");
+		assert.equal(stepCalendarDate("2024-02-28", "day", 1), "2024-02-29");
+		assert.equal(stepCalendarDate("2026-12-15", "month", 1), "2027-01-15");
+		assert.equal(stepCalendarDate("2026-01-15", "month", -1), "2025-12-15");
+	});
+
+	it("holds a month step to a day that month has", () => {
+		assert.equal(stepCalendarDate("2026-03-31", "month", -1), "2026-02-28");
+		assert.equal(stepCalendarDate("2026-01-31", "month", 1), "2026-02-28");
+		assert.equal(stepCalendarDate("2024-01-31", "month", 1), "2024-02-29");
+		assert.equal(stepCalendarDate("2024-02-29", "year", 1), "2025-02-28");
+	});
+});
+
+describe("isoDate", () => {
+	it("names the day an instant falls on by the device's own clock", () => {
+		assert.equal(isoDate(new Date(2026, 5, 10, 9, 30)), "2026-06-10");
+		assert.equal(isoDate(new Date(2026, 0, 1, 0, 0)), "2026-01-01");
+		assert.equal(isoDate(new Date(2026, 11, 31, 23, 59)), "2026-12-31");
+	});
+});
+
+describe("readCalendarIds", () => {
+	it("reads repeated params, a single one, and none", () => {
+		assert.deepEqual(readCalendarIds(["cal_a", "cal_b"]), ["cal_a", "cal_b"]);
+		assert.deepEqual(readCalendarIds("cal_a"), ["cal_a"]);
+		assert.deepEqual(readCalendarIds(undefined), []);
+	});
+
+	it("spells one set of ticked calendars one way", () => {
+		assert.deepEqual(readCalendarIds(["cal_b", "cal_a", "cal_b"]), [
+			"cal_a",
+			"cal_b",
+		]);
+	});
+
+	it("keeps a numeric-looking id the router handed through as a number", () => {
+		assert.deepEqual(readCalendarIds([12, "cal_a"]), ["12", "cal_a"]);
+	});
+
+	it("drops what is not an id rather than refusing the address", () => {
+		assert.deepEqual(readCalendarIds(["", "cal_a", null, { id: "x" }]), [
+			"cal_a",
+		]);
+	});
+});
+
+describe("calendarSearchSchema", () => {
+	it("carries the ticked calendars", () => {
+		assert.deepEqual(calendarSearchSchema.parse({ calendarId: "cal_a" }), {
+			calendarId: ["cal_a"],
+		});
+		assert.deepEqual(
+			calendarSearchSchema.parse({ calendarId: ["cal_b", "cal_a"] }),
+			{ calendarId: ["cal_a", "cal_b"] },
+		);
+	});
+
+	it("leaves the param out where nothing is ticked off", () => {
+		// Absent rather than empty: the router writes no param for `undefined`, so
+		// a calendar showing everything is one the query says nothing about.
+		assert.equal(calendarSearchSchema.parse({}).calendarId, undefined);
+		assert.equal(
+			calendarSearchSchema.parse({ calendarId: [] }).calendarId,
+			undefined,
+		);
+		assert.equal(
+			calendarSearchSchema.parse({ calendarId: ["", null] }).calendarId,
+			undefined,
+		);
+	});
+
+	it("strips a param that is not the calendar's to carry", () => {
+		const parsed = calendarSearchSchema.parse({
+			calendarId: ["cal_a"],
+			q: "invoice",
+			// Density is a device preference, so an address naming one is ignored
+			// rather than obeyed: a link must not resize another reader's day.
+			density: "compact",
+			date: "2026-06-10",
+		});
+		assert.deepEqual(parsed, { calendarId: ["cal_a"] });
+	});
+});
+
+describe("density is not URL state", () => {
+	it("is stored against the device, under a key of its own", () => {
+		assert.equal(CALENDAR_DENSITY_KEY, "remit:calendar-density");
+	});
+
+	it("has no reading in the query", () => {
+		assert.deepEqual(calendarSearchSchema.parse({ density: "compact" }), {});
+	});
+});

package/src/lib/calendar-route.ts

@@ -0,0 +1,183 @@
+/**
+ * The calendar's address, read and written in one place.
+ *
+ * `/calendar/{view}/{date}` and, under it, the event a reader has open. The
+ * five zoom levels are mutually exclusive and each is a different surface, so
+ * the view is a path segment (R5); the date is one too, because the strip is
+ * infinite and the address has to name where it opened — a `?date=` param
+ * would be a query compensating for a missing segment (R4). What the reader
+ * has ticked off modifies the view without changing what is mounted, so the
+ * calendar filter is query (R2), validated here rather than at the read site
+ * (R7).
+ *
+ * Nothing here reads a clock. Every function takes the instant it needs, so
+ * "today" is a decision the caller makes once and this module can be tested
+ * without one.
+ */
+import type { CalendarViewId } from "@remit/ui";
+import { z } from "zod";
+
+/** The zoom ladder, widest first. The union `@remit/ui` already publishes. */
+export const calendarViews = [
+	"year",
+	"month",
+	"week",
+	"day",
+	"agenda",
+] as const satisfies readonly CalendarViewId[];
+
+const calendarViewSchema = z.enum(calendarViews);
+
+/** Where `/calendar` sends a reader who named no zoom of their own. */
+export const DEFAULT_CALENDAR_VIEW: CalendarViewId = "week";
+
+/**
+ * The views the grid draws today. The other three are named surfaces that
+ * arrive in later stages, and they say so on screen rather than matching a
+ * route that renders nothing.
+ */
+const GRID_VIEWS = new Set<CalendarViewId>(["week", "day"]);
+
+export const calendarViewMountsGrid = (view: CalendarViewId): boolean =>
+	GRID_VIEWS.has(view);
+
+/** The view a segment names, or `undefined` where it names none. */
+export function parseCalendarView(segment: string): CalendarViewId | undefined {
+	const parsed = calendarViewSchema.safeParse(segment);
+	return parsed.success ? parsed.data : undefined;
+}
+
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+
+/**
+ * The day a segment names, or `undefined`. A date the calendar does not have —
+ * the 31st of February, the 13th month — is not a day, so it is rejected
+ * rather than rolled forward into one the reader did not ask for.
+ */
+export function parseCalendarDate(segment: string): string | undefined {
+	if (!ISO_DATE.test(segment)) return undefined;
+	const [year, month, day] = segment.split("-").map(Number);
+	const instant = Date.UTC(year, month - 1, day);
+	const round = new Date(instant);
+	if (round.getUTCFullYear() !== year) return undefined;
+	if (round.getUTCMonth() !== month - 1) return undefined;
+	if (round.getUTCDate() !== day) return undefined;
+	return segment;
+}
+
+const pad = (value: number): string => String(value).padStart(2, "0");
+
+/** The day an instant falls on, by the clock the reader's device is running. */
+export function isoDate(instant: Date): string {
+	return `${instant.getFullYear()}-${pad(instant.getMonth() + 1)}-${pad(
+		instant.getDate(),
+	)}`;
+}
+
+export interface CalendarParams {
+	view: CalendarViewId;
+	date: string;
+}
+
+/**
+ * The address a pair of segments resolves to.
+ *
+ * A hand-edited or stale URL is a normal thing to receive, so an unreadable
+ * segment is replaced rather than thrown: the half that was readable is kept,
+ * and the reader lands on a calendar instead of an error. The caller compares
+ * this with what it was given and redirects when they differ, so the address
+ * bar ends up naming exactly what is on screen.
+ */
+export function canonicalCalendarParams(
+	segments: { view: string; date: string },
+	today: string,
+): CalendarParams {
+	return {
+		view: parseCalendarView(segments.view) ?? DEFAULT_CALENDAR_VIEW,
+		date: parseCalendarDate(segments.date) ?? today,
+	};
+}
+
+/**
+ * The day the previous or next screenful starts on. A step is measured in the
+ * view's own unit, which is what makes back-and-forward land where the reader
+ * came from at every zoom. Agenda steps a week, the range it loads.
+ */
+export function stepCalendarDate(
+	date: string,
+	view: CalendarViewId,
+	direction: -1 | 1,
+): string {
+	const [year, month, day] = date.split("-").map(Number);
+	if (view === "year") return clampedDate(year + direction, month, day);
+	if (view === "month") return clampedDate(year, month + direction, day);
+	const days = view === "day" ? 1 : 7;
+	const stepped = new Date(Date.UTC(year, month - 1, day + days * direction));
+	return isoDateUtc(stepped);
+}
+
+const isoDateUtc = (instant: Date): string =>
+	`${instant.getUTCFullYear()}-${pad(instant.getUTCMonth() + 1)}-${pad(
+		instant.getUTCDate(),
+	)}`;
+
+/**
+ * A month or a year away from a date, held to a day that month has. Stepping
+ * off the 31st of March must land in February rather than skipping it.
+ */
+function clampedDate(year: number, month: number, day: number): string {
+	const normalisedYear = year + Math.floor((month - 1) / 12);
+	const normalisedMonth = ((((month - 1) % 12) + 12) % 12) + 1;
+	const lastDay = new Date(
+		Date.UTC(normalisedYear, normalisedMonth, 0),
+	).getUTCDate();
+	return `${normalisedYear}-${pad(normalisedMonth)}-${pad(
+		Math.min(day, lastDay),
+	)}`;
+}
+
+/**
+ * A calendar's id, as the URL carries it. A hand-written schema is a second
+ * owner of a shape the domain will publish, so stage A.3 replaces this with
+ * the generated one and every read site keeps working.
+ */
+const calendarIdSchema = z.string().min(1);
+
+/**
+ * The calendars a query string has ticked.
+ *
+ * Repeated `calendarId=` params are the shape, and the shape the address is
+ * written back in (`lib/search-params.ts`). They arrive here in three readings
+ * all the same: a list from repeated params, a scalar from a single one, and a
+ * number where the id looked like one. One set of ticked calendars has one
+ * spelling, which is what deduplicating and sorting is for.
+ */
+export function readCalendarIds(value: unknown): string[] {
+	const raw = value === undefined || value === null ? [] : [value].flat();
+	const named = new Set<string>();
+	for (const entry of raw) {
+		if (typeof entry !== "string" && typeof entry !== "number") continue;
+		const id = calendarIdSchema.safeParse(String(entry));
+		if (id.success) named.add(id.data);
+	}
+	return [...named].sort();
+}
+
+/**
+ * What the calendar reads out of the query, and all of it.
+ *
+ * Ticking nothing off leaves the param out rather than writing an empty list:
+ * the address states what a reader has narrowed to, so a calendar showing
+ * everything is a calendar the query has nothing to say about.
+ *
+ * Density is absent on purpose: it is how much of a day this device fits on
+ * screen, which is a preference the device holds (`lib/calendar-density.ts`)
+ * rather than a fact about the view, so it belongs to no tier of the address.
+ */
+export const calendarSearchSchema = z.object({
+	calendarId: z
+		.preprocess(readCalendarIds, z.array(calendarIdSchema))
+		.transform((ids) => (ids.length === 0 ? undefined : ids)),
+});
+
+export type CalendarSearch = z.infer<typeof calendarSearchSchema>;