@12-apps/discounts 1.12.0 → 1.13.0

package/src/engine/teaser.ts

@@ -0,0 +1,150 @@
+import { comboRuleAcceptsLine } from "./combo-match";
+import { buildLineIndex, coveredLineIds } from "./eligibility";
+import { compareRuleOrder } from "./evaluate-passes";
+import type { DiscountType } from "./kinds";
+import { nextWindowToday, scheduleCovers, type LocalClock } from "./schedule";
+import type { DiscountCartLine, DiscountRule } from "./types";
+
+/**
+ * "Happy hour: 10% das 16h às 20h" — what a card may say about a promotion
+ * that has not started yet (FUT-996).
+ *
+ * This returns a LABELLING fact, never a price, and that distinction is not a
+ * new one: `previewItemDiscount` already refuses to badge a combo because "a
+ * combo price only exists once the OTHER components are in the cart, so
+ * striking a single item's price through with it would advertise a number this
+ * item alone can never reach", and `comboOffersForItem` exists precisely to say
+ * the true half of that out loud. A happy hour before 16:00 is the same shape:
+ * the OFFER is true, the PRICE is not yet. So it gets a sentence and no struck
+ * price, and the badge takes over the moment the window opens.
+ *
+ * Without it a merchant's best promotion goes unsold to everyone who looks
+ * before it starts — which, for a happy hour, is most of the day.
+ *
+ * Pure and copy-free like the rest of the engine: the merchant's `name` is the
+ * only string here and it is already their own words. A host renders the
+ * sentence around the two times.
+ */
+
+/** One promotion this item takes part in that opens later today. */
+export interface ScheduledOfferTeaser {
+  discountId: string;
+  /** The merchant's own promotion name — already their copy, their language. */
+  name: string;
+  type: DiscountType;
+  /** Basis points off. Non-null iff `type === "PERCENTAGE"`. */
+  percentOffBp: number | null;
+  /** Cents off. Non-null iff `type === "FIXED_AMOUNT"`. */
+  amountOffCents: number | null;
+  /** `HH:MM` the window opens, in the store's timezone. */
+  from: string;
+  /** `HH:MM` the window closes, exclusive. */
+  to: string;
+}
+
+export interface ScheduledTeaserInput {
+  /** The BASE (grouping) menu-item id the card renders. */
+  menuItemId: string;
+  /** The variation whose price the card shows, when it shows one. */
+  variationMenuItemId?: string | null;
+  /** The item's own category id followed by its ancestors, nearest first. */
+  categoryPath: readonly string[];
+  /** The tenant's live discount rules, loaded once for the whole menu. */
+  rules: readonly DiscountRule[];
+  /** Evaluation instant. Injected — this module never calls `new Date()`. */
+  now: Date;
+  /** `now` as the STORE's wall clock. Null ⇒ nothing is teased. */
+  localNow?: LocalClock | null;
+}
+
+const TEASER_LINE_ID = "teaser";
+
+function toTeaserLine(input: ScheduledTeaserInput): DiscountCartLine {
+  return {
+    lineId: TEASER_LINE_ID,
+    menuItemId: input.menuItemId,
+    variationMenuItemId: input.variationMenuItemId ?? null,
+    categoryPath: input.categoryPath,
+    quantity: 1,
+    // A teaser asks whether the rule REACHES this item, which no price enters
+    // into — and deliberately never asks whether it is running, since the
+    // whole point is that it is not.
+    unitPriceCents: 0,
+  };
+}
+
+/**
+ * Worth teasing at all: an automatic, live, unexhausted, SCHEDULED rule that is
+ * not running at this moment.
+ *
+ * `ORDER` scope is excluded for the reason `previewItemDiscount` excludes it —
+ * an order-wide promotion is not this item's offer, and teasing it on a card
+ * would put the same sentence on every card in the menu.
+ *
+ * A rule with no schedule is excluded because it cannot be "starting later":
+ * either it is running, in which case the badge already speaks, or its campaign
+ * has not opened, which is a date and not an hour.
+ */
+function isTeasable(rule: DiscountRule, now: Date, localNow: LocalClock | null): boolean {
+  if (!isTeasableShape(rule)) return false;
+  if (!withinCampaign(rule, now)) return false;
+  // Already running ⇒ the badge owns this card. Never both.
+  if (scheduleCovers(rule.schedule, localNow)) return false;
+  return rule.usageLimit === null || rule.usageCount < rule.usageLimit;
+}
+
+/**
+ * The static half: a rule that could ever be teased at all.
+ *
+ * `ORDER` is excluded for the reason `previewItemDiscount` excludes it, and an
+ * unscheduled rule for the reason in the header — it cannot be "starting
+ * later", only running or not yet begun, and the second is a date.
+ */
+function isTeasableShape(rule: DiscountRule): boolean {
+  if (rule.trigger !== "AUTOMATIC" || !rule.active || rule.scope === "ORDER") return false;
+  return rule.schedule !== null && rule.schedule !== undefined;
+}
+
+/** Inside `[startsAt, endsAt)` — the CAMPAIGN, not the weekly schedule. */
+function withinCampaign(rule: DiscountRule, now: Date): boolean {
+  if (rule.startsAt !== null && now.getTime() < rule.startsAt.getTime()) return false;
+  return rule.endsAt === null || now.getTime() < rule.endsAt.getTime();
+}
+
+/** Whether this rule reaches this item at all, by whichever route its scope uses. */
+function reachesItem(rule: DiscountRule, line: DiscountCartLine): boolean {
+  if (rule.scope === "COMBO") return comboRuleAcceptsLine(rule, line);
+  return coveredLineIds(rule, [line], buildLineIndex([line])).has(TEASER_LINE_ID);
+}
+
+/**
+ * Every promotion this item takes part in that opens later TODAY, in the
+ * evaluator's canonical rule order so a card and a cart never disagree about
+ * which of two promotions comes first.
+ *
+ * Empty is the common case and the one a host should render as nothing at all.
+ */
+export function upcomingOffersForItem(
+  input: ScheduledTeaserInput,
+): readonly ScheduledOfferTeaser[] {
+  const localNow = input.localNow ?? null;
+  if (localNow === null) return [];
+  const line = toTeaserLine(input);
+  return input.rules
+    .filter((rule) => isTeasable(rule, input.now, localNow) && reachesItem(rule, line))
+    .map((rule) => ({ rule, window: nextWindowToday(rule.schedule, localNow) }))
+    .filter(
+      (entry): entry is { rule: DiscountRule; window: NonNullable<typeof entry.window> } =>
+        entry.window !== null,
+    )
+    .sort((a, b) => compareRuleOrder(a.rule, b.rule))
+    .map(({ rule, window }) => ({
+      discountId: rule.id,
+      name: rule.name,
+      type: rule.type,
+      percentOffBp: rule.percentOffBp,
+      amountOffCents: rule.amountOffCents,
+      from: window.from,
+      to: window.to,
+    }));
+}

package/src/engine/types.ts

@@ -4,6 +4,7 @@ import type {
   DiscountTrigger,
   DiscountType,
 } from "./kinds";
+import type { DiscountSchedule, LocalClock } from "./schedule";
 
 /**
  * The evaluator's type contract (FUT-245). Types only, no logic — the shape
@@ -100,6 +101,16 @@ export interface DiscountRule {
   startsAt: Date | null;
   /** EXCLUSIVE upper bound of the active window; null = never closes. */
   endsAt: Date | null;
+  /**
+   * The WEEKLY schedule INSIDE that window (FUT-996) — "toda sexta, das 16:00
+   * às 20:00". Null or omitted = always, within `[startsAt, endsAt)`, which is
+   * every rule that predates the feature.
+   *
+   * OPTIONAL for the reason `comboRequirements` is: a schedule is a capability
+   * a host opts into, so requiring the field would have made recurring
+   * promotions a breaking change for every adopter that does not want them.
+   */
+  schedule?: DiscountSchedule | null;
   /** Minimum PRE-discount subtotal in cents; null = no threshold. */
   minSubtotalCents: number | null;
   /** Global redemption cap; null = uncapped. */
@@ -137,6 +148,20 @@ export interface DiscountCartLine {
   quantity: number;
   /** Composed unit price in integer cents. */
   unitPriceCents: number;
+  /**
+   * WHEN this line was committed, as the store's own wall clock (FUT-996).
+   *
+   * The instant a scheduled promotion is screened against — never the instant
+   * of payment. For a cart line that is `cart_items.created_at`; for a comanda
+   * line it is the kitchen-send time at which its price was already frozen.
+   * That is what makes "the beer ordered at 19:55 was ordered during happy
+   * hour" true however long the table takes to settle.
+   *
+   * Optional, and `null` means "the host could not resolve one" — which makes
+   * a scheduled rule cover the line rather than skip it. See `scheduleCovers`
+   * for why the unknown fails in that direction.
+   */
+  committedLocal?: LocalClock | null;
 }
 
 export interface DiscountEvaluationInput {
@@ -147,6 +172,17 @@ export interface DiscountEvaluationInput {
   couponCode: string | null;
   /** Evaluation instant. Injected — the evaluator never calls `new Date()`. */
   now: Date;
+  /**
+   * `now` as the STORE's wall clock (FUT-996) — what an `ORDER`-scoped
+   * scheduled rule is screened against.
+   *
+   * `ORDER` scope is the one place a schedule cannot be answered per line: an
+   * order-wide discount names no line, and the order itself comes into
+   * existence at checkout. Every other scope screens each line against its own
+   * `committedLocal`. That asymmetry is deliberate and is surfaced to the
+   * operator in the form rather than left invisible.
+   */
+  localNow?: LocalClock | null;
 }
 
 /** Why a discount the buyer asked for was not applied. */

package/src/index.ts

@@ -64,6 +64,38 @@ export type {
 
 export { evaluateDiscounts } from "./engine/evaluate";
 
+/**
+ * The WEEKLY schedule (FUT-996) — "toda sexta, das 16:00 às 20:00".
+ *
+ * `scheduleCovers` and `nextWindowToday` are exported because a host has two
+ * jobs this package cannot do for it: resolve an instant into the STORE's wall
+ * clock (an IANA zone, which this engine deliberately cannot read), and write
+ * the sentence around a window. Both answers must come from the same predicate
+ * the evaluator screens with, or an admin grid's "ativa agora" dot and the
+ * price a shopper is charged will disagree about the same minute.
+ */
+export {
+  isUsableSchedule,
+  MAX_SCHEDULE_WINDOWS,
+  nextWindowToday,
+  scheduleCovers,
+  toMinutes,
+  type DiscountSchedule,
+  type DiscountScheduleWindow,
+  type LocalClock,
+} from "./engine/schedule";
+
+/**
+ * The teaser: what a card may say about a promotion that has not started yet.
+ * A LABEL, never a price — see `./engine/teaser.ts` for why that line is the
+ * same one `comboOffersForItem` already draws.
+ */
+export {
+  upcomingOffersForItem,
+  type ScheduledOfferTeaser,
+  type ScheduledTeaserInput,
+} from "./engine/teaser";
+
 export {
   previewItemDiscount,
   type ItemDiscountPreview,

package/src/react/api.ts

@@ -1,3 +1,4 @@
+import type { DiscountSchedule } from "../engine/schedule";
 import type { ComboRequirement } from "../engine/types";
 
 import type { DiscountsFormatters } from "./format";
@@ -30,6 +31,8 @@ export interface DiscountWireRecord {
   code: string | null;
   startsAt: string | null;
   endsAt: string | null;
+  /** The weekly schedule (FUT-996), or null for "always". */
+  schedule?: DiscountSchedule | null;
   minSubtotalCents: number | null;
   usageLimit: number | null;
   perBuyerLimit: number | null;
@@ -100,6 +103,15 @@ export interface DiscountFormPayload {
   menuItemIds: string[];
   /** The combo's groups, in the operator's own order. Empty at every other scope. */
   comboRequirements: readonly ComboRequirement[];
+  /**
+   * The weekly schedule (FUT-996), or null for "sempre".
+   *
+   * Not a form STRING like the two dates beside it, for the reason the target
+   * id lists are not: it is a nested structure the operator edits with chips
+   * and clocks, so it lives in state beside the container and is merged in at
+   * submit.
+   */
+  schedule: DiscountSchedule | null;
 }
 
 /** A money amount as integer cents, or null when blank. */
@@ -165,6 +177,7 @@ export function toWriteBody(
     code: input.trigger === "CODE" ? toNullable(input.code) : null,
     startsAt: toNullable(input.startsAt),
     endsAt: toNullable(input.endsAt),
+    schedule: input.schedule,
     minSubtotalCents: toCents(input.minSubtotal, formatters),
     usageLimit: toCount(input.usageLimit, formatters),
     perBuyerLimit: toCount(input.perBuyerLimit, formatters),

package/src/react/copy.ts

@@ -7,6 +7,8 @@ import type {
   DiscountWindowState,
 } from "../engine/kinds";
 
+import type { DiscountsScheduleCopy } from "./schedule-copy";
+
 /**
  * Every word the discounts ADMIN screens put in front of a human — required
  * host config, with NO defaults.
@@ -274,6 +276,7 @@ export interface DiscountsWebCopy {
   readonly screen: DiscountsScreenCopy;
   readonly labels: DiscountsVocabularyCopy;
   readonly window: DiscountsWindowCopy;
+  readonly schedule: DiscountsScheduleCopy;
   readonly form: DiscountsFormCopy;
   readonly combo: DiscountsComboCopy;
   readonly targets: DiscountsTargetCopy;

package/src/react/create-web-discounts.tsx

@@ -2,6 +2,8 @@
 
 import { useMemo, type ComponentType, type JSX } from "react";
 
+import { timeZoneLabel } from "../timezone";
+
 import { createDiscountsApiClient, type DiscountsApiClient } from "./api";
 import { missingWebCopy, type DiscountsWebCopy } from "./copy";
 import { DiscountForm, type DiscountFormProps } from "./discount-form";
@@ -47,6 +49,34 @@ export interface DiscountsWebConfig {
   locale: string;
   /** ISO 4217, e.g. `BRL`. */
   currency: string;
+  /**
+   * The STORE's timezone, as a name an operator recognises ("São Paulo") —
+   * shown under the schedule's clocks (FUT-996).
+   *
+   * A label rather than an IANA id, because it is read by a person and
+   * "America/Sao_Paulo" is not how anyone says it. The engine never sees this:
+   * resolving an instant into the store's wall clock is the SERVER's job, and
+   * this string exists so a merchant typing 16:00 knows whose 16:00 it is —
+   * which is not a rhetorical worry for a store admin sitting in another one.
+   *
+   * Optional: a host that has not adopted schedules yet shows the builder
+   * without the line rather than a wrong one.
+   */
+  timezoneLabel?: string;
+  /**
+   * The store's IANA timezone (`America/Sao_Paulo`) — what the grid's
+   * "ativa agora" dot is computed against (FUT-996).
+   *
+   * Separate from {@link timezoneLabel} because they do different jobs: this
+   * one is read by `Intl`, that one is read by a person. Deriving the label
+   * from this would print "Sao_Paulo" at a merchant.
+   *
+   * Omitted ⇒ no dot. A rule's SCHEDULE still shows in the vigência cell; only
+   * the live "is it running this minute" answer is withheld, because without a
+   * zone it would be the browser's answer rather than the store's — and a shop
+   * whose admin is abroad would be told its happy hour is off while it is on.
+   */
+  timezone?: string;
   /**
    * Where a failure goes, beyond the operator's own screen — REQUIRED, and for
    * the same reason `createApiDiscounts` requires a logger.
@@ -110,7 +140,12 @@ function assertConfig(config: DiscountsWebConfig): void {
 
 export function createWebDiscounts(config: DiscountsWebConfig): WebDiscounts {
   assertConfig(config);
-  const { copy, onError, currencyField, breadcrumb } = config;
+  const { copy, onError, currencyField, breadcrumb, timezone } = config;
+  // DERIVED from the zone unless the host insists otherwise. A host naming the
+  // zone in words would be shipping copy, which has to be bilingual; `Intl`
+  // already knows it in every locale.
+  const timezoneLabel =
+    config.timezoneLabel ?? (timezone ? timeZoneLabel(timezone, config.locale) : undefined);
   const formatters = createFormatters(config.locale, config.currency);
   const transport = config.transport ?? httpDiscountsTransport(copy.form.saveFailed);
   const api = createDiscountsApiClient(config.apiBase, transport, formatters);
@@ -122,6 +157,8 @@ export function createWebDiscounts(config: DiscountsWebConfig): WebDiscounts {
     currencyField,
     onError,
     ...(breadcrumb ? { breadcrumb } : {}),
+    ...(timezoneLabel ? { timezoneLabel } : {}),
+    ...(timezone ? { timezone } : {}),
   };
 
   return {
@@ -133,6 +170,7 @@ export function createWebDiscounts(config: DiscountsWebConfig): WebDiscounts {
         formatters={formatters}
         currencyField={currencyField}
         onError={onError}
+        {...(timezoneLabel ? { timezoneLabel } : {})}
         {...props}
       />
     ),

package/src/react/discount-actions-menu.tsx

@@ -47,6 +47,8 @@ export interface DiscountActionsMenuProps {
    */
   groups?: readonly WireTargetGroup[];
   onError: (error: unknown, context: string) => void;
+  /** The store's timezone as a person says it, for the schedule editor. */
+  timezoneLabel?: string;
 }
 
 /**
@@ -85,6 +87,7 @@ export function DiscountActionsMenu({
   currencyField,
   groups,
   onError,
+  timezoneLabel,
 }: DiscountActionsMenuProps): JSX.Element {
   const { onRefresh } = useCardActions();
   const [editOpen, setEditOpen] = useState(false);
@@ -143,6 +146,7 @@ export function DiscountActionsMenu({
                 groups={groups}
                 editing={row.record}
                 onError={onError}
+                {...(timezoneLabel ? { timezoneLabel } : {})}
                 onSaved={() => {
                   setEditOpen(false);
                   onRefresh();

package/src/react/discount-form-fields.tsx

@@ -2,6 +2,7 @@
 
 import type { JSX } from "react";
 
+import { FormControl, FormLabel } from "@12-apps/ui/form/Form";
 import { Switch } from "@12-apps/ui/form/Switch";
 import { Fields, useFormContext } from "@12-apps/ui/form/total-form";
 import { Box } from "@12-apps/ui/mui/Box";
@@ -9,9 +10,11 @@ import { Stack } from "@12-apps/ui/mui/Stack";
 import { Text } from "@12-apps/ui/typography/Text";
 
 import { DISCOUNT_TRIGGERS } from "../engine/kinds";
+import type { DiscountSchedule } from "../engine/schedule";
 
 import type { DiscountsWebCopy } from "./copy";
 import { COMBO_REWARDS, isComboKind, SELECTABLE_DISCOUNT_SCOPES, type DiscountKind } from "./form-kind";
+import { ScheduleBuilder } from "./schedule-builder";
 
 /**
  * The form's inputs, split from the form itself for the 400-line file gate —
@@ -249,16 +252,97 @@ export function ComboCapField({ copy }: { copy: DiscountsWebCopy }): JSX.Element
   );
 }
 
-/** The active window. Both sides optional; the end date is EXCLUSIVE. */
-export function WindowFields({ copy }: { copy: DiscountsWebCopy }): JSX.Element {
+/**
+ * "Quando vale" — the campaign PERIOD, and the weekly schedule inside it
+ * (FUT-996).
+ *
+ * The two are one section because they answer one question in two halves, and
+ * an operator reads them together: "de setembro a novembro" and "toda sexta,
+ * das 16 às 20" describe the same promotion. They were a bare pair of date
+ * inputs before there was a second half to pair with.
+ *
+ * Repetition defaults to "Sempre", so every rule that predates this and every
+ * simple new one is untouched — an operator creating a plain 10%-off never sees
+ * the builder. That default is what keeps the screen from getting harder for
+ * the promotions nobody schedules.
+ */
+export function WindowFields({
+  copy,
+  schedule,
+  scheduleEnabled,
+  timezoneLabel,
+  onScheduleChange,
+  onScheduleEnabledChange,
+}: {
+  copy: DiscountsWebCopy;
+  schedule: DiscountSchedule;
+  scheduleEnabled: boolean;
+  timezoneLabel: string | null;
+  onScheduleChange: (next: DiscountSchedule) => void;
+  onScheduleEnabledChange: (next: boolean) => void;
+}): JSX.Element {
   return (
-    <Box sx={{ display: "grid", gap: 2, gridTemplateColumns: { xs: "1fr", sm: "1fr 1fr" } }}>
-      <Fields.TextField name="startsAt" label={copy.form.startsAt} type="date" />
-      <Fields.TextField name="endsAt" label={copy.form.endsAt} type="date" />
-    </Box>
+    <Stack spacing={1.5}>
+      <Text variant="heading">{copy.schedule.sectionTitle}</Text>
+      <Stack spacing={0.5}>
+        <Box sx={{ display: "grid", gap: 2, gridTemplateColumns: { xs: "1fr", sm: "1fr 1fr" } }}>
+          <Fields.TextField name="startsAt" label={copy.form.startsAt} type="date" />
+          <Fields.TextField name="endsAt" label={copy.form.endsAt} type="date" />
+        </Box>
+        <Text variant="caption">{copy.schedule.periodHint}</Text>
+      </Stack>
+      <FormControl>
+        <FormLabel>{copy.schedule.repetitionTitle}</FormLabel>
+        <Stack spacing={0.5}>
+          {[
+            [false, copy.schedule.always] as const,
+            [true, copy.schedule.specific] as const,
+          ].map(([value, label]) => (
+            <label key={label} style={{ display: "flex", gap: 8, alignItems: "center" }}>
+              <input
+                type="radio"
+                name="discount-repetition"
+                checked={scheduleEnabled === value}
+                onChange={() => onScheduleEnabledChange(value)}
+                data-testid={value ? "repetition-specific" : "repetition-always"}
+              />
+              <Text variant="body">{label}</Text>
+            </label>
+          ))}
+        </Stack>
+      </FormControl>
+      {scheduleEnabled && (
+        <>
+          <ScheduleBuilder
+            schedule={schedule}
+            copy={copy}
+            timezone={timezoneLabel ?? ""}
+            onChange={onScheduleChange}
+          />
+          <OrderScopeScheduleNote copy={copy} />
+        </>
+      )}
+    </Stack>
   );
 }
 
+/**
+ * The ORDER-scope asymmetry, at the point of confusion.
+ *
+ * An order-wide rule has no line to anchor a schedule to, so it is judged at
+ * CHECKOUT while every other scope is judged per line — which means a cart
+ * straddling 20:00 behaves differently under "10% em tudo" than under "10% em
+ * cervejas". That is a real difference and an invisible one, so it is said
+ * here, only for the combination that has it, rather than left in a document
+ * nobody opens while filling in a form.
+ */
+function OrderScopeScheduleNote({ copy }: { copy: DiscountsWebCopy }): JSX.Element | null {
+  const { values } = useFormContext();
+  const kind = values.kind ?? "PERCENTAGE";
+  if (isComboKind(kind) || values.scope !== "ORDER") return null;
+  return <Text variant="caption">{copy.schedule.orderScopeNote}</Text>;
+}
+
 /** The minimum basket and the two redemption caps. */
 export function LimitFields({
   copy,

package/src/react/discount-form-validate.ts

@@ -1,3 +1,4 @@
+import { toMinutes, type DiscountSchedule } from "../engine/schedule";
 import type { ComboRequirement } from "../engine/types";
 
 import { comboUnits } from "./combo-slot-builder";
@@ -141,16 +142,55 @@ export interface FormTargets {
 }
 
 /** The cross-field rules a per-input schema cannot express. */
+/**
+ * The weekly schedule, when the operator asked for one (FUT-996).
+ *
+ * Three refusals, and each is a thing the operator can SEE and fix on the row
+ * in front of them. Deliberately NOT refused: a `to` earlier than `from` — that
+ * is a bar shutting at 02:00, the commonest happy hour there is, and the
+ * builder's own sentence says "do dia seguinte" so it can be checked rather
+ * than guessed at.
+ *
+ * Every one of these is re-checked on the server (`assertSchedule`), which is
+ * the authority. This half exists so the operator is told before they submit.
+ */
+function checkSchedule(
+  state: ScheduleState,
+  copy: DiscountsWebCopy,
+): Record<string, string> {
+  if (!state.enabled) return {};
+  const { windows } = state.schedule;
+  if (windows.length === 0) return { schedule: copy.schedule.windowsRequired };
+  if (windows.some((window) => window.days.length === 0)) {
+    return { schedule: copy.schedule.daysRequired };
+  }
+  const badTime = windows.some(
+    (window) =>
+      toMinutes(window.from) === null ||
+      toMinutes(window.to) === null ||
+      window.from === window.to,
+  );
+  return badTime ? { schedule: copy.schedule.timesRequired } : {};
+}
+
+/** The schedule editor's state: its switch and its rows, kept separate. */
+interface ScheduleState {
+  enabled: boolean;
+  schedule: DiscountSchedule;
+}
+
 export function validate(
   values: DiscountFormValues,
   targets: FormTargets,
   formatters: DiscountsFormatters,
   copy: DiscountsWebCopy,
+  scheduleState: ScheduleState,
 ): Record<string, string> {
   const slots = targets.comboRequirements;
   const errors: Record<string, string> = {
     ...checkValue(values, slots, formatters, copy),
     ...checkCombo(values, slots, copy),
+    ...checkSchedule(scheduleState, copy),
   };
   if (values.trigger === "CODE" && values.code.trim() === "") {
     errors.code = copy.form.codeRequired;