@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-6JHU2UBS.js

@@ -0,0 +1,2058 @@
+"use client";
+import {
+  InlineDisabledReason,
+  SelectMenuPanel
+} from "./chunk-3CPWWGNK.js";
+import {
+  MENU_CHECK_CLASS,
+  MENU_SURFACE_CLASS
+} from "./chunk-5OTQA7CM.js";
+import {
+  containedPortal
+} from "./chunk-UD6AAZSC.js";
+import {
+  cn
+} from "./chunk-TXS65BB2.js";
+import {
+  createOpenGeniText,
+  useOpenGeniText
+} from "./chunk-7T2ZE3VT.js";
+
+// src/ui/cadence-picker.tsx
+import {
+  useEffect,
+  useId,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import {
+  CalendarClockIcon,
+  CalendarIcon,
+  CheckIcon,
+  ChevronDownIcon,
+  ChevronLeftIcon,
+  ChevronRightIcon,
+  CircleAlertIcon,
+  GlobeIcon,
+  SearchIcon
+} from "lucide-react";
+import { Popover as PopoverPrimitive, Select as SelectPrimitive } from "radix-ui";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var SelectContainedPortal = containedPortal(SelectPrimitive.Portal);
+var PopoverContainedPortal = containedPortal(PopoverPrimitive.Portal);
+var WEEKDAYS = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"];
+var WORKDAYS = ["mon", "tue", "wed", "thu", "fri"];
+var ENGLISH = createOpenGeniText();
+var WEEKDAY_KEYS = {
+  mon: {
+    short: "cadence.day.mon.short",
+    long: "cadence.day.mon.long",
+    plural: "cadence.day.mon.plural"
+  },
+  tue: {
+    short: "cadence.day.tue.short",
+    long: "cadence.day.tue.long",
+    plural: "cadence.day.tue.plural"
+  },
+  wed: {
+    short: "cadence.day.wed.short",
+    long: "cadence.day.wed.long",
+    plural: "cadence.day.wed.plural"
+  },
+  thu: {
+    short: "cadence.day.thu.short",
+    long: "cadence.day.thu.long",
+    plural: "cadence.day.thu.plural"
+  },
+  fri: {
+    short: "cadence.day.fri.short",
+    long: "cadence.day.fri.long",
+    plural: "cadence.day.fri.plural"
+  },
+  sat: {
+    short: "cadence.day.sat.short",
+    long: "cadence.day.sat.long",
+    plural: "cadence.day.sat.plural"
+  },
+  sun: {
+    short: "cadence.day.sun.short",
+    long: "cadence.day.sun.long",
+    plural: "cadence.day.sun.plural"
+  }
+};
+function weekdayName(t, day, form) {
+  return t(WEEKDAY_KEYS[day][form]);
+}
+var API_WEEKDAYS = {
+  mon: "MONDAY",
+  tue: "TUESDAY",
+  wed: "WEDNESDAY",
+  thu: "THURSDAY",
+  fri: "FRIDAY",
+  sat: "SATURDAY",
+  sun: "SUNDAY"
+};
+var MONTH_KEYS = [
+  { short: "cadence.month.jan.short", long: "cadence.month.jan.long" },
+  { short: "cadence.month.feb.short", long: "cadence.month.feb.long" },
+  { short: "cadence.month.mar.short", long: "cadence.month.mar.long" },
+  { short: "cadence.month.apr.short", long: "cadence.month.apr.long" },
+  { short: "cadence.month.may.short", long: "cadence.month.may.long" },
+  { short: "cadence.month.jun.short", long: "cadence.month.jun.long" },
+  { short: "cadence.month.jul.short", long: "cadence.month.jul.long" },
+  { short: "cadence.month.aug.short", long: "cadence.month.aug.long" },
+  { short: "cadence.month.sep.short", long: "cadence.month.sep.long" },
+  { short: "cadence.month.oct.short", long: "cadence.month.oct.long" },
+  { short: "cadence.month.nov.short", long: "cadence.month.nov.long" },
+  { short: "cadence.month.dec.short", long: "cadence.month.dec.long" }
+];
+function monthName(t, month, form) {
+  return t(MONTH_KEYS[month - 1][form]);
+}
+var TYPED_MONTHS = [
+  "january",
+  "february",
+  "march",
+  "april",
+  "may",
+  "june",
+  "july",
+  "august",
+  "september",
+  "october",
+  "november",
+  "december"
+];
+var UNIT_SECONDS = { minutes: 60, hours: 3600, days: 86400 };
+var UNIT_LIMITS = { minutes: 1440, hours: 168, days: 365 };
+var DAY_MS = 864e5;
+var DEFAULT_CADENCE_TIME = "09:00";
+var partsFormatters = /* @__PURE__ */ new Map();
+function partsFormatter(timeZone) {
+  let formatter = partsFormatters.get(timeZone);
+  if (!formatter) {
+    formatter = new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      hourCycle: "h23",
+      year: "numeric",
+      month: "numeric",
+      day: "numeric",
+      hour: "numeric",
+      minute: "numeric",
+      second: "numeric"
+    });
+    partsFormatters.set(timeZone, formatter);
+  }
+  return formatter;
+}
+function zonedParts(date, timeZone) {
+  const values = {};
+  for (const part of partsFormatter(timeZone).formatToParts(date)) {
+    if (part.type !== "literal") values[part.type] = Number(part.value);
+  }
+  return {
+    year: values.year ?? 1970,
+    month: values.month ?? 1,
+    day: values.day ?? 1,
+    hour: (values.hour ?? 0) % 24,
+    minute: values.minute ?? 0,
+    second: values.second ?? 0
+  };
+}
+function offsetMs(date, timeZone) {
+  const p = zonedParts(date, timeZone);
+  const asUtc = Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute, p.second);
+  return asUtc - Math.floor(date.getTime() / 1e3) * 1e3;
+}
+function zonedTimeToUtc(date, time, timeZone) {
+  const guess = Date.UTC(date.year, date.month - 1, date.day, time.hour, time.minute);
+  const first = offsetMs(new Date(guess), timeZone);
+  let instant = guess - first;
+  const second = offsetMs(new Date(instant), timeZone);
+  if (second !== first) instant = guess - second;
+  return new Date(instant);
+}
+function localDateOf(date, timeZone) {
+  const { year, month, day } = zonedParts(date, timeZone);
+  return { year, month, day };
+}
+function addDays(date, days) {
+  const next = new Date(Date.UTC(date.year, date.month - 1, date.day + days));
+  return { year: next.getUTCFullYear(), month: next.getUTCMonth() + 1, day: next.getUTCDate() };
+}
+function dayNumber(date) {
+  return Date.UTC(date.year, date.month - 1, date.day) / DAY_MS;
+}
+function weekdayOf(date) {
+  const index = (new Date(Date.UTC(date.year, date.month - 1, date.day)).getUTCDay() + 6) % 7;
+  return WEEKDAYS[index];
+}
+function daysInMonth(year, month) {
+  return new Date(Date.UTC(year, month, 0)).getUTCDate();
+}
+function formatLocalDate(date) {
+  return `${date.year}-${pad(date.month)}-${pad(date.day)}`;
+}
+function parseLocalDate(value) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (!match) return null;
+  const date = { year: Number(match[1]), month: Number(match[2]), day: Number(match[3]) };
+  if (date.month < 1 || date.month > 12) return null;
+  if (date.day < 1 || date.day > daysInMonth(date.year, date.month)) return null;
+  return date;
+}
+function timeZoneLabels(timeZone, text = ENGLISH) {
+  if (timeZone === "UTC" || timeZone === "Etc/UTC") return { label: "UTC", shortLabel: "UTC" };
+  const city = (timeZone.split("/").pop() ?? timeZone).replaceAll("_", " ");
+  return { label: text("cadence.zoneTime", { city }), shortLabel: city };
+}
+function pad(value) {
+  return String(value).padStart(2, "0");
+}
+function parseTime(value) {
+  const match = /^([01]\d|2[0-3]):([0-5]\d)$/.exec(value);
+  if (!match) return null;
+  return { hour: Number(match[1]), minute: Number(match[2]) };
+}
+function normalizeTime(input) {
+  const text = input.trim().toLowerCase().replace(/\s+/g, "");
+  if (!text) return null;
+  const meridiem = /^(\d{1,2})(?:[:.]?(\d{2}))?(am|pm)$/.exec(text);
+  if (meridiem) {
+    let hour2 = Number(meridiem[1]);
+    const minute2 = Number(meridiem[2] ?? "0");
+    if (hour2 < 1 || hour2 > 12 || minute2 > 59) return null;
+    if (meridiem[3] === "am") hour2 = hour2 === 12 ? 0 : hour2;
+    else hour2 = hour2 === 12 ? 12 : hour2 + 12;
+    return `${pad(hour2)}:${pad(minute2)}`;
+  }
+  let hour;
+  let minute;
+  const separated = /^(\d{1,2})[:.h](\d{1,2})$/.exec(text);
+  if (separated) {
+    hour = Number(separated[1]);
+    minute = Number(separated[2].length === 1 ? `${separated[2]}0` : separated[2]);
+  } else if (/^\d{1,2}$/.test(text)) {
+    hour = Number(text);
+    minute = 0;
+  } else if (/^\d{3,4}$/.test(text)) {
+    hour = Number(text.slice(0, -2));
+    minute = Number(text.slice(-2));
+  } else {
+    return null;
+  }
+  if (hour > 23 || minute > 59) return null;
+  return `${pad(hour)}:${pad(minute)}`;
+}
+function stepTime(value, minutes) {
+  const time = parseTime(value) ?? parseTime(DEFAULT_CADENCE_TIME);
+  const total = ((time.hour * 60 + time.minute + minutes) % 1440 + 1440) % 1440;
+  return `${pad(Math.floor(total / 60))}:${pad(total % 60)}`;
+}
+function dateLabel(t, date, today) {
+  const words = {
+    weekday: weekdayName(t, weekdayOf(date), "short"),
+    day: date.day,
+    month: monthName(t, date.month, "short")
+  };
+  return date.year === today.year ? t("cadence.date", words) : t("cadence.dateWithYear", { ...words, year: date.year });
+}
+function relativeDateLabel(t, date, today) {
+  const delta = dayNumber(date) - dayNumber(today);
+  if (delta === 0) return t("cadence.today");
+  if (delta === 1) return t("cadence.tomorrow");
+  return dateLabel(t, date, today);
+}
+function joinList(t, items) {
+  if (items.length <= 1) return items.join("");
+  return t("cadence.and", { head: items.slice(0, -1).join(", "), last: items.at(-1) });
+}
+function formatRunTime(date, { timeZone, now, text = ENGLISH }) {
+  const parts = zonedParts(date, timeZone);
+  const today = localDateOf(now, timeZone);
+  return text("cadence.runTime", {
+    date: relativeDateLabel(text, parts, today),
+    time: `${pad(parts.hour)}:${pad(parts.minute)}`
+  });
+}
+function describeNextRuns(runs, options) {
+  const [first, ...rest] = runs;
+  if (!first) return "";
+  const t = options.text ?? ENGLISH;
+  const today = localDateOf(options.now, options.timeZone);
+  const firstParts = zonedParts(first, options.timeZone);
+  const labels = rest.map((run, index) => {
+    const parts = zonedParts(run, options.timeZone);
+    const previous = zonedParts(runs[index], options.timeZone);
+    const time = `${pad(parts.hour)}:${pad(parts.minute)}`;
+    if (dayNumber(parts) === dayNumber(previous)) return time;
+    if (parts.hour === firstParts.hour && parts.minute === firstParts.minute) {
+      return relativeDateLabel(t, parts, today);
+    }
+    return t("cadence.runTime", { date: relativeDateLabel(t, parts, today), time });
+  });
+  const head = formatRunTime(first, options);
+  if (labels.length === 0) return head;
+  return t("cadence.then", { first: head, rest: joinList(t, labels) });
+}
+function listDays(t, days, form) {
+  const names = sortDays(days).map((day) => weekdayName(t, day, form));
+  if (form === "short" && names.length > 2) return names.join(", ");
+  return joinList(t, names);
+}
+function sortDays(days) {
+  return WEEKDAYS.filter((day) => days.includes(day));
+}
+function sameDays(a, b) {
+  const left = sortDays(a);
+  const right = sortDays(b);
+  return left.length === right.length && left.every((day, index) => day === right[index]);
+}
+function unitLabel(t, every, unit) {
+  switch (unit) {
+    case "minutes":
+      return t("cadence.every.minutes", { count: every });
+    case "hours":
+      return t("cadence.every.hours", { count: every });
+    case "days":
+      return t("cadence.every.days", { count: every });
+  }
+}
+function describeCadence(rule, options) {
+  const t = options.text ?? ENGLISH;
+  const labels = timeZoneLabels(options.timeZone, t);
+  const zone = options.timeZoneLabel ?? labels.label;
+  const zoneShort = options.timeZoneShortLabel ?? labels.shortLabel;
+  const at = (time) => t("cadence.at", { time, zone }).trim();
+  const atShort = (time) => t("cadence.atShort", { time, zone: zoneShort });
+  switch (rule.frequency) {
+    case "hourly":
+      return {
+        sentence: t("cadence.describe.hourly"),
+        short: t("cadence.describe.hourlyShort")
+      };
+    case "daily":
+      return {
+        sentence: t("cadence.describe.daily", { at: at(rule.time) }),
+        short: t("cadence.describe.dailyShort", { at: atShort(rule.time) })
+      };
+    case "weekdays":
+      return {
+        sentence: t("cadence.describe.weekdays", { at: at(rule.time) }),
+        short: t("cadence.describe.weekdaysShort", { at: atShort(rule.time) })
+      };
+    case "weekly": {
+      if (sameDays(rule.days, WORKDAYS)) {
+        return describeCadence({ frequency: "weekdays", time: rule.time }, options);
+      }
+      if (sameDays(rule.days, WEEKDAYS)) {
+        return describeCadence({ frequency: "daily", time: rule.time }, options);
+      }
+      if (rule.days.length === 0) {
+        return {
+          sentence: t("cadence.describe.weeklyNoDays"),
+          short: t("cadence.describe.weeklyNoDaysShort")
+        };
+      }
+      return {
+        sentence: t("cadence.describe.weekly", {
+          days: listDays(t, rule.days, "long"),
+          at: at(rule.time)
+        }),
+        short: t("cadence.describe.weeklyShort", {
+          days: listDays(t, rule.days, "short"),
+          at: atShort(rule.time)
+        })
+      };
+    }
+    case "monthly":
+      return {
+        sentence: t("cadence.describe.monthly", { day: rule.dayOfMonth, at: at(rule.time) }),
+        short: t("cadence.describe.monthlyShort", { day: rule.dayOfMonth, at: atShort(rule.time) })
+      };
+    case "interval": {
+      const every = unitLabel(t, rule.every, rule.unit);
+      if (rule.unit === "days" && rule.time) {
+        return {
+          sentence: t("cadence.describe.intervalAt", { every, at: at(rule.time) }),
+          short: t("cadence.describe.intervalAtShort", { every, at: atShort(rule.time) })
+        };
+      }
+      return {
+        sentence: t("cadence.describe.interval", { every }),
+        short: t("cadence.describe.intervalShort", { every })
+      };
+    }
+    case "once": {
+      const once = onceParts(rule, options.timeZone);
+      if (!once) {
+        return { sentence: t("cadence.describe.once"), short: t("cadence.describe.onceShort") };
+      }
+      const today = options.now ? localDateOf(options.now, options.timeZone) : once.date;
+      const date = dateLabel(t, once.date, today);
+      return {
+        sentence: t("cadence.describe.onceOn", { date, at: at(once.time) }),
+        short: t("cadence.describe.onceOnShort", { date, time: once.time, zone: zoneShort })
+      };
+    }
+  }
+}
+function onceParts(rule, timeZone) {
+  if ("at" in rule) {
+    const instant = new Date(rule.at);
+    if (Number.isNaN(instant.getTime())) return null;
+    const parts = zonedParts(instant, timeZone);
+    return { date: parts, time: `${pad(parts.hour)}:${pad(parts.minute)}` };
+  }
+  const date = parseLocalDate(rule.date);
+  return date ? { date, time: rule.time } : null;
+}
+function normalizeCadenceRule(rule, timeZone) {
+  if (rule.frequency !== "once" || !("at" in rule)) return rule;
+  const once = onceParts(rule, timeZone);
+  if (!once) return rule;
+  return { frequency: "once", date: formatLocalDate(once.date), time: once.time };
+}
+function validateCadence(rule, { timeZone, now, text = ENGLISH }) {
+  const timeIssue = (time) => time !== void 0 && !parseTime(time) ? { field: "time", message: text("cadence.issue.time") } : null;
+  switch (rule.frequency) {
+    case "hourly":
+      return null;
+    case "daily":
+    case "weekdays":
+      return timeIssue(rule.time);
+    case "weekly":
+      if (rule.days.length === 0) return { field: "days", message: text("cadence.issue.days") };
+      return timeIssue(rule.time);
+    case "monthly":
+      if (!Number.isInteger(rule.dayOfMonth) || rule.dayOfMonth < 1 || rule.dayOfMonth > 31) {
+        return { field: "dayOfMonth", message: text("cadence.issue.dayOfMonth") };
+      }
+      return timeIssue(rule.time);
+    case "interval": {
+      const limit = UNIT_LIMITS[rule.unit];
+      if (!Number.isInteger(rule.every) || rule.every < 1 || rule.every > limit) {
+        return { field: "every", message: text("cadence.issue.every", { limit }) };
+      }
+      return rule.unit === "days" ? timeIssue(rule.time) : null;
+    }
+    case "once": {
+      if (!("at" in rule)) {
+        if (!parseLocalDate(rule.date))
+          return { field: "date", message: text("cadence.issue.date") };
+        const issue = timeIssue(rule.time);
+        if (issue) return issue;
+      }
+      const [run] = onceRun(rule, timeZone);
+      if (!run) return { field: "date", message: text("cadence.issue.date") };
+      if (run.getTime() <= now.getTime()) {
+        return {
+          field: "date",
+          message: text("cadence.issue.passed", {
+            time: formatRunTime(run, { timeZone, now, text })
+          })
+        };
+      }
+      return null;
+    }
+  }
+}
+function onceRun(rule, timeZone) {
+  if ("at" in rule) {
+    const instant = new Date(rule.at);
+    return Number.isNaN(instant.getTime()) ? [] : [instant];
+  }
+  const date = parseLocalDate(rule.date);
+  const time = parseTime(rule.time);
+  return date && time ? [zonedTimeToUtc(date, time, timeZone)] : [];
+}
+function intervalAnchor(rule, { timeZone, now }) {
+  if (rule.startAt) {
+    const start = new Date(rule.startAt).getTime();
+    if (!Number.isNaN(start)) return start;
+  }
+  const time = rule.unit === "days" && rule.time ? parseTime(rule.time) : null;
+  if (!time) return 0;
+  const today = localDateOf(now, timeZone);
+  const todayRun = zonedTimeToUtc(today, time, timeZone);
+  return todayRun.getTime() > now.getTime() ? todayRun.getTime() : zonedTimeToUtc(addDays(today, 1), time, timeZone).getTime();
+}
+function nextRuns(rule, options) {
+  const { timeZone, now } = options;
+  const count = options.count ?? 3;
+  if (validateCadence(rule, options)) return [];
+  const runs = [];
+  const nowMs = now.getTime();
+  const calendarRuns = (time, matches) => {
+    const clock = parseTime(time);
+    const today = localDateOf(now, timeZone);
+    for (let offset = 0; offset < 400 && runs.length < count; offset += 1) {
+      const date = addDays(today, offset);
+      if (!matches(date)) continue;
+      const run = zonedTimeToUtc(date, clock, timeZone);
+      if (run.getTime() > nowMs) runs.push(run);
+    }
+  };
+  switch (rule.frequency) {
+    case "hourly":
+      return nextRuns({ frequency: "interval", every: 1, unit: "hours" }, options);
+    case "daily":
+      calendarRuns(rule.time, () => true);
+      return runs;
+    case "weekdays":
+      calendarRuns(rule.time, (date) => WORKDAYS.includes(weekdayOf(date)));
+      return runs;
+    case "weekly":
+      calendarRuns(rule.time, (date) => rule.days.includes(weekdayOf(date)));
+      return runs;
+    case "monthly": {
+      const clock = parseTime(rule.time);
+      const today = localDateOf(now, timeZone);
+      for (let step = 0; step < 48 && runs.length < count; step += 1) {
+        const monthIndex = today.month - 1 + step;
+        const year = today.year + Math.floor(monthIndex / 12);
+        const month = monthIndex % 12 + 1;
+        if (rule.dayOfMonth > daysInMonth(year, month)) continue;
+        const run = zonedTimeToUtc({ year, month, day: rule.dayOfMonth }, clock, timeZone);
+        if (run.getTime() > nowMs) runs.push(run);
+      }
+      return runs;
+    }
+    case "interval": {
+      const period = rule.every * UNIT_SECONDS[rule.unit] * 1e3;
+      const anchor = intervalAnchor(rule, options);
+      let next = anchor > nowMs ? anchor : anchor + (Math.floor((nowMs - anchor) / period) + 1) * period;
+      while (runs.length < count) {
+        runs.push(new Date(next));
+        next += period;
+      }
+      return runs;
+    }
+    case "once":
+      return onceRun(rule, timeZone).filter((run) => run.getTime() > nowMs);
+  }
+}
+function toScheduleSpec(rule, { timeZone, now }) {
+  const calendar = (time, extra) => {
+    const clock = parseTime(time) ?? parseTime(DEFAULT_CADENCE_TIME);
+    return {
+      type: "calendar",
+      timeZone,
+      hour: clock.hour,
+      minute: clock.minute,
+      ...extra
+    };
+  };
+  switch (rule.frequency) {
+    case "hourly":
+      return { type: "interval", everySeconds: 3600 };
+    case "daily":
+      return calendar(rule.time, {});
+    case "weekdays":
+      return calendar(rule.time, { daysOfWeek: WORKDAYS.map((day) => API_WEEKDAYS[day]) });
+    case "weekly":
+      return calendar(rule.time, {
+        daysOfWeek: sortDays(rule.days).map((day) => API_WEEKDAYS[day])
+      });
+    case "monthly":
+      return calendar(rule.time, { daysOfMonth: [rule.dayOfMonth] });
+    case "interval": {
+      const everySeconds = rule.every * UNIT_SECONDS[rule.unit];
+      if (rule.startAt) return { type: "interval", everySeconds, startAt: rule.startAt };
+      if (rule.unit === "days" && rule.time) {
+        const anchor = intervalAnchor(rule, { timeZone, now });
+        return { type: "interval", everySeconds, startAt: new Date(anchor).toISOString() };
+      }
+      return { type: "interval", everySeconds };
+    }
+    case "once": {
+      const [run] = onceRun(rule, timeZone);
+      return { type: "once", runAt: (run ?? now).toISOString(), timeZone };
+    }
+  }
+}
+function cadenceFromScheduleSpec(spec, fallbackTimeZone) {
+  switch (spec.type) {
+    case "once": {
+      const instant = new Date(spec.runAt);
+      const parts = zonedParts(instant, spec.timeZone);
+      return {
+        timeZone: spec.timeZone,
+        rule: {
+          frequency: "once",
+          date: formatLocalDate(parts),
+          time: `${pad(parts.hour)}:${pad(parts.minute)}`
+        }
+      };
+    }
+    case "interval": {
+      const seconds = spec.everySeconds;
+      if (seconds === 3600 && !spec.startAt) {
+        return { timeZone: fallbackTimeZone, rule: { frequency: "hourly" } };
+      }
+      if (seconds % 86400 === 0) {
+        const time = spec.startAt ? zonedParts(new Date(spec.startAt), fallbackTimeZone) : null;
+        return {
+          timeZone: fallbackTimeZone,
+          rule: {
+            frequency: "interval",
+            every: seconds / 86400,
+            unit: "days",
+            ...time ? { time: `${pad(time.hour)}:${pad(time.minute)}` } : {},
+            ...spec.startAt ? { startAt: spec.startAt } : {}
+          }
+        };
+      }
+      const unit = seconds % 3600 === 0 ? "hours" : "minutes";
+      return {
+        timeZone: fallbackTimeZone,
+        rule: {
+          frequency: "interval",
+          every: Math.max(1, Math.round(seconds / UNIT_SECONDS[unit])),
+          unit,
+          ...spec.startAt ? { startAt: spec.startAt } : {}
+        }
+      };
+    }
+    case "calendar": {
+      const time = `${pad(spec.hour)}:${pad(spec.minute)}`;
+      const monthDay = spec.daysOfMonth?.[0];
+      if (monthDay !== void 0) {
+        return {
+          timeZone: spec.timeZone,
+          rule: { frequency: "monthly", dayOfMonth: monthDay, time }
+        };
+      }
+      const days = (spec.daysOfWeek ?? []).flatMap(
+        (apiDay) => WEEKDAYS.filter((day) => API_WEEKDAYS[day] === apiDay)
+      );
+      if (days.length === 0 || sameDays(days, WEEKDAYS)) {
+        return { timeZone: spec.timeZone, rule: { frequency: "daily", time } };
+      }
+      if (sameDays(days, WORKDAYS)) {
+        return { timeZone: spec.timeZone, rule: { frequency: "weekdays", time } };
+      }
+      return { timeZone: spec.timeZone, rule: { frequency: "weekly", days: sortDays(days), time } };
+    }
+  }
+}
+var DAY_TOKENS = [
+  [/\bmon(?:day)?s?\b/g, "mon"],
+  [/\btue(?:s|sday)?s?\b/g, "tue"],
+  [/\bwed(?:nesday)?s?\b/g, "wed"],
+  [/\bthu(?:r|rs|rsday)?s?\b/g, "thu"],
+  [/\bfri(?:day)?s?\b/g, "fri"],
+  [/\bsat(?:urday)?s?\b/g, "sat"],
+  [/\bsun(?:day)?s?\b/g, "sun"]
+];
+var PARSE_HINT = 'Try "every weekday at 8" or "1st of every month at 9".';
+function parseCadence(input, { timeZone, now }) {
+  let text = ` ${input.toLowerCase().replace(/[,;]/g, " ").replace(/\s+/g, " ").trim()} `;
+  text = text.replace(/^ (?:runs?|repeat|repeats) /, " ");
+  if (!text.trim()) {
+    return { ok: false, message: 'Describe when it should run, like "every weekday at 8".' };
+  }
+  let time = null;
+  let badTime = false;
+  const takeTime = (pattern, read) => {
+    if (time || badTime) return;
+    const match = pattern.exec(text);
+    if (!match) return;
+    const value = read(match);
+    if (value) time = value;
+    else badTime = true;
+    text = text.replace(match[0], " ");
+  };
+  takeTime(/\b(?:at )?(noon|midday)\b/, () => "12:00");
+  takeTime(/\b(?:at )?midnight\b/, () => "00:00");
+  takeTime(
+    /\b(?:at )?(\d{1,2})(?:[:.](\d{2}))? ?(am|pm)\b/,
+    (m) => normalizeTime(`${m[1]}${m[2] ? `:${m[2]}` : ""}${m[3]}`)
+  );
+  takeTime(
+    /\bat (\d{1,2})(?:[:.h](\d{2}))?\b/,
+    (m) => normalizeTime(`${m[1]}${m[2] ? `:${m[2]}` : ""}`)
+  );
+  takeTime(/\b(\d{1,2})[:.](\d{2})\b/, (m) => normalizeTime(`${m[1]}:${m[2]}`));
+  if (badTime) return { ok: false, message: "That time doesn't exist. Use a time like 08:00." };
+  const clock = time ?? DEFAULT_CADENCE_TIME;
+  const halfHour = /\bevery half(?: an)? hour\b/.exec(text);
+  if (halfHour) return { ok: true, rule: { frequency: "interval", every: 30, unit: "minutes" } };
+  if (/\bevery other day\b/.test(text)) {
+    return { ok: true, rule: { frequency: "interval", every: 2, unit: "days", time: clock } };
+  }
+  const interval = /\bevery (\d+) ?(minutes?|mins?|m|hours?|hrs?|h|days?|d)\b/.exec(text);
+  if (interval) {
+    const every = Number(interval[1]);
+    const token = interval[2];
+    const unit = token.startsWith("m") ? "minutes" : token.startsWith("h") ? "hours" : "days";
+    if (unit === "hours" && every === 1) return { ok: true, rule: { frequency: "hourly" } };
+    if (unit === "days" && every === 1)
+      return { ok: true, rule: { frequency: "daily", time: clock } };
+    const rule = unit === "days" ? { frequency: "interval", every, unit, time: clock } : { frequency: "interval", every, unit };
+    const issue = validateCadence(rule, { timeZone, now });
+    return issue ? { ok: false, message: issue.message } : { ok: true, rule };
+  }
+  if (/\b(?:every|each) minute\b/.test(text)) {
+    return { ok: true, rule: { frequency: "interval", every: 1, unit: "minutes" } };
+  }
+  if (/\b(?:hourly|(?:every|each) hour)\b/.test(text))
+    return { ok: true, rule: { frequency: "hourly" } };
+  if (/\b(?:monthly|(?:every|each|a|per) month|of (?:every|each|the) month)\b/.test(text)) {
+    if (/\blast day\b/.test(text)) {
+      return {
+        ok: false,
+        message: "The last day of the month isn't supported yet. Pick a day from 1 to 31."
+      };
+    }
+    const dayMatch = /\b(?:day )?(\d{1,2})(?:st|nd|rd|th)?\b/.exec(
+      text.replace(/\b(?:monthly|every|each|month|of|the|on)\b/g, " ")
+    );
+    const dayOfMonth = dayMatch ? Number(dayMatch[1]) : 1;
+    const rule = { frequency: "monthly", dayOfMonth, time: clock };
+    const issue = validateCadence(rule, { timeZone, now });
+    return issue ? { ok: false, message: issue.message } : { ok: true, rule };
+  }
+  if (/\b(?:weekdays?|workdays?|business days?|working days?)\b/.test(text) || /\bmon(?:day)? ?(?:-|to|through|until) ?fri(?:day)?\b/.test(text)) {
+    return { ok: true, rule: { frequency: "weekdays", time: clock } };
+  }
+  if (/\bweekends?\b/.test(text)) {
+    return { ok: true, rule: { frequency: "weekly", days: ["sat", "sun"], time: clock } };
+  }
+  const today = localDateOf(now, timeZone);
+  let onceDate = null;
+  if (/\btoday\b|\btonight\b/.test(text)) onceDate = today;
+  else if (/\btomorrow\b/.test(text)) onceDate = addDays(today, 1);
+  else {
+    const iso = /\b(\d{4}-\d{2}-\d{2})\b/.exec(text);
+    if (iso) onceDate = parseLocalDate(iso[1]);
+    const monthPattern = TYPED_MONTHS.map((name) => name.slice(0, 3)).join("|");
+    const dayMonth = new RegExp(
+      `\\b(\\d{1,2})(?:st|nd|rd|th)? (?:of )?(${monthPattern})[a-z]*\\b`
+    ).exec(text);
+    const monthDay = new RegExp(`\\b(${monthPattern})[a-z]* (\\d{1,2})(?:st|nd|rd|th)?\\b`).exec(
+      text
+    );
+    const found = dayMonth ? { day: Number(dayMonth[1]), month: dayMonth[2] } : monthDay ? { day: Number(monthDay[2]), month: monthDay[1] } : null;
+    if (!onceDate && found) {
+      const month = TYPED_MONTHS.findIndex((name) => name.startsWith(found.month)) + 1;
+      let year = today.year;
+      if (month < today.month || month === today.month && found.day < today.day) year += 1;
+      onceDate = found.day <= daysInMonth(year, month) ? { year, month, day: found.day } : null;
+      if (!onceDate) return { ok: false, message: "That date doesn't exist. Pick another day." };
+    }
+    const nextDay = /\b(next|this) (mon|tue|wed|thu|fri|sat|sun)(?:day)?\b/.exec(text);
+    if (!onceDate && nextDay && !/\b(?:every|each)\b/.test(text)) {
+      const target = WEEKDAYS.indexOf(nextDay[2]);
+      const current = WEEKDAYS.indexOf(weekdayOf(today));
+      const delta = (target - current + 7) % 7;
+      onceDate = addDays(today, delta === 0 && nextDay[1] === "next" ? 7 : delta);
+    }
+  }
+  if (onceDate) {
+    const rule = { frequency: "once", date: formatLocalDate(onceDate), time: clock };
+    const issue = validateCadence(rule, { timeZone, now });
+    return issue ? { ok: false, message: issue.message } : { ok: true, rule };
+  }
+  const days = /* @__PURE__ */ new Set();
+  for (const [pattern, day] of DAY_TOKENS) {
+    if (new RegExp(pattern.source).test(text)) days.add(day);
+  }
+  if (days.size > 0) {
+    const sorted = sortDays([...days]);
+    if (sameDays(sorted, WORKDAYS))
+      return { ok: true, rule: { frequency: "weekdays", time: clock } };
+    if (sameDays(sorted, WEEKDAYS)) return { ok: true, rule: { frequency: "daily", time: clock } };
+    return { ok: true, rule: { frequency: "weekly", days: sorted, time: clock } };
+  }
+  if (/\b(?:daily|(?:every|each) (?:day|morning|evening|night))\b/.test(text) || time && /\bevery\b/.test(text)) {
+    return { ok: true, rule: { frequency: "daily", time: clock } };
+  }
+  if (/\b(?:weekly|(?:every|each) week)\b/.test(text)) {
+    return { ok: true, rule: { frequency: "weekly", days: ["mon"], time: clock } };
+  }
+  return { ok: false, message: `Couldn't read that. ${PARSE_HINT}` };
+}
+var ALL_FREQUENCIES = [
+  "hourly",
+  "daily",
+  "weekdays",
+  "weekly",
+  "monthly",
+  "interval",
+  "once"
+];
+function frequencyWords(t, frequency) {
+  switch (frequency) {
+    case "hourly":
+      return {
+        label: t("cadence.frequency.hourly"),
+        trigger: t("cadence.frequency.hourly"),
+        preset: t("cadence.frequency.hourlyPreset"),
+        description: t("cadence.frequency.hourlyDescription")
+      };
+    case "daily":
+      return {
+        label: t("cadence.frequency.daily"),
+        trigger: t("cadence.frequency.daily"),
+        preset: t("cadence.frequency.dailyPreset"),
+        description: t("cadence.frequency.dailyDescription")
+      };
+    case "weekdays":
+      return {
+        label: t("cadence.frequency.weekdays"),
+        trigger: t("cadence.frequency.weekdays"),
+        preset: t("cadence.frequency.weekdaysPreset"),
+        description: t("cadence.frequency.weekdaysDescription")
+      };
+    case "weekly":
+      return {
+        label: t("cadence.frequency.weekly"),
+        trigger: t("cadence.frequency.weekly"),
+        preset: t("cadence.frequency.weeklyPreset"),
+        description: t("cadence.frequency.weeklyDescription")
+      };
+    case "monthly":
+      return {
+        label: t("cadence.frequency.monthly"),
+        trigger: t("cadence.frequency.monthly"),
+        preset: t("cadence.frequency.monthlyPreset"),
+        description: t("cadence.frequency.monthlyDescription")
+      };
+    case "interval":
+      return {
+        label: t("cadence.frequency.interval"),
+        trigger: t("cadence.frequency.intervalTrigger"),
+        preset: t("cadence.frequency.intervalPreset"),
+        description: t("cadence.frequency.intervalDescription")
+      };
+    case "once":
+      return {
+        label: t("cadence.frequency.once"),
+        trigger: t("cadence.frequency.once"),
+        preset: t("cadence.frequency.oncePreset"),
+        description: t("cadence.frequency.onceDescription")
+      };
+  }
+}
+function unitOptions(t, every) {
+  const one = every === 1;
+  return [
+    { value: "minutes", label: one ? t("cadence.unit.minute") : t("cadence.unit.minutes") },
+    { value: "hours", label: one ? t("cadence.unit.hour") : t("cadence.unit.hours") },
+    { value: "days", label: one ? t("cadence.unit.day") : t("cadence.unit.days") }
+  ];
+}
+function ruleTime(rule) {
+  if (rule.frequency === "hourly") return void 0;
+  if (rule.frequency === "once") return "at" in rule ? void 0 : rule.time;
+  return rule.time;
+}
+function usesTime(rule) {
+  if (rule.frequency === "hourly") return false;
+  if (rule.frequency === "interval") return rule.unit === "days";
+  return true;
+}
+function switchFrequency(rule, frequency, { timeZone, now }) {
+  const time = ruleTime(rule) ?? DEFAULT_CADENCE_TIME;
+  switch (frequency) {
+    case "hourly":
+      return { frequency: "hourly" };
+    case "daily":
+      return { frequency: "daily", time };
+    case "weekdays":
+      return { frequency: "weekdays", time };
+    case "weekly":
+      return {
+        frequency: "weekly",
+        days: rule.frequency === "weekly" && rule.days.length > 0 ? rule.days : ["mon"],
+        time
+      };
+    case "monthly":
+      return { frequency: "monthly", dayOfMonth: 1, time };
+    case "interval":
+      return { frequency: "interval", every: 30, unit: "minutes" };
+    case "once":
+      return {
+        frequency: "once",
+        date: formatLocalDate(addDays(localDateOf(now, timeZone), 1)),
+        time
+      };
+  }
+}
+function withTime(rule, time) {
+  if (rule.frequency === "hourly") return rule;
+  if (rule.frequency === "once") return "at" in rule ? rule : { ...rule, time };
+  return { ...rule, time };
+}
+function cadencePhrase(rule, timeZone, now) {
+  const { sentence } = describeCadence(rule, { timeZone, timeZoneLabel: "", now });
+  return sentence.replace(/^Runs /, "").trim();
+}
+var fieldBase = "inline-flex h-9 min-w-0 items-center gap-2 rounded-[10px] border border-border bg-surface px-3 text-sm text-fg transition-colors duration-[120ms] hover:border-border-strong disabled:cursor-not-allowed disabled:border-border disabled:bg-surface-2 disabled:text-fg-muted aria-invalid:border-danger aria-invalid:hover:border-danger data-[state=open]:border-border-strong pointer-coarse:h-11";
+var inputBase = cn(
+  fieldBase,
+  "cursor-text justify-center px-2 text-center tabular-nums focus-visible:border-brand pointer-coarse:text-base"
+);
+var popoverPanel = cn(MENU_SURFACE_CLASS, "z-50 overflow-hidden p-0 outline-hidden");
+var menuContent = cn(
+  popoverPanel,
+  "max-h-(--radix-select-content-available-height) min-w-(--radix-select-trigger-width)"
+);
+var menuItem = "relative flex min-h-8 cursor-pointer items-start gap-2.5 rounded-[10px] py-1.5 pr-9 pl-2.5 text-sm text-fg outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:text-fg-muted data-[highlighted]:bg-surface-2 pointer-coarse:min-h-11";
+var connector = "text-sm text-fg-muted";
+function ValueSelect({
+  value,
+  options,
+  onValueChange,
+  triggerLabel,
+  label,
+  disabled,
+  invalid,
+  describedBy,
+  className,
+  contentClassName
+}) {
+  const selected = options.find((option) => option.value === value);
+  return /* @__PURE__ */ jsxs(
+    SelectPrimitive.Root,
+    {
+      value,
+      onValueChange: (next) => onValueChange(next),
+      disabled: disabled ?? false,
+      children: [
+        /* @__PURE__ */ jsxs(
+          SelectPrimitive.Trigger,
+          {
+            "aria-label": label,
+            "aria-invalid": invalid || void 0,
+            "aria-describedby": describedBy,
+            className: cn(fieldBase, "group/value-select justify-between", className),
+            children: [
+              /* @__PURE__ */ jsx("span", { className: "min-w-0 truncate", children: /* @__PURE__ */ jsx(SelectPrimitive.Value, { children: triggerLabel ?? selected?.label }) }),
+              /* @__PURE__ */ jsx(SelectPrimitive.Icon, { asChild: true, children: /* @__PURE__ */ jsx(
+                ChevronDownIcon,
+                {
+                  "aria-hidden": "true",
+                  className: "size-4 shrink-0 text-fg-subtle transition-transform duration-[120ms] group-data-[state=open]/value-select:rotate-180"
+                }
+              ) })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx(SelectContainedPortal, { children: /* @__PURE__ */ jsx(
+          SelectPrimitive.Content,
+          {
+            position: "popper",
+            sideOffset: 6,
+            align: "start",
+            className: cn(menuContent, contentClassName),
+            children: /* @__PURE__ */ jsx(SelectPrimitive.Viewport, { className: "max-h-[26rem] p-1.5", children: options.map((option) => /* @__PURE__ */ jsxs(SelectPrimitive.Item, { value: option.value, className: menuItem, children: [
+              /* @__PURE__ */ jsxs("span", { className: "flex min-w-0 flex-col", children: [
+                /* @__PURE__ */ jsx(SelectPrimitive.ItemText, { children: /* @__PURE__ */ jsx("span", { children: option.label }) }),
+                option.description ? /* @__PURE__ */ jsx("span", { className: "mt-0.5 text-xs leading-4.5 text-fg-muted", children: option.description }) : null
+              ] }),
+              /* @__PURE__ */ jsx(SelectPrimitive.ItemIndicator, { className: "absolute top-2 right-2.5", children: /* @__PURE__ */ jsx(CheckIcon, { "aria-hidden": "true", className: MENU_CHECK_CLASS }) })
+            ] }, option.value)) })
+          }
+        ) })
+      ]
+    }
+  );
+}
+function TimeField({
+  value,
+  onChange,
+  label: labelProp,
+  disabled,
+  id,
+  className
+}) {
+  const t = useOpenGeniText();
+  const label = labelProp ?? t("cadence.picker.time");
+  const [draft, setDraft] = useState(value);
+  const [focused, setFocused] = useState(false);
+  useEffect(() => {
+    if (!focused) setDraft(value);
+  }, [focused, value]);
+  const normalized = normalizeTime(draft);
+  const invalid = !normalized || !parseTime(value);
+  const commit = () => {
+    if (normalized) {
+      setDraft(normalized);
+      if (normalized !== value) onChange(normalized);
+    }
+  };
+  const onKeyDown = (event) => {
+    if (event.key === "ArrowUp" || event.key === "ArrowDown") {
+      event.preventDefault();
+      const next = stepTime(normalized ?? value, event.key === "ArrowUp" ? 15 : -15);
+      setDraft(next);
+      onChange(next);
+    } else if (event.key === "Enter") {
+      commit();
+    }
+  };
+  return /* @__PURE__ */ jsx(
+    "input",
+    {
+      id,
+      type: "text",
+      inputMode: "numeric",
+      autoComplete: "off",
+      spellCheck: false,
+      "aria-label": label,
+      "aria-invalid": invalid || void 0,
+      disabled,
+      value: draft,
+      maxLength: 8,
+      placeholder: "08:00",
+      onChange: (event) => {
+        setDraft(event.target.value);
+        const next = normalizeTime(event.target.value);
+        if (next && /^\d{1,2}[:.]\d{2}$/.test(event.target.value.trim())) onChange(next);
+      },
+      onFocus: (event) => {
+        setFocused(true);
+        event.currentTarget.select();
+      },
+      onBlur: () => {
+        setFocused(false);
+        commit();
+      },
+      onKeyDown,
+      className: cn(inputBase, "w-[4.75rem] placeholder:text-fg-subtle", className)
+    }
+  );
+}
+function NumberField({
+  value,
+  onChange,
+  label,
+  max,
+  disabled,
+  invalid,
+  describedBy
+}) {
+  const [draft, setDraft] = useState(String(value));
+  useEffect(() => setDraft(String(value)), [value]);
+  return /* @__PURE__ */ jsx(
+    "input",
+    {
+      type: "text",
+      inputMode: "numeric",
+      autoComplete: "off",
+      "aria-label": label,
+      "aria-invalid": invalid || void 0,
+      "aria-describedby": describedBy,
+      disabled,
+      value: draft,
+      onChange: (event) => {
+        const text = event.target.value.replace(/[^\d]/g, "").slice(0, 4);
+        setDraft(text);
+        if (text) onChange(Number(text));
+      },
+      onBlur: () => setDraft(String(value)),
+      onKeyDown: (event) => {
+        if (event.key !== "ArrowUp" && event.key !== "ArrowDown") return;
+        event.preventDefault();
+        onChange(Math.min(max, Math.max(1, value + (event.key === "ArrowUp" ? 1 : -1))));
+      },
+      className: cn(inputBase, "w-16")
+    }
+  );
+}
+function DayToggleGroup({
+  days,
+  onChange,
+  disabled,
+  invalid,
+  describedBy
+}) {
+  const t = useOpenGeniText();
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      role: "group",
+      "aria-label": t("cadence.picker.days"),
+      "aria-invalid": invalid || void 0,
+      "aria-describedby": describedBy,
+      className: cn(
+        "inline-flex h-9 shrink-0 items-center gap-0.5 rounded-[10px] border p-[3px] transition-colors duration-[120ms] pointer-coarse:h-11",
+        invalid ? "border-danger" : "border-border",
+        disabled ? "bg-surface-2" : "bg-surface"
+      ),
+      children: WEEKDAYS.map((day) => {
+        const on = days.includes(day);
+        return /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            "aria-pressed": on,
+            "aria-label": weekdayName(t, day, "long"),
+            disabled,
+            onClick: () => onChange(on ? days.filter((each) => each !== day) : sortDays([...days, day])),
+            className: cn(
+              "inline-flex h-7 w-9 items-center justify-center rounded-sm text-sm font-medium transition-colors duration-[120ms] disabled:cursor-not-allowed pointer-coarse:h-9 pointer-coarse:w-10",
+              on ? "bg-brand/10 text-brand disabled:bg-surface-3 disabled:text-fg-muted" : "text-fg-muted hover:bg-surface-2 hover:text-fg disabled:text-fg-subtle disabled:hover:bg-transparent"
+            ),
+            children: weekdayName(t, day, "short").slice(0, 2)
+          },
+          day
+        );
+      })
+    }
+  );
+}
+var allZonesCache = /* @__PURE__ */ new WeakMap();
+var NO_TIME_ZONES = [];
+function offsetLabelFor(timeZone, at) {
+  try {
+    const name = new Intl.DateTimeFormat("en-US", { timeZone, timeZoneName: "shortOffset" }).formatToParts(at).find((part) => part.type === "timeZoneName")?.value;
+    if (!name || name === "GMT") return "UTC";
+    return name.replace("GMT", "UTC");
+  } catch {
+    return "";
+  }
+}
+function allTimeZones(at, t) {
+  const cached = allZonesCache.get(t);
+  if (cached) return cached;
+  const ids = typeof Intl.supportedValuesOf === "function" ? Intl.supportedValuesOf("timeZone") : [];
+  const zones = ids.map((id) => ({
+    id,
+    ...timeZoneLabels(id, t),
+    offsetLabel: offsetLabelFor(id, at)
+  }));
+  allZonesCache.set(t, zones);
+  return zones;
+}
+function zoneOption(timeZone, suggested, at, t) {
+  return suggested.find((zone) => zone.id === timeZone) ?? {
+    id: timeZone,
+    ...timeZoneLabels(timeZone, t),
+    offsetLabel: offsetLabelFor(timeZone, at)
+  };
+}
+function TimeZoneSearch({
+  value,
+  onSelect,
+  timeZones = NO_TIME_ZONES,
+  now,
+  initialQuery = "",
+  autoFocus = true,
+  preview = false,
+  className
+}) {
+  const t = useOpenGeniText();
+  const [clock] = useState(() => now ?? /* @__PURE__ */ new Date());
+  const [query, setQuery] = useState(initialQuery);
+  const listId = useId();
+  const optionPrefix = useId();
+  const options = useMemo(() => {
+    const needle = query.trim().toLowerCase();
+    if (!needle) return [...timeZones];
+    const seen = /* @__PURE__ */ new Set();
+    const results = [];
+    for (const zone of [...timeZones, ...allTimeZones(clock, t)]) {
+      if (seen.has(zone.id)) continue;
+      const haystack = `${zone.label} ${zone.id} ${zone.offsetLabel ?? ""}`.toLowerCase();
+      if (haystack.includes(needle)) {
+        seen.add(zone.id);
+        results.push(zone);
+      }
+      if (results.length >= 50) break;
+    }
+    return results;
+  }, [clock, query, t, timeZones]);
+  const [active, setActive] = useState(
+    () => Math.max(
+      0,
+      options.findIndex((zone) => zone.id === value)
+    )
+  );
+  const activeIndex = Math.min(active, Math.max(0, options.length - 1));
+  const searching = query.trim().length > 0;
+  const panelOptions = useMemo(
+    () => options.map((zone) => ({
+      value: zone.id,
+      label: zone.label,
+      meta: zone.offsetLabel || void 0,
+      // Search results name the region so "New Salem time" is findable and clear.
+      description: searching && zone.id.includes("/") ? regionOf(zone.id) : void 0,
+      group: searching ? void 0 : t("cadence.picker.suggested")
+    })),
+    [options, searching, t]
+  );
+  const onKeyDown = (event) => {
+    if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+      event.preventDefault();
+      const delta = event.key === "ArrowDown" ? 1 : -1;
+      setActive(
+        (current) => options.length === 0 ? 0 : (Math.min(current, options.length - 1) + delta + options.length) % options.length
+      );
+    } else if (event.key === "Enter") {
+      const zone = options[activeIndex];
+      if (zone) {
+        event.preventDefault();
+        onSelect(zone.id);
+      }
+    }
+  };
+  return /* @__PURE__ */ jsx(
+    SelectMenuPanel,
+    {
+      options: panelOptions,
+      value,
+      activeIndex: options.length > 0 ? activeIndex : -1,
+      onActiveIndexChange: setActive,
+      onSelect,
+      listboxId: listId,
+      idPrefix: optionPrefix,
+      "aria-label": t("cadence.picker.timeZones"),
+      preview,
+      emptyMessage: t("cadence.picker.noZonesMatch", { query: query.trim() }),
+      className,
+      header: /* @__PURE__ */ jsxs("div", { className: "flex h-11 shrink-0 items-center gap-2 border-b border-border px-3.5", children: [
+        /* @__PURE__ */ jsx(SearchIcon, { "aria-hidden": "true", className: "size-4 shrink-0 text-fg-subtle" }),
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            role: "combobox",
+            "aria-expanded": !preview,
+            "aria-controls": listId,
+            "aria-autocomplete": "list",
+            "aria-activedescendant": options[activeIndex] ? `${optionPrefix}-${activeIndex}` : void 0,
+            "aria-label": t("cadence.picker.searchZones"),
+            autoFocus: autoFocus && !preview,
+            autoComplete: "off",
+            spellCheck: false,
+            readOnly: preview,
+            value: query,
+            placeholder: t("cadence.picker.searchZonesPlaceholder"),
+            onChange: (event) => {
+              setQuery(event.target.value);
+              setActive(0);
+            },
+            onKeyDown,
+            className: "h-full min-w-0 flex-1 bg-transparent text-sm text-fg outline-hidden! placeholder:text-fg-subtle pointer-coarse:text-base"
+          }
+        )
+      ] })
+    }
+  );
+}
+function regionOf(timeZone) {
+  return timeZone.split("/").slice(0, -1).join(" / ").replaceAll("_", " ");
+}
+function TimeZonePicker({
+  value,
+  onChange,
+  timeZones = NO_TIME_ZONES,
+  now,
+  disabled,
+  className,
+  variant = "field"
+}) {
+  const t = useOpenGeniText();
+  const [open, setOpen] = useState(false);
+  const [clock] = useState(() => now ?? /* @__PURE__ */ new Date());
+  const current = zoneOption(value, timeZones, clock, t);
+  return /* @__PURE__ */ jsxs(PopoverPrimitive.Root, { open, onOpenChange: setOpen, children: [
+    /* @__PURE__ */ jsxs(
+      PopoverPrimitive.Trigger,
+      {
+        type: "button",
+        disabled,
+        "aria-label": t("cadence.picker.timeZoneLabel", { zone: current.label }),
+        className: cn(
+          fieldBase,
+          "group/zone justify-between",
+          variant === "ghost" && "h-7 gap-1.5 border-transparent bg-transparent px-2 text-fg-muted hover:border-transparent hover:bg-surface-2 hover:text-fg disabled:bg-transparent data-[state=open]:border-transparent data-[state=open]:bg-surface-2 data-[state=open]:text-fg pointer-coarse:h-9",
+          className
+        ),
+        children: [
+          variant === "ghost" ? /* @__PURE__ */ jsx(GlobeIcon, { "aria-hidden": "true", className: "size-4 shrink-0" }) : null,
+          variant === "ghost" && current.shortLabel ? (
+            // Inside a narrow field the city alone is enough ("Oslo").
+            /* @__PURE__ */ jsxs(Fragment, { children: [
+              /* @__PURE__ */ jsx("span", { className: "min-w-0 truncate @max-[26rem]/cadence-text:hidden", children: current.label }),
+              /* @__PURE__ */ jsx("span", { className: "hidden min-w-0 truncate @max-[26rem]/cadence-text:inline", children: current.shortLabel })
+            ] })
+          ) : /* @__PURE__ */ jsx("span", { className: "min-w-0 truncate", children: current.label }),
+          /* @__PURE__ */ jsx(
+            ChevronDownIcon,
+            {
+              "aria-hidden": "true",
+              className: "size-4 shrink-0 text-fg-subtle transition-transform duration-[120ms] group-data-[state=open]/zone:rotate-180"
+            }
+          )
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx(PopoverContainedPortal, { children: /* @__PURE__ */ jsx(
+      PopoverPrimitive.Content,
+      {
+        align: variant === "ghost" ? "end" : "start",
+        sideOffset: 6,
+        collisionPadding: 12,
+        className: cn(
+          popoverPanel,
+          "flex max-h-[min(22rem,var(--radix-popover-content-available-height))] w-[min(20rem,calc(100vw-24px))] flex-col"
+        ),
+        children: /* @__PURE__ */ jsx(
+          TimeZoneSearch,
+          {
+            value,
+            timeZones,
+            now: clock,
+            onSelect: (zone) => {
+              onChange(zone);
+              setOpen(false);
+            }
+          }
+        )
+      }
+    ) })
+  ] });
+}
+function CalendarGrid({
+  value,
+  min,
+  onSelect
+}) {
+  const t = useOpenGeniText();
+  const [focus, setFocus] = useState(value ?? min);
+  const [view, setView] = useState({ year: focus.year, month: focus.month });
+  const gridRef = useRef(null);
+  const shouldFocus = useRef(true);
+  useEffect(() => {
+    if (!shouldFocus.current) return;
+    gridRef.current?.querySelector(`[data-date="${formatLocalDate(focus)}"]`)?.focus();
+  }, [focus, view]);
+  const first = { year: view.year, month: view.month, day: 1 };
+  const leading = WEEKDAYS.indexOf(weekdayOf(first));
+  const total = daysInMonth(view.year, view.month);
+  const cells = [
+    ...Array.from({ length: leading }, () => null),
+    ...Array.from({ length: total }, (_, index) => ({ ...first, day: index + 1 }))
+  ];
+  const minDay = dayNumber(min);
+  const move = (date) => {
+    const target = dayNumber(date) < minDay ? min : date;
+    shouldFocus.current = true;
+    setFocus(target);
+    setView({ year: target.year, month: target.month });
+  };
+  const shiftMonth = (delta) => {
+    const index = view.month - 1 + delta;
+    const year = view.year + Math.floor(index / 12);
+    const month = (index % 12 + 12) % 12 + 1;
+    shouldFocus.current = false;
+    setView({ year, month });
+  };
+  const onKeyDown = (event) => {
+    const steps = {
+      ArrowLeft: -1,
+      ArrowRight: 1,
+      ArrowUp: -7,
+      ArrowDown: 7
+    };
+    const step = steps[event.key];
+    if (step !== void 0) {
+      event.preventDefault();
+      move(addDays(focus, step));
+    } else if (event.key === "PageUp" || event.key === "PageDown") {
+      event.preventDefault();
+      const delta = event.key === "PageUp" ? -1 : 1;
+      const index = focus.month - 1 + delta;
+      const year = focus.year + Math.floor(index / 12);
+      const month = (index % 12 + 12) % 12 + 1;
+      move({ year, month, day: Math.min(focus.day, daysInMonth(year, month)) });
+    }
+  };
+  const canGoBack = view.year > min.year || view.year === min.year && view.month > min.month;
+  return /* @__PURE__ */ jsxs("div", { className: "w-[17.5rem] p-3", children: [
+    /* @__PURE__ */ jsxs("div", { className: "mb-2 flex items-center justify-between", children: [
+      /* @__PURE__ */ jsx("p", { "aria-live": "polite", className: "text-sm font-semibold text-fg", children: t("cadence.picker.monthYear", {
+        month: monthName(t, view.month, "long"),
+        year: view.year
+      }) }),
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1", children: [
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            "aria-label": t("cadence.picker.previousMonth"),
+            disabled: !canGoBack,
+            onClick: () => shiftMonth(-1),
+            className: "grid size-8 place-items-center rounded-[10px] text-fg-muted transition-colors duration-[120ms] hover:bg-surface-2 hover:text-fg disabled:cursor-not-allowed disabled:text-fg-subtle disabled:hover:bg-transparent pointer-coarse:size-11",
+            children: /* @__PURE__ */ jsx(ChevronLeftIcon, { "aria-hidden": "true", className: "size-4" })
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            "aria-label": t("cadence.picker.nextMonth"),
+            onClick: () => shiftMonth(1),
+            className: "grid size-8 place-items-center rounded-[10px] text-fg-muted transition-colors duration-[120ms] hover:bg-surface-2 hover:text-fg pointer-coarse:size-11",
+            children: /* @__PURE__ */ jsx(ChevronRightIcon, { "aria-hidden": "true", className: "size-4" })
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ref: gridRef,
+        role: "grid",
+        "aria-label": t("cadence.picker.monthYear", {
+          month: monthName(t, view.month, "long"),
+          year: view.year
+        }),
+        onKeyDown,
+        children: [
+          /* @__PURE__ */ jsx("div", { role: "row", className: "grid grid-cols-7", children: WEEKDAYS.map((day) => /* @__PURE__ */ jsx(
+            "span",
+            {
+              role: "columnheader",
+              "aria-label": weekdayName(t, day, "long"),
+              className: "grid h-8 place-items-center text-xs font-medium text-fg-subtle",
+              children: weekdayName(t, day, "short").slice(0, 2)
+            },
+            day
+          )) }),
+          Array.from({ length: Math.ceil(cells.length / 7) }, (_, row) => /* @__PURE__ */ jsx(
+            "div",
+            {
+              role: "row",
+              className: "grid grid-cols-7",
+              children: cells.slice(row * 7, row * 7 + 7).map((date, column) => {
+                if (!date) return /* @__PURE__ */ jsx("span", { role: "gridcell" }, `blank-${WEEKDAYS[column]}`);
+                const iso = formatLocalDate(date);
+                const selected = value !== null && dayNumber(value) === dayNumber(date);
+                const isToday = dayNumber(date) === minDay;
+                const past = dayNumber(date) < minDay;
+                const focused = dayNumber(date) === dayNumber(focus);
+                return /* @__PURE__ */ jsx("span", { role: "gridcell", "aria-selected": selected, children: /* @__PURE__ */ jsxs(
+                  "button",
+                  {
+                    type: "button",
+                    "data-date": iso,
+                    tabIndex: focused ? 0 : -1,
+                    disabled: past,
+                    "aria-label": t(
+                      isToday ? "cadence.picker.monthDayToday" : "cadence.picker.monthDay",
+                      {
+                        weekday: weekdayName(t, weekdayOf(date), "long"),
+                        day: date.day,
+                        month: monthName(t, date.month, "long"),
+                        year: date.year
+                      }
+                    ),
+                    onClick: () => onSelect(date),
+                    className: cn(
+                      "relative mx-auto grid size-9 place-items-center rounded-[10px] text-sm tabular-nums transition-colors duration-[120ms]",
+                      selected ? "border border-primary-border bg-primary font-medium text-primary-foreground" : past ? "cursor-not-allowed text-fg-subtle" : "text-fg hover:bg-surface-2"
+                    ),
+                    children: [
+                      date.day,
+                      isToday && !selected ? /* @__PURE__ */ jsx(
+                        "span",
+                        {
+                          "aria-hidden": "true",
+                          className: "absolute bottom-1 size-1 rounded-full bg-brand"
+                        }
+                      ) : null
+                    ]
+                  }
+                ) }, iso);
+              })
+            },
+            `week-${view.year}-${view.month}-${row}`
+          ))
+        ]
+      }
+    )
+  ] });
+}
+function DateField({
+  value,
+  onChange,
+  timeZone,
+  now,
+  disabled,
+  invalid,
+  describedBy,
+  className
+}) {
+  const t = useOpenGeniText();
+  const [open, setOpen] = useState(false);
+  const date = parseLocalDate(value);
+  const today = localDateOf(now, timeZone);
+  const label = date ? dateLabel(t, date, today) : t("cadence.picker.pickDate");
+  return /* @__PURE__ */ jsxs(PopoverPrimitive.Root, { open, onOpenChange: setOpen, children: [
+    /* @__PURE__ */ jsxs(
+      PopoverPrimitive.Trigger,
+      {
+        type: "button",
+        disabled,
+        "aria-label": t("cadence.picker.dateLabel", { date: label }),
+        "aria-invalid": invalid || void 0,
+        "aria-describedby": describedBy,
+        className: cn(fieldBase, "justify-between", className),
+        children: [
+          /* @__PURE__ */ jsx(CalendarIcon, { "aria-hidden": "true", className: "size-4 shrink-0 text-fg-subtle" }),
+          /* @__PURE__ */ jsx("span", { className: "min-w-0 truncate", children: label })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx(PopoverContainedPortal, { children: /* @__PURE__ */ jsx(
+      PopoverPrimitive.Content,
+      {
+        align: "start",
+        sideOffset: 6,
+        collisionPadding: 12,
+        className: popoverPanel,
+        children: /* @__PURE__ */ jsx(
+          CalendarGrid,
+          {
+            value: date,
+            min: today,
+            onSelect: (picked) => {
+              onChange(formatLocalDate(picked));
+              setOpen(false);
+            }
+          }
+        )
+      }
+    ) })
+  ] });
+}
+function CadencePreview({
+  value,
+  now,
+  timeZones = NO_TIME_ZONES,
+  viewerTimeZone,
+  count = 3,
+  issue,
+  id,
+  className
+}) {
+  const t = useOpenGeniText();
+  const zone = zoneOption(value.timeZone, timeZones, now, t);
+  const options = { timeZone: value.timeZone, now, text: t };
+  const problem = issue ?? validateCadence(value.rule, options)?.message ?? null;
+  const description = describeCadence(value.rule, {
+    timeZone: value.timeZone,
+    timeZoneLabel: zone.label,
+    timeZoneShortLabel: zone.shortLabel,
+    now,
+    text: t
+  });
+  const runs = problem ? [] : nextRuns(value.rule, { ...options, count });
+  const viewerZone = viewerTimeZone && viewerTimeZone !== value.timeZone && usesTime(value.rule) ? viewerTimeZone : null;
+  const viewerLine = viewerZone && runs[0] ? (() => {
+    const local = zonedParts(runs[0], viewerZone);
+    const viewerLabel = zoneOption(viewerZone, timeZones, now, t).label;
+    return t("cadence.picker.viewerTime", {
+      time: `${pad(local.hour)}:${pad(local.minute)}`,
+      zone: viewerLabel
+    });
+  })() : null;
+  if (problem) {
+    return /* @__PURE__ */ jsxs(
+      "p",
+      {
+        id,
+        role: "status",
+        "aria-live": "polite",
+        className: cn(
+          "flex min-w-0 items-start gap-1.5 text-xs leading-4.5 text-danger",
+          className
+        ),
+        children: [
+          /* @__PURE__ */ jsx(CircleAlertIcon, { "aria-hidden": "true", className: "mt-0.5 size-3.5 shrink-0" }),
+          /* @__PURE__ */ jsx("span", { className: "min-w-0 break-words", children: problem })
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      id,
+      role: "status",
+      "aria-live": "polite",
+      className: cn(
+        "flex min-w-0 items-start gap-2.5 rounded-[10px] bg-surface-2 px-3 py-2.5",
+        className
+      ),
+      children: [
+        /* @__PURE__ */ jsx(CalendarClockIcon, { "aria-hidden": "true", className: "mt-0.5 size-4 shrink-0 text-fg-subtle" }),
+        /* @__PURE__ */ jsxs("div", { className: "min-w-0", children: [
+          /* @__PURE__ */ jsxs("p", { className: "text-sm font-medium text-fg", children: [
+            description.sentence,
+            "."
+          ] }),
+          /* @__PURE__ */ jsx("p", { className: "mt-0.5 text-xs leading-4.5 text-fg-muted", children: runs.length > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx("span", { className: "text-fg-subtle", children: t("cadence.picker.next") }),
+            describeNextRuns(runs, options)
+          ] }) : t("cadence.picker.noUpcomingRuns") }),
+          viewerLine ? /* @__PURE__ */ jsx("p", { className: "mt-0.5 text-xs leading-4.5 text-fg-subtle", children: viewerLine }) : null
+        ] })
+      ]
+    }
+  );
+}
+function FrequencySelect({ value, update, now, disabled, frequencies }) {
+  const rule = value.rule;
+  const t = useOpenGeniText();
+  return /* @__PURE__ */ jsx(
+    ValueSelect,
+    {
+      label: t("cadence.picker.howOften"),
+      value: rule.frequency,
+      triggerLabel: frequencyWords(t, rule.frequency).trigger,
+      disabled,
+      options: frequencies.map((frequency) => {
+        const words = frequencyWords(t, frequency);
+        return { value: frequency, label: words.label, description: words.description };
+      }),
+      onValueChange: (frequency) => update(switchFrequency(rule, frequency, { timeZone: value.timeZone, now })),
+      contentClassName: "w-64"
+    }
+  );
+}
+var DAY_OF_MONTH_OPTIONS = Array.from({ length: 31 }, (_, index) => ({
+  value: String(index + 1),
+  label: String(index + 1)
+}));
+function Phrase({ inline, children }) {
+  return inline ? /* @__PURE__ */ jsx("span", { className: "inline-flex min-w-0 items-center gap-2", children }) : /* @__PURE__ */ jsx(Fragment, { children });
+}
+function RuleDetails({
+  value,
+  update,
+  issue,
+  issueId,
+  now,
+  disabled,
+  layout
+}) {
+  const rule = normalizeCadenceRule(value.rule, value.timeZone);
+  const invalid = (field) => issue?.field === field;
+  const described = (field) => issue?.field === field ? issueId : void 0;
+  const t = useOpenGeniText();
+  const word = (text) => layout === "inline" ? /* @__PURE__ */ jsx("span", { className: connector, children: text }) : null;
+  const inline = layout === "inline";
+  switch (rule.frequency) {
+    case "weekly":
+      return /* @__PURE__ */ jsxs(Phrase, { inline, children: [
+        word(t("cadence.picker.wordOn")),
+        /* @__PURE__ */ jsx(
+          DayToggleGroup,
+          {
+            days: rule.days,
+            disabled,
+            invalid: invalid("days"),
+            describedBy: described("days"),
+            onChange: (days) => update({ ...rule, days })
+          }
+        )
+      ] });
+    case "monthly":
+      return /* @__PURE__ */ jsxs(Phrase, { inline, children: [
+        word(t("cadence.picker.wordOnDay")),
+        /* @__PURE__ */ jsx(
+          ValueSelect,
+          {
+            label: t("cadence.picker.dayOfMonth"),
+            value: String(rule.dayOfMonth),
+            options: DAY_OF_MONTH_OPTIONS,
+            disabled,
+            invalid: invalid("dayOfMonth"),
+            describedBy: described("dayOfMonth"),
+            onValueChange: (day) => update({ ...rule, dayOfMonth: Number(day) }),
+            className: "w-[4.5rem]",
+            contentClassName: "w-24"
+          }
+        )
+      ] });
+    case "interval":
+      return /* @__PURE__ */ jsxs(Phrase, { inline, children: [
+        /* @__PURE__ */ jsx(
+          NumberField,
+          {
+            label: t("cadence.picker.everyHowMany"),
+            value: rule.every,
+            max: UNIT_LIMITS[rule.unit],
+            disabled,
+            invalid: invalid("every"),
+            describedBy: described("every"),
+            onChange: (every) => update({ ...rule, every })
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          ValueSelect,
+          {
+            label: t("cadence.picker.unit"),
+            value: rule.unit,
+            options: unitOptions(t, rule.every),
+            disabled,
+            onValueChange: (unit) => update(
+              unit === "days" ? {
+                frequency: "interval",
+                every: Math.min(rule.every, UNIT_LIMITS.days),
+                unit,
+                time: rule.time ?? DEFAULT_CADENCE_TIME
+              } : { frequency: "interval", every: Math.min(rule.every, UNIT_LIMITS[unit]), unit }
+            ),
+            className: "w-[6.5rem]"
+          }
+        )
+      ] });
+    case "once":
+      if ("at" in rule) return null;
+      return /* @__PURE__ */ jsxs(Phrase, { inline, children: [
+        word(t("cadence.picker.wordOn")),
+        /* @__PURE__ */ jsx(
+          DateField,
+          {
+            value: rule.date,
+            timeZone: value.timeZone,
+            now,
+            disabled,
+            invalid: invalid("date"),
+            describedBy: described("date"),
+            onChange: (date) => update({ ...rule, date })
+          }
+        )
+      ] });
+    default:
+      return null;
+  }
+}
+function monthDayHint(t, rule) {
+  if (rule.frequency !== "monthly" || rule.dayOfMonth <= 28) return null;
+  return rule.dayOfMonth === 29 ? t("cadence.picker.skipsFebruary") : t("cadence.picker.skipsShortMonths", { day: rule.dayOfMonth });
+}
+function SentenceVariant(props) {
+  const { value, update, updateZone, now, disabled, timeZones } = props;
+  const rule = value.rule;
+  const time = ruleTime(normalizeCadenceRule(rule, value.timeZone));
+  const showTime = usesTime(rule) && time !== void 0;
+  const t = useOpenGeniText();
+  return /* @__PURE__ */ jsxs("div", { className: "flex min-w-0 flex-wrap items-center gap-x-2 gap-y-2", children: [
+    /* @__PURE__ */ jsx(FrequencySelect, { ...props }),
+    rule.frequency === "hourly" ? /* @__PURE__ */ jsx("span", { className: connector, children: t("cadence.picker.onTheHour") }) : null,
+    /* @__PURE__ */ jsx(RuleDetails, { ...props, layout: "inline" }),
+    showTime ? /* @__PURE__ */ jsxs("span", { className: "inline-flex min-w-0 items-center gap-2", children: [
+      /* @__PURE__ */ jsx("span", { className: connector, children: t("cadence.picker.wordAt") }),
+      /* @__PURE__ */ jsx(
+        TimeField,
+        {
+          value: time,
+          disabled,
+          onChange: (next) => update(withTime(normalizeCadenceRule(rule, value.timeZone), next))
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        TimeZonePicker,
+        {
+          value: value.timeZone,
+          onChange: updateZone,
+          timeZones,
+          now,
+          disabled
+        }
+      )
+    ] }) : null
+  ] });
+}
+function PresetChips({
+  value,
+  frequencies,
+  onChange,
+  disabled,
+  labelledBy
+}) {
+  const t = useOpenGeniText();
+  const refs = useRef([]);
+  const onKeyDown = (event, index) => {
+    const delta = event.key === "ArrowRight" || event.key === "ArrowDown" ? 1 : event.key === "ArrowLeft" || event.key === "ArrowUp" ? -1 : 0;
+    if (!delta) return;
+    event.preventDefault();
+    const next = (index + delta + frequencies.length) % frequencies.length;
+    onChange(frequencies[next]);
+    refs.current[next]?.focus();
+  };
+  return /* @__PURE__ */ jsx("div", { role: "radiogroup", "aria-labelledby": labelledBy, className: "flex min-w-0 flex-wrap gap-1.5", children: frequencies.map((frequency, index) => {
+    const checked = frequency === value;
+    return /* @__PURE__ */ jsx(
+      "button",
+      {
+        ref: (node) => {
+          refs.current[index] = node;
+        },
+        type: "button",
+        role: "radio",
+        "aria-checked": checked,
+        tabIndex: checked ? 0 : -1,
+        disabled,
+        onClick: () => onChange(frequency),
+        onKeyDown: (event) => onKeyDown(event, index),
+        className: cn(
+          "inline-flex h-8 items-center rounded-full border px-3 text-sm font-medium transition-colors duration-[120ms] disabled:cursor-not-allowed pointer-coarse:h-11",
+          // Selected matches the outlined segmented control: brand tint, soft brand edge.
+          checked ? "border-brand/45 bg-brand/10 text-brand disabled:border-border disabled:bg-surface-3 disabled:text-fg-muted" : "border-border bg-surface text-fg-muted hover:border-border-strong hover:text-fg disabled:bg-surface-2 disabled:text-fg-subtle disabled:hover:border-border"
+        ),
+        children: frequencyWords(t, frequency).preset
+      },
+      frequency
+    );
+  }) });
+}
+function PresetField({
+  label,
+  htmlFor,
+  labelId,
+  children
+}) {
+  return /* @__PURE__ */ jsxs("div", { className: "flex min-w-0 flex-col gap-1.5", children: [
+    htmlFor ? /* @__PURE__ */ jsx("label", { htmlFor, id: labelId, className: "text-xs leading-4.5 font-medium text-fg", children: label }) : /* @__PURE__ */ jsx("span", { id: labelId, className: "text-xs leading-4.5 font-medium text-fg", children: label }),
+    /* @__PURE__ */ jsx("div", { className: "flex min-w-0 flex-wrap items-center gap-2", children })
+  ] });
+}
+function PresetsVariant(props) {
+  const { value, update, updateZone, now, disabled, timeZones, frequencies } = props;
+  const rule = normalizeCadenceRule(value.rule, value.timeZone);
+  const time = ruleTime(rule);
+  const repeatsId = useId();
+  const timeId = useId();
+  const t = useOpenGeniText();
+  const detailLabel = {
+    weekly: t("cadence.picker.days"),
+    monthly: t("cadence.picker.dayOfMonth"),
+    interval: t("cadence.picker.every"),
+    once: t("cadence.picker.date")
+  };
+  const detail = detailLabel[rule.frequency];
+  return /* @__PURE__ */ jsxs("div", { className: "flex min-w-0 flex-col gap-4", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex min-w-0 flex-col gap-2", children: [
+      /* @__PURE__ */ jsx("span", { id: repeatsId, className: "text-xs leading-4.5 font-medium text-fg", children: t("cadence.picker.repeats") }),
+      /* @__PURE__ */ jsx(
+        PresetChips,
+        {
+          value: rule.frequency,
+          frequencies,
+          labelledBy: repeatsId,
+          disabled,
+          onChange: (frequency) => update(switchFrequency(rule, frequency, { timeZone: value.timeZone, now }))
+        }
+      )
+    ] }),
+    detail ? /* @__PURE__ */ jsx(PresetField, { label: detail, children: /* @__PURE__ */ jsx(RuleDetails, { ...props, layout: "stacked" }) }) : null,
+    usesTime(rule) && time !== void 0 ? /* @__PURE__ */ jsxs("div", { className: "grid min-w-0 grid-cols-[auto_minmax(0,1fr)] gap-4", children: [
+      /* @__PURE__ */ jsx(PresetField, { label: t("cadence.picker.time"), htmlFor: timeId, children: /* @__PURE__ */ jsx(
+        TimeField,
+        {
+          id: timeId,
+          value: time,
+          disabled,
+          onChange: (next) => update(withTime(rule, next))
+        }
+      ) }),
+      /* @__PURE__ */ jsx(PresetField, { label: t("cadence.picker.timeZone"), children: /* @__PURE__ */ jsx(
+        TimeZonePicker,
+        {
+          value: value.timeZone,
+          onChange: updateZone,
+          timeZones,
+          now,
+          disabled,
+          className: "w-full max-w-60"
+        }
+      ) })
+    ] }) : null
+  ] });
+}
+var TEXT_EXAMPLES = [
+  "weekdays at 8",
+  "mon and thu at 9:30",
+  "1st of the month at 9",
+  "every 30 min"
+];
+function TextVariant({
+  value,
+  update,
+  updateZone,
+  now,
+  disabled,
+  timeZones,
+  inputIssueId,
+  onIssue
+}) {
+  const [text, setText] = useState(() => cadencePhrase(value.rule, value.timeZone, now));
+  const inputId = useId();
+  const read = (next) => {
+    setText(next);
+    const result = parseCadence(next, { timeZone: value.timeZone, now });
+    if (result.ok) {
+      onIssue(null);
+      update(result.rule);
+    } else {
+      onIssue(result.message);
+    }
+  };
+  return /* @__PURE__ */ jsxs("div", { className: "@container/cadence-text flex min-w-0 flex-col gap-2.5", children: [
+    /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: cn(
+          "flex h-9 min-w-0 items-center gap-1 rounded-[10px] border border-border pr-1 pl-3 transition-colors duration-[120ms] pointer-coarse:h-11",
+          disabled ? "bg-surface-2 text-fg-muted" : "bg-surface hover:border-border-strong focus-within:border-brand focus-within:outline-2 focus-within:outline-offset-2 focus-within:outline-brand/55 focus-within:hover:border-brand"
+        ),
+        children: [
+          /* @__PURE__ */ jsx(CalendarClockIcon, { "aria-hidden": "true", className: "size-4 shrink-0 text-fg-subtle" }),
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              id: inputId,
+              type: "text",
+              autoComplete: "off",
+              spellCheck: false,
+              "aria-label": "When it runs, in words",
+              "aria-describedby": inputIssueId,
+              disabled,
+              value: text,
+              placeholder: 'For example "every weekday at 8"',
+              onChange: (event) => read(event.target.value),
+              className: "h-full min-w-0 flex-1 bg-transparent px-1.5 text-sm text-fg outline-hidden! placeholder:text-fg-subtle disabled:cursor-not-allowed disabled:text-fg-muted pointer-coarse:text-base"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            TimeZonePicker,
+            {
+              value: value.timeZone,
+              onChange: updateZone,
+              timeZones,
+              now,
+              disabled,
+              variant: "ghost",
+              className: "max-w-44 shrink-0"
+            }
+          )
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs("div", { className: "flex min-w-0 flex-wrap items-center gap-1.5", children: [
+      /* @__PURE__ */ jsx("span", { className: "text-xs text-fg-subtle", children: "Try" }),
+      TEXT_EXAMPLES.map((example) => /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          disabled,
+          onClick: () => read(example),
+          className: "inline-flex h-7 items-center rounded-full border border-border bg-surface px-2.5 text-xs text-fg-muted transition-colors duration-[120ms] hover:border-border-strong hover:text-fg disabled:cursor-not-allowed disabled:bg-surface-2 disabled:text-fg-subtle disabled:hover:border-border pointer-coarse:h-9",
+          children: example
+        },
+        example
+      ))
+    ] })
+  ] });
+}
+function CadencePicker({
+  value,
+  onChange,
+  variant = "sentence",
+  timeZones = NO_TIME_ZONES,
+  frequencies = ALL_FREQUENCIES,
+  now: nowProp,
+  viewerTimeZone,
+  previewCount = 3,
+  disabled,
+  disabledReason,
+  "aria-labelledby": labelledBy,
+  className
+}) {
+  const [firstRender] = useState(() => /* @__PURE__ */ new Date());
+  const now = nowProp ?? firstRender;
+  const issueId = useId();
+  const reasonId = useId();
+  const t = useOpenGeniText();
+  const [parseIssue, setParseIssue] = useState(null);
+  const issue = validateCadence(value.rule, { timeZone: value.timeZone, now, text: t });
+  const hint = monthDayHint(t, value.rule);
+  const parts = {
+    value,
+    update: (rule) => onChange({ ...value, rule }),
+    updateZone: (timeZone) => onChange({ ...value, timeZone }),
+    issue,
+    issueId,
+    now,
+    disabled,
+    timeZones,
+    frequencies
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      role: "group",
+      "aria-labelledby": labelledBy,
+      "aria-describedby": disabled && disabledReason ? reasonId : void 0,
+      "data-variant": variant,
+      className: cn("flex min-w-0 flex-col gap-3", className),
+      children: [
+        variant === "presets" ? /* @__PURE__ */ jsx(PresetsVariant, { ...parts }) : variant === "text" ? /* @__PURE__ */ jsx(TextVariant, { ...parts, inputIssueId: issueId, onIssue: setParseIssue }) : /* @__PURE__ */ jsx(SentenceVariant, { ...parts }),
+        hint && !issue ? /* @__PURE__ */ jsx("p", { className: "-mt-1 text-xs leading-4.5 text-fg-muted", children: hint }) : null,
+        /* @__PURE__ */ jsx(
+          CadencePreview,
+          {
+            id: issueId,
+            value,
+            now,
+            timeZones,
+            viewerTimeZone,
+            count: previewCount,
+            issue: variant === "text" ? parseIssue : null,
+            className: variant === "text" && parseIssue || issue ? "-mt-1.5" : void 0
+          }
+        ),
+        disabled && disabledReason ? /* @__PURE__ */ jsx(InlineDisabledReason, { id: reasonId, children: disabledReason }) : null
+      ]
+    }
+  );
+}
+
+export {
+  WEEKDAYS,
+  DEFAULT_CADENCE_TIME,
+  zonedParts,
+  zonedTimeToUtc,
+  formatLocalDate,
+  parseLocalDate,
+  timeZoneLabels,
+  parseTime,
+  normalizeTime,
+  stepTime,
+  formatRunTime,
+  describeNextRuns,
+  describeCadence,
+  normalizeCadenceRule,
+  validateCadence,
+  nextRuns,
+  toScheduleSpec,
+  cadenceFromScheduleSpec,
+  parseCadence,
+  switchFrequency,
+  cadencePhrase,
+  TimeField,
+  TimeZoneSearch,
+  TimeZonePicker,
+  CadencePreview,
+  CadencePicker
+};
+//# sourceMappingURL=chunk-6JHU2UBS.js.map