@tuturuuu/utils 0.34.0 → 0.35.0

package/src/__tests__/tutoring-teacher-hours.test.ts

@@ -0,0 +1,274 @@
+import { Temporal } from '@js-temporal/polyfill';
+import { describe, expect, it } from 'vitest';
+import {
+  assessTeacherHoursSlot,
+  type HoursSlot,
+  resetTeacherHoursOverride,
+  resolveTeacherHours,
+  type StaffHours,
+  validateHoursFrame,
+  validateHoursWeek,
+  validateHoursWriteReceipt,
+} from '../tutoring-teacher-hours';
+
+const defaults: StaffHours = {
+  revision: '900719925474099312345',
+  frame: { timeZone: 'Asia/Ho_Chi_Minh', confirmed: true },
+  week: { 1: [{ start: '09:00', end: '17:00' }], 2: [] },
+};
+const monday: HoursSlot = {
+  date: '2026-10-05',
+  start: '09:00',
+  endDate: '2026-10-05',
+  end: '10:00',
+};
+const decide = (slot: HoursSlot, hours = defaults) =>
+  assessTeacherHoursSlot(hours, null, slot).state;
+
+describe('teacher-hours authority and per-day inheritance', () => {
+  it('keeps teacher availability unknown without confirmed staff hours', () => {
+    expect(
+      resolveTeacherHours(null, null).every((day) => day.state === 'unknown')
+    ).toBe(true);
+    expect(assessTeacherHoursSlot(null, null, monday)).toEqual({
+      state: 'unknown',
+    });
+  });
+
+  it('distinguishes missing staff day from explicitly closed day', () => {
+    const week = resolveTeacherHours(defaults, null);
+    expect(week[0]).toMatchObject({ state: 'hours', source: 'default' });
+    expect(week[1]).toMatchObject({ state: 'closed', source: 'default' });
+    expect(week[2]).toMatchObject({ state: 'unknown', source: 'unknown' });
+  });
+
+  it('replaces, never unions, one overridden day and inherits absent weekdays', () => {
+    const week = resolveTeacherHours(defaults, {
+      revision: 'override:1',
+      week: { 1: [{ start: '18:00', end: '20:00' }] },
+    });
+    expect(week[0]?.intervals).toEqual([{ start: '18:00', end: '20:00' }]);
+    expect(week[0]?.source).toBe('override');
+    expect(week[1]?.state).toBe('closed');
+  });
+
+  it('explicit empty override closes the day; removing it inherits latest default', () => {
+    expect(
+      resolveTeacherHours(defaults, { revision: 'a', week: { 1: [] } })[0]
+        ?.state
+    ).toBe('closed');
+    const reset = resetTeacherHoursOverride('a', 'b');
+    expect(reset).toEqual({ revision: 'b', week: {} });
+    expect(
+      resolveTeacherHours({ ...defaults, week: { 1: [] } }, reset)[0]?.state
+    ).toBe('closed');
+    expect(resolveTeacherHours(defaults, reset)[0]?.state).toBe('hours');
+  });
+
+  it('cannot use custom overrides without a confirmed staff timezone', () => {
+    expect(
+      resolveTeacherHours(null, {
+        revision: 'a',
+        week: { 1: [{ start: '09:00', end: '17:00' }] },
+      })[0]?.state
+    ).toBe('unknown');
+  });
+
+  it('returns defensive interval copies', () => {
+    const week = resolveTeacherHours(defaults, null);
+    expect(week[0]?.intervals[0]).not.toBe(defaults.week[1]?.[0]);
+  });
+});
+
+describe('lossless receipt and reset contract', () => {
+  it('retains opaque revisions above JS safe precision and tombstone after reset', () => {
+    const before = '900719925474099312345';
+    const after = '900719925474099312346';
+    expect(Number(before)).toBe(Number(after));
+    const reset = resetTeacherHoursOverride(before, after);
+    expect(reset.revision).toBe(after);
+    expect(reset.week).toEqual({});
+    expect(resetTeacherHoursOverride(null, before).revision).toBe(before);
+  });
+
+  it('rejects reused same-content receipt revisions and malformed revisions', () => {
+    expect(() => validateHoursWriteReceipt('a', 'a')).toThrow();
+    expect(() => validateHoursWriteReceipt('a', '')).toThrow();
+    expect(() => validateHoursWriteReceipt(' ', 'b')).toThrow();
+    expect(() => validateHoursWriteReceipt(null, 'b')).not.toThrow();
+    // No pure helper claims to enforce storage CAS: stale/reset ABA needs atomic DB proof.
+  });
+});
+
+describe('strict frame and weekly window validation', () => {
+  it.each(['auto', '', '+07:00', 'Not/AZone'])(
+    'rejects nonconfirmed IANA frame %s',
+    (timeZone) => {
+      expect(() => validateHoursFrame({ timeZone, confirmed: true })).toThrow();
+    }
+  );
+  it('rejects unconfirmed valid timezone', () => {
+    expect(() =>
+      validateHoursFrame({ timeZone: 'UTC', confirmed: false } as never)
+    ).toThrow();
+  });
+  it.each([
+    { 0: [] },
+    { 8: [] },
+    { 1: [{ start: '9:00', end: '10:00' }] },
+    { 1: [{ start: '24:00', end: '24:00' }] },
+    { 1: [{ start: '10:00', end: '09:00' }] },
+    {
+      1: [
+        { start: '09:00', end: '11:00' },
+        { start: '10:00', end: '12:00' },
+      ],
+    },
+    {
+      1: [
+        { start: '12:00', end: '13:00' },
+        { start: '09:00', end: '10:00' },
+      ],
+    },
+  ])('rejects malformed/overlapping/unsorted week %j', (week) => {
+    expect(() => validateHoursWeek(week)).toThrow();
+  });
+  it('allows half-open adjacency and explicit midnight end', () => {
+    expect(() =>
+      validateHoursWeek({
+        1: [
+          { start: '00:00', end: '12:00' },
+          { start: '12:00', end: '24:00' },
+        ],
+      })
+    ).not.toThrow();
+  });
+});
+
+describe('candidate coverage and actual Temporal boundary', () => {
+  it('allows exact boundaries and rejects outside hours', () => {
+    expect(decide({ ...monday, end: '17:00' })).toBe('allowed');
+    expect(decide({ ...monday, start: '08:59' })).toBe('closed');
+    expect(decide({ ...monday, end: '17:01' })).toBe('closed');
+    expect(
+      decide({ ...monday, date: '2026-10-07', endDate: '2026-10-07' })
+    ).toBe('unknown');
+  });
+  it('covers adjacent intervals continuously without bridging a gap', () => {
+    const week = {
+      1: [
+        { start: '09:00', end: '10:00' },
+        { start: '10:00', end: '11:00' },
+      ],
+    };
+    expect(decide({ ...monday, end: '11:00' }, { ...defaults, week })).toBe(
+      'allowed'
+    );
+    week[1][1] = { start: '10:01', end: '11:00' };
+    expect(decide({ ...monday, end: '11:00' }, { ...defaults, week })).toBe(
+      'closed'
+    );
+  });
+  it('requires explicit coverage on both days for overnight and Sunday wrap', () => {
+    const slot = {
+      date: '2026-10-11',
+      start: '23:00',
+      endDate: '2026-10-12',
+      end: '01:00',
+    };
+    const hours = {
+      ...defaults,
+      week: {
+        7: [{ start: '22:00', end: '24:00' }],
+        1: [{ start: '00:00', end: '02:00' }],
+      },
+    };
+    expect(decide(slot, hours)).toBe('allowed');
+    expect(decide(slot, { ...hours, week: { 7: hours.week[7] } })).toBe(
+      'unknown'
+    );
+    expect(decide(slot, { ...hours, week: { ...hours.week, 1: [] } })).toBe(
+      'closed'
+    );
+    expect(
+      decide(
+        { ...slot, end: '00:00' },
+        { ...hours, week: { 7: hours.week[7] } }
+      )
+    ).toBe('allowed');
+  });
+  it('rejects zero/negative/unbounded slots and invalid civil dates', () => {
+    for (const slot of [
+      { ...monday, end: '09:00' },
+      { ...monday, end: '08:00' },
+      { ...monday, endDate: '2026-10-13' },
+      { ...monday, date: '2026-02-30' },
+      { ...monday, start: '9:00' },
+    ])
+      expect(decide(slot)).toBe('invalid');
+  });
+  it('proves compatible Temporal conversion would move a nonexistent clock time', () => {
+    const local = Temporal.PlainDateTime.from('2026-03-08T02:30');
+    expect(local.toZonedDateTime('America/New_York').hour).toBe(3);
+    const hours = {
+      ...defaults,
+      frame: { timeZone: 'America/New_York', confirmed: true as const },
+      week: { 7: [{ start: '00:00', end: '24:00' }] },
+    };
+    expect(
+      decide(
+        {
+          date: '2026-03-08',
+          start: '02:30',
+          endDate: '2026-03-08',
+          end: '04:00',
+        },
+        hours
+      )
+    ).toBe('invalid');
+    expect(
+      decide(
+        {
+          date: '2026-11-01',
+          start: '01:30',
+          endDate: '2026-11-01',
+          end: '03:00',
+        },
+        hours
+      )
+    ).toBe('invalid');
+    expect(
+      decide(
+        {
+          date: '2026-03-08',
+          start: '01:00',
+          endDate: '2026-03-08',
+          end: '04:00',
+        },
+        hours
+      )
+    ).toBe('invalid');
+    expect(
+      decide(
+        {
+          date: '2026-11-01',
+          start: '00:30',
+          endDate: '2026-11-01',
+          end: '03:00',
+        },
+        hours
+      )
+    ).toBe('invalid');
+    expect(
+      decide(
+        {
+          date: '2026-03-09',
+          start: '09:00',
+          endDate: '2026-03-09',
+          end: '10:00',
+        },
+        { ...hours, week: defaults.week }
+      )
+    ).toBe('allowed');
+  });
+});

package/src/calendar-provider-readonly.ts

@@ -0,0 +1,49 @@
+/** Internal-only transport marker; never written back to a provider. */
+const marker = '__tuturuuuProviderReadonlyRecurrence';
+export type ProviderReadonlyRecurrence = {
+  state: 'unsupported';
+  master_id: string;
+  provider: 'google' | 'microsoft';
+};
+export function markProviderRecurrenceReadonly<T extends object>(
+  event: T,
+  provider: ProviderReadonlyRecurrence['provider'],
+  masterId: string
+): T {
+  return {
+    ...event,
+    [marker]: { state: 'unsupported', master_id: masterId, provider },
+  };
+}
+export function providerReadonlyProjection(event: unknown): {
+  locked?: true;
+  scheduling_metadata?: { provider_recurrence: ProviderReadonlyRecurrence };
+} {
+  if (!event || typeof event !== 'object') return {};
+  const value = (event as Record<string, unknown>)[marker];
+  if (!value || typeof value !== 'object') return {};
+  const entry = value as Partial<ProviderReadonlyRecurrence>;
+  if (
+    entry.state !== 'unsupported' ||
+    typeof entry.master_id !== 'string' ||
+    !entry.master_id ||
+    !['google', 'microsoft'].includes(entry.provider ?? '')
+  )
+    return {};
+  return {
+    locked: true,
+    scheduling_metadata: {
+      provider_recurrence: entry as ProviderReadonlyRecurrence,
+    },
+  };
+}
+export function isProviderRecurrenceReadonly(event: unknown): boolean {
+  if (!event || typeof event !== 'object') return false;
+  const metadata = (event as { scheduling_metadata?: unknown })
+    .scheduling_metadata;
+  if (!metadata || typeof metadata !== 'object') return false;
+  return (
+    (metadata as { provider_recurrence?: { state?: unknown } })
+      .provider_recurrence?.state === 'unsupported'
+  );
+}

package/src/calendar-recurrence-edit.ts

@@ -0,0 +1,148 @@
+import { Temporal } from '@js-temporal/polyfill';
+import type {
+  CalendarRecurrenceAnchor,
+  CalendarRecurrenceRule,
+} from '@tuturuuu/types/primitives/calendar-recurrence';
+import { matchesCalendarRecurrenceDate } from './calendar-recurrence-pattern';
+import {
+  CalendarLocalDateTimeSchema,
+  validateCalendarRecurrence,
+} from './calendar-recurrence-validation';
+
+/** Validates immutable occurrence identity and counts slots before exceptions.
+ * Never trust a caller-provided instance index for COUNT or future splits. */
+export function inspectCalendarRecurrenceSlot(input: {
+  rule: CalendarRecurrenceRule;
+  anchor: CalendarRecurrenceAnchor;
+  originalStartLocal: string;
+}): {
+  precedingCount: number;
+  previousRule: CalendarRecurrenceRule | null;
+  remainingRule: CalendarRecurrenceRule;
+} {
+  const { rule, anchor } = validateCalendarRecurrence(input.rule, input.anchor);
+  const slot = Temporal.PlainDateTime.from(
+    CalendarLocalDateTimeSchema.parse(input.originalStartLocal)
+  );
+  const first = Temporal.PlainDateTime.from(anchor.startLocal);
+  if (
+    Temporal.PlainDateTime.compare(slot, first) < 0 ||
+    !slot.toPlainTime().equals(first.toPlainTime())
+  )
+    throw new RangeError('Not a series occurrence');
+  let precedingCount = 0;
+  let scanned = 0;
+  for (
+    let date = first.toPlainDate();
+    Temporal.PlainDate.compare(date, slot.toPlainDate()) <= 0;
+    date = date.add({ days: 1 })
+  ) {
+    if (++scanned > 36600)
+      throw new RangeError('Recurrence scan exceeds 100 years');
+    if (
+      rule.end.type === 'until' &&
+      Temporal.PlainDate.compare(date, rule.end.date) > 0
+    )
+      break;
+    if (!matchesCalendarRecurrenceDate(date, first.toPlainDate(), rule))
+      continue;
+    const local = date.toPlainDateTime(first.toPlainTime());
+    if (
+      !local
+        .toZonedDateTime(rule.timeZone, { disambiguation: 'compatible' })
+        .toPlainDateTime()
+        .equals(local)
+    )
+      continue;
+    if (rule.end.type === 'count' && precedingCount >= rule.end.count) break;
+    if (local.equals(slot)) {
+      return {
+        precedingCount,
+        previousRule:
+          precedingCount === 0
+            ? null
+            : {
+                ...rule,
+                end: {
+                  type: 'until',
+                  date: slot.toPlainDate().subtract({ days: 1 }).toString(),
+                },
+              },
+        remainingRule: {
+          ...rule,
+          ...(rule.end.type === 'count'
+            ? { end: { type: 'count', count: rule.end.count - precedingCount } }
+            : {}),
+        },
+      };
+    }
+    precedingCount++;
+  }
+  throw new RangeError('Not a series occurrence');
+}
+
+export function calendarAnchorAtSlot(
+  anchor: CalendarRecurrenceAnchor,
+  originalStartLocal: string
+): CalendarRecurrenceAnchor {
+  const start = Temporal.PlainDateTime.from(anchor.startLocal);
+  const duration = start.until(anchor.endLocal, { largestUnit: 'days' });
+  const slot = Temporal.PlainDateTime.from(
+    CalendarLocalDateTimeSchema.parse(originalStartLocal)
+  );
+  return {
+    ...anchor,
+    startLocal: slot.toString({ smallestUnit: 'second' }),
+    endLocal: slot.add(duration).toString({ smallestUnit: 'second' }),
+  };
+}
+
+/** Immutable original slot as a UTC instant for provider occurrence lookup. */
+export function calendarRecurrenceSlotInstant(input: {
+  rule: CalendarRecurrenceRule;
+  anchor: CalendarRecurrenceAnchor;
+  originalStartLocal: string;
+}) {
+  inspectCalendarRecurrenceSlot(input);
+  return Temporal.PlainDateTime.from(input.originalStartLocal)
+    .toZonedDateTime(input.rule.timeZone, { disambiguation: 'compatible' })
+    .toInstant()
+    .toString();
+}
+
+/** Normalize a provider date-time without falling back to the machine timezone. */
+export function calendarProviderDateTimeLocal(
+  input: { dateTime: string; timeZone?: string },
+  timeZone: string
+) {
+  const instant = /(?:Z|[+-]\d{2}:\d{2})$/i.test(input.dateTime)
+    ? Temporal.Instant.from(input.dateTime)
+    : Temporal.PlainDateTime.from(input.dateTime)
+        .toZonedDateTime(input.timeZone ?? timeZone, {
+          disambiguation: 'compatible',
+        })
+        .toInstant();
+  if (instant.epochNanoseconds % 1_000_000_000n !== 0n)
+    throw new RangeError(
+      'Provider occurrence has unsupported fractional precision'
+    );
+  return instant
+    .toZonedDateTimeISO(timeZone)
+    .toPlainDateTime()
+    .toString({ smallestUnit: 'second' });
+}
+
+/** Original slot interval, before moves/cancellations, for coverage fencing. */
+export function calendarRecurrenceSlotBounds(input: {
+  rule: CalendarRecurrenceRule;
+  anchor: CalendarRecurrenceAnchor;
+  originalStartLocal: string;
+}) {
+  const start = calendarRecurrenceSlotInstant(input);
+  const slot = calendarAnchorAtSlot(input.anchor, input.originalStartLocal);
+  const end = Temporal.PlainDateTime.from(slot.endLocal)
+    .toZonedDateTime(input.rule.timeZone, { disambiguation: 'compatible' })
+    .toInstant()
+    .toString();
+  return { start, end };
+}

package/src/calendar-recurrence-expansion.ts

@@ -0,0 +1,131 @@
+import { Temporal } from '@js-temporal/polyfill';
+import type {
+  CalendarRecurrenceAnchor,
+  CalendarRecurrenceException,
+  CalendarRecurrenceOccurrence,
+  CalendarRecurrenceRule,
+} from '@tuturuuu/types/primitives/calendar-recurrence';
+import { matchesCalendarRecurrenceDate } from './calendar-recurrence-pattern';
+import {
+  CalendarRecurrenceAnchorSchema,
+  CalendarRecurrenceExceptionSchema,
+  validateCalendarRecurrence,
+} from './calendar-recurrence-validation';
+
+const MAX_SCANNED_DAYS = 36600;
+
+/** A bounded recurrence expansion. Count is applied before cancellations/moves.
+ * Nonexistent DST wall-clock slots are skipped; folds use the earlier instant.
+ * Throws on a scan limit rather than presenting incomplete history as complete. */
+export function expandCalendarRecurrence(args: {
+  rule: CalendarRecurrenceRule;
+  anchor: CalendarRecurrenceAnchor;
+  from: string;
+  to: string;
+  exceptions?: CalendarRecurrenceException[];
+  limit?: number;
+}): { occurrences: CalendarRecurrenceOccurrence[]; truncated: boolean } {
+  const { rule, anchor } = validateCalendarRecurrence(args.rule, args.anchor);
+  const from = Temporal.Instant.from(args.from);
+  const to = Temporal.Instant.from(args.to);
+  if (Temporal.Instant.compare(from, to) >= 0)
+    throw new RangeError('Invalid recurrence range');
+  const limit = args.limit ?? 500;
+  if (!Number.isInteger(limit) || limit < 1 || limit > 1000)
+    throw new RangeError('Occurrence limit must be 1–1000');
+  const start = Temporal.PlainDateTime.from(anchor.startLocal);
+  const duration = start.until(anchor.endLocal, { largestUnit: 'days' });
+  const first = start.toPlainDate();
+  const exceptionBySlot = new Map<string, CalendarRecurrenceException>();
+  let stop = to.toZonedDateTimeISO(rule.timeZone).toPlainDate();
+  if ((args.exceptions?.length ?? 0) > 1000)
+    throw new RangeError('Exception limit exceeds 1000');
+  for (const rawException of args.exceptions ?? []) {
+    const exception = CalendarRecurrenceExceptionSchema.parse(rawException);
+    const slot = Temporal.PlainDateTime.from(
+      exception.originalStartLocal
+    ).toString({ smallestUnit: 'second' });
+    if (exceptionBySlot.has(slot))
+      throw new RangeError('Duplicate recurrence exception slot');
+    if (exception.startLocal || exception.endLocal) {
+      CalendarRecurrenceAnchorSchema.parse({
+        startLocal: exception.startLocal,
+        endLocal: exception.endLocal,
+        allDay: anchor.allDay,
+      });
+    }
+    exceptionBySlot.set(slot, exception);
+    const date = Temporal.PlainDateTime.from(slot).toPlainDate();
+    if (Temporal.PlainDate.compare(date, stop) > 0) stop = date;
+  }
+  if (
+    rule.end.type === 'until' &&
+    Temporal.PlainDate.compare(stop, rule.end.date) > 0
+  )
+    stop = Temporal.PlainDate.from(rule.end.date);
+  // An uncounted rule necessarily visits every date through the effective stop.
+  // Reject oversized history before constructing thousands of zoned occurrences.
+  // COUNT can terminate earlier, so its existing incremental guard remains below.
+  if (
+    rule.end.type !== 'count' &&
+    first.until(stop, { largestUnit: 'days' }).days >= MAX_SCANNED_DAYS
+  )
+    throw new RangeError('Recurrence scan exceeds 100 years');
+  const occurrences: CalendarRecurrenceOccurrence[] = [];
+  let count = 0;
+  let scanned = 0;
+  for (
+    let date = first;
+    Temporal.PlainDate.compare(date, stop) <= 0;
+    date = date.add({ days: 1 })
+  ) {
+    if (++scanned > MAX_SCANNED_DAYS)
+      throw new RangeError('Recurrence scan exceeds 100 years');
+    if (!matchesCalendarRecurrenceDate(date, first, rule)) continue;
+    const local = date.toPlainDateTime(start.toPlainTime());
+    const zoned = local.toZonedDateTime(rule.timeZone, {
+      disambiguation: 'compatible',
+    });
+    // RFC 5545 invalid/nonexistent local times do not consume COUNT.
+    if (!zoned.toPlainDateTime().equals(local)) continue;
+    if (rule.end.type === 'count' && ++count > rule.end.count) break;
+    const slot = local.toString({ smallestUnit: 'second' });
+    const exception = exceptionBySlot.get(slot);
+    if (exception?.cancelled) continue;
+    const actualStart = exception?.startLocal
+      ? Temporal.PlainDateTime.from(exception.startLocal)
+      : local;
+    const actualEnd = exception?.endLocal
+      ? Temporal.PlainDateTime.from(exception.endLocal)
+      : local.add(duration);
+    const startInstant = actualStart
+      .toZonedDateTime(rule.timeZone, { disambiguation: 'compatible' })
+      .toInstant();
+    const endInstant = actualEnd
+      .toZonedDateTime(rule.timeZone, { disambiguation: 'compatible' })
+      .toInstant();
+    if (Temporal.Instant.compare(endInstant, startInstant) <= 0)
+      throw new RangeError('Occurrence end must follow start');
+    if (
+      Temporal.Instant.compare(startInstant, to) >= 0 ||
+      Temporal.Instant.compare(endInstant, from) <= 0
+    )
+      continue;
+    occurrences.push({
+      originalStartLocal: slot,
+      start_at: startInstant.toString(),
+      end_at: endInstant.toString(),
+      is_all_day: anchor.allDay,
+      isException: Boolean(exception),
+    });
+  }
+  occurrences.sort(
+    (a, b) =>
+      Temporal.Instant.compare(a.start_at, b.start_at) ||
+      a.originalStartLocal.localeCompare(b.originalStartLocal)
+  );
+  return {
+    occurrences: occurrences.slice(0, limit),
+    truncated: occurrences.length > limit,
+  };
+}

package/src/calendar-recurrence-local.ts

@@ -0,0 +1,45 @@
+import { Temporal } from '@js-temporal/polyfill';
+import type { CalendarRecurrenceAnchor } from '@tuturuuu/types/primitives/calendar-recurrence';
+export function recurrenceLocalParts(value: string) {
+  const date = Temporal.PlainDateTime.from(value);
+  return { day: date.day, month: date.month, dayOfWeek: date.dayOfWeek };
+}
+export function recurrenceInitialTimes(timeZone: string, now: Date) {
+  const start = Temporal.Instant.from(now.toISOString())
+    .toZonedDateTimeISO(timeZone)
+    .toPlainDateTime()
+    .with({ second: 0, millisecond: 0 });
+  return {
+    startLocal: start.toString({ smallestUnit: 'minute' }),
+    endLocal: start.add({ hours: 1 }).toString({ smallestUnit: 'minute' }),
+    day: start.day,
+    dayOfWeek: start.dayOfWeek,
+  };
+}
+export function recurrenceInstantLocal(instant: string, timeZone: string) {
+  return Temporal.Instant.from(instant)
+    .toZonedDateTimeISO(timeZone)
+    .toPlainDateTime()
+    .toString({ smallestUnit: 'minute' });
+}
+export function recurrenceLocalAnchor(
+  start: string,
+  end: string,
+  allDay: boolean
+): CalendarRecurrenceAnchor {
+  return {
+    startLocal: Temporal.PlainDateTime.from(start).toString({
+      smallestUnit: 'second',
+    }),
+    endLocal: Temporal.PlainDateTime.from(end).toString({
+      smallestUnit: 'second',
+    }),
+    allDay,
+  };
+}
+export function recurrenceMidnightRange(startLocal: string, endLocal: string) {
+  const start = Temporal.PlainDateTime.from(startLocal).toPlainDate();
+  let end = Temporal.PlainDateTime.from(endLocal).toPlainDate();
+  if (Temporal.PlainDate.compare(end, start) <= 0) end = start.add({ days: 1 });
+  return { startLocal: `${start}T00:00`, endLocal: `${end}T00:00` };
+}