@super-calendar/core 2.3.1 → 2.4.0

package/dist/index.d.mts

@@ -1,6 +1,5 @@
 import { Locale } from "date-fns";
 import { Dispatch, SetStateAction } from "react";
-
 //#region src/types.d.ts
 /** The view the calendar renders: a day-column grid (`day`, `3days`, `week`, `custom`), the `month` grid, or the `schedule` list. */
 type CalendarMode = "day" | "3days" | "week" | "custom" | "month" | "schedule";
@@ -300,10 +299,7 @@ declare const getViewDays: (mode: CalendarMode, date: Date, weekStartsOn: WeekSt
  * `weekStartsOn`. `showSixWeeks` always returns six rows (42 days) for a
  * fixed-height grid; `isRTL` reverses each week's day order.
  */
-declare const buildMonthWeeks: (month: Date, weekStartsOn: WeekStartsOn, {
-  showSixWeeks,
-  isRTL
-}?: {
+declare const buildMonthWeeks: (month: Date, weekStartsOn: WeekStartsOn, { showSixWeeks, isRTL }?: {
   showSixWeeks?: boolean;
   isRTL?: boolean;
 }) => Date[][];
@@ -328,10 +324,11 @@ declare function shiftMinutes(date: Date, minutes: number): Date;
 /**
  * Resolve a committed drag into the event's new bounds: `start` shifts by
  * `deltaStartMinutes`, `end` by `deltaEndMinutes` (a move passes the same delta
- * to both; a resize passes 0 for the start). Returns `null` when the change
- * would collapse the event below one `snapMinutes` step, so the gesture leaves
- * the event untouched rather than committing a degenerate duration. Pure, so the
- * commit path is unit-testable without a running gesture.
+ * to both; a resize passes 0 for the start). Returns `null` only when the change
+ * would *shrink* the event below one `snapMinutes` step, so a resize can't commit
+ * a degenerate duration; a pure move (both deltas equal) keeps its duration and is
+ * never rejected, even for an already sub-step event. Pure, so the commit path is
+ * unit-testable without a running gesture.
  */
 declare function resolveDraggedBounds(start: Date, end: Date, deltaStartMinutes: number, deltaEndMinutes: number, snapMinutes: number): {
   start: Date;
@@ -367,7 +364,8 @@ declare function eventAccessibilityLabel(args: {
   isAllDay: boolean;
   start: Date;
   end: Date;
-  ampm: boolean; /** Spoken text for an all-day event. Default "all day". */
+  ampm: boolean;
+  /** Spoken text for an all-day event. Default "all day". */
   allDayLabel?: string;
 }): string;
 /**
@@ -408,7 +406,8 @@ declare function eventTimeLabel(args: {
   start: Date;
   end: Date;
   ampm: boolean;
-  showTime: boolean; /** Text for an all-day event in the schedule. Default "All day". */
+  showTime: boolean;
+  /** Text for an all-day event in the schedule. Default "All day". */
   allDayLabel?: string;
 }): string | null;
 /**
@@ -434,7 +433,8 @@ type EventChipLayout = {
    * Max whole title lines that fit in the box. `0` means "no clamp" (the box
    * height is unknown, e.g. the schedule), so the title may wrap freely.
    */
-  titleMaxLines: number; /** Whether the secondary time line still has room below the title. */
+  titleMaxLines: number;
+  /** Whether the secondary time line still has room below the title. */
   showTime: boolean;
 };
 /**
@@ -460,7 +460,9 @@ declare function eventChipLayout(args: {
 }): EventChipLayout;
 /** How many month-cell chips fit in the available height. */
 type MonthEventCapacity = {
-  /** Count when every event fits, with no overflow label. */full: number; /** Count that leaves room for the "+N more" label. */
+  /** Count when every event fits, with no overflow label. */
+  full: number;
+  /** Count that leaves room for the "+N more" label. */
   withMore: number;
 };
 /**
@@ -519,11 +521,17 @@ declare function toICalendar(events: ICalEvent[], options?: ToICalendarOptions):
 //#region src/utils/layout.d.ts
 /** An event placed on a single day's time grid by {@link layoutDayEvents}, with its vertical span and overlap column. */
 type PositionedEvent<T> = {
-  /** The source event for this segment. */event: CalendarEvent<T>; /** Hours from midnight to the event's segment start on this day (fractional). */
-  startHours: number; /** Segment duration in hours on this day (clamped to a small minimum). */
-  durationHours: number; /** Zero-based column index within its overlap cluster. */
-  column: number; /** Total columns in this event's overlap cluster. */
-  columns: number; /** True when the segment is clipped because the event continues before/after this day. */
+  /** The source event for this segment. */
+  event: CalendarEvent<T>;
+  /** Hours from midnight to the event's segment start on this day (fractional). */
+  startHours: number;
+  /** Segment duration in hours on this day (clamped to a small minimum). */
+  durationHours: number;
+  /** Zero-based column index within its overlap cluster. */
+  column: number;
+  /** Total columns in this event's overlap cluster. */
+  columns: number;
+  /** True when the segment is clipped because the event continues before/after this day. */
   continuesBefore: boolean;
   continuesAfter: boolean;
 };

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 import { Dispatch, SetStateAction } from "react";
 import { Locale } from "date-fns";
-
 //#region src/types.d.ts
 /** The view the calendar renders: a day-column grid (`day`, `3days`, `week`, `custom`), the `month` grid, or the `schedule` list. */
 type CalendarMode = "day" | "3days" | "week" | "custom" | "month" | "schedule";
@@ -300,10 +299,7 @@ declare const getViewDays: (mode: CalendarMode, date: Date, weekStartsOn: WeekSt
  * `weekStartsOn`. `showSixWeeks` always returns six rows (42 days) for a
  * fixed-height grid; `isRTL` reverses each week's day order.
  */
-declare const buildMonthWeeks: (month: Date, weekStartsOn: WeekStartsOn, {
-  showSixWeeks,
-  isRTL
-}?: {
+declare const buildMonthWeeks: (month: Date, weekStartsOn: WeekStartsOn, { showSixWeeks, isRTL }?: {
   showSixWeeks?: boolean;
   isRTL?: boolean;
 }) => Date[][];
@@ -328,10 +324,11 @@ declare function shiftMinutes(date: Date, minutes: number): Date;
 /**
  * Resolve a committed drag into the event's new bounds: `start` shifts by
  * `deltaStartMinutes`, `end` by `deltaEndMinutes` (a move passes the same delta
- * to both; a resize passes 0 for the start). Returns `null` when the change
- * would collapse the event below one `snapMinutes` step, so the gesture leaves
- * the event untouched rather than committing a degenerate duration. Pure, so the
- * commit path is unit-testable without a running gesture.
+ * to both; a resize passes 0 for the start). Returns `null` only when the change
+ * would *shrink* the event below one `snapMinutes` step, so a resize can't commit
+ * a degenerate duration; a pure move (both deltas equal) keeps its duration and is
+ * never rejected, even for an already sub-step event. Pure, so the commit path is
+ * unit-testable without a running gesture.
  */
 declare function resolveDraggedBounds(start: Date, end: Date, deltaStartMinutes: number, deltaEndMinutes: number, snapMinutes: number): {
   start: Date;
@@ -367,7 +364,8 @@ declare function eventAccessibilityLabel(args: {
   isAllDay: boolean;
   start: Date;
   end: Date;
-  ampm: boolean; /** Spoken text for an all-day event. Default "all day". */
+  ampm: boolean;
+  /** Spoken text for an all-day event. Default "all day". */
   allDayLabel?: string;
 }): string;
 /**
@@ -408,7 +406,8 @@ declare function eventTimeLabel(args: {
   start: Date;
   end: Date;
   ampm: boolean;
-  showTime: boolean; /** Text for an all-day event in the schedule. Default "All day". */
+  showTime: boolean;
+  /** Text for an all-day event in the schedule. Default "All day". */
   allDayLabel?: string;
 }): string | null;
 /**
@@ -434,7 +433,8 @@ type EventChipLayout = {
    * Max whole title lines that fit in the box. `0` means "no clamp" (the box
    * height is unknown, e.g. the schedule), so the title may wrap freely.
    */
-  titleMaxLines: number; /** Whether the secondary time line still has room below the title. */
+  titleMaxLines: number;
+  /** Whether the secondary time line still has room below the title. */
   showTime: boolean;
 };
 /**
@@ -460,7 +460,9 @@ declare function eventChipLayout(args: {
 }): EventChipLayout;
 /** How many month-cell chips fit in the available height. */
 type MonthEventCapacity = {
-  /** Count when every event fits, with no overflow label. */full: number; /** Count that leaves room for the "+N more" label. */
+  /** Count when every event fits, with no overflow label. */
+  full: number;
+  /** Count that leaves room for the "+N more" label. */
   withMore: number;
 };
 /**
@@ -519,11 +521,17 @@ declare function toICalendar(events: ICalEvent[], options?: ToICalendarOptions):
 //#region src/utils/layout.d.ts
 /** An event placed on a single day's time grid by {@link layoutDayEvents}, with its vertical span and overlap column. */
 type PositionedEvent<T> = {
-  /** The source event for this segment. */event: CalendarEvent<T>; /** Hours from midnight to the event's segment start on this day (fractional). */
-  startHours: number; /** Segment duration in hours on this day (clamped to a small minimum). */
-  durationHours: number; /** Zero-based column index within its overlap cluster. */
-  column: number; /** Total columns in this event's overlap cluster. */
-  columns: number; /** True when the segment is clipped because the event continues before/after this day. */
+  /** The source event for this segment. */
+  event: CalendarEvent<T>;
+  /** Hours from midnight to the event's segment start on this day (fractional). */
+  startHours: number;
+  /** Segment duration in hours on this day (clamped to a small minimum). */
+  durationHours: number;
+  /** Zero-based column index within its overlap cluster. */
+  column: number;
+  /** Total columns in this event's overlap cluster. */
+  columns: number;
+  /** True when the segment is clipped because the event continues before/after this day. */
   continuesBefore: boolean;
   continuesAfter: boolean;
 };

package/dist/index.js

@@ -278,15 +278,18 @@ function shiftMinutes(date, minutes) {
 /**
 * Resolve a committed drag into the event's new bounds: `start` shifts by
 * `deltaStartMinutes`, `end` by `deltaEndMinutes` (a move passes the same delta
-* to both; a resize passes 0 for the start). Returns `null` when the change
-* would collapse the event below one `snapMinutes` step, so the gesture leaves
-* the event untouched rather than committing a degenerate duration. Pure, so the
-* commit path is unit-testable without a running gesture.
+* to both; a resize passes 0 for the start). Returns `null` only when the change
+* would *shrink* the event below one `snapMinutes` step, so a resize can't commit
+* a degenerate duration; a pure move (both deltas equal) keeps its duration and is
+* never rejected, even for an already sub-step event. Pure, so the commit path is
+* unit-testable without a running gesture.
 */
 function resolveDraggedBounds(start, end, deltaStartMinutes, deltaEndMinutes, snapMinutes) {
 	const nextStart = shiftMinutes(start, deltaStartMinutes);
 	const nextEnd = shiftMinutes(end, deltaEndMinutes);
-	if (nextEnd.getTime() - nextStart.getTime() < snapMinutes * 6e4) return null;
+	const oldDuration = end.getTime() - start.getTime();
+	const newDuration = nextEnd.getTime() - nextStart.getTime();
+	if (newDuration < snapMinutes * 6e4 && newDuration < oldDuration) return null;
 	return {
 		start: nextStart,
 		end: nextEnd
@@ -1023,6 +1026,12 @@ const STEP = {
 	yearly: date_fns.addYears
 };
 const MAX_OCCURRENCES = 5e3;
+const APPROX_STEP_MS = {
+	daily: 864e5,
+	weekly: 6048e5,
+	monthly: 2629746e3,
+	yearly: 31556952e3
+};
 function withTimeOf(date, source) {
 	const next = new Date(date);
 	next.setHours(source.getHours(), source.getMinutes(), source.getSeconds(), source.getMilliseconds());
@@ -1038,10 +1047,21 @@ function nthWeekdayOfMonth(year, month, week, weekday) {
 	const date = new Date(year, month, day);
 	return date.getMonth() === month ? date : null;
 }
-function* occurrenceStarts(start, rule, rangeEnd) {
+function* occurrenceStarts(start, rule, earliestStart, rangeEnd) {
 	const interval = Math.max(1, Math.trunc(rule.interval ?? 1));
 	let produced = 0;
-	const within = (date) => date.getTime() <= rangeEnd.getTime() && (rule.until == null || date.getTime() <= rule.until.getTime()) && (rule.count == null || produced < rule.count) && produced < MAX_OCCURRENCES;
+	let emitted = 0;
+	const consider = (date) => {
+		if (date.getTime() < start.getTime()) return "skip";
+		if (date.getTime() > rangeEnd.getTime()) return "stop";
+		if (rule.until != null && date.getTime() > rule.until.getTime()) return "stop";
+		if (rule.count != null && produced >= rule.count) return "stop";
+		produced += 1;
+		if (date.getTime() < earliestStart.getTime()) return "skip";
+		if (emitted >= MAX_OCCURRENCES) return "stop";
+		emitted += 1;
+		return "emit";
+	};
 	if (rule.freq === "weekly" && rule.weekdays?.length) {
 		const weekdays = [...new Set(rule.weekdays)].sort((a, b) => a - b);
 		let weekStart = (0, date_fns.startOfWeek)(start, { weekStartsOn: 0 });
@@ -1049,9 +1069,9 @@ function* occurrenceStarts(start, rule, rangeEnd) {
 			let advanced = false;
 			for (const weekday of weekdays) {
 				const date = withTimeOf((0, date_fns.addDays)(weekStart, weekday), start);
-				if (date.getTime() < start.getTime()) continue;
-				if (!within(date)) return;
-				produced += 1;
+				const verdict = consider(date);
+				if (verdict === "stop") return;
+				if (verdict === "skip") continue;
 				advanced = true;
 				yield date;
 			}
@@ -1068,9 +1088,9 @@ function* occurrenceStarts(start, rule, rangeEnd) {
 			const days = [...new Set(rule.monthDays.map((d) => d < 0 ? daysInMonth + d + 1 : d))].filter((d) => d >= 1 && d <= daysInMonth).sort((a, b) => a - b);
 			for (const d of days) {
 				const date = withTimeOf(new Date(year, month, d), start);
-				if (date.getTime() < start.getTime()) continue;
-				if (!within(date)) return;
-				produced += 1;
+				const verdict = consider(date);
+				if (verdict === "stop") return;
+				if (verdict === "skip") continue;
 				yield date;
 			}
 			month += interval;
@@ -1088,11 +1108,9 @@ function* occurrenceStarts(start, rule, rangeEnd) {
 			const day = nthWeekdayOfMonth(year, month, week, weekday);
 			if (day) {
 				const date = withTimeOf(day, start);
-				if (date.getTime() >= start.getTime()) {
-					if (!within(date)) return;
-					produced += 1;
-					yield date;
-				}
+				const verdict = consider(date);
+				if (verdict === "stop") return;
+				if (verdict === "emit") yield date;
 			}
 			month += stepMonths;
 			year += Math.floor(month / 12);
@@ -1109,20 +1127,32 @@ function* occurrenceStarts(start, rule, rangeEnd) {
 				const month = m - 1;
 				if (day > new Date(year, month + 1, 0).getDate()) continue;
 				const date = withTimeOf(new Date(year, month, day), start);
-				if (date.getTime() < start.getTime()) continue;
-				if (!within(date)) return;
-				produced += 1;
+				const verdict = consider(date);
+				if (verdict === "stop") return;
+				if (verdict === "skip") continue;
 				yield date;
 			}
 			year += interval;
 			if (new Date(year, 0, 1).getTime() > rangeEnd.getTime()) return;
 		}
 	}
-	let cursor = start;
-	while (within(cursor)) {
-		produced += 1;
-		yield cursor;
-		cursor = STEP[rule.freq](cursor, interval);
+	const occAt = (n) => STEP[rule.freq](start, n * interval);
+	const lowerBound = earliestStart.getTime();
+	let n = 0;
+	if (occAt(0).getTime() < lowerBound) {
+		n = Math.max(0, Math.floor((lowerBound - start.getTime()) / (APPROX_STEP_MS[rule.freq] * interval)));
+		while (n > 0 && occAt(n - 1).getTime() >= lowerBound) n -= 1;
+		while (occAt(n).getTime() < lowerBound) n += 1;
+	}
+	while (true) {
+		if (rule.count != null && n >= rule.count) return;
+		if (emitted >= MAX_OCCURRENCES) return;
+		const date = occAt(n);
+		if (date.getTime() > rangeEnd.getTime()) return;
+		if (rule.until != null && date.getTime() > rule.until.getTime()) return;
+		emitted += 1;
+		n += 1;
+		yield date;
 	}
 }
 function instanceAt(event, start, durationMs) {
@@ -1151,7 +1181,8 @@ function expandRecurringEvents(events, rangeStart, rangeEnd) {
 		const dayKey = (d) => `${d.getFullYear()}-${d.getMonth()}-${d.getDate()}`;
 		const excluded = new Set((event.recurrence.exdates ?? []).map(dayKey));
 		const starts = /* @__PURE__ */ new Map();
-		for (const start of occurrenceStarts(event.start, event.recurrence, rangeEnd)) starts.set(start.getTime(), start);
+		const earliestStart = new Date(rangeStart.getTime() - durationMs);
+		for (const start of occurrenceStarts(event.start, event.recurrence, earliestStart, rangeEnd)) starts.set(start.getTime(), start);
 		for (const rdate of event.recurrence.rdates ?? []) if (rdate.getTime() <= rangeEnd.getTime()) starts.set(rdate.getTime(), rdate);
 		const ordered = [...starts.values()].sort((a, b) => a.getTime() - b.getTime());
 		for (const start of ordered) {

package/dist/index.mjs

@@ -277,15 +277,18 @@ function shiftMinutes(date, minutes) {
 /**
 * Resolve a committed drag into the event's new bounds: `start` shifts by
 * `deltaStartMinutes`, `end` by `deltaEndMinutes` (a move passes the same delta
-* to both; a resize passes 0 for the start). Returns `null` when the change
-* would collapse the event below one `snapMinutes` step, so the gesture leaves
-* the event untouched rather than committing a degenerate duration. Pure, so the
-* commit path is unit-testable without a running gesture.
+* to both; a resize passes 0 for the start). Returns `null` only when the change
+* would *shrink* the event below one `snapMinutes` step, so a resize can't commit
+* a degenerate duration; a pure move (both deltas equal) keeps its duration and is
+* never rejected, even for an already sub-step event. Pure, so the commit path is
+* unit-testable without a running gesture.
 */
 function resolveDraggedBounds(start, end, deltaStartMinutes, deltaEndMinutes, snapMinutes) {
 	const nextStart = shiftMinutes(start, deltaStartMinutes);
 	const nextEnd = shiftMinutes(end, deltaEndMinutes);
-	if (nextEnd.getTime() - nextStart.getTime() < snapMinutes * 6e4) return null;
+	const oldDuration = end.getTime() - start.getTime();
+	const newDuration = nextEnd.getTime() - nextStart.getTime();
+	if (newDuration < snapMinutes * 6e4 && newDuration < oldDuration) return null;
 	return {
 		start: nextStart,
 		end: nextEnd
@@ -1022,6 +1025,12 @@ const STEP = {
 	yearly: addYears
 };
 const MAX_OCCURRENCES = 5e3;
+const APPROX_STEP_MS = {
+	daily: 864e5,
+	weekly: 6048e5,
+	monthly: 2629746e3,
+	yearly: 31556952e3
+};
 function withTimeOf(date, source) {
 	const next = new Date(date);
 	next.setHours(source.getHours(), source.getMinutes(), source.getSeconds(), source.getMilliseconds());
@@ -1037,10 +1046,21 @@ function nthWeekdayOfMonth(year, month, week, weekday) {
 	const date = new Date(year, month, day);
 	return date.getMonth() === month ? date : null;
 }
-function* occurrenceStarts(start, rule, rangeEnd) {
+function* occurrenceStarts(start, rule, earliestStart, rangeEnd) {
 	const interval = Math.max(1, Math.trunc(rule.interval ?? 1));
 	let produced = 0;
-	const within = (date) => date.getTime() <= rangeEnd.getTime() && (rule.until == null || date.getTime() <= rule.until.getTime()) && (rule.count == null || produced < rule.count) && produced < MAX_OCCURRENCES;
+	let emitted = 0;
+	const consider = (date) => {
+		if (date.getTime() < start.getTime()) return "skip";
+		if (date.getTime() > rangeEnd.getTime()) return "stop";
+		if (rule.until != null && date.getTime() > rule.until.getTime()) return "stop";
+		if (rule.count != null && produced >= rule.count) return "stop";
+		produced += 1;
+		if (date.getTime() < earliestStart.getTime()) return "skip";
+		if (emitted >= MAX_OCCURRENCES) return "stop";
+		emitted += 1;
+		return "emit";
+	};
 	if (rule.freq === "weekly" && rule.weekdays?.length) {
 		const weekdays = [...new Set(rule.weekdays)].sort((a, b) => a - b);
 		let weekStart = startOfWeek(start, { weekStartsOn: 0 });
@@ -1048,9 +1068,9 @@ function* occurrenceStarts(start, rule, rangeEnd) {
 			let advanced = false;
 			for (const weekday of weekdays) {
 				const date = withTimeOf(addDays(weekStart, weekday), start);
-				if (date.getTime() < start.getTime()) continue;
-				if (!within(date)) return;
-				produced += 1;
+				const verdict = consider(date);
+				if (verdict === "stop") return;
+				if (verdict === "skip") continue;
 				advanced = true;
 				yield date;
 			}
@@ -1067,9 +1087,9 @@ function* occurrenceStarts(start, rule, rangeEnd) {
 			const days = [...new Set(rule.monthDays.map((d) => d < 0 ? daysInMonth + d + 1 : d))].filter((d) => d >= 1 && d <= daysInMonth).sort((a, b) => a - b);
 			for (const d of days) {
 				const date = withTimeOf(new Date(year, month, d), start);
-				if (date.getTime() < start.getTime()) continue;
-				if (!within(date)) return;
-				produced += 1;
+				const verdict = consider(date);
+				if (verdict === "stop") return;
+				if (verdict === "skip") continue;
 				yield date;
 			}
 			month += interval;
@@ -1087,11 +1107,9 @@ function* occurrenceStarts(start, rule, rangeEnd) {
 			const day = nthWeekdayOfMonth(year, month, week, weekday);
 			if (day) {
 				const date = withTimeOf(day, start);
-				if (date.getTime() >= start.getTime()) {
-					if (!within(date)) return;
-					produced += 1;
-					yield date;
-				}
+				const verdict = consider(date);
+				if (verdict === "stop") return;
+				if (verdict === "emit") yield date;
 			}
 			month += stepMonths;
 			year += Math.floor(month / 12);
@@ -1108,20 +1126,32 @@ function* occurrenceStarts(start, rule, rangeEnd) {
 				const month = m - 1;
 				if (day > new Date(year, month + 1, 0).getDate()) continue;
 				const date = withTimeOf(new Date(year, month, day), start);
-				if (date.getTime() < start.getTime()) continue;
-				if (!within(date)) return;
-				produced += 1;
+				const verdict = consider(date);
+				if (verdict === "stop") return;
+				if (verdict === "skip") continue;
 				yield date;
 			}
 			year += interval;
 			if (new Date(year, 0, 1).getTime() > rangeEnd.getTime()) return;
 		}
 	}
-	let cursor = start;
-	while (within(cursor)) {
-		produced += 1;
-		yield cursor;
-		cursor = STEP[rule.freq](cursor, interval);
+	const occAt = (n) => STEP[rule.freq](start, n * interval);
+	const lowerBound = earliestStart.getTime();
+	let n = 0;
+	if (occAt(0).getTime() < lowerBound) {
+		n = Math.max(0, Math.floor((lowerBound - start.getTime()) / (APPROX_STEP_MS[rule.freq] * interval)));
+		while (n > 0 && occAt(n - 1).getTime() >= lowerBound) n -= 1;
+		while (occAt(n).getTime() < lowerBound) n += 1;
+	}
+	while (true) {
+		if (rule.count != null && n >= rule.count) return;
+		if (emitted >= MAX_OCCURRENCES) return;
+		const date = occAt(n);
+		if (date.getTime() > rangeEnd.getTime()) return;
+		if (rule.until != null && date.getTime() > rule.until.getTime()) return;
+		emitted += 1;
+		n += 1;
+		yield date;
 	}
 }
 function instanceAt(event, start, durationMs) {
@@ -1150,7 +1180,8 @@ function expandRecurringEvents(events, rangeStart, rangeEnd) {
 		const dayKey = (d) => `${d.getFullYear()}-${d.getMonth()}-${d.getDate()}`;
 		const excluded = new Set((event.recurrence.exdates ?? []).map(dayKey));
 		const starts = /* @__PURE__ */ new Map();
-		for (const start of occurrenceStarts(event.start, event.recurrence, rangeEnd)) starts.set(start.getTime(), start);
+		const earliestStart = new Date(rangeStart.getTime() - durationMs);
+		for (const start of occurrenceStarts(event.start, event.recurrence, earliestStart, rangeEnd)) starts.set(start.getTime(), start);
 		for (const rdate of event.recurrence.rdates ?? []) if (rdate.getTime() <= rangeEnd.getTime()) starts.set(rdate.getTime(), rdate);
 		const ordered = [...starts.values()].sort((a, b) => a.getTime() - b.getTime());
 		for (const start of ordered) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@super-calendar/core",
-  "version": "2.3.1",
+  "version": "2.4.0",
   "description": "Render-agnostic core for super-calendar: date math, selection model, event layout, the month-grid builder, headless hooks, and neutral theme tokens. No renderer.",
   "keywords": [
     "calendar",

package/src/utils/drag.ts

@@ -24,10 +24,11 @@ export function shiftMinutes(date: Date, minutes: number): Date {
 /**
  * Resolve a committed drag into the event's new bounds: `start` shifts by
  * `deltaStartMinutes`, `end` by `deltaEndMinutes` (a move passes the same delta
- * to both; a resize passes 0 for the start). Returns `null` when the change
- * would collapse the event below one `snapMinutes` step, so the gesture leaves
- * the event untouched rather than committing a degenerate duration. Pure, so the
- * commit path is unit-testable without a running gesture.
+ * to both; a resize passes 0 for the start). Returns `null` only when the change
+ * would *shrink* the event below one `snapMinutes` step, so a resize can't commit
+ * a degenerate duration; a pure move (both deltas equal) keeps its duration and is
+ * never rejected, even for an already sub-step event. Pure, so the commit path is
+ * unit-testable without a running gesture.
  */
 export function resolveDraggedBounds(
   start: Date,
@@ -38,7 +39,10 @@ export function resolveDraggedBounds(
 ): { start: Date; end: Date } | null {
   const nextStart = shiftMinutes(start, deltaStartMinutes);
   const nextEnd = shiftMinutes(end, deltaEndMinutes);
-  if (nextEnd.getTime() - nextStart.getTime() < snapMinutes * 60_000) return null;
+  const oldDuration = end.getTime() - start.getTime();
+  const newDuration = nextEnd.getTime() - nextStart.getTime();
+  // Reject only a shrink past one step — never a move, which preserves duration.
+  if (newDuration < snapMinutes * 60_000 && newDuration < oldDuration) return null;
   return { start: nextStart, end: nextEnd };
 }
 

package/src/utils/recurrence.ts

@@ -8,10 +8,20 @@ const STEP: Record<RecurrenceFrequency, (date: Date, amount: number) => Date> =
   yearly: addYears,
 };
 
-// Runaway guard. Generous enough for realistic ranges (e.g. ~13 years of a daily
-// event); set `count`/`until`, or query a tighter range, for anything larger.
+// Runaway guard on in-range occurrences. Generous enough for realistic windows
+// (e.g. ~13 years of a daily event); set `count`/`until`, or query a tighter
+// range, for anything larger.
 const MAX_OCCURRENCES = 5000;
 
+// Average length of each frequency's step, used only to estimate how far to
+// fast-forward before iterating; the estimate is then corrected exactly.
+const APPROX_STEP_MS: Record<RecurrenceFrequency, number> = {
+  daily: 864e5,
+  weekly: 6048e5,
+  monthly: 2629746e3,
+  yearly: 31556952e3,
+};
+
 // Copy `source`'s time of day onto `date`.
 function withTimeOf(date: Date, source: Date): Date {
   const next = new Date(date);
@@ -44,15 +54,32 @@ function nthWeekdayOfMonth(
 }
 
 // Occurrence start dates from `event.start` forward, in chronological order, up
-// to `rangeEnd` (and the rule's own `count`/`until`).
-function* occurrenceStarts(start: Date, rule: RecurrenceRule, rangeEnd: Date): Generator<Date> {
+// to `rangeEnd` (and the rule's own `count`/`until`). `earliestStart` is the
+// earliest occurrence-start that can still overlap the query window
+// (`rangeStart - duration`); the plain fallback rule fast-forwards to it.
+function* occurrenceStarts(
+  start: Date,
+  rule: RecurrenceRule,
+  earliestStart: Date,
+  rangeEnd: Date,
+): Generator<Date> {
   const interval = Math.max(1, Math.trunc(rule.interval ?? 1));
+  // `produced` counts occurrences from the origin, honouring `count`; `emitted`
+  // counts only in-window yields, so the runaway guard isn't spent on the
+  // throwaway occurrences that precede a far-future query window.
   let produced = 0;
-  const within = (date: Date) =>
-    date.getTime() <= rangeEnd.getTime() &&
-    (rule.until == null || date.getTime() <= rule.until.getTime()) &&
-    (rule.count == null || produced < rule.count) &&
-    produced < MAX_OCCURRENCES;
+  let emitted = 0;
+  const consider = (date: Date): "skip" | "stop" | "emit" => {
+    if (date.getTime() < start.getTime()) return "skip"; // before the first occurrence
+    if (date.getTime() > rangeEnd.getTime()) return "stop";
+    if (rule.until != null && date.getTime() > rule.until.getTime()) return "stop";
+    if (rule.count != null && produced >= rule.count) return "stop";
+    produced += 1;
+    if (date.getTime() < earliestStart.getTime()) return "skip"; // before the window
+    if (emitted >= MAX_OCCURRENCES) return "stop";
+    emitted += 1;
+    return "emit";
+  };
 
   if (rule.freq === "weekly" && rule.weekdays?.length) {
     const weekdays = [...new Set(rule.weekdays)].sort((a, b) => a - b);
@@ -61,9 +88,9 @@ function* occurrenceStarts(start: Date, rule: RecurrenceRule, rangeEnd: Date): G
       let advanced = false;
       for (const weekday of weekdays) {
         const date = withTimeOf(addDays(weekStart, weekday), start);
-        if (date.getTime() < start.getTime()) continue; // before the first occurrence
-        if (!within(date)) return;
-        produced += 1;
+        const verdict = consider(date);
+        if (verdict === "stop") return;
+        if (verdict === "skip") continue;
         advanced = true;
         yield date;
       }
@@ -86,9 +113,9 @@ function* occurrenceStarts(start: Date, rule: RecurrenceRule, rangeEnd: Date): G
         .sort((a, b) => a - b);
       for (const d of days) {
         const date = withTimeOf(new Date(year, month, d), start);
-        if (date.getTime() < start.getTime()) continue; // before the first occurrence
-        if (!within(date)) return;
-        produced += 1;
+        const verdict = consider(date);
+        if (verdict === "stop") return;
+        if (verdict === "skip") continue;
         yield date;
       }
       month += interval;
@@ -108,11 +135,9 @@ function* occurrenceStarts(start: Date, rule: RecurrenceRule, rangeEnd: Date): G
       const day = nthWeekdayOfMonth(year, month, week, weekday);
       if (day) {
         const date = withTimeOf(day, start);
-        if (date.getTime() >= start.getTime()) {
-          if (!within(date)) return;
-          produced += 1;
-          yield date;
-        }
+        const verdict = consider(date);
+        if (verdict === "stop") return;
+        if (verdict === "emit") yield date;
       }
       month += stepMonths;
       year += Math.floor(month / 12);
@@ -132,9 +157,9 @@ function* occurrenceStarts(start: Date, rule: RecurrenceRule, rangeEnd: Date): G
         // Skip a year whose listed month lacks the start's day (e.g. Feb 29).
         if (day > new Date(year, month + 1, 0).getDate()) continue;
         const date = withTimeOf(new Date(year, month, day), start);
-        if (date.getTime() < start.getTime()) continue; // before the first occurrence
-        if (!within(date)) return;
-        produced += 1;
+        const verdict = consider(date);
+        if (verdict === "stop") return;
+        if (verdict === "skip") continue;
         yield date;
       }
       year += interval;
@@ -142,11 +167,32 @@ function* occurrenceStarts(start: Date, rule: RecurrenceRule, rangeEnd: Date): G
     }
   }
 
-  let cursor = start;
-  while (within(cursor)) {
-    produced += 1;
-    yield cursor;
-    cursor = STEP[rule.freq](cursor, interval);
+  // Fallback: plain daily/weekly/monthly/yearly stepping. Each occurrence is
+  // computed from the original `start` (never the previous occurrence), so a
+  // month-end or Feb-29 start doesn't drift as date-fns clamps shorter months.
+  const occAt = (n: number) => STEP[rule.freq](start, n * interval);
+  const lowerBound = earliestStart.getTime();
+  // Fast-forward to the first occurrence that can overlap the window so a
+  // far-future query doesn't iterate (and exhaust the guard) from `start`.
+  let n = 0;
+  if (occAt(0).getTime() < lowerBound) {
+    n = Math.max(
+      0,
+      Math.floor((lowerBound - start.getTime()) / (APPROX_STEP_MS[rule.freq] * interval)),
+    );
+    // Correct the estimate exactly for calendar/DST wobble.
+    while (n > 0 && occAt(n - 1).getTime() >= lowerBound) n -= 1;
+    while (occAt(n).getTime() < lowerBound) n += 1;
+  }
+  while (true) {
+    if (rule.count != null && n >= rule.count) return;
+    if (emitted >= MAX_OCCURRENCES) return;
+    const date = occAt(n);
+    if (date.getTime() > rangeEnd.getTime()) return;
+    if (rule.until != null && date.getTime() > rule.until.getTime()) return;
+    emitted += 1;
+    n += 1;
+    yield date;
   }
 }
 
@@ -181,7 +227,9 @@ export function expandRecurringEvents<T>(
     // Union the rule's occurrences with any explicit RDATE additions, keyed by
     // exact start time so a date the rule already produces isn't duplicated.
     const starts = new Map<number, Date>();
-    for (const start of occurrenceStarts(event.start, event.recurrence, rangeEnd)) {
+    // Occurrences starting up to one duration before the range can still overlap it.
+    const earliestStart = new Date(rangeStart.getTime() - durationMs);
+    for (const start of occurrenceStarts(event.start, event.recurrence, earliestStart, rangeEnd)) {
       starts.set(start.getTime(), start);
     }
     for (const rdate of event.recurrence.rdates ?? []) {