@forcecalendar/core 2.5.0 → 2.5.1

package/core/events/RRuleParser.js

@@ -216,10 +216,26 @@ export class RRuleParser {
   }
 
   /**
-   * Validate and normalize rule
+   * Validate and normalize a rule.
+   *
+   * Works on a copy: rule objects handed in are typically the stored
+   * recurrenceRule of an Event, and normalising them in place would make
+   * the stored event differ from the data it was created from (a spurious
+   * update on the next reconcile) and let the engines' per-rule caches leak
+   * into it. The copy is shallow except for the array fields, which are
+   * copied as well.
+   * @param {Object} rule - Rule object (not modified)
+   * @returns {Object} Normalised copy
    * @private
    */
   static validateRule(rule) {
+    rule = { ...rule };
+    for (const field of ['byDay', 'bySetPos', 'exceptions']) {
+      if (Array.isArray(rule[field])) {
+        rule[field] = [...rule[field]];
+      }
+    }
+
     // Ensure frequency is set
     if (!rule.freq) {
       rule.freq = 'DAILY';
@@ -230,8 +246,8 @@ export class RRuleParser {
       throw new Error('RRULE cannot have both COUNT and UNTIL');
     }
 
-    // Validate interval
-    if (rule.interval < 1) {
+    // Validate interval (RFC 5545 default is 1; rule objects may omit it)
+    if (!Number.isInteger(rule.interval) || rule.interval < 1) {
       rule.interval = 1;
     }
 

package/core/events/RecurrenceEngine.js

@@ -4,6 +4,11 @@ import { RRuleParser } from './RRuleParser.js';
 
 const DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
 
+// Timezone databases know only local mean time before the 19th century, so
+// a span that ends before this instant is checked at its ends rather than
+// probed week by week
+const PRE_TZDATA_FLOOR_MS = Date.UTC(1800, 0, 1);
+
 /**
  * RecurrenceEngine - Handles expansion of recurring events
  * Full support for RFC 5545 (iCalendar) RRULE specification
@@ -196,12 +201,12 @@ export class RecurrenceEngine {
    * const nextFive = RecurrenceEngine.takeOccurrences(event, 5, { after: new Date() });
    *
    * @param {import('./Event.js').Event} event - The event to query
-   * @param {number} count - Maximum number of occurrences to return
+   * @param {number} count - Maximum number of occurrences to return (fractions are floored)
    * @param {import('../types.js').OccurrenceIteratorOptions} [options={}] - Window and timezone
    * @returns {import('../types.js').EventOccurrence[]} Up to `count` occurrences in chronological order
    */
   static takeOccurrences(event, count, options = {}) {
-    const limit = Math.min(count, RecurrenceEngine.MAX_OCCURRENCES_HARD_LIMIT);
+    const limit = Math.floor(Math.min(count, RecurrenceEngine.MAX_OCCURRENCES_HARD_LIMIT));
     const taken = [];
     if (!(limit > 0)) {
       return taken;
@@ -822,7 +827,9 @@ export class RecurrenceEngine {
 
   /**
    * Find the next system-timezone offset transition after fromMs.
-   * Cached module-wide: the system timezone is fixed for the process.
+   * Cached module-wide: the system timezone is fixed for the process. The
+   * cache grows incrementally, so extending coverage (a view navigating
+   * forward, a series with a far-past DTSTART) scans only the new span.
    * @param {number} fromMs - Search from this timestamp (exclusive)
    * @param {number} toMs - Extend cache coverage at least this far
    * @returns {number} Transition timestamp, or Infinity if none within coverage
@@ -833,18 +840,34 @@ export class RecurrenceEngine {
       return Infinity;
     }
     let cache = this._systemTransitions;
-    if (!cache || fromMs < cache.from || toMs > cache.to) {
-      const from = Math.min(fromMs, cache ? cache.from : fromMs);
-      const to = Math.max(toMs, cache ? cache.to : toMs);
-      cache = { from, to, transitions: this._scanSystemTransitions(from, to) };
+    if (!cache) {
+      cache = { from: fromMs, to: toMs, transitions: this._scanSystemTransitions(fromMs, toMs) };
       this._systemTransitions = cache;
+    } else {
+      if (fromMs < cache.from) {
+        cache.transitions = this._scanSystemTransitions(fromMs, cache.from).concat(
+          cache.transitions
+        );
+        cache.from = fromMs;
+      }
+      if (toMs > cache.to) {
+        cache.transitions = cache.transitions.concat(this._scanSystemTransitions(cache.to, toMs));
+        cache.to = toMs;
+      }
     }
-    for (const t of cache.transitions) {
-      if (t > fromMs) {
-        return t;
+    // First transition after fromMs; the list is sorted
+    const transitions = cache.transitions;
+    let lo = 0;
+    let hi = transitions.length;
+    while (lo < hi) {
+      const mid = (lo + hi) >>> 1;
+      if (transitions[mid] > fromMs) {
+        hi = mid;
+      } else {
+        lo = mid + 1;
       }
     }
-    return Infinity;
+    return lo < transitions.length ? transitions[lo] : Infinity;
   }
 
   /**
@@ -858,6 +881,12 @@ export class RecurrenceEngine {
     const transitions = [];
     let lo = fromMs;
     let loOffset = new Date(lo).getTimezoneOffset();
+    // The pre-tzdata era has a single offset (local mean time) and is
+    // skipped in one step; probing it week by week could take minutes
+    if (lo < PRE_TZDATA_FLOOR_MS) {
+      lo = Math.min(toMs, PRE_TZDATA_FLOOR_MS);
+      loOffset = new Date(lo).getTimezoneOffset();
+    }
     while (lo < toMs) {
       const hi = Math.min(lo + WEEK, toMs);
       const hiOffset = new Date(hi).getTimezoneOffset();
@@ -918,8 +947,14 @@ export class RecurrenceEngine {
     switch (rule.freq) {
       case 'YEARLY':
         return occurrence.start.getFullYear();
-      case 'WEEKLY':
-        return `${occurrence.start.getFullYear()}-W${DateUtils.getWeekNumber(occurrence.start)}`;
+      case 'WEEKLY': {
+        // ISO week-year: the week's Thursday decides the year, so the days
+        // of a week that straddles New Year share one period key
+        const thursday = new Date(occurrence.start);
+        thursday.setHours(0, 0, 0, 0);
+        thursday.setDate(thursday.getDate() + 4 - (thursday.getDay() || 7));
+        return `${thursday.getFullYear()}-W${DateUtils.getWeekNumber(occurrence.start)}`;
+      }
       default:
         return `${occurrence.start.getFullYear()}-${occurrence.start.getMonth()}`;
     }
@@ -1037,11 +1072,21 @@ export class RecurrenceEngine {
       case 'MONTHLY':
         if (rule.byMonthDay && rule.byMonthDay.length > 0) {
           // Specific day(s) of month
-          const currentMonth = next.getMonth();
-          next.setMonth(currentMonth + rule.interval);
-          // Clamp to last day of month if day doesn't exist
-          const daysInMonth = this._daysInMonth(next.getFullYear(), next.getMonth());
-          next.setDate(Math.min(rule.byMonthDay[0], daysInMonth));
+          const monthDay = rule.byMonthDay[0];
+          if (monthDay < 0) {
+            // Counted from the end of the month (-1 is the last day). Move
+            // to the first so the month step cannot overflow from a 31st.
+            next.setDate(1);
+            next.setMonth(next.getMonth() + rule.interval);
+            const daysInMonth = this._daysInMonth(next.getFullYear(), next.getMonth());
+            next.setDate(Math.max(1, daysInMonth + monthDay + 1));
+          } else {
+            const currentMonth = next.getMonth();
+            next.setMonth(currentMonth + rule.interval);
+            // Clamp to last day of month if day doesn't exist
+            const daysInMonth = this._daysInMonth(next.getFullYear(), next.getMonth());
+            next.setDate(Math.min(monthDay, daysInMonth));
+          }
         } else if (rule.byDay && rule.byDay.length > 0) {
           // Specific weekday of month (e.g., "2nd Tuesday")
           next.setMonth(next.getMonth() + rule.interval);

package/core/events/RecurrenceEngineV2.js

@@ -12,6 +12,21 @@ const DAY = 86400000;
 // How far ahead of the iteration cursor DST transitions are scanned at a time
 const DST_SCAN_CHUNK = 100 * DAY;
 
+const WEEKDAYS = { SU: 0, MO: 1, TU: 2, WE: 3, TH: 4, FR: 5, SA: 6 };
+
+// An expansion cut short by MAX_ITERATIONS_HARD_LIMIT is reported once per
+// process rather than on every render
+let iterationLimitWarned = false;
+function warnIterationLimit(eventId) {
+  if (iterationLimitWarned) {
+    return;
+  }
+  iterationLimitWarned = true;
+  console.warn(
+    `RecurrenceEngineV2: expansion of event ${eventId} stopped after ${RecurrenceEngineV2.MAX_ITERATIONS_HARD_LIMIT} steps without reaching the end of the range; results are truncated`
+  );
+}
+
 export class RecurrenceEngineV2 {
   // Hard limit to prevent resource exhaustion regardless of caller input
   static MAX_OCCURRENCES_HARD_LIMIT = 10000;
@@ -39,10 +54,15 @@ export class RecurrenceEngineV2 {
   /**
    * Expand recurring event with advanced handling
    *
-   * Occurrences before rangeStart are skipped without being generated:
-   * daily, weekly, hourly and minutely rules seek straight to the range, so
-   * a series that started years before the queried window is expanded at
-   * the same cost as one that started yesterday.
+   * Occurrences before rangeStart are skipped without being generated for
+   * the rules seekToRange can seek: DAILY (without BYHOUR), WEEKLY (with or
+   * without BYDAY), HOURLY and MINUTELY. Such a series that started years
+   * before the queried window is expanded at the same cost as one that
+   * started yesterday. MONTHLY and YEARLY rules, and DAILY with BYHOUR,
+   * are stepped from DTSTART; they take few enough steps per year that
+   * this is cheap, but an expansion that would need more than
+   * MAX_ITERATIONS_HARD_LIMIT steps is truncated (with one console.warn
+   * per process).
    *
    * @param {import('./Event.js').Event} event - Recurring event
    * @param {Date} rangeStart - Start of expansion range
@@ -69,7 +89,7 @@ export class RecurrenceEngineV2 {
     const maxOccurrences = Math.min(requestedMax, RecurrenceEngineV2.MAX_OCCURRENCES_HARD_LIMIT);
 
     // Check cache
-    const cacheKey = this.getCacheKey(event.id, rangeStart, rangeEnd, options);
+    const cacheKey = this.getCacheKey(event, rangeStart, rangeEnd, options);
     if (this.occurrenceCache.has(cacheKey)) {
       return this.cloneOccurrences(this.occurrenceCache.get(cacheKey));
     }
@@ -145,6 +165,14 @@ export class RecurrenceEngineV2 {
       }
     }
 
+    if (
+      iterations >= RecurrenceEngineV2.MAX_ITERATIONS_HARD_LIMIT &&
+      state.currentDate <= rangeEnd &&
+      occurrences.length < maxOccurrences
+    ) {
+      warnIterationLimit(event.id);
+    }
+
     // Cache results
     this.cacheOccurrences(cacheKey, occurrences);
 
@@ -158,7 +186,7 @@ export class RecurrenceEngineV2 {
    * time and without the expansion cache: stored instance modifications
    * and exceptions are applied as each occurrence is produced, so changes
    * made through addModifiedInstance or addException are visible on the
-   * next pull. Rules seekToRange can seek (plain daily and weekly, hourly,
+   * next pull. Rules seekToRange can seek (daily, weekly, hourly,
    * minutely) jump straight to `after`, and DST transitions are scanned
    * lazily ahead of the cursor instead of for the whole window up front.
    *
@@ -234,12 +262,12 @@ export class RecurrenceEngineV2 {
    * const nextFive = engine.takeOccurrences(event, 5, { after: new Date() });
    *
    * @param {import('./Event.js').Event} event - The event to query
-   * @param {number} count - Maximum number of occurrences to return
+   * @param {number} count - Maximum number of occurrences to return (fractions are floored)
    * @param {import('../types.js').ExpandedOccurrenceIteratorOptions} [options={}] - Window and expansion options
    * @returns {import('../types.js').ExpandedOccurrence[]} Up to `count` occurrences in chronological order
    */
   takeOccurrences(event, count, options = {}) {
-    const limit = Math.min(count, RecurrenceEngineV2.MAX_OCCURRENCES_HARD_LIMIT);
+    const limit = Math.floor(Math.min(count, RecurrenceEngineV2.MAX_OCCURRENCES_HARD_LIMIT));
     const taken = [];
     if (!(limit > 0)) {
       return taken;
@@ -350,6 +378,7 @@ export class RecurrenceEngineV2 {
       }
       idleSteps++;
       if (idleSteps >= RecurrenceEngineV2.MAX_ITERATIONS_HARD_LIMIT) {
+        warnIterationLimit(event.id);
         return;
       }
     }
@@ -392,8 +421,9 @@ export class RecurrenceEngineV2 {
    * without stepping through every occurrence in between.
    *
    * Applies to rules whose step is a fixed duration between system-timezone
-   * transitions (plain DAILY and WEEKLY, HOURLY, MINUTELY); the step that
-   * crosses a transition is taken with getNextDate so the result is exactly
+   * transitions (plain DAILY and WEEKLY, HOURLY, MINUTELY) and to WEEKLY
+   * rules with BYDAY, whose steps repeat in a weekly cycle; the steps that
+   * cross a transition are taken with getNextDate so the result is exactly
    * what stepping from DTSTART would produce. Never seeks past UNTIL, and
    * counts skipped steps against COUNT.
    *
@@ -404,6 +434,10 @@ export class RecurrenceEngineV2 {
    * @param {string} timezone - Expansion timezone
    */
   seekToRange(state, rule, rangeStart, rangeEnd, timezone) {
+    if (rule.freq === 'WEEKLY' && rule.byDay && rule.byDay.length > 0) {
+      this._seekWeekCycle(state, rule, rangeStart, rangeEnd, timezone);
+      return;
+    }
     const stepMs = this.getFixedStepMs(rule);
     if (stepMs <= 0) {
       return;
@@ -433,6 +467,127 @@ export class RecurrenceEngineV2 {
     state.count = seek.steps;
   }
 
+  /**
+   * Seek for WEEKLY rules with BYDAY. getNextWeekly picks the next weekday
+   * from the BYDAY list (in list order), so the step from each weekday is
+   * fixed and the walk from DTSTART settles into a cycle of weekdays that
+   * repeats every whole number of weeks. The cursor is stepped one
+   * occurrence at a time until it is on that cycle (at most six steps),
+   * then whole cycles are skipped arithmetically between system-timezone
+   * transitions, exactly as seekToRange does for fixed steps.
+   * @param {Object} state - Expansion state (currentDate and count are updated)
+   * @param {Object} rule - Parsed recurrence rule
+   * @param {Date} rangeStart - Start of expansion range
+   * @param {Date} rangeEnd - End of expansion range
+   * @param {string} timezone - Expansion timezone
+   * @private
+   */
+  _seekWeekCycle(state, rule, rangeStart, rangeEnd, timezone) {
+    const deltas = this._weekdayDeltas(rule);
+    if (!deltas) {
+      return;
+    }
+    let targetMs = rangeStart.getTime();
+    if (rule.until) {
+      const untilMs = new Date(rule.until).getTime();
+      if (untilMs < targetMs) {
+        targetMs = untilMs;
+      }
+    }
+    if (!(state.currentDate.getTime() < targetMs)) {
+      return;
+    }
+    const maxSteps = rule.count ? rule.count - 1 : Infinity;
+
+    // Follow the weekday graph from the cursor until a weekday repeats:
+    // the steps before the repeat lead in to the cycle
+    const path = [];
+    const seen = new Map();
+    let weekday = state.currentDate.getDay();
+    while (!seen.has(weekday)) {
+      seen.set(weekday, path.length);
+      path.push(weekday);
+      weekday = (weekday + deltas[weekday]) % 7;
+    }
+    const leadIn = seen.get(weekday);
+    const cycleSteps = path.length - leadIn;
+    let cycleDays = 0;
+    for (let i = leadIn; i < path.length; i++) {
+      cycleDays += deltas[path[i]];
+    }
+
+    // Lead-in: single steps, identical to the expansion loop's
+    for (let i = 0; i < leadIn; i++) {
+      if (state.count >= maxSteps) {
+        return;
+      }
+      const next = this.getNextDate(state.currentDate, rule, timezone, state);
+      if (!(next.getTime() < targetMs)) {
+        return; // the next step lands in the range; the loop takes it
+      }
+      state.currentDate = next;
+      state.count++;
+    }
+
+    const seek = RecurrenceEngine._seekFixedStep(
+      state.currentDate.getTime(),
+      targetMs,
+      rangeEnd.getTime(),
+      cycleDays * DAY,
+      Math.floor((maxSteps - state.count) / cycleSteps),
+      cursor => {
+        for (let i = 0; i < cycleSteps; i++) {
+          cursor.setTime(this.getNextDate(cursor, rule, timezone, state).getTime());
+        }
+      }
+    );
+    state.currentDate = new Date(seek.ms);
+    state.count += seek.steps * cycleSteps;
+  }
+
+  /**
+   * Days getNextWeekly adds from each weekday (index 0-6) for a WEEKLY
+   * rule with BYDAY, or null when the rule cannot be seeked (an invalid
+   * interval or day code, which the expansion loop handles as before)
+   * @param {Object} rule - Parsed recurrence rule
+   * @returns {number[]|null} Delta table indexed by Date#getDay()
+   * @private
+   */
+  _weekdayDeltas(rule) {
+    const interval = rule.interval;
+    if (!Number.isInteger(interval) || interval <= 0) {
+      return null;
+    }
+    const targets = this._weekdayTargets(rule);
+    if (targets.some(target => target === undefined)) {
+      return null;
+    }
+    const deltas = [];
+    for (let weekday = 0; weekday < 7; weekday++) {
+      const next = targets.find(target => target > weekday);
+      deltas[weekday] =
+        next !== undefined ? next - weekday : 7 - weekday + targets[0] + 7 * (interval - 1);
+    }
+    return deltas;
+  }
+
+  /**
+   * Weekday numbers (Date#getDay) of a rule's BYDAY entries in ascending
+   * order, computed once per parsed rule. Invalid day codes map to
+   * undefined and sort last.
+   * @param {Object} rule - Parsed recurrence rule with byDay
+   * @returns {number[]} Sorted weekday numbers
+   * @private
+   */
+  _weekdayTargets(rule) {
+    if (!rule._weekdayTargets) {
+      rule._weekdayTargets = rule.byDay
+        .map(byDay => WEEKDAYS[byDay.weekday || byDay])
+        .sort((a, b) => (a === undefined) - (b === undefined) || a - b);
+    }
+    return rule._weekdayTargets;
+  }
+
   /**
    * Milliseconds per step for rules getNextDate advances by a fixed
    * duration while the system UTC offset is constant
@@ -556,33 +711,16 @@ export class RecurrenceEngineV2 {
     const next = new Date(date);
 
     if (rule.byDay && rule.byDay.length > 0) {
-      // Find next matching weekday
-      const dayMap = {
-        SU: 0,
-        MO: 1,
-        TU: 2,
-        WE: 3,
-        TH: 4,
-        FR: 5,
-        SA: 6
-      };
-
+      // BYDAY is a set: the next weekday in it after the current one, or the
+      // earliest one INTERVAL weeks on when the week has none left
+      const targets = this._weekdayTargets(rule);
       const currentDay = next.getDay();
-      let daysToAdd = null;
-
-      // Find next occurrence day
-      for (const byDay of rule.byDay) {
-        const targetDay = dayMap[byDay.weekday || byDay];
-        if (targetDay > currentDay) {
-          daysToAdd = targetDay - currentDay;
-          break;
-        }
-      }
-
-      // If no day found in current week, go to next week
-      if (daysToAdd === null) {
-        const firstDay = dayMap[rule.byDay[0].weekday || rule.byDay[0]];
-        daysToAdd = 7 - currentDay + firstDay;
+      const nextDay = targets.find(target => target > currentDay);
+      let daysToAdd;
+      if (nextDay !== undefined) {
+        daysToAdd = nextDay - currentDay;
+      } else {
+        daysToAdd = 7 - currentDay + targets[0];
 
         // Apply interval for weekly recurrence
         if (rule.interval > 1) {
@@ -615,15 +753,17 @@ export class RecurrenceEngineV2 {
         // Found a day in current month
         next.setDate(targetDay);
       } else {
-        // Move to next month
-        next.setMonth(next.getMonth() + rule.interval);
-
-        // Handle negative days (from end of month)
         targetDay = targetDays[0];
         if (targetDay < 0) {
+          // Counted from the end of the month (-1 is the last day). Move to
+          // the first so the month step cannot overflow from a 31st.
+          next.setDate(1);
+          next.setMonth(next.getMonth() + rule.interval);
           const lastDay = new Date(next.getFullYear(), next.getMonth() + 1, 0).getDate();
-          next.setDate(lastDay + targetDay + 1);
+          next.setDate(Math.max(1, lastDay + targetDay + 1));
         } else {
+          // Move to next month
+          next.setMonth(next.getMonth() + rule.interval);
           next.setDate(targetDay);
         }
       }
@@ -944,9 +1084,45 @@ export class RecurrenceEngineV2 {
 
   /**
    * Create cache key
+   *
+   * When given the event itself the key also covers everything the
+   * expansion depends on (DTSTART, end, recurrence rule), so a series that
+   * is updated, replaced or re-added under the same id can never be served
+   * a stale expansion. Keys always start with `<eventId>_`, which is what
+   * {@link RecurrenceEngineV2#clearEventCache} matches on.
+   * @param {import('./Event.js').Event|string} event - Recurring event, or just its id
+   * @param {Date} start - Start of expansion range
+   * @param {Date} end - End of expansion range
+   * @param {Object} options - Expansion options
+   * @returns {string} Cache key
+   */
+  getCacheKey(event, start, end, options) {
+    const eventId = typeof event === 'string' ? event : event.id;
+    const key = `${eventId}_${start.getTime()}_${end.getTime()}_${JSON.stringify(options)}`;
+    if (typeof event === 'string') {
+      return key;
+    }
+    const startMs = new Date(event.start).getTime();
+    const endMs = new Date(event.end).getTime();
+    return `${key}|${startMs}|${endMs}|${this._ruleFingerprint(event.recurrenceRule)}`;
+  }
+
+  /**
+   * Stable text form of a recurrence rule for cache keys. A rule that
+   * cannot be serialised gets a unique fingerprint, i.e. is never cached.
+   * @param {string|Object} rule - RRULE string or rule object
+   * @returns {string} Fingerprint
+   * @private
    */
-  getCacheKey(eventId, start, end, options) {
-    return `${eventId}_${start.getTime()}_${end.getTime()}_${JSON.stringify(options)}`;
+  _ruleFingerprint(rule) {
+    if (typeof rule === 'string') {
+      return rule;
+    }
+    try {
+      return JSON.stringify(rule);
+    } catch {
+      return `uncacheable:${Date.now()}:${Math.random()}`;
+    }
   }
 
   /**

package/core/index.js

@@ -32,7 +32,7 @@ export { ConflictDetector } from './conflicts/ConflictDetector.js';
 export { EnhancedCalendar } from './integration/EnhancedCalendar.js';
 
 // Version — keep in sync with package.json
-export const VERSION = '2.5.0';
+export const VERSION = '2.5.1';
 
 // Default export
 export { Calendar as default } from './calendar/Calendar.js';

package/core/integration/EnhancedCalendar.js

@@ -24,6 +24,40 @@ export class EnhancedCalendar extends Calendar {
 
     // Setup event listeners for real-time indexing
     this.setupRealtimeIndexing();
+
+    // The enhanced engine keeps its own expansion cache, so drop the entries
+    // of every series the store changes
+    this._unsubscribeCacheInvalidation = this.eventStore.subscribe(change =>
+      this._invalidateOccurrenceCache(change)
+    );
+  }
+
+  /**
+   * Invalidate the enhanced engine's cached expansions for a store change
+   * @param {import('../types.js').EventStoreChange} change - Store change
+   * @private
+   */
+  _invalidateOccurrenceCache(change) {
+    const engine = this.recurrenceEngine;
+    if (!engine || !change) {
+      return;
+    }
+    switch (change.type) {
+      case 'add':
+      case 'update':
+      case 'remove':
+        if (change.event) {
+          engine.clearEventCache(change.event.id);
+        }
+        break;
+      case 'batch':
+        for (const entry of change.changes || []) {
+          this._invalidateOccurrenceCache(entry);
+        }
+        break;
+      default:
+        engine.occurrenceCache.clear();
+    }
   }
 
   /**
@@ -440,6 +474,10 @@ export class EnhancedCalendar extends Calendar {
       this._clearReindexTimeout();
       this._clearReindexTimeout = null;
     }
+    if (typeof this._unsubscribeCacheInvalidation === 'function') {
+      this._unsubscribeCacheInvalidation();
+      this._unsubscribeCacheInvalidation = null;
+    }
 
     // Clean up worker
     if (this.searchManager) {

package/core/timezone/TimezoneManager.js

@@ -10,6 +10,11 @@ import { TimezoneDatabase } from './TimezoneDatabase.js';
 // Singleton instance for shared use across the application
 let sharedInstance = null;
 
+// Timezone databases know only local mean time before the 19th century, so
+// transition scans check a span that ends before this instant at its ends
+// rather than probing it week by week
+const PRE_TZDATA_FLOOR_MS = Date.UTC(1800, 0, 1);
+
 export class TimezoneManager {
   /**
    * Get the shared singleton instance of TimezoneManager
@@ -215,19 +220,43 @@ export class TimezoneManager {
     }
     timezone = this.database.resolveAlias(timezone);
     let cached = this.transitionCache.get(timezone);
-    if (!cached || fromMs < cached.from || toMs > cached.to) {
-      // Extend coverage generously so repeated expansions over the same
-      // span hit the cache
-      const from = Math.min(fromMs, cached ? cached.from : fromMs);
-      const to = Math.max(toMs, cached ? cached.to : toMs);
-      cached = { from, to, transitions: this._scanTransitions(timezone, from, to) };
+    if (!cached) {
+      cached = {
+        from: fromMs,
+        to: toMs,
+        transitions: this._scanTransitions(timezone, fromMs, toMs)
+      };
       this.transitionCache.set(timezone, cached);
+    } else {
+      // Extend coverage incrementally so only the uncovered span is scanned
+      if (fromMs < cached.from) {
+        cached.transitions = this._scanTransitions(timezone, fromMs, cached.from).concat(
+          cached.transitions
+        );
+        cached.from = fromMs;
+      }
+      if (toMs > cached.to) {
+        cached.transitions = cached.transitions.concat(
+          this._scanTransitions(timezone, cached.to, toMs)
+        );
+        cached.to = toMs;
+      }
     }
-    for (const t of cached.transitions) {
-      if (t > fromMs) {
-        return t <= toMs ? t : Infinity;
+    // First transition after fromMs; the list is sorted
+    const transitions = cached.transitions;
+    let lo = 0;
+    let hi = transitions.length;
+    while (lo < hi) {
+      const mid = (lo + hi) >>> 1;
+      if (transitions[mid] > fromMs) {
+        hi = mid;
+      } else {
+        lo = mid + 1;
       }
     }
+    if (lo < transitions.length && transitions[lo] <= toMs) {
+      return transitions[lo];
+    }
     return Infinity;
   }
 
@@ -247,6 +276,13 @@ export class TimezoneManager {
     const offsetAt = ms => this.getTimezoneOffset(new Date(ms), timezone);
     let lo = fromMs;
     let loOffset = offsetAt(lo);
+    // Timezone databases know only local mean time before the 19th century:
+    // that era has a single offset and is skipped in one step (probing it
+    // week by week could take minutes for a very old DTSTART)
+    if (lo < PRE_TZDATA_FLOOR_MS) {
+      lo = Math.min(toMs, PRE_TZDATA_FLOOR_MS);
+      loOffset = offsetAt(lo);
+    }
     while (lo < toMs) {
       const hi = Math.min(lo + WEEK, toMs);
       const hiOffset = offsetAt(hi);