cronli5 0.1.6 → 0.1.7

package/dist/lang/zh.cjs

@@ -44,6 +44,26 @@ function arithmeticStep(values) {
   }
   return { start: values[0], interval, last: values[values.length - 1] };
 }
+function weekdayDisplayKey(value) {
+  return value === 0 ? 7 : value;
+}
+function orderWeekdaysForDisplay(segments) {
+  const flattened = segments.flatMap(function flat(segment) {
+    return segment.kind === "step" ? segment.fires.map(function single(value) {
+      return { kind: "single", value: "" + value };
+    }) : [segment];
+  });
+  function key(segment) {
+    return segment.kind === "range" ? weekdayDisplayKey(+segment.bounds[0]) : weekdayDisplayKey(+segment.value);
+  }
+  return flattened.map(function index(segment, position) {
+    return [segment, position];
+  }).sort(function byDisplayKey(a, b) {
+    return key(a[0]) - key(b[0]) || a[1] - b[1];
+  }).map(function unwrap(pair) {
+    return pair[0];
+  });
+}
 function toFieldNumber(token, numberMap) {
   return isNonNegativeInteger(token) ? +token : numberMap[token.toUpperCase()];
 }
@@ -384,6 +404,15 @@ function hourCadencePhrase(ir) {
     anchor: ""
   });
 }
+function minuteZeroConfinement(ir, stride, prefix) {
+  if (stride.interval === 2 && stride.start === 0) {
+    return "\u5728\u5076\u6570\u5C0F\u65F60\u5206" + secondTail(ir);
+  }
+  if (prefix.indexOf("\u4ECE") !== -1) {
+    return prefix + "0\u5206" + secondTail(ir);
+  }
+  return null;
+}
 function hourCadence(ir) {
   const stride = hourStride(ir);
   if (!stride) {
@@ -400,7 +429,7 @@ function hourCadence(ir) {
   const minute = +ir.pattern.minute;
   const subMinute = ir.pattern.second === "*" || ir.shapes.second === "step";
   if (minute === 0 && subMinute) {
-    return stride.interval === 2 && stride.start === 0 ? "\u5728\u5076\u6570\u5C0F\u65F60\u5206" + secondTail(ir) : null;
+    return minuteZeroConfinement(ir, stride, prefix);
   }
   if (minute === 0) {
     return prefix + "0\u5206" + secondTail(ir);
@@ -634,7 +663,7 @@ function quartzDate(token, monthPrefix) {
   if (token.startsWith("L-")) {
     return monthPrefix + "\u6700\u540E\u7B2C" + token.slice(2) + "\u5929";
   }
-  return "\u6700\u63A5\u8FD1" + token.slice(0, -1) + "\u65E5\u7684\u5DE5\u4F5C\u65E5";
+  return monthPrefix + "\u6700\u63A5\u8FD1" + token.slice(0, -1) + "\u65E5\u7684\u5DE5\u4F5C\u65E5";
 }
 function datePhrase(ir) {
   const month = monthPhrase(ir);
@@ -648,7 +677,11 @@ function datePhrase(ir) {
   if (ir.shapes.date === "step") {
     return month + cadence(stepSegment(ir, "date").interval, "\u5929");
   }
-  return month ? month + dayList(ir) : "\u6BCF\u6708" + dayList(ir);
+  if (!month) {
+    return "\u6BCF\u6708" + dayList(ir);
+  }
+  const monthMulti = ir.shapes.month === "range" || ir.shapes.month === "list";
+  return month + (monthMulti ? "\uFF0C" : "") + dayList(ir);
 }
 function dateCore(ir, quartzPrefix) {
   if (ir.shapes.date === "quartz") {
@@ -690,10 +723,8 @@ function weekdayPhrase(ir, orContext, monthPrefix) {
     return "\u6BCF" + weekdayName(from) + "\u81F3" + weekdayName(to);
   }
   const days = [];
-  segs.forEach(function expand(seg) {
-    if (seg.kind === "step") {
-      days.push(...seg.fires);
-    } else if (seg.kind === "single") {
+  orderWeekdaysForDisplay(segs).forEach(function expand(seg) {
+    if (seg.kind === "single") {
       days.push(toFieldNumber(seg.value, weekdayNumbers));
     }
   });

package/dist/lang/zh.js

@@ -18,6 +18,26 @@ function arithmeticStep(values) {
   }
   return { start: values[0], interval, last: values[values.length - 1] };
 }
+function weekdayDisplayKey(value) {
+  return value === 0 ? 7 : value;
+}
+function orderWeekdaysForDisplay(segments) {
+  const flattened = segments.flatMap(function flat(segment) {
+    return segment.kind === "step" ? segment.fires.map(function single(value) {
+      return { kind: "single", value: "" + value };
+    }) : [segment];
+  });
+  function key(segment) {
+    return segment.kind === "range" ? weekdayDisplayKey(+segment.bounds[0]) : weekdayDisplayKey(+segment.value);
+  }
+  return flattened.map(function index(segment, position) {
+    return [segment, position];
+  }).sort(function byDisplayKey(a, b) {
+    return key(a[0]) - key(b[0]) || a[1] - b[1];
+  }).map(function unwrap(pair) {
+    return pair[0];
+  });
+}
 function toFieldNumber(token, numberMap) {
   return isNonNegativeInteger(token) ? +token : numberMap[token.toUpperCase()];
 }
@@ -358,6 +378,15 @@ function hourCadencePhrase(ir) {
     anchor: ""
   });
 }
+function minuteZeroConfinement(ir, stride, prefix) {
+  if (stride.interval === 2 && stride.start === 0) {
+    return "\u5728\u5076\u6570\u5C0F\u65F60\u5206" + secondTail(ir);
+  }
+  if (prefix.indexOf("\u4ECE") !== -1) {
+    return prefix + "0\u5206" + secondTail(ir);
+  }
+  return null;
+}
 function hourCadence(ir) {
   const stride = hourStride(ir);
   if (!stride) {
@@ -374,7 +403,7 @@ function hourCadence(ir) {
   const minute = +ir.pattern.minute;
   const subMinute = ir.pattern.second === "*" || ir.shapes.second === "step";
   if (minute === 0 && subMinute) {
-    return stride.interval === 2 && stride.start === 0 ? "\u5728\u5076\u6570\u5C0F\u65F60\u5206" + secondTail(ir) : null;
+    return minuteZeroConfinement(ir, stride, prefix);
   }
   if (minute === 0) {
     return prefix + "0\u5206" + secondTail(ir);
@@ -608,7 +637,7 @@ function quartzDate(token, monthPrefix) {
   if (token.startsWith("L-")) {
     return monthPrefix + "\u6700\u540E\u7B2C" + token.slice(2) + "\u5929";
   }
-  return "\u6700\u63A5\u8FD1" + token.slice(0, -1) + "\u65E5\u7684\u5DE5\u4F5C\u65E5";
+  return monthPrefix + "\u6700\u63A5\u8FD1" + token.slice(0, -1) + "\u65E5\u7684\u5DE5\u4F5C\u65E5";
 }
 function datePhrase(ir) {
   const month = monthPhrase(ir);
@@ -622,7 +651,11 @@ function datePhrase(ir) {
   if (ir.shapes.date === "step") {
     return month + cadence(stepSegment(ir, "date").interval, "\u5929");
   }
-  return month ? month + dayList(ir) : "\u6BCF\u6708" + dayList(ir);
+  if (!month) {
+    return "\u6BCF\u6708" + dayList(ir);
+  }
+  const monthMulti = ir.shapes.month === "range" || ir.shapes.month === "list";
+  return month + (monthMulti ? "\uFF0C" : "") + dayList(ir);
 }
 function dateCore(ir, quartzPrefix) {
   if (ir.shapes.date === "quartz") {
@@ -664,10 +697,8 @@ function weekdayPhrase(ir, orContext, monthPrefix) {
     return "\u6BCF" + weekdayName(from) + "\u81F3" + weekdayName(to);
   }
   const days = [];
-  segs.forEach(function expand(seg) {
-    if (seg.kind === "step") {
-      days.push(...seg.fires);
-    } else if (seg.kind === "single") {
+  orderWeekdaysForDisplay(segs).forEach(function expand(seg) {
+    if (seg.kind === "single") {
       days.push(toFieldNumber(seg.value, weekdayNumbers));
     }
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cronli5",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Cron Like I'm Five: A Cron to English Utility",
   "repository": {
     "type": "git",

package/src/core/util.ts

@@ -1,5 +1,7 @@
 // Small shared utilities for the core.
 
+import type {Segment} from './ir.js';
+
 function includes(str: string | number, sub: string): boolean {
   return ('' + str).indexOf(sub) !== -1;
 }
@@ -44,6 +46,54 @@ function arithmeticStep(values: number[]):
   return {start: values[0], interval, last: values[values.length - 1]};
 }
 
+// The display sort key for a canonical weekday number: Monday (1) first,
+// Sunday (0) last. The IR keeps Sunday=0 canonical; this is display-only.
+function weekdayDisplayKey(value: number): number {
+  return value === 0 ? 7 : value;
+}
+
+// A weekday display segment: a single day or a (possibly wrap) range. Steps
+// are flattened away into singles before sorting, so the result is only these
+// two kinds; each renderer turns them into names exactly as it does today.
+type WeekdaySegment =
+  | {kind: 'single'; value: string}
+  | {kind: 'range'; bounds: [string, string]};
+
+// Reorder weekday segments Monday-first (Sunday last) for display, so a weekend
+// list reads "Saturday and Sunday" rather than the canonical Sunday-first
+// "Sunday and Saturday". Display-only: the IR / canonical order is unchanged (a
+// fresh array is returned). A step expands to its fires as singles so the days
+// sort into the list; a range stays one unit and keeps its own bounds order (a
+// wrap range is not reordered into a list), sorting by its opening bound — so a
+// lone range sorts to a one-element list and is unchanged. The sort is stable,
+// so equal opening days keep input order.
+function orderWeekdaysForDisplay(segments: Segment[]): WeekdaySegment[] {
+  const flattened: WeekdaySegment[] = segments.flatMap(function flat(segment) {
+    return segment.kind === 'step' ?
+      segment.fires.map(function single(value): WeekdaySegment {
+        return {kind: 'single', value: '' + value};
+      }) :
+      [segment];
+  });
+
+  function key(segment: WeekdaySegment): number {
+    return segment.kind === 'range' ?
+      weekdayDisplayKey(+segment.bounds[0]) :
+      weekdayDisplayKey(+segment.value);
+  }
+
+  return flattened
+    .map(function index(segment, position): [WeekdaySegment, number] {
+      return [segment, position];
+    })
+    .sort(function byDisplayKey(a, b): number {
+      return key(a[0]) - key(b[0]) || a[1] - b[1];
+    })
+    .map(function unwrap(pair): WeekdaySegment {
+      return pair[0];
+    });
+}
+
 // Resolve a numeric or named field token (e.g. '5' or 'FRI') to its number.
 function toFieldNumber(
   token: string,
@@ -54,5 +104,6 @@ function toFieldNumber(
   return isNonNegativeInteger(token) ? +token : numberMap![token.toUpperCase()];
 }
 export {
-  arithmeticStep, includes, isNonNegativeInteger, toFieldNumber, unique
+  arithmeticStep, includes, isNonNegativeInteger, orderWeekdaysForDisplay,
+  toFieldNumber, unique
 };

package/src/lang/de/index.ts

@@ -3,7 +3,9 @@
 
 import {pad} from '../../core/format.js';
 import {maxClockTimes, weekdayNumbers} from '../../core/specs.js';
-import {arithmeticStep, toFieldNumber} from '../../core/util.js';
+import {
+  arithmeticStep, orderWeekdaysForDisplay, toFieldNumber
+} from '../../core/util.js';
 import type {Cronli5Options} from '../../types.js';
 import type {
   Field, HourTimesPlan, IR, Language, NormalizedOptions, PlanNode, Segment
@@ -51,6 +53,12 @@ function everyN(interval: number, unit: Unit): string {
   return 'alle ' + interval + ' ' + unit.plural;
 }
 
+// Append a scope anchor to a clause, separated by a space; an empty anchor
+// (a context that names that field in its own clause) leaves the clause bare.
+function withAnchor(clause: string, anchor: string): string {
+  return anchor ? clause + ' ' + anchor : clause;
+}
+
 // The first segment of a step field, which the plan guarantees is step-kinded.
 function stepSegment(segments: Segment[] | null): StepSegment {
   return (segments as Segment[])[0] as StepSegment;
@@ -108,8 +116,9 @@ function stepClause(segment: StepSegment, unit: Unit, anchor: string): string {
   const short = start !== 0 && segment.fires.length <= 3;
 
   if (segment.startToken.indexOf('-') !== -1 || short) {
-    return 'in den ' + unit.plural + ' ' + joinList(segment.fires.map(String)) +
-      ' ' + anchor;
+    return withAnchor(
+      'in den ' + unit.plural + ' ' + joinList(segment.fires.map(String)),
+      anchor);
   }
 
   return renderStride({
@@ -208,7 +217,9 @@ function weekdayRange(bounds: [string, string]): string {
 
 // "montags", "montags bis freitags", "montags, mittwochs und freitags".
 function weekdayQualifier(ir: IR): string {
-  const segments = flattenSteps(fieldSegments(ir, 'weekday'));
+  // Weekday lists display Monday-first (Sunday last); a lone range keeps its
+  // form. The IR stays canonical (Sunday=0). The helper flattens steps.
+  const segments = orderWeekdaysForDisplay(fieldSegments(ir, 'weekday'));
 
   if (segments.length === 1 && segments[0].kind === 'range') {
     return weekdayRange(segments[0].bounds);
@@ -460,10 +471,21 @@ function countedPhrase(
   return 'in den ' + plural + ' ' + joinList(fieldValues(ir, field));
 }
 
-// The seconds clause: "alle 30 Sekunden" for a step, else "in Sekunde 15
-// jeder Minute".
+// The minute scope for a seconds clause: "jeder Minute" only when the minute
+// is a wildcard (the seconds really do fire in every minute). A restricted
+// minute (single/list/range/step) is named by its own clause, so the seconds
+// clause drops the scope — "jeder Minute" would otherwise contradict the fixed
+// minute ("in Sekunde 30 jeder Minute, in Minute 30" fires at second 30 of
+// minute 30, not every minute).
+function minuteAnchor(ir: IR): string {
+  return ir.pattern.minute === '*' ? 'jeder Minute' : '';
+}
+
+// The seconds clause: "alle 30 Sekunden" for a step, "in Sekunde 15 jeder
+// Minute" under a wildcard minute, else the bare "in Sekunde 15" when the
+// minute is fixed (its own clause names it).
 function secondsLead(ir: IR): string {
-  return secondsClause(ir, 'jeder Minute');
+  return secondsClause(ir, minuteAnchor(ir));
 }
 
 // The second clause counted against an arbitrary anchor. The anchor is "jeder
@@ -486,7 +508,7 @@ function secondsClause(ir: IR, anchor: string): string {
   }
 
   return strideFromSegments(segments as Segment[], UNITS.second, anchor) ??
-    countedPhrase(ir, 'second', 'Sekunde', 'Sekunden') + ' ' + anchor;
+    withAnchor(countedPhrase(ir, 'second', 'Sekunde', 'Sekunden'), anchor);
 }
 
 // A clock time that always shows its minutes: "9:00", "9:30".
@@ -888,15 +910,22 @@ function renderMinuteFrequency(
   const segment = stepSegment(ir.analyses.segments.minute);
   const sep = opts.style.sep;
   const clean = cleanStep(segment, 60);
-  const base = stepClause(segment, UNITS.minute, 'jeder Stunde');
 
   if (plan.hours.kind === 'window') {
+    // A single fixed hour (from === to) drops the "jeder Stunde" tail — the
+    // window names that one hour, so "jeder Stunde" (every hour) contradicts
+    // it. A range keeps it: the cadence truly repeats across each hour.
+    const singleHour = plan.hours.from === plan.hours.to;
+    const base = stepClause(segment, UNITS.minute,
+      singleHour ? '' : 'jeder Stunde');
     const window = hourWindow(plan.hours.from, plan.hours.to, plan.hours.last,
       sep);
 
     return clean ? base + ' ' + window : base + ', ' + window;
   }
 
+  const base = stepClause(segment, UNITS.minute, 'jeder Stunde');
+
   if (plan.hours.kind === 'during') {
     // A bounded or uneven hour stride confines the minute cadence to its own
     // endpoint-pinning hour cadence ("alle 15 Minuten, alle 5 Stunden von 0 bis
@@ -918,9 +947,13 @@ function renderMinuteFrequency(
   return base;
 }
 
-// A stepped hour field as a phrase: an offset-clean stride is its bare or "ab"
-// cadence; a bounded or uneven stride pins both ends ("alle 2 Stunden von 9
+// A stepped hour field as a phrase: a clean stride from midnight is the bare
+// cadence ("alle 2 Stunden"); an open offset-clean stride names only its start
+// ("alle 2 Stunden ab 1 Uhr") since it wraps the day with no distinct
+// endpoint; a bounded or uneven stride pins both ends ("alle 2 Stunden von 9
 // bis 17 Uhr"). Shared by the bare hour step and the minute-step compositions.
+// An explicitly bounded step (`a-b/n`) keeps its enumerated hours, matching
+// en/fi/zh; only an OPEN step (`m/n`) reads as the wrapping cadence.
 function hourStepPhrase(ir: IR): string {
   const cadence = unevenHourCadence(ir);
 
@@ -930,9 +963,34 @@ function hourStepPhrase(ir: IR): string {
 
   const segment = stepSegment(ir.analyses.segments.hour);
 
-  return cleanStep(segment, 24) ?
-    everyN(segment.interval, UNITS.hour) :
-    atHours(segment.fires);
+  if (cleanStep(segment, 24)) {
+    return everyN(segment.interval, UNITS.hour);
+  }
+
+  // An open offset-clean step (`m/n`, m < n dividing 24) wraps the day with no
+  // endpoint: name only its start, the cadence en/fi/zh and the compose paths
+  // already speak — never the enumerated hour list. A bounded `a-b/n` keeps its
+  // explicit hours.
+  const stride = openOffsetCleanStride(ir, segment);
+
+  return stride ? hourStrideCadence(stride) : atHours(segment.fires);
+}
+
+// The stride of an OPEN offset-clean hour step (`m/n`, m < n dividing 24),
+// or null for any other step: such a step wraps the day with no endpoint and
+// reads as the "alle N Stunden ab M Uhr" cadence. An explicitly bounded step
+// (`a-b/n`, startToken carries a `-`) is excluded so it keeps its enumerated
+// hours, matching en/fi/zh.
+function openOffsetCleanStride(
+  ir: IR, segment: StepSegment
+): {start: number; interval: number; last: number} | null {
+  if (segment.startToken.indexOf('-') !== -1) {
+    return null;
+  }
+
+  const stride = hourStride(ir);
+
+  return stride && offsetCleanStride(stride) ? stride : null;
 }
 
 // --- Hour-step cadence (the 24-cycle analog of renderStride). ---
@@ -1078,7 +1136,7 @@ function subMinuteSecond(ir: IR): boolean {
 function hourCadenceLead(ir: IR, minute: number): string {
   if (minute === 0) {
     if (subMinuteSecond(ir)) {
-      return secondsClause(ir, 'jeder Minute') + ' für eine Minute';
+      return withAnchor(secondsClause(ir, minuteAnchor(ir)), 'für eine Minute');
     }
 
     return secondsClause(ir, 'jeder Stunde');
@@ -1092,7 +1150,7 @@ function hourCadenceLead(ir: IR, minute: number): string {
     return minutePhrase;
   }
 
-  return secondsClause(ir, 'jeder Minute') + ', ' + minutePhrase;
+  return secondsClause(ir, minuteAnchor(ir)) + ', ' + minutePhrase;
 }
 
 // Render an hour step (or arithmetic-progression hour list) under a single
@@ -1134,8 +1192,8 @@ function hourCadence(ir: IR, minute: number): string | null {
     confinedHourStride(segment);
 
   if (confined) {
-    return secondsClause(ir, 'jeder Minute') + ' für eine Minute ' +
-      everyNthHour(segment);
+    return withAnchor(secondsClause(ir, minuteAnchor(ir)), 'für eine Minute') +
+      ' ' + everyNthHour(segment);
   }
 
   // A plain top-of-the-hour fire (minute 0 with no meaningful second) has no
@@ -1208,11 +1266,14 @@ function renderHourRange(
   plan: Extract<PlanNode, {kind: 'hourRange'}>,
   opts: Opts
 ): string {
-  // A bare close (`boundMinute` null) lands on the top of the final hour
-  // (minute 0), matching the minute-0 baseline, with the minutes stated
-  // separately; a single fire or wildcard names an exact closing minute.
-  const window = hourWindow(plan.from, plan.to, plan.boundMinute ?? 0,
-    opts.style.sep);
+  // The close lands on the top of the final hour (minute 0) unless the minute
+  // genuinely runs to the end of that hour — i.e. a wildcard minute, which
+  // fills every minute and states no separate clause. A pinned/listed/ranged
+  // minute is named in its own lead clause, so folding it into the close too
+  // would read as a span ("bis 17:05 Uhr") that contradicts the minute clause;
+  // the window stays bare ("bis 17 Uhr").
+  const last = plan.minuteForm === 'wildcard' ? plan.boundMinute ?? 0 : 0;
+  const window = hourWindow(plan.from, plan.to, last, opts.style.sep);
 
   if (plan.minuteForm === 'wildcard') {
     return 'jede Minute ' + window;
@@ -1343,8 +1404,17 @@ function needsDailyFrame(ir: IR): boolean {
     return true;
   }
 
-  return ir.plan.kind === 'hourStep' &&
-    !cleanStep(stepSegment(ir.analyses.segments.hour), 24);
+  if (ir.plan.kind !== 'hourStep') {
+    return false;
+  }
+
+  // An hour step rendered as a cadence ("alle N Stunden [ab M Uhr]") is a
+  // frequency, not a daily clock-time list, so it takes no "täglich" frame —
+  // only a bounded `a-b/n` step that enumerates its hours ("um 1, 3, … Uhr")
+  // needs the recurring frame.
+  const segment = stepSegment(ir.analyses.segments.hour);
+
+  return !cleanStep(segment, 24) && !openOffsetCleanStride(ir, segment);
 }
 
 function render(ir: IR, plan: PlanNode, opts: Opts): string {

package/src/lang/en/index.ts

@@ -3,7 +3,7 @@
 // the core stays semantic, and this module's only input is the IR.
 // See docs/i18n-design.md.
 
-import {arithmeticStep} from '../../core/util.js';
+import {arithmeticStep, orderWeekdaysForDisplay} from '../../core/util.js';
 import {maxClockTimes} from '../../core/specs.js';
 import {clockDigits, numeral} from '../../core/format.js';
 import type {Cronli5Options} from '../../types.js';
@@ -596,12 +596,17 @@ function renderHourStep(ir: IR, plan: PlanOf<'hourStep'>,
     trailingQualifier(ir, opts);
 }
 
-// The hour-range plan as a window whose closing minute honors `boundMinute`:
-// a bare close (`null`) lands on the top of the final hour (`:00`), matching
-// the minute-0 baseline, with the minutes stated separately elsewhere.
+// The hour-range plan as a window. The close lands on the top of the final
+// hour (`:00`) unless the minute genuinely runs to the end of that hour — i.e.
+// a wildcard minute, which fills every minute and states no separate clause.
+// A pinned/listed/ranged minute is named in its own lead clause, so folding it
+// into the close too would read as a span ("through 5:05 p.m.") that
+// contradicts the minute clause; the window stays bare ("through 5 p.m.").
 function boundedWindow(plan: PlanOf<'hourRange'>):
   {from: number; to: number; last: number} {
-  return {from: plan.from, last: plan.boundMinute ?? 0, to: plan.to};
+  const last = plan.minuteForm === 'wildcard' ? plan.boundMinute ?? 0 : 0;
+
+  return {from: plan.from, last, to: plan.to};
 }
 
 // An hour window phrase, e.g. "from 9 a.m. through 5:45 p.m.". Windows
@@ -1499,29 +1504,51 @@ function monthFoldsIntoDate(ir: IR): boolean {
 
 // Compose the "day-of-month or day-of-week" phrase used when both fields
 // are restricted: cron fires when either is a match. A restricted month
-// scopes both.
+// scopes BOTH halves, so it attaches to the whole or, never to a single
+// branch. When the month folds into a calendar date ("on June 13") it also
+// names itself on the weekday ("or on Friday in June"), keeping both halves
+// scoped; otherwise (a Quartz date, an open day step, a month range, or the
+// odd/even frequency) it trails the whole or as ", in <month>".
 function dateOrWeekday(ir: IR, opts: NormalizedOptions): string {
   const pattern = ir.pattern;
   const weekdayPart = quartzWeekdayPhrase(pattern.weekday, opts) ||
     'on ' + weekdayPhrase(ir, opts);
+
+  if (pattern.month !== '*' && monthFoldsIntoDate(ir) &&
+      !quartzDatePhrase(pattern.date, opts) && !isOpenStep(pattern.date)) {
+    return 'on ' + monthDatePhrase(ir, opts) + ' or ' + weekdayPart +
+      ' in ' + monthName(ir, opts);
+  }
+
+  return datePart(ir, opts) + ' or ' + weekdayPart + orMonthScope(ir, opts);
+}
+
+// The day-of-month half of an or-day phrase, without any month scope (the
+// month scopes the whole or, applied by the caller).
+function datePart(ir: IR, opts: NormalizedOptions): string {
+  const pattern = ir.pattern;
   const quartzDate = quartzDatePhrase(pattern.date, opts);
 
   if (quartzDate) {
-    return quartzDate + monthScope(ir, opts) + ' or ' + weekdayPart;
+    return quartzDate;
   }
 
   if (isOpenStep(pattern.date)) {
-    return stepDates(pattern.date) + monthScope(ir, opts) + ' or ' +
-      weekdayPart;
+    return stepDates(pattern.date);
   }
 
-  if (pattern.month !== '*' && monthFoldsIntoDate(ir)) {
-    return 'on ' + monthDatePhrase(ir, opts) + ' or ' + weekdayPart +
-      ' in ' + monthName(ir, opts);
+  return 'on the ' + dateOrdinals(ir, opts);
+}
+
+// A trailing month scope for the whole or, set off by a comma so it reads
+// over both day halves ("…or on Friday, in June"); empty when the month is a
+// wildcard.
+function orMonthScope(ir: IR, opts: NormalizedOptions): string {
+  if (ir.pattern.month === '*') {
+    return '';
   }
 
-  return 'on the ' + dateOrdinals(ir, opts) + ' or ' + weekdayPart +
-    monthScope(ir, opts);
+  return ', in ' + monthName(ir, opts);
 }
 
 // The day-qualifier phrase for a Quartz date field (e.g. "on the last day
@@ -1665,8 +1692,12 @@ function oddEvenMonth(monthField: string): string | null {
 // Render the weekday field as names. Ranges read in their connective form
 // ("Monday through Friday", or "Mon-Fri" with `short`).
 function weekdayPhrase(ir: IR, opts: NormalizedOptions): string {
-  // Reached only with a restricted weekday, which has segments.
-  return renderSegments(ir.analyses.segments.weekday!, function name(value) {
+  // Reached only with a restricted weekday, which has segments. Weekday lists
+  // display Monday-first (Sunday last) so a weekend reads naturally; the IR
+  // stays canonical (Sunday=0) and ranges keep their form.
+  const segments = orderWeekdaysForDisplay(ir.analyses.segments.weekday!);
+
+  return renderSegments(segments, function name(value) {
     return getWeekday(value, opts);
   }, opts);
 }