slotlock 0.1.1 → 0.2.0

package/sync.js

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import ICAL from 'ical.js';
-import { zonedDateTimeToUtc } from './timezone.js';
+import { createTimeZoneConverter, utcFrame, zonedDateTimeFields, zonedDateTimeToUtc, } from './timezone.js';
 /** The most text one feed may be, in UTF-8 bytes. */
 export const MAX_ICAL_INPUT_BYTES = 2_000_000;
 const MAX_ICAL_OCCURRENCES = 2_000;
@@ -513,8 +513,8 @@ function calendarTimeValue(value, propertyTimezone, calendarTimezone) {
         }
         catch {
             // A standards-compliant embedded VTIMEZONE may use a private TZID that Intl does not know.
-            // ical.js resolves that definition itself; an undeclared TZID remains `floating` and cannot
-            // reach this fallback.
+            // ical.js resolves that definition itself; an undeclared TZID Intl does not know either
+            // remains `floating` and cannot reach this fallback.
             if (zone && valueZone === zone && valueZone !== 'floating' && valueZone !== 'local') {
                 const resolved = time.toJSDate();
                 if (Number.isFinite(resolved.getTime()))
@@ -527,6 +527,13 @@ function calendarTimeValue(value, propertyTimezone, calendarTimezone) {
         return time.toJSDate();
     throw new CalendarContractError('invalid_icalendar');
 }
+/** The TZID of a time ical.js reads in a zone (a VTIMEZONE's, an IntlTimezone, UTC); else none. */
+function ownZone(value) {
+    if (!(value instanceof ICAL.Time))
+        return undefined;
+    const tzid = value.zone?.tzid;
+    return tzid && tzid !== 'floating' && tzid !== 'local' ? tzid : undefined;
+}
 /**
  * What one parse may spend: steps searching for occurrences, and time from its start. The time is
  * checked at every step and after every piece of ical.js work the parse does, so work that takes no
@@ -612,6 +619,35 @@ function budgetedExpansion(event, Budgeted) {
     if (!Array.isArray(iterators) || !iterators.every((iterator) => iterator instanceof Budgeted)) {
         throw new CalendarContractError('invalid_icalendar');
     }
+    return withEveryRule(expansion);
+}
+/**
+ * `expansion`, choosing among its RRULEs' iterators correctly. ical.js 2.2.1's own choice
+ * (RecurExpansion#_nextRecurrenceIter) drops one that has ended by index as it walks them: it
+ * skipped the iterator after an ended first one, and for any other removed the one before it,
+ * which had not ended, so a series with two RRULEs lost occurrences once either rule ended.
+ */
+function withEveryRule(expansion) {
+    const state = expansion;
+    if (typeof state._nextRecurrenceIter !== 'function') {
+        throw new CalendarContractError('invalid_icalendar');
+    }
+    state._nextRecurrenceIter = () => {
+        const iterators = state.ruleIterators;
+        let chosen = null;
+        for (let index = 0; index < iterators.length;) {
+            const iterator = iterators[index];
+            if (iterator.completed) {
+                iterators.splice(index, 1);
+                continue;
+            }
+            // The earliest next time; the first of equal ones, as ical.js chose.
+            if (chosen === null || chosen.last.compare(iterator.last) > 0)
+                chosen = iterator;
+            index += 1;
+        }
+        return chosen;
+    };
     return expansion;
 }
 /**
@@ -625,12 +661,31 @@ function valueCount(property) {
 function fieldsMs(time) {
     return Date.UTC(time.year, time.month - 1, time.day, time.hour, time.minute, time.second);
 }
+/** The day a time's own fields name: how ical.js matches a DATE EXDATE with an occurrence. */
+function dayOf(time) {
+    return `${time.year}-${time.month}-${time.day}`;
+}
+/**
+ * Milliseconds since 1970 of a DATE or DATE-TIME property's first value as written, ignoring its
+ * zone, or undefined for anything else. Read from the raw form, so nothing resolves a zone yet.
+ */
+function writtenFieldsMs(property) {
+    const value = property?.jCal[3];
+    if (typeof value !== 'string')
+        return undefined;
+    const match = /^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2}):(\d{2})Z?)?$/.exec(value);
+    if (!match)
+        return undefined;
+    const [year, month, day, hour, minute, second] = match.slice(1).map((part) => Number(part ?? 0));
+    return utcFrame(year, month, day, hour, minute, second, 0).getTime();
+}
 /**
- * Refuse a VEVENT that ical.js would spend unbounded work reading, before anything reads its end:
+ * Refuse a VEVENT that ical.js would spend unbounded work reading, before anything reads its times:
  * a DURATION, or a DTEND after its DTSTART, longer than MAX_ICAL_STEP_DAYS (ical.js adds a span to
  * a time a month at a time, Time#adjust, and `DURATION:PT99999999999999999999S` held the process),
  * a negative DURATION, or more RDATE and EXDATE values than MAX_ICAL_DATES_PER_EVENT. Returns how
- * many it lists, for the feed's own limit.
+ * many it lists, for the feed's own limit. It reads times only as written, so it runs before the
+ * times are framed: framing reads every date value, and 115,000 EXDATE values took 11 seconds.
  */
 function boundComponent(component) {
     const maxMs = MAX_ICAL_STEP_DAYS * 24 * 60 * 60 * 1000;
@@ -641,11 +696,11 @@ function boundComponent(component) {
         if (duration.isNegative || duration.toSeconds() * 1000 > maxMs)
             expansionLimit();
     }
-    const start = component.getFirstPropertyValue('dtstart');
-    const end = component.getFirstPropertyValue('dtend');
-    if (start instanceof ICAL.Time && end instanceof ICAL.Time) {
+    const start = writtenFieldsMs(component.getFirstProperty('dtstart'));
+    const end = writtenFieldsMs(component.getFirstProperty('dtend'));
+    if (start !== undefined && end !== undefined) {
         // The fields ignore zones, so allow the day they can be out by.
-        if (Math.abs(fieldsMs(end) - fieldsMs(start)) > maxMs + 24 * 60 * 60 * 1000)
+        if (Math.abs(end - start) > maxMs + 24 * 60 * 60 * 1000)
             expansionLimit();
     }
     let dates = 0;
@@ -966,12 +1021,22 @@ function seriesKey(component) {
         component.hasProperty('exdate')) {
         return null;
     }
+    const start = starts[0];
+    const rule = rules[0];
+    // Slotlock 0.1 compared a zoned series' occurrences with its UTC UNTIL as if they were UTC, so a
+    // cursor it kept for one that ends may have ended an occurrence early or gone one past: such a
+    // series has a key of its own now, and those cursors are searched past from the start.
+    const zone = start.getParameter('tzid');
+    const zonedUntil = typeof zone === 'string' &&
+        zone.trim() !== 'UTC' &&
+        rule.jCal[3]?.until !== undefined;
     return createHash('sha256')
         .update(JSON.stringify([
         SERIES_CURSOR_FORMAT,
         ICAL_JS_VERSION,
-        starts[0].toICALString(),
-        rules[0].toICALString(),
+        start.toICALString(),
+        rule.toICALString(),
+        ...(zonedUntil ? ['zoned-until'] : []),
     ]))
         .digest('hex');
 }
@@ -1106,7 +1171,7 @@ function resumedExpansion(event, Budgeted, cursor) {
     if (iterators.length !== 1 || !(iterators[0] instanceof Budgeted)) {
         throw new CalendarContractError('invalid_icalendar');
     }
-    return expansion;
+    return withEveryRule(expansion);
 }
 /**
  * Whether a cursor's iterator state agrees with `reference`, an iterator ical.js built for the same
@@ -1151,6 +1216,299 @@ function cursorFitsRule(state, reference, rule) {
         return false;
     return true;
 }
+/**
+ * An IANA zone ical.js reads through Intl, for a TZID a calendar names without a VTIMEZONE (RFC
+ * 5545 wants one for each; real feeds, and the series Slotlock stores, name IANA zones bare). Left
+ * alone, ical.js reads such a time as floating and compares it with UTC values (an UNTIL, EXDATE,
+ * RDATE or RECURRENCE-ID) as if it were UTC: a 09:00 Berlin series lost the occurrence its UNTIL
+ * named, and a moved or excluded occurrence was not found. Offsets come from the converter the rest
+ * of Slotlock reads wall times with: a gap moves forward, a fold takes its first instant.
+ */
+class IntlTimezone extends ICAL.Timezone {
+    converter;
+    /** Offsets already found, by wall time: ical.js asks again at every comparison. */
+    offsets = new Map();
+    constructor(tzid) {
+        super({ tzid });
+        // A TZID is matched as written (" Europe/Berlin" is that TZID); Slotlock reads its zone trimmed.
+        this.converter = createTimeZoneConverter(tzid.trim());
+    }
+    utcOffset(time) {
+        const wall = utcFrame(time.year, time.month, time.day, time.hour, time.minute, time.second, 0);
+        const wallMs = wall.getTime();
+        let offset = this.offsets.get(wallMs);
+        if (offset === undefined) {
+            offset = Math.round((wallMs - this.converter.wallFrameToUtc(wallMs).getTime()) / 1000);
+            if (this.offsets.size >= 4_096)
+                this.offsets.clear();
+            this.offsets.set(wallMs, offset);
+        }
+        return offset;
+    }
+}
+/** VEVENT properties whose times ical.js compares with one another. */
+const COMPARED_TIME_PROPERTIES = ['dtstart', 'dtend', 'recurrence-id', 'rdate', 'exdate'];
+function isKnownTimezone(timezone) {
+    try {
+        validTimezone(timezone);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Wall-clock fields as a jCal DATE-TIME, `2027-01-04T09:00:00`, with a `Z` when they are UTC's. */
+function jCalDateTime(fields, utc = false) {
+    const pad = (value, width = 2) => String(value).padStart(width, '0');
+    const date = `${pad(fields.year, 4)}-${pad(fields.month)}-${pad(fields.day)}`;
+    const time = `${pad(fields.hour)}:${pad(fields.minute)}:${pad(fields.second)}`;
+    return `${date}T${time}${utc ? 'Z' : ''}`;
+}
+/** The instant an ical.js time names, read in its own zone; undefined when it has none. */
+function zonedInstant(time) {
+    return ownZone(time) === undefined ? undefined : new Date(time.toUnixTime() * 1000);
+}
+/** `value` (a jCal date-time) as the date it falls on in `timezone`; undefined if it cannot say. */
+function localDateOf(value, tzid, timezone) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(Z?)$/.exec(value);
+    if (!match)
+        return undefined;
+    const [year, month, day, hour, minute, second] = match.slice(1, 7).map(Number);
+    const fields = { year, month, day, hour, minute, second };
+    let instant;
+    if (match[7] === 'Z') {
+        instant = utcFrame(year, month, day, hour, minute, second, 0);
+    }
+    else if (typeof tzid === 'string' && isKnownTimezone(tzid)) {
+        instant = zonedDateTimeToUtc(fields, tzid.trim());
+    }
+    else {
+        // Floating: the wall time is the calendar's own, and so is its date.
+        return value.slice(0, 10);
+    }
+    return jCalDateTime(zonedDateTimeFields(instant, timezone)).slice(0, 10);
+}
+/**
+ * Prepare a calendar's events before anything reads their times, so ical.js compares them at their
+ * real instants:
+ * - a floating time is framed in the calendar's zone, the zone Slotlock reads it in;
+ * - each zone the events name that Intl knows becomes an IntlTimezone, whether or not the feed
+ *   defines it; a feed names no more zones it does not define than it may define
+ *   (MAX_ICAL_TIMEZONES): 50,000 spellings of one zone, each a zone of its own to ical.js, took
+ *   3.4 seconds;
+ * - an all-day series' UTC or zoned UNTIL, EXDATE and RECURRENCE-ID become the local dates they
+ *   fall on (RFC 5545 wants them as dates; a local midnight east of UTC is the day before in UTC);
+ * - a PERIOD RDATE becomes its start, its end kept in the map returned, by event: ical.js orders a
+ *   period among times by whether a time falls inside it, and hands back the period itself;
+ * - then, every zone resolving, a timed series' own times are aligned (alignSeriesTimes).
+ * Every DATE and DATE-TIME value this reads is one boundComponents has counted.
+ */
+function frameEventTimes(root, components, calendarTimezone, budget) {
+    const timezone = calendarTimezone !== undefined && isKnownTimezone(calendarTimezone)
+        ? calendarTimezone
+        : undefined;
+    const declared = new Set(root.getAllSubcomponents('vtimezone').map((zone) => zone.getFirstPropertyValue('tzid')));
+    const named = new Set();
+    let undeclared = 0;
+    const nameZone = (tzid) => {
+        if (named.has(tzid))
+            return;
+        named.add(tzid);
+        if (!declared.has(tzid) && ++undeclared > MAX_ICAL_TIMEZONES)
+            expansionLimit();
+    };
+    const periods = new Map();
+    const allDayMasters = new Set();
+    for (const component of components) {
+        for (const name of COMPARED_TIME_PROPERTIES) {
+            for (const property of component.getAllProperties(name)) {
+                const values = property.jCal.slice(3);
+                const starts = values.map((value) => (Array.isArray(value) ? value[0] : value));
+                const tzid = property.getParameter('tzid');
+                if (typeof tzid === 'string') {
+                    nameZone(tzid);
+                }
+                else if (timezone &&
+                    (property.type === 'date-time' || property.type === 'period') &&
+                    starts.some((start) => typeof start === 'string' && !start.endsWith('Z'))) {
+                    property.setParameter('tzid', timezone);
+                    nameZone(timezone);
+                }
+                if (name === 'rdate' && property.type === 'period') {
+                    const kept = periods.get(component) ?? [];
+                    for (const value of values) {
+                        const [start, end] = Array.isArray(value) ? value : [];
+                        if (typeof start !== 'string' || typeof end !== 'string') {
+                            throw new CalendarContractError('invalid_icalendar');
+                        }
+                        kept.push({ property, start, end });
+                    }
+                    periods.set(component, kept);
+                    property.resetType('date-time');
+                    for (const value of values)
+                        property.jCal.push(value[0]);
+                }
+                budget.check();
+            }
+        }
+        if (!component.hasProperty('recurrence-id') &&
+            component.getFirstProperty('dtstart')?.type === 'date') {
+            const uid = component.getFirstPropertyValue('uid');
+            if (typeof uid === 'string')
+                allDayMasters.add(uid);
+        }
+    }
+    if (timezone) {
+        const toDate = (property) => {
+            budget.check();
+            if (property.type !== 'date-time')
+                return;
+            const tzid = property.getParameter('tzid');
+            const dates = property.jCal.slice(3).map((value) => typeof value === 'string' ? localDateOf(value, tzid, timezone) : undefined);
+            if (dates.some((date) => date === undefined))
+                return;
+            property.resetType('date');
+            property.removeParameter('tzid');
+            for (const date of dates)
+                property.jCal.push(date);
+        };
+        for (const component of components) {
+            const uid = component.getFirstPropertyValue('uid');
+            if (typeof uid !== 'string' || !allDayMasters.has(uid))
+                continue;
+            if (component.hasProperty('recurrence-id')) {
+                for (const property of component.getAllProperties('recurrence-id'))
+                    toDate(property);
+                continue;
+            }
+            for (const property of component.getAllProperties('exdate'))
+                toDate(property);
+            for (const property of component.getAllProperties('rrule')) {
+                const rule = property.jCal[3];
+                if (typeof rule?.until === 'string' && rule.until.length > 10) {
+                    const date = localDateOf(rule.until, undefined, timezone);
+                    if (date !== undefined)
+                        rule.until = date;
+                }
+            }
+        }
+    }
+    const cache = root._timezoneCache;
+    for (const tzid of named) {
+        // A zone Intl knows by this name is read through Intl, as calendarTimeValue reads it, even when
+        // the feed defines it: ical.js read a stale VTIMEZONE's rules (standard time only) while
+        // Slotlock read Intl's, so the two placed one time an hour apart and a moved occurrence was
+        // found in a feed but not in the series stored from it.
+        if (ICAL.TimezoneService.has(tzid) || !isKnownTimezone(tzid))
+            continue;
+        // ical.js keeps a calendar's zones here; without it, it could not use one of these.
+        if (!(cache instanceof Map))
+            throw new CalendarContractError('invalid_icalendar');
+        cache.set(tzid, new IntlTimezone(tzid));
+        budget.check();
+    }
+    alignSeriesTimes(components, budget);
+    return periods;
+}
+/**
+ * With every zone resolving, put what ical.js compares with a timed series' own times in the terms
+ * it compares them in:
+ * - a floating UNTIL becomes the UTC instant it names on the series' clock: RFC 5545 §3.3.10 reads
+ *   it as DTSTART is read, and ical.js read it as UTC, so a New York series lost its last day;
+ * - a RECURRENCE-ID named in another zone becomes the same instant in UTC, which ical.js matches
+ *   with an occurrence (it matched one in New York time with none); one for this and every later
+ *   occurrence (RANGE=THISANDFUTURE) becomes the series' own wall time instead, since ical.js moves
+ *   those by the wall-clock distance from it to the exception's start, read in the start's zone.
+ * A DATE EXDATE of a timed series becomes the series' start time that day: ical.js excluded every
+ * occurrence that day, and a series stored from the feed, whose exceptions are instants, excluded
+ * none (most series occur once a day; one that occurs more keeps the others). And a series of
+ * RDATEs with no RRULE gets its DTSTART as one: it is the first instance (RFC 5545 §3.8.2.4), which
+ * ical.js left out.
+ */
+function alignSeriesTimes(components, budget) {
+    const seriesStarts = new Map();
+    for (const component of components) {
+        if (component.hasProperty('recurrence-id'))
+            continue;
+        const uid = component.getFirstPropertyValue('uid');
+        const start = component.getFirstProperty('dtstart');
+        const value = start?.jCal[3];
+        if (typeof uid !== 'string' || !start || typeof value !== 'string')
+            continue;
+        if (component.hasProperty('rdate') && !component.hasProperty('rrule')) {
+            const parameters = { ...start.jCal[1] };
+            component.addProperty(new ICAL.Property(['rdate', parameters, start.type, value]));
+        }
+        if (start.type !== 'date-time')
+            continue;
+        const time = ICAL.Time.fromDateTimeString(value, start);
+        if (zonedInstant(time) === undefined)
+            continue;
+        seriesStarts.set(uid, { time, tzid: start.getParameter('tzid') });
+        for (const property of component.getAllProperties('exdate')) {
+            const days = property.jCal.slice(3);
+            if (property.type !== 'date' || !days.every((day) => typeof day === 'string'))
+                continue;
+            property.resetType('date-time');
+            const zone = start.getParameter('tzid');
+            if (typeof zone === 'string')
+                property.setParameter('tzid', zone);
+            for (const day of days)
+                property.jCal.push(`${day}${value.slice(10)}`);
+        }
+        for (const property of component.getAllProperties('rrule')) {
+            const rule = property.jCal[3];
+            const until = rule?.until;
+            if (typeof until !== 'string' || until.length <= 10 || until.endsWith('Z'))
+                continue;
+            const instant = zonedInstant(ICAL.Time.fromDateTimeString(until, start));
+            if (instant !== undefined && rule) {
+                rule.until = jCalDateTime(zonedDateTimeFields(instant, 'UTC'), true);
+            }
+        }
+        budget.check();
+    }
+    for (const component of components) {
+        const uid = component.getFirstPropertyValue('uid');
+        const series = typeof uid === 'string' ? seriesStarts.get(uid) : undefined;
+        if (series === undefined)
+            continue;
+        for (const property of component.getAllProperties('recurrence-id')) {
+            budget.check();
+            const value = property.jCal[3];
+            if (property.type !== 'date-time' || typeof value !== 'string')
+                continue;
+            // Named in the series' own zone, it is matched by its wall time as it stands.
+            if (typeof series.tzid === 'string' && property.getParameter('tzid') === series.tzid)
+                continue;
+            const time = ICAL.Time.fromDateTimeString(value, property);
+            const instant = zonedInstant(time);
+            if (instant === undefined)
+                continue;
+            const seriesZone = series.time.zone;
+            const zone = property.getParameter('range') === undefined ? ICAL.Timezone.utcTimezone : seriesZone;
+            if (time.zone?.tzid === zone.tzid)
+                continue;
+            let written;
+            if (zone.tzid === 'UTC') {
+                written = jCalDateTime(zonedDateTimeFields(instant, 'UTC'), true);
+            }
+            else if (zone instanceof IntlTimezone) {
+                written = jCalDateTime(zonedDateTimeFields(instant, zone.tzid.trim()));
+            }
+            else {
+                // A zone the calendar defines is ical.js's to read.
+                written = time.convertToZone(zone).toString();
+            }
+            property.resetType('date-time');
+            if (zone.tzid === 'UTC')
+                property.removeParameter('tzid');
+            else
+                property.setParameter('tzid', series.tzid);
+            property.jCal.push(written);
+        }
+    }
+}
 /** Parse VEVENTs with the standards library; event content is deliberately discarded. */
 export function parseICalendarChanges(input, calendarTimezone, expansionWindow) {
     return parseCalendarChanges(input, calendarTimezone, expansionWindow, FEED_LIMITS);
@@ -1162,12 +1520,17 @@ function parseCalendarChanges(input, calendarTimezone, expansionWindow, limits,
         boundInput(input);
         const budget = new RecurrenceBudget(limits);
         const root = new ICAL.Component(ICAL.parse(input));
+        // A bare VEVENT (or anything else) would read as a calendar with no events.
+        if (root.name !== 'vcalendar')
+            throw new CalendarContractError('invalid_icalendar');
         budget.check();
         let Budgeted;
         const budgeted = () => (Budgeted ??= budgetedRecurIterator(budget));
         budgetTimezoneRules(root, budgeted);
         budgetTimezoneCoverage(root, budget);
-        const timeValue = (value, zone, fallback) => budget.search(() => calendarTimeValue(value, zone, fallback));
+        // A time read in a zone of its own (a VTIMEZONE's, or an IntlTimezone) is read in that zone: an
+        // RDATE may name another zone than its series' DTSTART, and an occurrence keeps the RDATE's.
+        const timeValue = (value, zone, fallback) => budget.search(() => calendarTimeValue(value, ownZone(value) ?? zone, fallback));
         const embeddedTimezone = root.getFirstPropertyValue('x-wr-timezone');
         const defaultTimezone = calendarTimezone?.trim() ||
             (typeof embeddedTimezone === 'string' ? embeddedTimezone.trim() : '') ||
@@ -1177,6 +1540,7 @@ function parseCalendarChanges(input, calendarTimezone, expansionWindow, limits,
             throw new CalendarContractError('invalid_icalendar');
         }
         boundComponents(components, budget);
+        const periods = frameEventTimes(root, components, defaultTimezone, budget);
         const events = feedEvents(components, budget);
         const masters = new Map();
         const exceptionsByUid = new Map();
@@ -1206,33 +1570,132 @@ function parseCalendarChanges(input, calendarTimezone, expansionWindow, limits,
                 budget.check();
             }
         }
-        const normalizeEvent = (event, startValue, endValue, recurrenceValue) => {
+        /**
+         * One event or occurrence as a change, or null when it has no length: RFC 5545 §3.6.1 ends a
+         * DATE-TIME DTSTART without DTEND or DURATION when it starts, so it occupies no time. One that
+         * ends before it starts, or has no UID, makes the feed an invalid calendar. `knownEnd` is an end
+         * already found: a PERIOD RDATE's, or an occurrence's that starts in an hour the clocks skip.
+         */
+        const normalizeEvent = (event, startValue, endValue, recurrenceValue, knownEnd) => {
             const component = event.component;
             const startProperty = component.getFirstProperty('dtstart');
             const endProperty = component.getFirstProperty('dtend');
             const recurrenceProperty = component.getFirstProperty('recurrence-id');
             const status = String(component.getFirstPropertyValue('status') ?? 'confirmed').toLowerCase();
             const transparency = String(component.getFirstPropertyValue('transp') ?? 'opaque').toLowerCase();
+            const start = timeValue(startValue, startProperty?.getParameter('tzid'), defaultTimezone);
+            const end = knownEnd ??
+                timeValue(endValue, endProperty?.getParameter('tzid') ?? startProperty?.getParameter('tzid'), defaultTimezone);
             const change = {
                 externalId: event.uid,
-                start: timeValue(startValue, startProperty?.getParameter('tzid'), defaultTimezone),
-                end: timeValue(endValue, endProperty?.getParameter('tzid') ?? startProperty?.getParameter('tzid'), defaultTimezone),
+                start,
+                end,
                 status,
                 transparent: transparency === 'transparent',
                 sequence: Number(component.getFirstPropertyValue('sequence') ?? 0),
             };
+            if (end.getTime() === start.getTime()) {
+                if (status !== 'cancelled')
+                    return null;
+                // Cancelled, it still says so, with no time.
+                change.start = null;
+                change.end = null;
+            }
             if (recurrenceValue) {
                 change.recurrenceId = timeValue(recurrenceValue, recurrenceProperty?.getParameter('tzid') ?? startProperty?.getParameter('tzid'), defaultTimezone).toISOString();
             }
-            return normalizeExternalCalendarChange(change);
+            try {
+                return normalizeExternalCalendarChange(change);
+            }
+            catch (error) {
+                if (error instanceof CalendarContractError) {
+                    throw new CalendarContractError('invalid_icalendar');
+                }
+                throw error;
+            }
+        };
+        /** Each PERIOD RDATE of a series, by the instant it starts: the instant it ends. */
+        const periodEndsOf = (event) => {
+            const ends = new Map();
+            const maxMs = MAX_ICAL_STEP_DAYS * 24 * 60 * 60 * 1000;
+            for (const period of periods.get(event.component) ?? []) {
+                const zone = period.property.getParameter('tzid');
+                const start = ICAL.Time.fromDateTimeString(period.start, period.property);
+                let end;
+                if (/^[+-]?P/.test(period.end)) {
+                    // Bounded first, as boundComponent bounds a DURATION: ical.js adds a month at a time.
+                    const duration = ICAL.Duration.fromString(period.end);
+                    if (duration.isNegative || duration.toSeconds() * 1000 > maxMs)
+                        expansionLimit();
+                    end = start.clone();
+                    end.addDuration(duration);
+                }
+                else {
+                    end = ICAL.Time.fromDateTimeString(period.end, period.property);
+                    if (Math.abs(fieldsMs(end) - fieldsMs(start)) > maxMs + 24 * 60 * 60 * 1000) {
+                        expansionLimit();
+                    }
+                }
+                const startMs = timeValue(start, zone, defaultTimezone).getTime();
+                const endsAt = timeValue(end, zone, defaultTimezone);
+                if (endsAt.getTime() < startMs)
+                    throw new CalendarContractError('invalid_icalendar');
+                ends.set(startMs, endsAt);
+                budget.check();
+            }
+            return ends;
+        };
+        /**
+         * The exact length of a timed series: what its DTEND gives it (RFC 5545 §3.8.5.3), a clock
+         * change or not, or its DURATION in seconds (exact for hours, minutes and seconds, §3.3.6; days
+         * count as 24 hours, but a length of days never ends as it starts, where this is used);
+         * undefined for an all-day series.
+         */
+        const exactLengthOf = (event) => {
+            const startProperty = event.component.getFirstProperty('dtstart');
+            if (startProperty?.type !== 'date-time')
+                return undefined;
+            const duration = event.component.getFirstPropertyValue('duration');
+            if (duration instanceof ICAL.Duration)
+                return duration.toSeconds() * 1000;
+            const endProperty = event.component.getFirstProperty('dtend');
+            if (!endProperty)
+                return undefined;
+            const start = timeValue(event.startDate, startProperty.getParameter('tzid'), defaultTimezone);
+            const end = timeValue(event.endDate, endProperty.getParameter('tzid') ?? startProperty.getParameter('tzid'), defaultTimezone);
+            return end.getTime() - start.getTime();
+        };
+        /**
+         * A series' EXDATEs: the instants its DATE-TIME values name, and the days its DATE values name
+         * (one excludes every occurrence that day, as ical.js reads it). ical.js passes them one at a
+         * time as it goes, so an occurrence after two EXDATEs it had not passed, or the second of an
+         * instant both RRULE and RDATE name, escaped its EXDATE; RFC 5545 §3.8.5.1 has every EXDATE win.
+         */
+        const exclusionsOf = (event) => {
+            const instants = new Set();
+            const days = new Set();
+            const startZone = event.component.getFirstProperty('dtstart')?.getParameter('tzid');
+            for (const property of event.component.getAllProperties('exdate')) {
+                const zone = property.getParameter('tzid') ?? startZone;
+                for (const value of property.getValues()) {
+                    if (!(value instanceof ICAL.Time))
+                        throw new CalendarContractError('invalid_icalendar');
+                    if (value.isDate)
+                        days.add(dayOf(value));
+                    else
+                        instants.add(timeValue(value, zone, defaultTimezone).getTime());
+                }
+            }
+            return { instants, days };
         };
         const changes = [];
-        let remainingWork = MAX_ICAL_WORK;
         for (const event of events) {
             if (event.isRecurrenceException() && masters.has(event.uid))
                 continue;
             if (!event.isRecurring()) {
-                changes.push(normalizeEvent(event, event.startDate, event.endDate, event.recurrenceId ?? undefined));
+                const change = normalizeEvent(event, event.startDate, event.endDate, event.recurrenceId ?? undefined);
+                if (change)
+                    changes.push(change);
                 continue;
             }
             if (!expansionWindow ||
@@ -1242,6 +1705,8 @@ function parseCalendarChanges(input, calendarTimezone, expansionWindow, limits,
                 expansionWindow.end.getTime() - expansionWindow.start.getTime() > MAX_ICAL_WINDOW_MS) {
                 throw new CalendarContractError('invalid_icalendar');
             }
+            // What one series may pass from its start, so that one series' age never refuses another's.
+            let remainingWork = MAX_ICAL_WORK;
             let maxBackwardExceptionShiftMs = 0;
             for (const exception of exceptionsByUid.get(event.uid) ?? []) {
                 remainingWork -= 1;
@@ -1269,6 +1734,9 @@ function parseCalendarChanges(input, calendarTimezone, expansionWindow, limits,
                 ? kept
                 : null;
             const startZone = event.component.getFirstProperty('dtstart')?.getParameter('tzid');
+            let periodEnds;
+            let exclusions;
+            const exactLengthMs = exactLengthOf(event);
             // The occurrences in the window from `resume` (or the start), and the cursor to keep; null
             // when `resume` does not fit this series.
             const expand = (resume) => {
@@ -1284,6 +1752,7 @@ function parseCalendarChanges(input, calendarTimezone, expansionWindow, limits,
                 }
                 const found = [];
                 let position = resume?.position;
+                let previous;
                 let snapshot = resume;
                 let leaving = key !== null;
                 while (true) {
@@ -1305,12 +1774,43 @@ function parseCalendarChanges(input, calendarTimezone, expansionWindow, limits,
                     position = occurrenceStart.getTime();
                     if (occurrenceStart.getTime() >= recurrenceScanEndMs)
                         break;
+                    // An instant is one occurrence however many RRULEs and RDATEs name it (RFC 5545
+                    // §3.8.5.3; ical.js yields it again), and none where an EXDATE names it.
+                    const repeated = position === previous;
+                    previous = position;
+                    if (repeated)
+                        continue;
+                    if (event.component.hasProperty('exdate')) {
+                        exclusions ??= exclusionsOf(event);
+                        if (exclusions.instants.has(position) || exclusions.days.has(dayOf(occurrence))) {
+                            continue;
+                        }
+                    }
                     const details = event.getOccurrenceDetails(occurrence);
                     const start = timeValue(details.startDate, details.item.component.getFirstProperty('dtstart')?.getParameter('tzid'), defaultTimezone);
-                    const end = timeValue(details.endDate, details.item.component.getFirstProperty('dtend')?.getParameter('tzid') ??
-                        details.item.component.getFirstProperty('dtstart')?.getParameter('tzid'), defaultTimezone);
+                    // A PERIOD RDATE's occurrence ends where its period does, unless an exception moved it.
+                    let knownEnd = details.item === event
+                        ? (periodEnds ??= periodEndsOf(event)).get(occurrenceStart.getTime())
+                        : undefined;
+                    let end = knownEnd ??
+                        timeValue(details.endDate, details.item.component.getFirstProperty('dtend')?.getParameter('tzid') ??
+                            details.item.component.getFirstProperty('dtstart')?.getParameter('tzid'), defaultTimezone);
+                    // Any other ends on the wall clock, as calendars show it: ical.js adds its series' length
+                    // there. One that starts in an hour the clocks skip ended as it started (a 02:00-03:00
+                    // occurrence the night Berlin skips 02:00), and was dropped: it lasts its series' exact
+                    // length, as RFC 5545 §3.8.5.3 has every occurrence last.
+                    if (knownEnd === undefined &&
+                        details.item === event &&
+                        exactLengthMs !== undefined &&
+                        exactLengthMs > 0 &&
+                        end <= start) {
+                        knownEnd = new Date(start.getTime() + exactLengthMs);
+                        end = knownEnd;
+                    }
                     if (end > expansionWindow.start && start < expansionWindow.end) {
-                        found.push(normalizeEvent(details.item, details.startDate, details.endDate, occurrence));
+                        const change = normalizeEvent(details.item, details.startDate, details.endDate, occurrence, knownEnd);
+                        if (change)
+                            found.push(change);
                         if (changes.length + found.length > MAX_ICAL_OCCURRENCES)
                             expansionLimit();
                     }
@@ -1358,31 +1858,6 @@ function requiredEventText(value, code) {
     }
     return normalized;
 }
-function partsInZone(value, timezone) {
-    const formatter = new Intl.DateTimeFormat('en-GB', {
-        timeZone: timezone,
-        hourCycle: 'h23',
-        year: 'numeric',
-        month: '2-digit',
-        day: '2-digit',
-        hour: '2-digit',
-        minute: '2-digit',
-        second: '2-digit',
-    });
-    const values = {};
-    for (const part of formatter.formatToParts(value)) {
-        if (part.type !== 'literal')
-            values[part.type] = Number(part.value);
-    }
-    return {
-        year: values.year ?? 0,
-        month: values.month ?? 0,
-        day: values.day ?? 0,
-        hour: (values.hour ?? 0) % 24,
-        minute: values.minute ?? 0,
-        second: values.second ?? 0,
-    };
-}
 function addDateTimeProperty(component, name, value, timezone) {
     const property = new ICAL.Property(name);
     if (timezone === 'UTC') {
@@ -1390,7 +1865,7 @@ function addDateTimeProperty(component, name, value, timezone) {
     }
     else {
         property.setParameter('tzid', timezone);
-        property.setValue(ICAL.Time.fromData({ ...partsInZone(value, timezone), isDate: false }));
+        property.setValue(ICAL.Time.fromData({ ...zonedDateTimeFields(value, timezone), isDate: false }));
     }
     component.addProperty(property);
 }
@@ -1705,6 +2180,8 @@ export function parseTrustedICalendarEvents(input, calendarTimezone) {
         boundInput(input);
         const budget = new RecurrenceBudget(FEED_LIMITS);
         const root = new ICAL.Component(ICAL.parse(input));
+        if (root.name !== 'vcalendar')
+            throw new CalendarContractError('invalid_icalendar');
         budget.check();
         let Budgeted;
         budgetTimezoneRules(root, () => (Budgeted ??= budgetedRecurIterator(budget)));
@@ -1719,6 +2196,9 @@ export function parseTrustedICalendarEvents(input, calendarTimezone) {
             throw new CalendarContractError('invalid_icalendar');
         }
         boundComponents(components, budget);
+        // Times are read as a feed's are, so a stored series occupies what the feed reports: zones it
+        // names without defining them, floating times in the calendar's zone, all-day EXDATEs as days.
+        frameEventTimes(root, components, defaultTimezone, budget);
         const masters = new Map();
         const exceptionsByUid = new Map();
         for (const event of feedEvents(components, budget)) {
@@ -1867,7 +2347,8 @@ export function parseTrustedICalendarEvents(input, calendarTimezone) {
         return trusted;
     }
     catch (error) {
-        if (error instanceof CalendarContractError)
+        // An event the calendar gives no length or no UID is the calendar's fault, as in a feed.
+        if (error instanceof CalendarContractError && error.code === 'invalid_icalendar')
             throw error;
         throw new CalendarContractError('invalid_icalendar');
     }