Meeting planner

// Resolve a visitor's written date/time before enabling Compare. Do not silently
// move a spring-forward gap. Offer both instants when the local time repeats.
// After that deliberate choice, pass new Date(chosenUnix * 1000).toISOString()
// as SDK at. The server remains the final conversion; compare its returned local
// wall time with this chosen value before applying browser-based preferred hours.
function resolveMeetingTime(date, time, timezone) {
  if (!/^\d{4}-\d{2}-\d{2}$/.test(date) || date.startsWith('0000')
      || !/^(?:[01]\d|2[0-3]):[0-5]\d$/.test(time)) return { kind: 'invalid', instantsUnix: [] };
  const midnight = Date.parse(date + 'T00:00:00Z');
  if (!Number.isFinite(midnight) || new Date(midnight).toISOString().slice(0, 10) !== date) return { kind: 'invalid', instantsUnix: [] };
  let formatter;
  try { formatter = new Intl.DateTimeFormat('en-CA', { timeZone: timezone,
    year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', second: '2-digit', hourCycle: 'h23' }); }
  catch { return { kind: 'invalid', instantsUnix: [] }; }
  const written = Date.parse(date + 'T' + time + ':00Z');
  function local(instant) {
    const p = Object.fromEntries(formatter.formatToParts(instant).map(part => [part.type, part.value]));
    return `${p.year.padStart(4, '0')}-${p.month}-${p.day}T${p.hour}:${p.minute}:${p.second}`;
  }
  const offsets = new Set();
  for (let hours = -48; hours <= 48; hours += 6) {
    const sample = written + hours * 3600000;
    offsets.add(Date.parse(local(sample) + 'Z') - sample);
  }
  const instantsUnix = [...offsets].map(offset => written - offset)
    .filter(instant => local(instant) === date + 'T' + time + ':00')
    .sort((a, b) => a - b).map(instant => instant / 1000);
  return { kind: !instantsUnix.length ? 'gap' : instantsUnix.length === 1 ? 'unique' : 'repeated', instantsUnix };
}

// The SDK returns the same instant for every zone. Apply only hours the visitor
// supplied. These recurring daily clock windows do not imply calendar availability.
// Each start is minute-precise. An end earlier than its start continues overnight.
function meetingMinuteReader(timezone) {
  const formatter = new Intl.DateTimeFormat('en-CA', { timeZone: timezone,
    hour: '2-digit', minute: '2-digit', hourCycle: 'h23' });
  return instant => {
    const p = Object.fromEntries(formatter.formatToParts(instant).map(part => [part.type, part.value]));
    return Number(p.hour) * 60 + Number(p.minute);
  };
}
function meetingWindows(preferences, durationMinutes) {
  if (!Number.isInteger(durationMinutes) || durationMinutes < 1 || durationMinutes > 480) throw new RangeError('Use a duration from 1 to 480 minutes.');
  const time = /^(?:[01]\d|2[0-3]):[0-5]\d$/;
  const minutes = value => { const [h, m] = value.split(':').map(Number); return h * 60 + m; };
  return preferences.filter(row => row.enabled).map(row => {
    if (!time.test(row.start) || !time.test(row.end) || row.start === row.end) throw new RangeError('Enter different start and end hours.');
    return { read: meetingMinuteReader(row.timezone), start: minutes(row.start), end: minutes(row.end) };
  });
}
function meetingMinuteFits(instant, windows) {
  return windows.every(row => { const minute = row.read(instant);
    return row.start < row.end ? minute >= row.start && minute < row.end : minute >= row.start || minute < row.end;
  });
}
function meetingFitsHours(startUnix, durationMinutes, preferences) {
  if (!Number.isSafeInteger(startUnix)) throw new RangeError('Use whole Unix seconds.');
  const windows = meetingWindows(preferences, durationMinutes);
  if (!windows.length) return null; // Hours unknown, not unrestricted availability.
  // Check the entire real interval, including a backward clock change in its middle.
  for (let minute = 0; minute < durationMinutes; minute++) {
    if (!meetingMinuteFits(startUnix * 1000 + minute * 60000, windows)) return false;
  }
  return meetingMinuteFits(startUnix * 1000 + durationMinutes * 60000 - 1, windows);
}
function meetingSourceDay(date, timezone) {
  if (!/^\d{4}-\d{2}-\d{2}$/.test(date) || date.startsWith('0000')) throw new RangeError('Enter a calendar date.');
  const base = Date.parse(date + 'T00:00:00Z');
  if (!Number.isFinite(base) || new Date(base).toISOString().slice(0, 10) !== date) throw new RangeError('Enter a calendar date.');
  const formatter = new Intl.DateTimeFormat('en-CA', { timeZone: timezone, year: 'numeric', month: '2-digit', day: '2-digit' });
  const matches = instant => {
    const p = Object.fromEntries(formatter.formatToParts(instant).map(part => [part.type, part.value]));
    return `${p.year.padStart(4, '0')}-${p.month}-${p.day}` === date;
  };
  let first = null, last = null;
  for (let hour = -48; hour <= 48; hour++) {
    const sample = base + hour * 3600000;
    if (matches(sample)) { first ??= sample; last = sample; }
  }
  if (first === null) throw new RangeError('This date does not exist in the selected source zone.');
  // Local dates can last 23 or 25 hours, or begin after a midnight clock jump.
  let low = first - 3600000, high = first;
  while (high - low > 1) { const middle = Math.floor((high + low) / 2); if (matches(middle)) high = middle; else low = middle; }
  const start = high;
  low = last; high = last + 3600000;
  while (high - low > 1) { const middle = Math.floor((high + low) / 2); if (matches(middle)) low = middle; else high = middle; }
  return { start, end: high };
}
function findCommonMeetingStarts(date, source, durationMinutes, preferences) {
  const windows = meetingWindows(preferences, durationMinutes);
  if (!windows.length) return null;
  const day = meetingSourceDay(date, source);
  const count = Math.ceil((day.end - day.start) / 60000), unavailable = [0];
  // One scan, then a prefix count tests every full duration without reformatting
  // every minute separately for every possible candidate meeting.
  for (let minute = 0; minute < count + durationMinutes; minute++) {
    unavailable.push(unavailable[minute] + (meetingMinuteFits(day.start + minute * 60000, windows) ? 0 : 1));
  }
  const ranges = [];
  for (let minute = 0; minute < count; minute++) {
    if (unavailable[minute + durationMinutes] !== unavailable[minute]) continue;
    const unix = (day.start + minute * 60000) / 1000, previous = ranges.at(-1);
    if (previous && previous.lastUnix + 60 === unix) previous.lastUnix = unix;
    else ranges.push({ firstUnix: unix, lastUnix: unix });
  }
  return ranges; // null = no supplied hours; [] = no full-duration common start.
}