@12-apps/discounts 1.11.0 → 1.13.0

package/src/engine/schedule.ts

@@ -0,0 +1,191 @@
+/**
+ * The WEEKLY schedule inside a discount's campaign window (FUT-996).
+ *
+ * `startsAt`/`endsAt` answer "for how long is this campaign on?". This answers
+ * the second question a merchant actually asks — "and within that, on which
+ * days and at what hours?" — so that "toda sexta, das 16:00 às 20:00" and
+ * "segunda e terça à tarde" are expressible at all.
+ *
+ * Pure and clock-free, like the rest of the engine: it never calls `new Date()`
+ * and never touches `Intl`. A recurring window is a WALL-CLOCK fact and is
+ * therefore only meaningful in the store's own timezone — but resolving an
+ * IANA zone is the HOST's job, because this module runs in an offline tool
+ * generator, a browser bundle and a worker, and none of them may depend on a
+ * timezone database. The host resolves an instant into a {@link LocalClock} and
+ * passes it in; everything here is integer arithmetic over that.
+ *
+ * A rule with no schedule is every rule that exists today, and answers `true`
+ * unconditionally — which is what makes this a strictly additive change.
+ */
+
+/** Monday-first, matching the seven-entry week every hours surface uses. */
+export const MAX_SCHEDULE_WINDOWS = 7;
+
+/**
+ * One "these days, these hours" row of a schedule.
+ *
+ * A LIST of these rather than one shared time range, because "sexta 16–20 e
+ * sábado 12–16" is one promotion to the merchant selling it and two rows here.
+ * Deliberately NOT a per-weekday hours table (the shape `openingHours` uses):
+ * that editor asks seven questions to answer one, and a promotion is a
+ * sentence, not a business week.
+ */
+export interface DiscountScheduleWindow {
+  /**
+   * Weekdays this window runs on, **Monday-first, 0..6**.
+   *
+   * Monday-first because that is what `WeekHours` and every hours screen in a
+   * host already uses; `Date#getDay()` is Sunday-first and the conversion is
+   * `(getDay() + 6) % 7`. Stated here because a schedule that is off by one day
+   * is a promotion that runs on the wrong day and looks like a pricing bug.
+   */
+  days: readonly number[];
+  /** `HH:MM`, 24-hour, in the STORE's timezone. Inclusive. */
+  from: string;
+  /** `HH:MM`, 24-hour, in the STORE's timezone. EXCLUSIVE. */
+  to: string;
+}
+
+/** A rule's weekly schedule. Null/absent = always, within the campaign window. */
+export interface DiscountSchedule {
+  windows: readonly DiscountScheduleWindow[];
+}
+
+/**
+ * An instant already resolved into the store's own wall clock.
+ *
+ * Two integers rather than a `Date`, so this module cannot be tempted to read a
+ * timezone: by the time a value reaches here the only question left is
+ * arithmetic. The host builds it once per line and once per evaluation.
+ */
+export interface LocalClock {
+  /** Monday-first, 0..6 — the same axis as {@link DiscountScheduleWindow.days}. */
+  weekday: number;
+  /** Minutes since local midnight, 0..1439. */
+  minutes: number;
+}
+
+/** `HH:MM` → minutes since midnight, or null when it is not a time at all. */
+export function toMinutes(value: string): number | null {
+  const match = /^(\d{2}):(\d{2})$/.exec(value);
+  if (match === null) return null;
+  const hours = Number(match[1]);
+  const minutes = Number(match[2]);
+  if (hours > 23 || minutes > 59) return null;
+  return hours * 60 + minutes;
+}
+
+/** The weekday before this one, on the Monday-first axis. */
+function previousWeekday(weekday: number): number {
+  return (weekday + 6) % 7;
+}
+
+/**
+ * Whether one window is running at `clock`.
+ *
+ * A `to` EARLIER than `from` is a bar that shuts at 02:00, not a typo — the
+ * window runs past midnight into the next day, exactly as `minutesOpen` reads a
+ * store's opening hours. Treating it as invalid would refuse the single most
+ * common shape of a happy hour.
+ *
+ * So an overnight window is two intervals: `[from, 24:00)` on each of its own
+ * days, and `[00:00, to)` on the day AFTER each of them — which is why the
+ * second test asks about `previousWeekday`. A Saturday 00:30 instant is inside
+ * a Friday 22:00–02:00 window, and no amount of testing Saturday against
+ * `days` would ever discover that.
+ *
+ * Half-open `[from, to)`, matching `[startsAt, endsAt)`: a window ending at
+ * 20:00 is over the instant 20:00 begins.
+ */
+function windowCovers(window: DiscountScheduleWindow, clock: LocalClock): boolean {
+  const from = toMinutes(window.from);
+  const to = toMinutes(window.to);
+  // A malformed or empty window covers NOTHING rather than everything: it can
+  // only arrive by bypassing the validator, and the safe reading of "I cannot
+  // tell what this means" is not "charge the discount".
+  if (from === null || to === null || from === to) return false;
+  const days = new Set(window.days);
+  if (to > from) {
+    return days.has(clock.weekday) && clock.minutes >= from && clock.minutes < to;
+  }
+  if (days.has(clock.weekday) && clock.minutes >= from) return true;
+  return days.has(previousWeekday(clock.weekday)) && clock.minutes < to;
+}
+
+/**
+ * Whether the schedule is running at `clock` — true if ANY window is.
+ *
+ * `null` schedule → always true, which is every rule that predates this
+ * feature. A schedule with no windows is a rule an operator half-built; it
+ * covers nothing, and the validator refuses to save one.
+ *
+ * `clock` of `null` → **true**, and this is the load-bearing failure
+ * direction. It means the host could not resolve a timezone, and the same
+ * unknown makes `inStoreZone` fall back to the caller's clock rather than throw
+ * ("an unknown zone must not take the storefront down — nor refuse a payment")
+ * and `readStoreHours` keep a store selling. Failing the other way would
+ * silently switch off every scheduled promotion in a store on one bad timezone
+ * string — with nothing red anywhere, because a promotion that does not fire
+ * looks exactly like a promotion nobody qualified for.
+ */
+export function scheduleCovers(
+  schedule: DiscountSchedule | null | undefined,
+  clock: LocalClock | null | undefined,
+): boolean {
+  if (schedule === null || schedule === undefined) return true;
+  if (clock === null || clock === undefined) return true;
+  return schedule.windows.some((window) => windowCovers(window, clock));
+}
+
+/**
+ * Whether a schedule is one this engine can act on at all.
+ *
+ * Used by the validator and by hosts reading a stored blob back; the evaluator
+ * itself is deliberately tolerant (see `windowCovers`) because refusing to
+ * price a cart is never the right answer to a bad row.
+ */
+export function isUsableSchedule(schedule: DiscountSchedule): boolean {
+  if (schedule.windows.length === 0) return false;
+  if (schedule.windows.length > MAX_SCHEDULE_WINDOWS) return false;
+  return schedule.windows.every(
+    (window) =>
+      window.days.length > 0 &&
+      window.days.every((day) => Number.isInteger(day) && day >= 0 && day <= 6) &&
+      toMinutes(window.from) !== null &&
+      toMinutes(window.to) !== null &&
+      window.from !== window.to,
+  );
+}
+
+/**
+ * The next window that OPENS later today, or null — the teaser's whole input
+ * (FUT-996).
+ *
+ * "Later today" and not "next Friday": a card promising an offer six days out
+ * is noise on a screen the shopper is reading now, and it advertises a price
+ * they cannot have for almost a week. Scoped to the current weekday, the label
+ * is a reason to wait rather than a reason to leave.
+ *
+ * A window already running returns nothing from here — that is the BADGE's job,
+ * and a card must never carry both. The two are mutually exclusive by
+ * construction because this only looks at windows whose `from` is still ahead
+ * on the clock.
+ *
+ * Ties break on the earliest opening, so a card teases the offer that arrives
+ * soonest rather than whichever row the operator happened to add first.
+ */
+export function nextWindowToday(
+  schedule: DiscountSchedule | null | undefined,
+  clock: LocalClock | null | undefined,
+): DiscountScheduleWindow | null {
+  if (schedule === null || schedule === undefined) return null;
+  if (clock === null || clock === undefined) return null;
+  const upcoming = schedule.windows
+    .filter((window) => {
+      const from = toMinutes(window.from);
+      if (from === null || from <= clock.minutes) return false;
+      return window.days.includes(clock.weekday);
+    })
+    .sort((a, b) => (toMinutes(a.from) ?? 0) - (toMinutes(b.from) ?? 0));
+  return upcoming[0] ?? null;
+}

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/manifest/index.ts

@@ -82,6 +82,18 @@ export const discountsManifest = {
    * as the order that redeemed it is a rule that can be redeemed twice.
    */
   db: { partial: "prisma/discounts.prisma", migrations: "prisma/migrations" },
+  /**
+   * The promotions journeys (`../e2e`), and the world port a host implements
+   * to run them.
+   *
+   * Undeclared, they were adopted BY CONVENTION: a 167-line spec in the origin
+   * host asserting this package's own test ids from a repo it does not build —
+   * the arrangement whose failure mode is silent from here, since renaming an
+   * id in this package goes red somewhere this package cannot see. Declared, a
+   * host either binds `featuresRoot` or declines in writing, and the decline
+   * lands in the wiring report rather than in nobody's head.
+   */
+  e2e: { entry: "@12-apps/discounts/e2e", world: { factory: "defineDiscountsWorld" } },
   server: ["http"],
   web: ["surface", "areas"],
 } as const satisfies PackageManifest;

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);
@@ -92,17 +95,23 @@ export function DiscountActionsMenu({
 
   const remove = useDeleteConfirm(row, api, copy, onError);
 
+  // Each entry carries a test id derived from its STABLE id, never its label:
+  // a label is host copy, so a spec clicking one is pinned to a single
+  // adopter's words — which is exactly what the packaged journeys exist not to
+  // be. The origin host's spec reached for `menuitem { name: 'Editar' }`.
   const items: DropdownMenuItem[] = [];
   if (canEdit) {
     items.push({
       id: "edit",
       label: copy.actions.edit,
+      dataTestId: "discount-action-edit",
       onClick: () => setEditOpen(true),
     });
   }
   items.push({
     id: "delete",
     label: copy.actions.delete,
+    dataTestId: "discount-action-delete",
     color: "danger",
     onClick: remove.request,
   });
@@ -137,6 +146,7 @@ export function DiscountActionsMenu({
                 groups={groups}
                 editing={row.record}
                 onError={onError}
+                {...(timezoneLabel ? { timezoneLabel } : {})}
                 onSaved={() => {
                   setEditOpen(false);
                   onRefresh();