better-supabase 0.14.0 → 0.15.0

package/dist/blocks/calendar/index.js

@@ -1,9 +1,1077 @@
+import { n as dbError } from "../../errors-BVFgt8BZ.js";
+import { t as temporal } from "../../temporal-required-Dy0GGD8E.js";
+import { t as AsyncResult } from "../../result-ntFBW2p2.js";
 import { t as calendarSqlOptions } from "../../options-CTZNpb2n.js";
-import { n as entitySchema } from "../../entity-schema-BXXC1NnT.js";
+import { t as defineController } from "../../controller-BEliOBOv.js";
+import { A as requiredInstant, C as optionalText, D as recordOf, I as textOf, S as optionalInstant, b as oneOf, k as recordsOf, o as blockCall } from "../../block-helpers-CtBdjgO4.js";
+import { r as withBlockHooks } from "../../block-hooks-BfxX3682.js";
+import { n as entitySchema } from "../../entity-schema-BDv6w-OQ.js";
 import { n as event, t as defineEvents } from "../../event-map-CtPFhcOp.js";
-import { n as defineBlock } from "../../define-block-Dze77QTw.js";
-import { a as parseIcs, c as freeBusyOf, i as splitRule, l as workingHoursOf, n as createCalendar, o as toIcs, r as expandOccurrences, s as commonFreeTime, t as calendarEventOf } from "../../calendar-T3Vdpq7E.js";
-import { a as toEventCalendarResources, i as toEventCalendarEvents, n as fromEventCalendarUpdate, r as seriesOf, t as createCalendarController } from "../../client-yIxEJwTK.js";
+import { i as extraOf, n as blockFields, t as allWithFields } from "../../block-fields-DE_FgpOU.js";
+import { n as defineBlock } from "../../define-block-BGqOO8B3.js";
+import { t as expandRule } from "../../rrule-79K2c3Nr.js";
+import { t as sameRange } from "../../range-DwpWe8e7.js";
+//#region src/blocks/calendar/availability.ts
+const CALENDAR_EVENT_KINDS = [
+	"event",
+	"out_of_office",
+	"focus_time"
+];
+const CALENDAR_TRANSPARENCIES = ["opaque", "transparent"];
+const WEEKDAYS = /* @__PURE__ */ new Set([
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7
+]);
+function rangesOf(value, label) {
+	return recordsOf(value, label).map((row) => ({
+		from: requiredInstant(row["startsAt"], `${label}.startsAt`),
+		until: requiredInstant(row["endsAt"], `${label}.endsAt`)
+	}));
+}
+/** A `calendar_free_busy` result. */
+function freeBusyOf(value) {
+	return recordsOf(value, "calendar_free_busy").map((row) => {
+		const tz = optionalText(row["tz"]);
+		const hours = row["workingHours"] === null || row["workingHours"] === void 0 ? void 0 : rangesOf(row["workingHours"], "workingHours");
+		return {
+			userId: textOf(row["userId"]),
+			busy: rangesOf(row["busy"], "busy"),
+			outOfOffice: rangesOf(row["outOfOffice"], "outOfOffice"),
+			focusTime: rangesOf(row["focusTime"], "focusTime"),
+			...hours === void 0 ? {} : { workingHours: hours },
+			...tz === void 0 ? {} : { tz }
+		};
+	});
+}
+/** A `list_calendar_working_hours` result. */
+function workingHoursOf(value) {
+	return recordsOf(value, "list_calendar_working_hours").map((row) => ({
+		userId: textOf(row["userId"]),
+		tz: optionalText(row["tz"]) ?? "UTC",
+		hours: recordsOf(row["hours"], "hours").flatMap((hour) => {
+			const weekday = Number(hour["weekday"]);
+			if (!WEEKDAYS.has(weekday)) return [];
+			return [{
+				weekday,
+				start: textOf(hour["start"]),
+				end: textOf(hour["end"])
+			}];
+		})
+	}));
+}
+const ms = (instant) => instant.epochMilliseconds;
+/** Sorted, merged ranges. */
+function merge(ranges) {
+	const sorted = ranges.filter((range) => ms(range.until) > ms(range.from)).toSorted((a, b) => ms(a.from) - ms(b.from));
+	const merged = [];
+	for (const range of sorted) {
+		const last = merged.at(-1);
+		if (last !== void 0 && ms(range.from) <= ms(last.until)) {
+			if (ms(range.until) > ms(last.until)) merged[merged.length - 1] = {
+				from: last.from,
+				until: range.until
+			};
+		} else merged.push(range);
+	}
+	return merged;
+}
+/** `ranges` minus `cut`, both merged. */
+function subtract(ranges, cut) {
+	const result = [];
+	for (const range of ranges) {
+		let from = range.from;
+		for (const block of cut) {
+			if (ms(block.until) <= ms(from) || ms(block.from) >= ms(range.until)) continue;
+			if (ms(block.from) > ms(from)) result.push({
+				from,
+				until: block.from
+			});
+			if (ms(block.until) > ms(from)) from = block.until;
+		}
+		if (ms(from) < ms(range.until)) result.push({
+			from,
+			until: range.until
+		});
+	}
+	return result;
+}
+/** Where two merged range lists overlap. */
+function intersect(a, b) {
+	const result = [];
+	for (const left of a) for (const right of b) {
+		const from = ms(left.from) > ms(right.from) ? left.from : right.from;
+		const until = ms(left.until) < ms(right.until) ? left.until : right.until;
+		if (ms(until) > ms(from)) result.push({
+			from,
+			until
+		});
+	}
+	return merge(result);
+}
+/**
+* The ranges in `range` when every member in `freeBusy` is free, for a "find a
+* time" view or a scheduling suggestion.
+*/
+function commonFreeTime(freeBusy, range, options = {}) {
+	let free = [{
+		from: range.from,
+		until: range.until
+	}];
+	for (const member of freeBusy) {
+		free = subtract(free, merge(member.busy));
+		if (options.workingHours !== false && member.workingHours !== void 0) free = intersect(free, merge(member.workingHours));
+	}
+	const minimum = options.minimum?.total({ unit: "milliseconds" }) ?? 0;
+	return free.filter((slot) => ms(slot.until) - ms(slot.from) >= Math.max(minimum, 1));
+}
+//#endregion
+//#region src/blocks/calendar/ics.ts
+const ROLES$1 = {
+	CHAIR: "chair",
+	"REQ-PARTICIPANT": "required",
+	"OPT-PARTICIPANT": "optional",
+	"NON-PARTICIPANT": "non-participant"
+};
+const RESPONSES$1 = {
+	"NEEDS-ACTION": "needs-action",
+	ACCEPTED: "accepted",
+	DECLINED: "declined",
+	TENTATIVE: "tentative"
+};
+const STATUSES$1 = [
+	"confirmed",
+	"tentative",
+	"cancelled"
+];
+const DATE = /^(\d{4})(\d{2})(\d{2})$/;
+const DATE_TIME = /^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})(Z?)$/;
+/** Splits a content line at the first `:` and its `;` that are outside quotes. */
+function contentLine(line) {
+	const parts = [];
+	let quoted = false;
+	let start = 0;
+	for (let index = 0; index < line.length; index += 1) {
+		const char = line[index];
+		if (char === "\"") quoted = !quoted;
+		else if (!quoted && char === ";") {
+			parts.push(line.slice(start, index));
+			start = index + 1;
+		} else if (!quoted && char === ":") {
+			parts.push(line.slice(start, index));
+			const [name = "", ...rest] = parts;
+			const params = {};
+			for (const param of rest) {
+				const equals = param.indexOf("=");
+				if (equals < 1) continue;
+				params[param.slice(0, equals).toUpperCase()] = param.slice(equals + 1).replaceAll("\"", "");
+			}
+			return {
+				name: name.toUpperCase(),
+				params,
+				value: line.slice(index + 1)
+			};
+		}
+	}
+}
+/** RFC 5545 TEXT: `\n`, `\,`, `\;` and `\\`. */
+function unescapeText(value) {
+	return value.replaceAll(/\\([nN,;\\])/g, (_, char) => char === "n" || char === "N" ? "\n" : char);
+}
+function escapeText(value) {
+	return value.replaceAll("\\", "\\\\").replaceAll(";", "\\;").replaceAll(",", "\\,").replaceAll(/\r?\n/g, "\\n");
+}
+function zoneOr(zone, fallback) {
+	if (zone === void 0) return fallback;
+	try {
+		temporal().Now.zonedDateTimeISO(zone);
+		return zone;
+	} catch {
+		return fallback;
+	}
+}
+function dateValue(value, params, fallback) {
+	const time = temporal();
+	const tz = zoneOr(params["TZID"], fallback);
+	const date = DATE.exec(value);
+	if (date !== null || params["VALUE"] === "DATE") {
+		if (date === null) return;
+		return {
+			instant: time.PlainDate.from({
+				year: Number(date[1]),
+				month: Number(date[2]),
+				day: Number(date[3])
+			}).toZonedDateTime({ timeZone: tz }).toInstant(),
+			allDay: true,
+			tz
+		};
+	}
+	const match = DATE_TIME.exec(value);
+	if (match === null) return;
+	const fields = {
+		year: Number(match[1]),
+		month: Number(match[2]),
+		day: Number(match[3]),
+		hour: Number(match[4]),
+		minute: Number(match[5]),
+		second: Number(match[6])
+	};
+	if (match[7] === "Z") return {
+		instant: time.ZonedDateTime.from({
+			...fields,
+			timeZone: "UTC"
+		}).toInstant(),
+		allDay: false,
+		tz
+	};
+	return {
+		instant: time.ZonedDateTime.from({
+			...fields,
+			timeZone: tz
+		}).toInstant(),
+		allDay: false,
+		tz
+	};
+}
+function attendeeOf$1(line) {
+	const email = line.value.replace(/^mailto:/i, "").trim().toLowerCase();
+	if (email === "") return;
+	const name = line.params["CN"];
+	return {
+		email,
+		...name === void 0 ? {} : { name },
+		role: ROLES$1[(line.params["ROLE"] ?? "").toUpperCase()] ?? "required",
+		response: RESPONSES$1[(line.params["PARTSTAT"] ?? "").toUpperCase()] ?? "needs-action"
+	};
+}
+/** One `VEVENT`'s lines as an event, or `undefined` without UID or DTSTART. */
+function eventOf(lines, fallback) {
+	const time = temporal();
+	let uid;
+	let start;
+	let end;
+	let duration;
+	let title = "";
+	let description;
+	let location;
+	let status = "confirmed";
+	let transparent = false;
+	let rrule;
+	let originalStart;
+	const exdates = [];
+	const attendees = [];
+	for (const line of lines) switch (line.name) {
+		case "UID":
+			uid = line.value.trim();
+			break;
+		case "DTSTART":
+			start = dateValue(line.value, line.params, fallback);
+			break;
+		case "DTEND":
+			end = dateValue(line.value, line.params, fallback);
+			break;
+		case "DURATION":
+			try {
+				duration = time.Duration.from(line.value.trim());
+			} catch {
+				duration = void 0;
+			}
+			break;
+		case "SUMMARY":
+			title = unescapeText(line.value);
+			break;
+		case "DESCRIPTION":
+			description = unescapeText(line.value);
+			break;
+		case "LOCATION":
+			location = unescapeText(line.value);
+			break;
+		case "STATUS": {
+			const value = line.value.trim().toLowerCase();
+			status = STATUSES$1.find((item) => item === value) ?? "confirmed";
+			break;
+		}
+		case "TRANSP":
+			transparent = line.value.trim().toUpperCase() === "TRANSPARENT";
+			break;
+		case "RRULE":
+			rrule = line.value.trim();
+			break;
+		case "EXDATE":
+			for (const value of line.value.split(",")) {
+				const date = dateValue(value.trim(), line.params, fallback);
+				if (date !== void 0) exdates.push(date.instant);
+			}
+			break;
+		case "RECURRENCE-ID":
+			originalStart = dateValue(line.value, line.params, fallback)?.instant;
+			break;
+		case "ATTENDEE": {
+			const attendee = attendeeOf$1(line);
+			if (attendee !== void 0) attendees.push(attendee);
+			break;
+		}
+	}
+	if (uid === void 0 || uid === "" || start === void 0) return;
+	const zoned = start.instant.toZonedDateTimeISO(start.tz);
+	const endsAt = end?.instant ?? (duration === void 0 ? start.allDay ? zoned.add({ days: 1 }).toInstant() : start.instant : zoned.add(duration).toInstant());
+	return {
+		uid,
+		title,
+		...description === void 0 ? {} : { description },
+		...location === void 0 ? {} : { location },
+		startsAt: start.instant,
+		endsAt,
+		allDay: start.allDay,
+		tz: start.tz,
+		status,
+		...rrule === void 0 ? {} : { rrule },
+		exdates,
+		...originalStart === void 0 ? {} : { originalStart },
+		attendees,
+		...transparent ? { transparency: "transparent" } : {}
+	};
+}
+/**
+* Reads an iCalendar file (RFC 5545): unfolds lines, unescapes TEXT values and
+* reads each `VEVENT`'s times, recurrence (`RRULE`, `EXDATE`, `RECURRENCE-ID`)
+* and attendees. Times in a zone Temporal does not know, floating times and
+* dates use `X-WR-TIMEZONE`, else UTC.
+*/
+function parseIcs(text) {
+	const lines = text.replaceAll(/\r?\n[ \t]/g, "").split(/\r?\n/).flatMap((raw) => {
+		const line = contentLine(raw);
+		return line === void 0 ? [] : [line];
+	});
+	let name;
+	let tz = "UTC";
+	for (const line of lines) {
+		if (line.name === "X-WR-CALNAME") name = unescapeText(line.value);
+		if (line.name === "X-WR-TIMEZONE") tz = zoneOr(line.value.trim(), "UTC");
+	}
+	const events = [];
+	let skipped = 0;
+	let current;
+	let depth = 0;
+	for (const line of lines) if (line.name === "BEGIN" && line.value.toUpperCase() === "VEVENT") {
+		current = [];
+		depth = 0;
+	} else if (current !== void 0 && line.name === "BEGIN") depth += 1;
+	else if (current !== void 0 && line.name === "END") {
+		if (depth > 0) depth -= 1;
+		else if (line.value.toUpperCase() === "VEVENT") {
+			const event = eventOf(current, tz);
+			if (event === void 0) skipped += 1;
+			else events.push(event);
+			current = void 0;
+		}
+	} else if (current !== void 0 && depth === 0) current.push(line);
+	return {
+		...name === void 0 ? {} : { name },
+		tz,
+		events,
+		skipped
+	};
+}
+const pad = (value, size = 2) => String(value).padStart(size, "0");
+function compact(zoned) {
+	return `${pad(zoned.year, 4)}${pad(zoned.month)}${pad(zoned.day)}T${pad(zoned.hour)}${pad(zoned.minute)}${pad(zoned.second)}`;
+}
+function utc(instant) {
+	return `${compact(instant.toZonedDateTimeISO("UTC"))}Z`;
+}
+function day(instant, tz) {
+	const date = instant.toZonedDateTimeISO(tz);
+	return `${pad(date.year, 4)}${pad(date.month)}${pad(date.day)}`;
+}
+/** A property whose value is a date or date-time in the event's zone. */
+function timeProperty(name, instant, event) {
+	if (event.allDay) return `${name};VALUE=DATE:${day(instant, event.tz)}`;
+	if (event.tz === "UTC") return `${name}:${utc(instant)}`;
+	return `${name};TZID=${event.tz}:${compact(instant.toZonedDateTimeISO(event.tz))}`;
+}
+function offset(nanoseconds) {
+	const minutes = Math.round(nanoseconds / 6e10);
+	const sign = minutes < 0 ? "-" : "+";
+	const abs = Math.abs(minutes);
+	return `${sign}${pad(Math.floor(abs / 60))}${pad(abs % 60)}`;
+}
+/**
+* A `VTIMEZONE` with one observance per transition between `from` and `until`,
+* from Temporal's zone data, so `TZID` references resolve without an external
+* database.
+*/
+function vtimezone(tz, from, until) {
+	let zoned = from.toZonedDateTimeISO(tz);
+	const lines = [
+		"BEGIN:VTIMEZONE",
+		`TZID:${tz}`,
+		"BEGIN:STANDARD",
+		`DTSTART:${compact(zoned.toPlainDateTime())}`,
+		`TZOFFSETFROM:${offset(zoned.offsetNanoseconds)}`,
+		`TZOFFSETTO:${offset(zoned.offsetNanoseconds)}`,
+		"END:STANDARD"
+	];
+	for (let count = 0; count < 80; count += 1) {
+		const next = zoned.getTimeZoneTransition("next");
+		if (next === null || temporal().Instant.compare(next.toInstant(), until) > 0) break;
+		const before = zoned.offsetNanoseconds;
+		const after = next.offsetNanoseconds;
+		const kind = after > before ? "DAYLIGHT" : "STANDARD";
+		const onset = next.toInstant().toZonedDateTimeISO("UTC").add({ nanoseconds: before }).toPlainDateTime();
+		lines.push(`BEGIN:${kind}`, `DTSTART:${compact(onset)}`, `TZOFFSETFROM:${offset(before)}`, `TZOFFSETTO:${offset(after)}`, `END:${kind}`);
+		zoned = next;
+	}
+	lines.push("END:VTIMEZONE");
+	return lines;
+}
+/** Folds a content line to 75 octets, never inside a UTF-8 sequence. */
+function fold(line) {
+	const encoder = new TextEncoder();
+	if (encoder.encode(line).length <= 75) return line;
+	const parts = [];
+	let current = "";
+	let size = 0;
+	for (const char of line) {
+		const bytes = encoder.encode(char).length;
+		const limit = parts.length === 0 ? 75 : 74;
+		if (size + bytes > limit) {
+			parts.push(current);
+			current = "";
+			size = 0;
+		}
+		current += char;
+		size += bytes;
+	}
+	parts.push(current);
+	return parts.join("\r\n ");
+}
+const ROLE_OUT = {
+	chair: "CHAIR",
+	required: "REQ-PARTICIPANT",
+	optional: "OPT-PARTICIPANT",
+	"non-participant": "NON-PARTICIPANT"
+};
+function paramValue(value) {
+	const clean = value.replaceAll("\"", "");
+	return /[:;,]/.test(clean) ? `"${clean}"` : clean;
+}
+function eventLines(event, stamp) {
+	const lines = [
+		"BEGIN:VEVENT",
+		`UID:${event.uid}`,
+		`DTSTAMP:${utc(event.updatedAt ?? stamp)}`,
+		timeProperty("DTSTART", event.startsAt, event),
+		timeProperty("DTEND", event.endsAt, event)
+	];
+	if (event.originalStart !== void 0) lines.push(timeProperty("RECURRENCE-ID", event.originalStart, event));
+	if (event.rrule !== void 0) lines.push(`RRULE:${event.rrule}`);
+	for (const exdate of event.exdates) lines.push(timeProperty("EXDATE", exdate, event));
+	lines.push(`SUMMARY:${escapeText(event.title)}`);
+	if (event.description !== void 0) lines.push(`DESCRIPTION:${escapeText(event.description)}`);
+	if (event.location !== void 0) lines.push(`LOCATION:${escapeText(event.location)}`);
+	lines.push(`STATUS:${event.status.toUpperCase()}`);
+	if (event.transparency === "transparent") lines.push("TRANSP:TRANSPARENT");
+	for (const attendee of event.attendees ?? []) {
+		const cn = attendee.name === void 0 ? "" : `;CN=${paramValue(attendee.name)}`;
+		lines.push(`ATTENDEE${cn};ROLE=${ROLE_OUT[attendee.role]};PARTSTAT=${attendee.response.toUpperCase()}:mailto:${attendee.email}`);
+	}
+	lines.push("END:VEVENT");
+	return lines;
+}
+/**
+* Writes events as an iCalendar file (RFC 5545): CRLF line ends, lines folded
+* at 75 octets, escaped TEXT, and a `VTIMEZONE` for every zone a timed event
+* uses, so recurrence keeps its wall-clock time across DST.
+*/
+function toIcs(events, options = {}) {
+	const time = temporal();
+	const stamp = options.now ?? time.Now.instant();
+	const zones = /* @__PURE__ */ new Map();
+	for (const event of events) {
+		if (event.allDay || event.tz === "UTC") continue;
+		const from = event.startsAt.subtract({ hours: 24 });
+		const until = event.rrule === void 0 ? event.endsAt.add({ hours: 24 }) : event.startsAt.add({ hours: 26352 });
+		const known = zones.get(event.tz);
+		zones.set(event.tz, {
+			from: known === void 0 || time.Instant.compare(from, known.from) < 0 ? from : known.from,
+			until: known === void 0 || time.Instant.compare(until, known.until) > 0 ? until : known.until
+		});
+	}
+	const lines = [
+		"BEGIN:VCALENDAR",
+		"VERSION:2.0",
+		`PRODID:${options.prodId ?? "-//better-supabase//calendar//EN"}`,
+		"CALSCALE:GREGORIAN"
+	];
+	if (options.name !== void 0) lines.push(`X-WR-CALNAME:${escapeText(options.name)}`);
+	if (options.tz !== void 0) lines.push(`X-WR-TIMEZONE:${options.tz}`);
+	for (const [tz, range] of zones) lines.push(...vtimezone(tz, range.from, range.until));
+	for (const event of events) lines.push(...eventLines(event, stamp));
+	lines.push("END:VCALENDAR");
+	return `${lines.map(fold).join("\r\n")}\r\n`;
+}
+//#endregion
+//#region src/blocks/calendar/occurrences.ts
+const keyOf = (id, start) => `${id}::${start.toString()}`;
+function overlaps(start, end, range) {
+	const time = temporal();
+	return time.Instant.compare(start, range.until) < 0 && (time.Instant.compare(end, range.from) > 0 || time.Instant.compare(start, end) === 0 && time.Instant.compare(start, range.from) >= 0);
+}
+/**
+* Expands events into the occurrences that overlap `[from, until)`. Series
+* expand with the reminders block's `expandRule` in their own zone, so a weekly
+* 09:00 meeting stays at 09:00 across DST. `EXDATE`s drop occurrences, and
+* overrides replace the occurrence they name, also when they move it out of the
+* range.
+*/
+function expandOccurrences(events, range, options = {}) {
+	const time = temporal();
+	const keep = (event) => options.includeCancelled === true || event.status !== "cancelled";
+	const series = /* @__PURE__ */ new Map();
+	const overrides = /* @__PURE__ */ new Map();
+	for (const event of events) if (event.recurrenceId !== void 0 && event.originalStart !== void 0) overrides.set(keyOf(event.recurrenceId, event.originalStart), event);
+	else if (event.rrule !== void 0) series.set(event.id, event);
+	const found = [];
+	for (const event of events) {
+		if (event.recurrenceId !== void 0) {
+			const master = series.get(event.recurrenceId);
+			if (event.originalStart !== void 0 && keep(event) && overlaps(event.startsAt, event.endsAt, range)) found.push({
+				key: keyOf(event.recurrenceId, event.originalStart),
+				event,
+				...master === void 0 ? {} : { series: master },
+				start: event.startsAt,
+				end: event.endsAt,
+				originalStart: event.originalStart,
+				allDay: event.allDay,
+				recurring: true
+			});
+			continue;
+		}
+		if (event.rrule === void 0) {
+			if (keep(event) && overlaps(event.startsAt, event.endsAt, range)) found.push({
+				key: keyOf(event.id, event.startsAt),
+				event,
+				start: event.startsAt,
+				end: event.endsAt,
+				originalStart: event.startsAt,
+				allDay: event.allDay,
+				recurring: false
+			});
+			continue;
+		}
+		if (!keep(event)) continue;
+		const zoned = event.startsAt.toZonedDateTimeISO(event.tz);
+		const length = zoned.until(event.endsAt.toZonedDateTimeISO(event.tz), { largestUnit: event.allDay ? "days" : "hours" });
+		const reach = event.endsAt.since(event.startsAt).add({ hours: 25 });
+		const skipped = new Set(event.exdates.map((date) => date.epochMilliseconds));
+		for (const when of expandRule({
+			dtstart: zoned,
+			rrule: event.rrule,
+			window: {
+				from: range.from.subtract(reach),
+				until: range.until
+			}
+		})) {
+			const start = when.toInstant();
+			if (skipped.has(start.epochMilliseconds)) continue;
+			if (overrides.has(keyOf(event.id, start))) continue;
+			const end = when.add(length).toInstant();
+			if (!overlaps(start, end, range)) continue;
+			found.push({
+				key: keyOf(event.id, start),
+				event,
+				series: event,
+				start,
+				end,
+				originalStart: start,
+				allDay: event.allDay,
+				recurring: true
+			});
+		}
+	}
+	return found.toSorted((a, b) => time.Instant.compare(a.start, b.start) || a.key.localeCompare(b.key));
+}
+function ruleParts(rrule) {
+	const parts = /* @__PURE__ */ new Map();
+	for (const part of rrule.replace(/^RRULE:/i, "").split(";")) {
+		const [key, value] = part.split("=");
+		if (key !== void 0 && key !== "" && value !== void 0) parts.set(key.toUpperCase(), value);
+	}
+	return parts;
+}
+const joinRule = (parts) => [...parts].map(([key, value]) => `${key}=${value}`).join(";");
+/**
+* Splits a series for "this and following": the first rule ends one second
+* before `at` (RFC 5545 forbids `COUNT` with `UNTIL`, so it drops `COUNT`), and
+* the second keeps the occurrences that are left.
+*/
+function splitRule(rrule, dtstart, at) {
+	const parts = ruleParts(rrule);
+	if (temporal().Instant.compare(at, dtstart.toInstant()) <= 0) throw new RangeError("splitRule: at must come after the first occurrence");
+	const before = new Map(parts);
+	before.delete("COUNT");
+	const until = at.subtract({ seconds: 1 }).toZonedDateTimeISO("UTC");
+	before.set("UNTIL", `${String(until.year).padStart(4, "0")}${String(until.month).padStart(2, "0")}${String(until.day).padStart(2, "0")}T${String(until.hour).padStart(2, "0")}${String(until.minute).padStart(2, "0")}${String(until.second).padStart(2, "0")}Z`);
+	const after = new Map(parts);
+	const count = parts.get("COUNT");
+	if (count !== void 0) {
+		const used = expandRule({
+			dtstart,
+			rrule,
+			window: {
+				from: dtstart.toInstant(),
+				until: at
+			},
+			limit: Number(count)
+		}).length;
+		const left = Number(count) - used;
+		if (left <= 0) throw new RangeError("splitRule: the series has no occurrence at or after at");
+		after.set("COUNT", String(left));
+	}
+	return {
+		before: joinRule(before),
+		after: joinRule(after)
+	};
+}
+//#endregion
+//#region src/blocks/calendar/calendar.ts
+const ROLES = [
+	"chair",
+	"required",
+	"optional",
+	"non-participant"
+];
+const RESPONSES = [
+	"needs-action",
+	"accepted",
+	"declined",
+	"tentative"
+];
+const STATUSES = [
+	"confirmed",
+	"tentative",
+	"cancelled"
+];
+function attendeeOf(value) {
+	const name = optionalText(value["name"]);
+	const userId = optionalText(value["userId"]);
+	return {
+		email: textOf(value["email"]),
+		...name === void 0 ? {} : { name },
+		...userId === void 0 ? {} : { userId },
+		role: oneOf(value["role"], ROLES, "required"),
+		response: oneOf(value["response"], RESPONSES, "needs-action")
+	};
+}
+/** A `list_calendar_events` or `calendar_feed` row as an event. */
+function calendarEventOf(value) {
+	const row = recordOf(value, "calendar event");
+	const text = (key) => {
+		const found = optionalText(row[key]);
+		return found === void 0 ? {} : { [key]: found };
+	};
+	const originalStart = optionalInstant(row["originalStart"]);
+	const updatedAt = optionalInstant(row["updatedAt"]);
+	const exdates = Array.isArray(row["exdates"]) ? row["exdates"] : [];
+	return {
+		id: textOf(row["id"]),
+		calendarId: textOf(row["calendarId"]),
+		uid: textOf(row["uid"]),
+		title: optionalText(row["title"]) ?? "",
+		...text("description"),
+		...text("location"),
+		startsAt: requiredInstant(row["startsAt"], "startsAt"),
+		endsAt: requiredInstant(row["endsAt"], "endsAt"),
+		allDay: row["allDay"] === true,
+		tz: optionalText(row["tz"]) ?? "UTC",
+		status: oneOf(row["status"], STATUSES, "confirmed"),
+		...text("rrule"),
+		exdates: exdates.map((date) => requiredInstant(date, "exdate")),
+		...text("recurrenceId"),
+		...originalStart === void 0 ? {} : { originalStart },
+		...text("subjectType"),
+		...text("subjectId"),
+		...text("color"),
+		...row["kind"] === void 0 ? {} : { kind: oneOf(row["kind"], CALENDAR_EVENT_KINDS, "event") },
+		...row["transparency"] === void 0 ? {} : { transparency: oneOf(row["transparency"], CALENDAR_TRANSPARENCIES, "opaque") },
+		...typeof row["autoDecline"] === "boolean" ? { autoDecline: row["autoDecline"] } : {},
+		attendees: recordsOf(row["attendees"], "attendees").map(attendeeOf),
+		...updatedAt === void 0 ? {} : { updatedAt }
+	};
+}
+/** The jsonb `save_calendar_event` takes. */
+function itemOf(input) {
+	const item = {};
+	for (const [key, value] of Object.entries(input)) {
+		if (value === void 0) continue;
+		if (key === "exdates" && Array.isArray(value)) item[key] = value.map(String);
+		else if (key === "startsAt" || key === "endsAt" || key === "originalStart") item[key] = String(value);
+		else item[key] = value;
+	}
+	return item;
+}
+/** An imported event as the jsonb `import_calendar_events` takes. */
+function importItem(event) {
+	return itemOf({
+		uid: event.uid,
+		title: event.title,
+		description: event.description ?? null,
+		location: event.location ?? null,
+		startsAt: event.startsAt,
+		endsAt: event.endsAt,
+		allDay: event.allDay,
+		tz: event.tz,
+		status: event.status,
+		rrule: event.rrule ?? null,
+		exdates: event.exdates,
+		...event.originalStart === void 0 ? {} : { originalStart: event.originalStart },
+		...event.transparency === void 0 ? {} : { transparency: event.transparency }
+	});
+}
+/** The fields of a series that an override or a new series starts from. */
+function copyOf(event) {
+	return {
+		title: event.title,
+		...event.description === void 0 ? {} : { description: event.description },
+		...event.location === void 0 ? {} : { location: event.location },
+		allDay: event.allDay,
+		tz: event.tz,
+		status: event.status,
+		...event.subjectType === void 0 ? {} : { subjectType: event.subjectType },
+		...event.subjectId === void 0 ? {} : { subjectId: event.subjectId },
+		...event.color === void 0 ? {} : { color: event.color },
+		...event.kind === void 0 ? {} : { kind: event.kind },
+		...event.transparency === void 0 ? {} : { transparency: event.transparency },
+		...event.autoDecline === void 0 ? {} : { autoDecline: event.autoDecline }
+	};
+}
+const INFINITE = {
+	from: "-infinity",
+	until: "infinity"
+};
+/** The keys of an event write the block types itself. */
+const EVENT_INPUT = /* @__PURE__ */ new Set([
+	"id",
+	"title",
+	"description",
+	"location",
+	"startsAt",
+	"endsAt",
+	"allDay",
+	"tz",
+	"status",
+	"rrule",
+	"exdates",
+	"subjectType",
+	"subjectId",
+	"color",
+	"kind",
+	"transparency",
+	"autoDecline",
+	"uid",
+	"recurrenceId",
+	"originalStart"
+]);
+function createCalendar(options) {
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "event fields");
+	/** The item a write sends, with its extra fields validated. */
+	const checked = (input) => AsyncResult.from(() => fields.write(extraOf(input, EVENT_INPUT))).map((extra) => ({
+		...extra,
+		...itemOf(input)
+	}));
+	const saved = (value) => {
+		const row = recordOf(value, "save_calendar_event");
+		return {
+			id: textOf(row["id"]),
+			uid: textOf(row["uid"]),
+			created: row["created"] === true
+		};
+	};
+	const save = (calendarId, input) => checked(input).andThen((item) => call("save_calendar_event", {
+		calendar_id: calendarId,
+		item
+	}, saved));
+	const list = (calendarIds, range) => call("list_calendar_events", {
+		calendar_ids: [...calendarIds],
+		range_start: range.from.toString(),
+		range_end: range.until.toString()
+	}, (value) => recordsOf(value, "list_calendar_events").map((raw) => [raw, calendarEventOf(raw)])).andThen((rows) => allWithFields(fields, rows));
+	return withBlockHooks({
+		createCalendar: (organizationId, name, extra = {}) => call("create_calendar", {
+			tenant: organizationId,
+			name,
+			tz: extra.tz ?? "UTC",
+			owner_type: extra.ownerType ?? null,
+			owner_id: extra.ownerId ?? null
+		}, (value) => ({ id: textOf(recordOf(value, "create_calendar")["id"]) })),
+		deleteCalendar: (id) => call("delete_calendar", { calendar_id: id }, (value) => value === true),
+		listCalendars: (organizationId) => call("list_calendars", { tenant: organizationId }, (value) => recordsOf(value, "list_calendars").map((row) => {
+			const extra = {};
+			for (const key of [
+				"color",
+				"ownerType",
+				"ownerId"
+			]) {
+				const found = optionalText(row[key]);
+				if (found !== void 0) extra[key] = found;
+			}
+			return {
+				id: textOf(row["id"]),
+				name: textOf(row["name"]),
+				tz: optionalText(row["tz"]) ?? "UTC",
+				...extra
+			};
+		})),
+		upsert: save,
+		delete: (eventId) => call("delete_calendar_event", { event_id: eventId }, (value) => value === true),
+		events: list,
+		occurrences: (calendarIds, range, occurrenceOptions) => list(calendarIds, range).map((events) => expandOccurrences(events, range, occurrenceOptions)),
+		editOccurrence: (occurrence, changes) => {
+			const series = occurrence.series;
+			if (!occurrence.recurring || series === void 0) return save(occurrence.event.calendarId, {
+				...changes,
+				id: occurrence.event.id
+			});
+			if (occurrence.event.recurrenceId !== void 0) return save(occurrence.event.calendarId, {
+				...changes,
+				id: occurrence.event.id
+			});
+			return save(series.calendarId, {
+				...copyOf(series),
+				startsAt: occurrence.start,
+				endsAt: occurrence.end,
+				...changes,
+				rrule: null,
+				exdates: [],
+				recurrenceId: series.id,
+				originalStart: occurrence.originalStart
+			});
+		},
+		editFollowing: (occurrence, changes) => {
+			const series = occurrence.series;
+			if (!occurrence.recurring || series?.rrule === void 0) return save(occurrence.event.calendarId, {
+				...changes,
+				id: occurrence.event.id
+			}).map(({ id }) => ({ id }));
+			if (occurrence.originalStart.equals(series.startsAt)) return save(series.calendarId, {
+				...changes,
+				id: series.id
+			}).map(({ id }) => ({ id }));
+			let rules;
+			try {
+				rules = splitRule(series.rrule, series.startsAt.toZonedDateTimeISO(series.tz), occurrence.originalStart);
+			} catch (cause) {
+				return AsyncResult.err(dbError("invalid_input", cause instanceof Error ? cause.message : String(cause), { hint: "CALENDAR_SPLIT_INVALID" }));
+			}
+			const length = series.endsAt.since(series.startsAt);
+			return checked({
+				...copyOf(series),
+				startsAt: occurrence.originalStart,
+				endsAt: occurrence.originalStart.add(length),
+				rrule: rules.after,
+				...changes
+			}).andThen((item) => call("split_calendar_event", {
+				event_id: series.id,
+				split_at: occurrence.originalStart.toString(),
+				before_rrule: rules.before,
+				item
+			}, (value) => ({ id: textOf(recordOf(value, "split_calendar_event")["id"]) })));
+		},
+		cancelOccurrence: (occurrence) => {
+			const series = occurrence.series;
+			if (!occurrence.recurring || series === void 0) return call("delete_calendar_event", { event_id: occurrence.event.id }, (value) => value === true);
+			return call("cancel_calendar_occurrence", {
+				event_id: series.id,
+				original_start: occurrence.originalStart.toString()
+			}, (value) => value === true);
+		},
+		setAttendee: (eventId, attendee) => call("set_calendar_attendee", {
+			event_id: eventId,
+			email: attendee.email,
+			name: attendee.name ?? null,
+			user_id: attendee.userId ?? null,
+			role: attendee.role ?? "required"
+		}, (value) => value === true),
+		removeAttendee: (eventId, email) => call("remove_calendar_attendee", {
+			event_id: eventId,
+			email
+		}, (value) => value === true),
+		respond: (eventId, response) => call("respond_calendar_event", {
+			event_id: eventId,
+			response
+		}, (value) => value === true),
+		importIcs: (calendarId, text) => {
+			const parsed = parseIcs(text);
+			return call("import_calendar_events", {
+				calendar_id: calendarId,
+				source: { events: parsed.events.map(importItem) }
+			}, (value) => {
+				const row = recordOf(value, "import_calendar_events");
+				return {
+					created: Number(row["created"] ?? 0),
+					updated: Number(row["updated"] ?? 0),
+					skipped: Number(row["skipped"] ?? 0) + parsed.skipped
+				};
+			});
+		},
+		exportIcs: (calendar, range) => list([calendar.id], range ?? INFINITE).map((events) => toIcs(events, {
+			name: calendar.name,
+			tz: calendar.tz
+		})),
+		feed: (token) => call("calendar_feed", { token }, (value) => {
+			if (value === null || value === void 0) return null;
+			const row = recordOf(value, "calendar_feed");
+			const info = recordOf(row["calendar"], "calendar_feed");
+			return toIcs(recordsOf(row["events"], "calendar_feed").map(calendarEventOf), {
+				name: textOf(info["name"]),
+				tz: optionalText(info["tz"]) ?? "UTC"
+			});
+		}),
+		setWorkingHours: (organizationId, input) => call("set_calendar_working_hours", {
+			tenant: organizationId,
+			user_id: input.userId ?? null,
+			tz: input.tz,
+			hours: input.hours.map((hour) => ({ ...hour }))
+		}, (value) => Number(value ?? 0)),
+		workingHours: (organizationId, userIds) => call("list_calendar_working_hours", {
+			tenant: organizationId,
+			user_ids: userIds === void 0 ? null : [...userIds]
+		}, workingHoursOf),
+		freeBusy: (organizationId, userIds, range) => call("calendar_free_busy", {
+			tenant: organizationId,
+			user_ids: [...userIds],
+			range_start: range.from.toString(),
+			range_end: range.until.toString()
+		}, freeBusyOf)
+	}, options.hooks, {
+		block: "calendar",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/calendar/event-calendar.ts
+const toDate = (instant) => new Date(instant.epochMilliseconds);
+/**
+* Occurrences as event calendar events. Each id is the occurrence key, so an
+* overridden occurrence keeps its id; `data` carries the occurrence for
+* `fromEventCalendarUpdate` and your own handlers.
+*/
+function toEventCalendarEvents(occurrences, options = {}) {
+	return occurrences.map((occurrence) => {
+		const color = occurrence.event.color;
+		const resourceId = options.resourceOf === void 0 ? occurrence.event.calendarId : options.resourceOf(occurrence);
+		return {
+			id: occurrence.key,
+			title: occurrence.event.title,
+			start: toDate(occurrence.start),
+			end: toDate(occurrence.end),
+			allDay: occurrence.allDay,
+			...occurrence.recurring ? {
+				recurringEventId: occurrence.series?.id ?? occurrence.event.id,
+				originalStart: toDate(occurrence.originalStart)
+			} : {},
+			...color === void 0 ? {} : { color },
+			...options.readOnly?.(occurrence) === true ? { readOnly: true } : {},
+			...resourceId === void 0 ? {} : { resourceId },
+			data: occurrence
+		};
+	});
+}
+/** Calendars (or anything with an id and a name) as resources. */
+function toEventCalendarResources(items) {
+	return items.map((item) => ({
+		id: item.id,
+		title: item.name,
+		...item.color === void 0 ? {} : { color: item.color }
+	}));
+}
+/**
+* The new times of an `onEventUpdate` from an event calendar, for
+* `calendar.editOccurrence(occurrence, move)` or `editFollowing`.
+*/
+function fromEventCalendarUpdate(update) {
+	const time = temporal();
+	return {
+		startsAt: time.Instant.fromEpochMilliseconds(update.start.getTime()),
+		endsAt: time.Instant.fromEpochMilliseconds(update.end.getTime()),
+		...update.allDay === void 0 ? {} : { allDay: update.allDay }
+	};
+}
+/** The series of an occurrence, or the event itself. */
+const seriesOf = (occurrence) => occurrence.series ?? occurrence.event;
+//#endregion
+//#region src/blocks/calendar/client.ts
+/**
+* The occurrences of some calendars in the visible range, typed for a headless
+* event calendar such as ReUI's Event Calendar.
+*/
+function createCalendarController(options) {
+	const { client, calendarIds, resourceOf, readOnly } = options;
+	let range = options.range;
+	let ticket = 0;
+	const eventsOf = (occurrences) => toEventCalendarEvents(occurrences, {
+		...resourceOf === void 0 ? {} : { resourceOf },
+		...readOnly === void 0 ? {} : { readOnly }
+	});
+	return defineController({
+		occurrences: void 0,
+		events: [],
+		error: void 0,
+		loading: true
+	}, (state) => {
+		const refresh = async () => {
+			ticket += 1;
+			const request = ticket;
+			state.set({ loading: true });
+			const time = temporal();
+			const result = await client.occurrences(calendarIds, {
+				from: time.Instant.fromEpochMilliseconds(range.start.getTime()),
+				until: time.Instant.fromEpochMilliseconds(range.end.getTime())
+			});
+			if (request !== ticket) return;
+			state.set(result.ok ? {
+				occurrences: result.data,
+				events: eventsOf(result.data),
+				error: void 0,
+				loading: false
+			} : {
+				error: result.error,
+				loading: false
+			});
+		};
+		const after = async (result) => {
+			if (!result.ok) {
+				state.set({ error: result.error });
+				return false;
+			}
+			await refresh();
+			return true;
+		};
+		return {
+			actions: {
+				refresh,
+				setRange: (next) => {
+					if (sameRange(range, next)) return;
+					range = next;
+					refresh();
+				},
+				editOccurrence: async (occurrence, changes) => after(await client.editOccurrence(occurrence, changes)),
+				editFollowing: async (occurrence, changes) => after(await client.editFollowing(occurrence, changes)),
+				cancelOccurrence: async (occurrence) => after(await client.cancelOccurrence(occurrence))
+			},
+			start: () => {
+				refresh();
+			}
+		};
+	});
+}
+//#endregion
 //#region src/blocks/calendar/events.ts
 /** The `calendar` block's event types, for its manifest and `onBlockEvent`. */
 const calendarEvents = defineEvents({
@@ -15,7 +1083,7 @@ const calendarEvents = defineEvents({
 //#endregion
 //#region src/blocks/calendar/schemas.ts
 /**
-* What `save` takes for an event. Fields left out keep their value on update,
+* What `upsert` takes for an event. Fields left out keep their value on update,
 * so every field is optional.
 */
 const calendarEventInputSchema = entitySchema({