@open-mercato/core 0.10.1-develop.7724.1.95e4e7d38e → 0.10.1-develop.7727.1.0b89c4f800

package/src/modules/planner/commands/availability-date-specific.ts

@@ -3,6 +3,7 @@ import { registerCommand } from '@open-mercato/shared/lib/commands'
 import type { EntityManager } from '@mikro-orm/postgresql'
 import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
 import { parseAvailabilityRuleWindow } from '@open-mercato/core/modules/planner/lib/availabilitySchedule'
+import { warnOnUnresolvableTimeZone, zonedDateKey, zonedDayBounds, zonedWallTimeToInstant } from '@open-mercato/core/modules/planner/lib/availabilityTimezone'
 import { PlannerAvailabilityRule } from '../data/entities'
 import {
   plannerAvailabilityDateSpecificReplaceSchema,
@@ -52,22 +53,9 @@ type DateSpecificUndoPayload = {
   after: AvailabilityRuleSnapshot[]
 }
 
-function parseTimeInput(value: string): { hours: number; minutes: number } | null {
-  const [hours, minutes] = value.split(':').map((part) => Number(part))
-  if (!Number.isFinite(hours) || !Number.isFinite(minutes)) return null
-  if (hours < 0 || hours > 23 || minutes < 0 || minutes > 59) return null
-  return { hours, minutes }
-}
-
-function toDateForDay(value: string, time: string): Date | null {
-  if (!value) return null
-  const parsed = parseTimeInput(time)
-  if (!parsed) return null
-  const parts = value.split('-').map((part) => Number(part))
-  if (parts.length !== 3 || parts.some((part) => Number.isNaN(part))) return null
-  const [year, month, day] = parts
-  const date = new Date(year, month - 1, day, parsed.hours, parsed.minutes, 0, 0)
-  return Number.isNaN(date.getTime()) ? null : date
+function toDateForDay(dateKey: string, time: string, timeZone: string): Date | null {
+  if (!dateKey) return null
+  return zonedWallTimeToInstant(dateKey, time, timeZone)
 }
 
 function formatDuration(minutes: number): string {
@@ -86,18 +74,10 @@ function buildAvailabilityRrule(start: Date, end: Date): string {
   return `DTSTART:${dtStart}\nDURATION:${duration}\nRRULE:FREQ=DAILY;COUNT=1`
 }
 
-function buildFullDayRrule(date: string): string | null {
-  const start = toDateForDay(date, '00:00')
-  if (!start) return null
-  const end = new Date(start.getTime() + 24 * 60 * 60 * 1000)
-  return buildAvailabilityRrule(start, end)
-}
-
-function formatDateKey(value: Date): string {
-  const year = value.getFullYear()
-  const month = String(value.getMonth() + 1).padStart(2, '0')
-  const day = String(value.getDate()).padStart(2, '0')
-  return `${year}-${month}-${day}`
+function buildFullDayRrule(date: string, timeZone: string): string | null {
+  const bounds = zonedDayBounds(date, timeZone)
+  if (!bounds) return null
+  return buildAvailabilityRrule(bounds.start, bounds.end)
 }
 
 function toAvailabilityRuleSnapshot(record: PlannerAvailabilityRule): AvailabilityRuleSnapshot {
@@ -140,7 +120,7 @@ async function loadDateSpecificSnapshots(
     .filter((rule) => {
       const window = parseAvailabilityRuleWindow(rule)
       if (window.repeat !== 'once') return false
-      return params.dates.has(formatDateKey(window.startAt))
+      return params.dates.has(zonedDateKey(window.startAt, rule.timezone))
     })
     .map(toAvailabilityRuleSnapshot)
 }
@@ -199,6 +179,7 @@ const replaceDateSpecificAvailabilityCommand: CommandHandler<PlannerAvailability
   },
   async execute(input, ctx) {
     const parsed = plannerAvailabilityDateSpecificReplaceSchema.parse(input)
+    warnOnUnresolvableTimeZone(parsed.timezone, 'planner.availability.date-specific.replace')
     ensureTenantScope(ctx, parsed.tenantId)
     ensureOrganizationScope(ctx, parsed.organizationId)
     const dates = resolveDateSet(parsed)
@@ -223,7 +204,7 @@ const replaceDateSpecificAvailabilityCommand: CommandHandler<PlannerAvailability
         const toDelete = existing.filter((rule) => {
           const window = parseAvailabilityRuleWindow(rule)
           if (window.repeat !== 'once') return false
-          return dates.has(formatDateKey(window.startAt))
+          return dates.has(zonedDateKey(window.startAt, rule.timezone))
         })
         enforceCommandOptimisticLock({
           resourceKind: AVAILABILITY_RULE_RESOURCE_KIND,
@@ -244,7 +225,7 @@ const replaceDateSpecificAvailabilityCommand: CommandHandler<PlannerAvailability
 
       if (!isAvailable) {
         dates.forEach((date) => {
-          const rrule = buildFullDayRrule(date)
+          const rrule = buildFullDayRrule(date, parsed.timezone)
           if (!rrule) return
           const record = trx.create(PlannerAvailabilityRule, {
             tenantId: parsed.tenantId,
@@ -266,8 +247,8 @@ const replaceDateSpecificAvailabilityCommand: CommandHandler<PlannerAvailability
       } else {
         dates.forEach((date) => {
           windows.forEach((window) => {
-            const start = toDateForDay(date, window.start)
-            const end = toDateForDay(date, window.end)
+            const start = toDateForDay(date, window.start, parsed.timezone)
+            const end = toDateForDay(date, window.end, parsed.timezone)
             if (!start || !end || start >= end) return
             const rrule = buildAvailabilityRrule(start, end)
             const record = trx.create(PlannerAvailabilityRule, {

package/src/modules/planner/commands/availability-weekly.ts

@@ -2,6 +2,7 @@ import type { CommandHandler } from '@open-mercato/shared/lib/commands'
 import { registerCommand } from '@open-mercato/shared/lib/commands'
 import type { EntityManager } from '@mikro-orm/postgresql'
 import { parseAvailabilityRuleWindow } from '@open-mercato/core/modules/planner/lib/availabilitySchedule'
+import { warnOnUnresolvableTimeZone, zonedWeeklyAnchor, zonedWeekday } from '@open-mercato/core/modules/planner/lib/availabilityTimezone'
 import { PlannerAvailabilityRule, PlannerAvailabilityRuleSet } from '../data/entities'
 import {
   plannerAvailabilityWeeklyReplaceSchema,
@@ -54,24 +55,6 @@ type WeeklyUndoPayload = {
   after: AvailabilityRuleSnapshot[]
 }
 
-function parseTimeInput(value: string): { hours: number; minutes: number } | null {
-  const [hours, minutes] = value.split(':').map((part) => Number(part))
-  if (!Number.isFinite(hours) || !Number.isFinite(minutes)) return null
-  if (hours < 0 || hours > 23 || minutes < 0 || minutes > 59) return null
-  return { hours, minutes }
-}
-
-function toDateForWeekday(weekday: number, time: string): Date | null {
-  const parsed = parseTimeInput(time)
-  if (!parsed) return null
-  const now = new Date()
-  const base = new Date(now.getFullYear(), now.getMonth(), now.getDate())
-  const diff = (weekday - base.getDay() + 7) % 7
-  const target = new Date(base.getTime() + diff * 24 * 60 * 60 * 1000)
-  target.setHours(parsed.hours, parsed.minutes, 0, 0)
-  return target
-}
-
 function formatDuration(minutes: number): string {
   const clamped = Math.max(1, minutes)
   const hours = Math.floor(clamped / 60)
@@ -81,11 +64,18 @@ function formatDuration(minutes: number): string {
   return `PT${mins}M`
 }
 
-function buildWeeklyRrule(start: Date, end: Date): string {
+function buildWeeklyRrule(start: Date, end: Date, timeZone: string): string {
   const dtStart = start.toISOString().replace(/[-:]/g, '').split('.')[0] + 'Z'
   const durationMinutes = Math.max(1, Math.round((end.getTime() - start.getTime()) / 60000))
   const duration = formatDuration(durationMinutes)
-  const dayCode = DAY_CODES[start.getDay()] ?? 'MO'
+  // `BYDAY` names the weekday the window falls on in its DECLARED zone, which
+  // is the meaningful label for a recurring local-time window. It is therefore
+  // deliberately not consistent with the `Z`-suffixed `DTSTART` beside it: a
+  // Pacific/Auckland Monday 09:00 ships DTSTART:...T210000Z, a Sunday in UTC,
+  // with BYDAY=MO. Nothing in the planner reads BYDAY today (neither the
+  // expander nor `parseAvailabilityRuleWindow`); a future iCal export must
+  // re-derive it from the zone rather than trust it against DTSTART.
+  const dayCode = DAY_CODES[zonedWeekday(start, timeZone)] ?? 'MO'
   return `DTSTART:${dtStart}\nDURATION:${duration}\nRRULE:FREQ=WEEKLY;BYDAY=${dayCode}`
 }
 
@@ -185,6 +175,7 @@ const replaceWeeklyAvailabilityCommand: CommandHandler<PlannerAvailabilityWeekly
   },
   async execute(input, ctx) {
     const parsed = plannerAvailabilityWeeklyReplaceSchema.parse(input)
+    warnOnUnresolvableTimeZone(parsed.timezone, 'planner.availability.weekly.replace')
     ensureTenantScope(ctx, parsed.tenantId)
     ensureOrganizationScope(ctx, parsed.organizationId)
 
@@ -247,10 +238,10 @@ const replaceWeeklyAvailabilityCommand: CommandHandler<PlannerAvailabilityWeekly
       }
 
       parsed.windows.forEach((window) => {
-        const start = toDateForWeekday(window.weekday, window.start)
-        const end = toDateForWeekday(window.weekday, window.end)
-        if (!start || !end || start >= end) return
-        const rrule = buildWeeklyRrule(start, end)
+        const anchor = zonedWeeklyAnchor(window.weekday, window.start, window.end, parsed.timezone, now)
+        if (!anchor || anchor.start >= anchor.end) return
+        const { start, end } = anchor
+        const rrule = buildWeeklyRrule(start, end, parsed.timezone)
         const record = trx.create(PlannerAvailabilityRule, {
           tenantId: parsed.tenantId,
           organizationId: parsed.organizationId,

package/src/modules/planner/lib/availabilityMerge.ts

@@ -1,3 +1,5 @@
+import { resolveTimeZone, zonedWallDateToInstant } from './availabilityTimezone'
+
 type AvailabilityKind = 'availability' | 'unavailability'
 
 export type AvailabilityRuleLike = {
@@ -46,21 +48,8 @@ function zonedParts(instant: Date, timezone: string): { year: number; month: num
   return { year: number('year'), month: number('month'), day: number('day'), hour: number('hour'), minute: number('minute'), second: number('second') }
 }
 
-function zonedWallToInstant(wall: Date, timezone: string): Date | null {
-  const target = wall.getTime()
-  let candidate = target
-  for (let attempt = 0; attempt < 4; attempt += 1) {
-    const parts = zonedParts(new Date(candidate), timezone)
-    const displayed = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second)
-    const next = candidate + target - displayed
-    if (next === candidate) return new Date(candidate)
-    candidate = next
-  }
-  return null
-}
-
 function zonedStartOfDay(dayKey: string, timezone: string): Date | null {
-  return zonedWallToInstant(new Date(`${dayKey}T00:00:00Z`), timezone)
+  return zonedWallDateToInstant(new Date(`${dayKey}T00:00:00Z`), timezone)
 }
 
 function dayKeyForRule(instant: Date, timezone?: string): string {
@@ -146,10 +135,10 @@ function expandZonedRule(rule: AvailabilityRuleLike, parsed: ParsedRule, range:
   let wall = new Date(anchorWall + skipped * step)
   let remaining = (parsed.count ?? Number.POSITIVE_INFINITY) - skipped
   while (wall.getTime() <= range.end.getTime() + DAY_MS && remaining > 0) {
-    const start = zonedWallToInstant(wall, timezone)
-    if (start && !shouldExcludeOccurrence(start, rule.exdates, timezone)) {
-      const end = new Date(start.getTime() + duration)
-      if (end > range.start && start < range.end) windows.push({ start, end, ruleId: rule.id })
+    const start = zonedWallDateToInstant(wall, timezone)
+    if (!shouldExcludeOccurrence(start, rule.exdates, timezone)) {
+      const end = zonedWallDateToInstant(new Date(wall.getTime() + duration), timezone)
+      if (end > start && end > range.start && start < range.end) windows.push({ start, end, ruleId: rule.id })
     }
     wall = new Date(wall.getTime() + step)
     remaining -= 1
@@ -231,7 +220,12 @@ export function getMergedAvailabilityWindows(params: {
   respectTimezone?: boolean
   weeklyScheduleTemplate?: boolean
 }): AvailabilityWindow[] {
-  const rules = params.respectTimezone ? params.rules : params.rules.map((rule) => ({ ...rule, timezone: undefined }))
+  const rules: AvailabilityRuleLike[] = params.respectTimezone
+    ? params.rules.map((rule) => ({
+        ...rule,
+        timezone: rule.timezone ? resolveTimeZone(rule.timezone) : rule.timezone,
+      }))
+    : params.rules.map((rule) => ({ ...rule, timezone: undefined }))
   const parsedRules = rules
     .map((rule) => {
       const parsed = parseRrule(rule.rrule)

package/src/modules/planner/lib/availabilityTimezone.ts

@@ -0,0 +1,242 @@
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('planner').child({ component: 'availability' })
+
+const FALLBACK_TIME_ZONE = 'UTC'
+const DATE_KEY_PATTERN = /^\d{4}-\d{2}-\d{2}$/
+
+/**
+ * Availability rows store `timezone` as free-form `text`, so a malformed value
+ * must not turn a read or a write into a 500. Unknown zones degrade to UTC,
+ * which is already how the expander interprets every stored instant.
+ */
+export function resolveTimeZone(value: string | null | undefined): string {
+  if (!isResolvableTimeZone(value)) return FALLBACK_TIME_ZONE
+  return value.trim()
+}
+
+export function isResolvableTimeZone(value: string | null | undefined): value is string {
+  if (typeof value !== 'string' || !value.trim().length) return false
+  try {
+    new Intl.DateTimeFormat('en-US', { timeZone: value.trim() })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * The replace endpoints anchor `DTSTART` in the declared zone, so an
+ * unresolvable value is persisted as a UTC-anchored instant under a label
+ * nothing can resolve. Rejecting it with a 400 would narrow the replace
+ * schemas (a `data/validators.ts` contract surface), so for now the write is
+ * accepted and flagged; the 400 is announced in UPGRADE_NOTES.md.
+ */
+export function warnOnUnresolvableTimeZone(value: string, commandId: string): void {
+  if (isResolvableTimeZone(value)) return
+  logger.warn('[deprecated] Unresolvable availability timezone anchored to UTC; this will be rejected with 400 in a future minor release', {
+    commandId,
+    timezone: value,
+    fallback: FALLBACK_TIME_ZONE,
+  })
+}
+
+function parseTimeOfDay(value: string): { hours: number; minutes: number } | null {
+  const [hours, minutes] = String(value).split(':').map((part) => Number(part))
+  if (!Number.isFinite(hours) || !Number.isFinite(minutes)) return null
+  if (hours < 0 || hours > 23 || minutes < 0 || minutes > 59) return null
+  return { hours, minutes }
+}
+
+type WallClock = { year: number; month: number; day: number; hours: number; minutes: number; seconds: number }
+
+const MINUTE_MS = 60 * 1000
+const DAY_MS = 24 * 60 * MINUTE_MS
+const formatterCache = new Map<string, Intl.DateTimeFormat>()
+
+function zonedFormatter(timeZone: string): Intl.DateTimeFormat {
+  let formatter = formatterCache.get(timeZone)
+  if (!formatter) {
+    formatter = new Intl.DateTimeFormat('en-US', {
+      timeZone,
+      hourCycle: 'h23',
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit',
+    })
+    formatterCache.set(timeZone, formatter)
+  }
+  return formatter
+}
+
+/**
+ * Wall clock of an instant in `timeZone`, read through `Intl` only. `date-fns-tz`
+ * seeds its offset search with host-local getters, so around DST transitions
+ * the same input resolved differently depending on the serving machine's `TZ`.
+ */
+function zonedWallClock(epochMs: number, timeZone: string): WallClock {
+  const values: Record<string, number> = {}
+  for (const part of zonedFormatter(timeZone).formatToParts(new Date(epochMs))) {
+    if (part.type !== 'literal') values[part.type] = Number(part.value)
+  }
+  return {
+    year: values.year,
+    month: values.month,
+    day: values.day,
+    hours: values.hour,
+    minutes: values.minute,
+    seconds: values.second,
+  }
+}
+
+function wallClockAsUtc(clock: WallClock): number {
+  return Date.UTC(clock.year, clock.month - 1, clock.day, clock.hours, clock.minutes, clock.seconds)
+}
+
+function offsetAt(epochMs: number, timeZone: string): number {
+  const flooredToMinute = Math.floor(epochMs / MINUTE_MS) * MINUTE_MS
+  return wallClockAsUtc(zonedWallClock(flooredToMinute, timeZone)) - flooredToMinute
+}
+
+function parseDateKey(dateKey: string): { year: number; month: number; day: number } | null {
+  if (!DATE_KEY_PATTERN.test(String(dateKey))) return null
+  const [year, month, day] = dateKey.split('-').map((part) => Number(part))
+  const probe = new Date(Date.UTC(year, month - 1, day))
+  if (probe.getUTCMonth() !== month - 1 || probe.getUTCDate() !== day) return null
+  return { year, month, day }
+}
+
+function formatUtcDateKey(epochMs: number): string {
+  return new Date(epochMs).toISOString().slice(0, 10)
+}
+
+/**
+ * `2026-06-15` + `09:00` + `Europe/Warsaw` → the absolute instant that wall
+ * time denotes. Replaces `new Date(y, m, d, h, min)`, whose result depended on
+ * the host process's `TZ` rather than on the zone the caller declared (#5862).
+ *
+ * DST transitions follow the `compatible` disambiguation of RFC 5545 §3.3.5 and
+ * Temporal: a repeated wall time resolves to its EARLIER occurrence, and a
+ * skipped one moves forward by the length of the gap (`Africa/Cairo` has no
+ * 2026-04-24 00:00, so it becomes 01:00 — the first instant of that date).
+ */
+export function zonedWallTimeToInstant(dateKey: string, time: string, timeZone: string): Date | null {
+  const date = parseDateKey(dateKey)
+  const parsed = parseTimeOfDay(time)
+  if (!date || !parsed) return null
+  const wall = new Date(Date.UTC(date.year, date.month - 1, date.day, parsed.hours, parsed.minutes))
+  return zonedWallDateToInstant(wall, timeZone)
+}
+
+/** Resolve a UTC-encoded wall clock with compatible DST disambiguation. */
+export function zonedWallDateToInstant(wall: Date, timeZone: string): Date {
+  const zone = resolveTimeZone(timeZone)
+  const wallAsUtc = wall.getTime()
+  const offsetBefore = offsetAt(wallAsUtc - DAY_MS, zone)
+  const offsetAfter = offsetAt(wallAsUtc + DAY_MS, zone)
+  if (offsetBefore === offsetAfter) return new Date(wallAsUtc - offsetBefore)
+  const candidates = [wallAsUtc - offsetBefore, wallAsUtc - offsetAfter].sort((left, right) => left - right)
+  const matching = candidates.find((candidate) => candidate + offsetAt(candidate, zone) === wallAsUtc)
+  return new Date(matching ?? wallAsUtc - offsetBefore)
+}
+
+/**
+ * The span a full-day block covers: from the first instant of `dateKey` to the
+ * first instant of the following date, both in `timeZone`. That is 23 or 25
+ * hours on DST days, so the block neither bleeds into nor falls short of its
+ * neighbours.
+ */
+export function zonedDayBounds(dateKey: string, timeZone: string): { start: Date; end: Date } | null {
+  const date = parseDateKey(dateKey)
+  if (!date) return null
+  const nextDateKey = formatUtcDateKey(Date.UTC(date.year, date.month - 1, date.day) + DAY_MS)
+  const start = zonedWallTimeToInstant(dateKey, '00:00', timeZone)
+  const end = zonedWallTimeToInstant(nextDateKey, '00:00', timeZone)
+  if (!start || !end || end <= start) return null
+  return { start, end }
+}
+
+/**
+ * The calendar date an instant falls on, as seen from `timeZone`.
+ *
+ * Which day an existing rule belongs to has to be read in that rule's own zone,
+ * the same zone its `DTSTART` was anchored in. Derived from the host clock
+ * instead, replace-by-date selected a different set of rows — and the 403 gate
+ * in `api/availability-date-specific.ts` admitted or refused the same request —
+ * depending on which machine served it.
+ */
+export function zonedDateKey(instant: Date, timeZone: string): string {
+  const clock = zonedWallClock(instant.getTime(), resolveTimeZone(timeZone))
+  return formatUtcDateKey(Date.UTC(clock.year, clock.month - 1, clock.day))
+}
+
+/** `Date.getDay()` index (0 = Sunday) of an instant, as seen from `timeZone`. */
+export function zonedWeekday(instant: Date, timeZone: string): number {
+  const clock = zonedWallClock(instant.getTime(), resolveTimeZone(timeZone))
+  return new Date(Date.UTC(clock.year, clock.month - 1, clock.day)).getUTCDay()
+}
+
+/**
+ * The next occurrence of `weekday` (0 = Sunday) at or after `from`, as a
+ * calendar date key in `timeZone`. The zone matters: at 12:00 UTC on a Monday
+ * it is already Tuesday in `Pacific/Auckland`, which shifted the whole series
+ * by a week before this was zone-aware.
+ */
+export function nextWeekdayDateKey(weekday: number, timeZone: string, from: Date = new Date()): string {
+  const clock = zonedWallClock(from.getTime(), resolveTimeZone(timeZone))
+  const localMidnight = Date.UTC(clock.year, clock.month - 1, clock.day)
+  const diff = (weekday - new Date(localMidnight).getUTCDay() + 7) % 7
+  return formatUtcDateKey(localMidnight + diff * DAY_MS)
+}
+
+/**
+ * The start and end instants of the occurrence a weekly window is anchored on.
+ *
+ * The anchor's exact length becomes the rule's `DURATION`, which every reader
+ * applies to every week. An anchor that spans a DST transition (Europe/Warsaw
+ * Sunday 00:00–08:00 on 2026-10-25 lasts 9 hours) or starts in a gap would
+ * therefore misstate the window for all ordinary weeks, so the upcoming
+ * occurrence is used only when both local endpoints and its exact length match
+ * the request; otherwise the previous week's occurrence anchors the series. Taking
+ * the earlier week keeps the upcoming occurrence inside the series for readers
+ * that expand forward from `DTSTART`.
+ *
+ * `from` is threaded in rather than defaulted per call: resolving a window's
+ * start and end against two separate `new Date()` reads can straddle midnight
+ * in the declared zone, which lands the anchors seven days apart.
+ */
+export function zonedWeeklyAnchor(
+  weekday: number,
+  startTime: string,
+  endTime: string,
+  timeZone: string,
+  from: Date,
+): { start: Date; end: Date } | null {
+  const startClock = parseTimeOfDay(startTime)
+  const endClock = parseTimeOfDay(endTime)
+  if (!startClock || !endClock) return null
+  const zone = resolveTimeZone(timeZone)
+  const startMinutes = startClock.hours * 60 + startClock.minutes
+  const endMinutes = endClock.hours * 60 + endClock.minutes
+  const localLengthMs = (endMinutes - startMinutes) * MINUTE_MS
+  const upcoming = parseDateKey(nextWeekdayDateKey(weekday, timeZone, from))
+  if (!upcoming) return null
+  const upcomingMidnight = Date.UTC(upcoming.year, upcoming.month - 1, upcoming.day)
+  let fallback: { start: Date; end: Date } | null = null
+  for (const weekOffset of [0, -1]) {
+    const midnight = upcomingMidnight + weekOffset * 7 * DAY_MS
+    const dateKey = formatUtcDateKey(midnight)
+    const start = zonedWallTimeToInstant(dateKey, startTime, timeZone)
+    const end = zonedWallTimeToInstant(dateKey, endTime, timeZone)
+    if (!start || !end) return null
+    const startWall = wallClockAsUtc(zonedWallClock(start.getTime(), zone))
+    const endWall = wallClockAsUtc(zonedWallClock(end.getTime(), zone))
+    if (startWall !== midnight + startMinutes * MINUTE_MS || endWall !== midnight + endMinutes * MINUTE_MS) continue
+    if (end.getTime() - start.getTime() === localLengthMs) return { start, end }
+    fallback ??= { start, end }
+  }
+  return fallback
+}