cronli5 0.8.2 → 0.8.5

package/dist/lang/zh.js

@@ -547,8 +547,8 @@ function secondClause(schedule) {
     return "\u6BCF\u79D2";
   }
   const first = segs[0];
-  if (segs.length === 1 && first.kind === "step" && first.startToken === "*") {
-    return cadence(first.interval, UNITS.second);
+  if (segs.length === 1 && first.kind === "step") {
+    return stepClause(first, "\u79D2", "\u79D2", "\u6BCF\u5206\u949F");
   }
   return strideFromSegments(segs, "\u79D2", "\u79D2", "\u6BCF\u5206\u949F") ?? "\u7B2C" + valueText(segs) + "\u79D2";
 }
@@ -587,7 +587,7 @@ function composeSecondsOnHour(schedule, plan, opts) {
     return "\u6BCF\u5929" + restText + secTail;
   }
   if (rest.kind === "singleMinute") {
-    return restText + "\uFF0C" + sec;
+    return secondIsCadence(schedule) ? restText + confinedSecondTail(sec) : restText + "\uFF0C" + sec;
   }
   return restText + secTail;
 }
@@ -644,6 +644,9 @@ function composeSecondsCadence(schedule) {
         return "\u6BCF\u5076\u6570\u5206\u949F\u7684\u6BCF\u4E00\u79D2";
       }
     }
+    if (!secondIsCadence(schedule) && !secondIsStride(schedule)) {
+      return minuteClause(schedule) + "\u7684" + sec;
+    }
     return sec + "\uFF0C" + minuteClause(schedule);
   }
   return hourFrame(schedule) + tail;
@@ -657,7 +660,7 @@ function composeSecondsListed(schedule) {
     return hourWord(hourFires(schedule)[0]) + minuteCad + "\u7684\u6BCF\u4E00\u79D2";
   }
   if (schedule.shapes.hour === "wildcard") {
-    return minutes + "\uFF0C" + sec;
+    return secondIsStride(schedule) ? minutes + "\uFF0C" + sec : minutes + confinedSecondTail(sec);
   }
   const hourCad = unevenHourCadence(schedule);
   if (hourCad !== null) {
@@ -665,9 +668,38 @@ function composeSecondsListed(schedule) {
   }
   return hourFrame(schedule) + minutes + "\uFF0C" + sec;
 }
+function isMinuteStride(schedule) {
+  if (schedule.shapes.minute === "step") {
+    return true;
+  }
+  const values = singleValues(segmentsOf(schedule, "minute"));
+  return values !== null && arithmeticStep(values) !== null;
+}
+function secondIsCadence(schedule) {
+  return schedule.pattern.second === "*" || schedule.shapes.second === "step";
+}
+function secondIsStride(schedule) {
+  if (schedule.shapes.second !== "list") {
+    return false;
+  }
+  const values = singleValues(segmentsOf(schedule, "second"));
+  return values !== null && arithmeticStep(values) !== null;
+}
+function confinedSecondTail(sec) {
+  return sec === "\u6BCF\u79D2" ? "\u7684\u6BCF\u4E00\u79D2" : "\u7684" + sec;
+}
+function isSteppedMinuteSeconds(schedule, composedClock) {
+  return !composedClock && schedule.shapes.hour === "wildcard" && secondIsCadence(schedule) && schedule.pattern.minute !== "*/2" && isMinuteStride(schedule);
+}
+function minuteStrideConfinement(schedule) {
+  return minuteHourClause(schedule) + confinedSecondTail(secondClause(schedule));
+}
 function renderComposeSeconds(schedule, plan, opts) {
   const { rest } = plan;
   const composedClock = rest.kind === "clockTimes" || rest.kind === "compactClockTimes";
+  if (isSteppedMinuteSeconds(schedule, composedClock)) {
+    return minuteStrideConfinement(schedule);
+  }
   if (schedule.pattern.minute === "0" || composedClock && schedule.shapes.minute === "single") {
     return composeSecondsOnHour(schedule, plan, opts);
   }

package/package.json

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

package/src/lang/de/index.ts

@@ -223,6 +223,16 @@ const stepOrdinals: {[interval: number]: string} = {
   12: 'zwölften'
 };
 
+// Dative ordinals for "in jeder N-ten Minute" — the step intervals a minute
+// cadence can take. The interval-2 step keeps its own "jeder zweiten Minute"
+// idiom and never reaches the confinement helper; a lookup miss falls back to
+// the cardinal "alle N Minuten" form, which still confines.
+const minuteStepOrdinals: {[interval: number]: string} = {
+  3: 'dritten', 4: 'vierten', 5: 'fünften', 6: 'sechsten', 7: 'siebten',
+  8: 'achten', 9: 'neunten', 10: 'zehnten', 12: 'zwölften',
+  15: 'fünfzehnten', 20: 'zwanzigsten', 30: 'dreißigsten'
+};
+
 // Confine a cadence to a clean hour stride: "in jeder zweiten Stunde", with
 // the start named when it is not midnight ("…ab 1 Uhr" for an odd stride).
 function everyNthHour(segment: StepSegment): string {
@@ -658,7 +668,17 @@ function renderSecondsWithinMinute(
       schedule.pattern.second + ' jeder Stunde';
   }
 
-  return secondsLead(schedule) + ', in Minute ' + schedule.pattern.minute +
+  // A second LIST or RANGE under a single minute confines that minute in the
+  // genitive ("in den Sekunden 5 und 10 der Minute 30 jeder Stunde"), never the
+  // comma juxtaposition; a STEP second is a cadence and keeps its own lead.
+  if (secondsConfinesMinute(schedule)) {
+    return secondsLead(schedule) + ' ' + confinedMinutePhrase(schedule);
+  }
+
+  // A cadence/stepped second leads straight into the locative "in Minute …"
+  // with NO comma ("alle 15 Sekunden in Minute 30 jeder Stunde"); the locative
+  // binds the two specs, matching the no-comma list/single confinement.
+  return secondsLead(schedule) + ' in Minute ' + schedule.pattern.minute +
     ' jeder Stunde';
 }
 
@@ -717,6 +737,155 @@ function isEveryOtherMinuteSeconds(
   return minuteStep.startToken === '*' && minuteStep.interval === 2;
 }
 
+// The minute field's step stride for the confinement frame, or null when the
+// minute is not a stepped cadence. A `step`-shaped field reads its segment; a
+// `list`-shaped field the core enumerated from a uneven step (`2/7` → 2,9,…,58)
+// recovers the progression from its values.
+function minuteStride(
+  schedule: Schedule
+): {start: number; interval: number; last: number} | null {
+  if (schedule.shapes.minute === 'step') {
+    const segment = stepSegment(schedule, 'minute');
+    const start = segment.startToken === '*' ? 0 : +segment.startToken;
+
+    return {interval: segment.interval, last:
+      segment.fires[segment.fires.length - 1], start};
+  }
+
+  const values = singleValues(segmentsOf(schedule, 'minute'));
+
+  return values && arithmeticStep(values);
+}
+
+// A stepped minute under a wildcard/stepped second and wildcard hour: bind the
+// second cadence to the minute cadence as a CONFINEMENT ("jede Sekunde in jeder
+// sechsten Minute ab Minute 4 jeder Stunde"), never the comma juxtaposition
+// that reads as two independent cadences. The cadence is ORDINAL ("in jeder
+// sechsten Minute") — the cardinal "alle 6 Minuten" is what fuels the misread —
+// and the start/bound mirror the standalone minute cadence.
+function minuteStepConfinement(
+  schedule: Schedule,
+  stride: {start: number; interval: number; last: number}
+): string {
+  const ordinal = minuteStepOrdinals[stride.interval];
+  const head = ordinal ?
+    'in jeder ' + ordinal + ' Minute' :
+    'alle ' + stride.interval + ' Minuten';
+
+  const tail = chooseStride({...stride, cycle: 60}, {
+    bare: () => '',
+    offset: () => ' ab Minute ' + stride.start,
+    bounded: () => ' von Minute ' + stride.start + ' bis ' + stride.last
+  });
+
+  return secondsLead(schedule) + ' ' + head + tail + ' jeder Stunde';
+}
+
+// Whether a stepped minute fills a wildcard hour under a wildcard/stepped
+// second — the shape the confinement frame above handles.
+function isSteppedMinuteSeconds(
+  schedule: Schedule,
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>
+): boolean {
+  return (plan.rest.kind === 'minuteFrequency' ||
+    plan.rest.kind === 'multipleMinutes') &&
+    (schedule.shapes.second === 'wildcard' ||
+      schedule.shapes.second === 'step') &&
+    schedule.shapes.hour === 'wildcard' &&
+    schedule.pattern.minute !== '*/2' &&
+    minuteStride(schedule) !== null;
+}
+
+// The CONFINED-minute phrase in the genitive that a clock-point second attaches
+// to ("jeder sechsten Minute ab Minute 4 jeder Stunde", "der Minuten 0, 15 und
+// 30 jeder Stunde", "der Minute 30 jeder Stunde"). A stepped minute reuses the
+// ordinal cadence; a list, range, or single names the minute(s) in the genitive
+// — so the seconds clause's bare lead never stacks a redundant "jeder Minute".
+function confinedMinutePhrase(schedule: Schedule): string {
+  const stride = minuteStride(schedule);
+
+  if (stride && schedule.pattern.minute !== '*/2') {
+    const ordinal = minuteStepOrdinals[stride.interval];
+    const head = ordinal ?
+      'jeder ' + ordinal + ' Minute' :
+      'alle ' + stride.interval + ' Minuten';
+    const tail = chooseStride({...stride, cycle: 60}, {
+      bare: () => '',
+      offset: () => ' ab Minute ' + stride.start,
+      bounded: () => ' von Minute ' + stride.start + ' bis ' + stride.last
+    });
+
+    return head + tail + ' jeder Stunde';
+  }
+
+  const genitive = schedule.shapes.minute === 'single' ?
+    'der Minute ' + schedule.pattern.minute :
+    'der Minuten ' + joinList(fieldValues(schedule, 'minute'));
+
+  return genitive + ' jeder Stunde';
+}
+
+// The minute-confinement rendering for a compose-seconds plan, or null when the
+// plan is not one. A CADENCE second over a stepped minute uses the ordinal
+// cadence form; a CLOCK-POINT second (list/range/single) over any restricted
+// minute uses the genitive form. Both bind the second beneath the minute
+// instead of juxtaposing the two behind a comma. Folded into one helper so
+// `renderComposeSeconds` carries a single branch.
+function minuteConfinementRender(
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>, schedule: Schedule
+): string | null {
+  if (isSteppedMinuteSeconds(schedule, plan)) {
+    return minuteStepConfinement(schedule, minuteStride(schedule)!);
+  }
+
+  const minuteRest = plan.rest.kind === 'minuteFrequency' ||
+    plan.rest.kind === 'multipleMinutes' ||
+    plan.rest.kind === 'rangeOfMinutes';
+
+  if (minuteRest && secondsConfinesMinute(schedule)) {
+    return secondsLead(schedule) + ' ' + confinedMinutePhrase(schedule);
+  }
+
+  return null;
+}
+
+// Whether a clock-point second (list, range, or single) sits under a restricted
+// minute and a wildcard hour — the shape that must CONFINE the minute in the
+// genitive rather than juxtapose it behind a comma (two independent schedules).
+// A second LIST the core enumerated from a step (`3/2`) is really a stride
+// cadence and stays out. The single-second + single-minute pair folds into one
+// coherent clock point ("in Minute 5 und Sekunde 30 jeder Stunde") and is
+// excluded.
+function secondsConfinesMinute(schedule: Schedule): boolean {
+  const {second, minute, hour} = schedule.shapes;
+
+  if (second === 'list') {
+    const values = singleValues(segmentsOf(schedule, 'second'));
+
+    if (values && arithmeticStep(values)) {
+      return false;
+    }
+  }
+
+  const clockPoint = second === 'single' || second === 'range' ||
+    second === 'list';
+
+  return clockPoint && minute !== 'wildcard' && hour === 'wildcard' &&
+    !(second === 'single' && minute === 'single');
+}
+
+// Whether a compose-seconds plan is a cadence/stepped second under a minute
+// LIST or SINGLE and a wildcard hour — the shape that leads into the locative
+// "in …" minute phrase with no comma. A restricted/cadence hour keeps the
+// comma, so it does not qualify.
+function isLocativeMinuteConfinement(
+  schedule: Schedule,
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>
+): boolean {
+  return (plan.rest.kind === 'multipleMinutes' ||
+    plan.rest.kind === 'singleMinute') && schedule.shapes.hour === 'wildcard';
+}
+
 function renderComposeSeconds(
   schedule: Schedule,
   plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
@@ -749,12 +918,32 @@ function renderComposeSeconds(
       clockMinuteGenitive(plan.rest.times, opts.style.sep);
   }
 
+  // A second confines the minute restriction (open hour), never the comma
+  // juxtaposition that reads as two independent cadences: a CADENCE second over
+  // a stepped minute uses the ordinal-cadence form ("jede Sekunde in jeder
+  // sechsten Minute …"); a CLOCK-POINT second uses the genitive form ("in den
+  // Sekunden 5, 10 und 15 jeder sechsten Minute …").
+  const confined = minuteConfinementRender(plan, schedule);
+
+  if (confined !== null) {
+    return confined;
+  }
+
   // A wildcard second under a minute */2 with a wildcard hour binds in the
   // genitive ("jede Sekunde jeder zweiten Minute").
   if (isEveryOtherMinuteSeconds(schedule, plan)) {
     return secondsLead(schedule) + ' jeder zweiten Minute';
   }
 
+  // A cadence/stepped second under a minute LIST or SINGLE and a wildcard hour
+  // leads straight into the locative minute phrase with NO comma ("jede Sekunde
+  // in den Minuten 0, 15 und 30 jeder Stunde"). The locative "in" already binds
+  // the two specs; the comma read as two independent specifications and is
+  // inconsistent with the no-comma stepped-minute and list-tier confinements.
+  if (isLocativeMinuteConfinement(schedule, plan)) {
+    return secondsLead(schedule) + ' ' + render(schedule, plan.rest, opts);
+  }
+
   // A compact clock-time rest folds a meaningful SINGLE second into its own
   // leading clause, so the composer must not prepend a second lead that would
   // double it. A wildcard or stepped second is not folded there (no

package/src/lang/en/index.ts

@@ -677,6 +677,67 @@ const stepOrdinals: Record<number, string> = {
   2: 'other', 3: 'third', 4: 'fourth', 6: 'sixth', 8: 'eighth', 12: 'twelfth'
 };
 
+// Spelled ordinals for "every Nth minute" — the step intervals a minute
+// cadence can take (2 reads idiomatically as "other"). A lookup miss falls back
+// to the suffixed numeric ordinal, so an unusually large interval still reads.
+const spelledOrdinals: Record<number, string> = {
+  2: 'other', 3: 'third', 4: 'fourth', 5: 'fifth', 6: 'sixth', 7: 'seventh',
+  8: 'eighth', 9: 'ninth', 10: 'tenth', 11: 'eleventh', 12: 'twelfth',
+  15: 'fifteenth', 20: 'twentieth', 30: 'thirtieth'
+};
+
+// The ordinal word for a cadence interval ("sixth", "seventh"), spelled where
+// known and suffixed-numeric ("13th") otherwise.
+function ordinalWord(interval: number): string {
+  return spelledOrdinals[interval] ?? getOrdinal(interval);
+}
+
+// A stepped minute under a seconds lead reads as a CONFINEMENT of that cadence,
+// not a juxtaposed clause (a comma there reads as two independent cadences) nor
+// a wall of enumerated minutes: "during every Nth minute" plus the step's
+// offset/bound. The cadence is ORDINAL ("every sixth minute"); the cardinal
+// ("every six minutes") is the form that reads as a separate cadence. The
+// offset/bound mirrors the standalone minute cadence: a clean stride from the
+// top names no offset, an offset-clean stride names only its start ("from four
+// minutes past the hour"), and an uneven one pins both endpoints ("from 2
+// through 58 minutes past the hour").
+function minuteStrideConfinement(stride: {start: number; interval: number;
+  last: number}, opts: NormalizedOptions): string {
+  const base = ' during every ' + ordinalWord(stride.interval) + ' minute';
+
+  return chooseStride({...stride, cycle: 60}, {
+    bare: () => base,
+    offset: () => base + ' from ' + getNumber(stride.start, opts) + ' ' +
+      pluralize(stride.start, 'minute') + ' past the hour',
+    bounded: () => {
+      const num = seriesNumber();
+
+      return base + ' from ' + num(stride.start) + through(opts) +
+        num(stride.last) + ' ' + pluralize(stride.last, 'minute') +
+        ' past the hour';
+    }
+  });
+}
+
+// The minute field's step stride for the confinement frame, or null when the
+// minute is not a stepped cadence. A `step`-shaped field (`*/6`) reads its
+// segment directly; a `list`-shaped field the core enumerated from an uneven
+// step (`2/7` → 2,9,…,58) recovers the progression from its values.
+function minuteStride(schedule: Schedule):
+  {start: number; interval: number; last: number} | null {
+  if (schedule.shapes.minute === 'step') {
+    const segment = stepSegment(schedule, 'minute');
+    const start = segment.startToken === '*' ? 0 : +segment.startToken;
+
+    return {interval: segment.interval, last:
+      segment.fires[segment.fires.length - 1], start};
+  }
+
+  const values = singleValues(segmentsOf(schedule, 'minute'));
+
+  return values && arithmeticStep(values);
+}
+
 // Confine a cadence to a clean hour stride: "during every other hour", with
 // the start named when it is not midnight ("…from 1 a.m." for an odd stride).
 function everyNthHour(segment: StepSegment, opts: NormalizedOptions): string {
@@ -1041,15 +1102,69 @@ function isCadenceField(token: string): boolean {
     token.startsWith('*/') && token.indexOf('-') === -1;
 }
 
+// Whether the second field leads the confinement frame as a clean cadence. A
+// wildcard ("every second") and a clean `*/n` step both lead via
+// `isCadenceField`; an OPEN OFFSET step (`m/n`) is the SAME cadence, only named
+// from its offset ("every six seconds from five seconds past the minute"), so
+// it leads the SAME confinement rather than juxtaposing the minute restriction
+// behind a comma — whether the offset is clean from the top (`0/n`) or not
+// (`5/n`). A bounded step (`a-b/n`, a windowed set) is not an open cadence and
+// keeps its existing form.
+function secondLeadsCadence(schedule: Schedule): boolean {
+  if (isCadenceField(schedule.pattern.second)) {
+    return true;
+  }
+
+  if (schedule.shapes.second !== 'step') {
+    return false;
+  }
+
+  // Reached only under a stepped second the `isCadenceField` guard did not
+  // already admit, so its `*/n` clean-cadence forms are gone and the remaining
+  // open form is the offset step `m/n` (`0/n` or non-zero). A bounded step
+  // `a-b/n` is a windowed set, not a cadence, and stays out.
+  return isOpenStep(schedule.pattern.second);
+}
+
+// Whether the second leads the confinement frame as a CLOCK-POINT clause (a
+// list, range, or single second), as opposed to a cadence. A clock-point second
+// under a minute restriction confines that restriction exactly as the cadence
+// does ("at 5, 10, and 15 seconds past the minute during every sixth minute …")
+// rather than juxtaposing it behind a comma, which reads as two independent
+// schedules. The single-second + single-minute pair is excluded: it folds into
+// one coherent clock point ("30 minutes and 15 seconds past the hour"), not a
+// juxtaposition, so it keeps that fold. The confinement only applies where the
+// minute is the restriction and the hour is open; `confinementEligible` gates
+// the rest (a restricted hour folds into a clock time, left to that renderer).
+function secondLeadsClockPoint(schedule: Schedule): boolean {
+  // Only a MEANINGFUL second leads a clause: the two seconds-bearing plans the
+  // core chooses for a real second. A 5-field pattern (or an explicit `0`
+  // second) carries no seconds clause — its plan is the minute's own — so it is
+  // not confined here, which would otherwise prepend "at zero seconds …".
+  if (schedule.plan.kind !== 'composeSeconds' &&
+      schedule.plan.kind !== 'secondsWithinMinute') {
+    return false;
+  }
+
+  const {second, minute, hour} = schedule.shapes;
+  const clockPoint = second === 'single' || second === 'range' ||
+    second === 'list';
+  const minuteRestricted = minute !== 'wildcard';
+
+  return clockPoint && minuteRestricted && hour === 'wildcard' &&
+    !(second === 'single' && minute === 'single');
+}
+
 // The leading cadence and whether the second is the leading field, or null when
 // the pattern has no cadence lead (the finest restricted field is a clock-point
-// single/range/list). The seconds lead when restricted as a cadence; otherwise
-// the minute leads when the second is a plain :00 and the minute is a cadence.
+// single/range/list). The seconds lead when restricted as a cadence, or as a
+// clock-point clause that confines a minute restriction; otherwise the minute
+// leads when the second is a plain :00 and the minute is a cadence.
 function leadingCadence(schedule: Schedule, opts: NormalizedOptions):
   {text: string; secondLead: boolean} | null {
   const {second, minute} = schedule.pattern;
 
-  if (isCadenceField(second)) {
+  if (secondLeadsCadence(schedule) || secondLeadsClockPoint(schedule)) {
     return {secondLead: true, text: secondsClause(schedule, 'minute', opts)};
   }
 
@@ -1078,12 +1193,22 @@ function minuteConfinement(schedule: Schedule,
     return '';
   }
 
-  if (isCadenceField(minute)) {
-    // The gate admits only the `*/2` "every other minute" step here; other
-    // minute steps defer to the existing renderer.
+  if (minute === '*/2') {
+    // The `*/2` clean step reads idiomatically as "every other minute" with no
+    // offset; other minute steps take the ordinal stride-cadence below.
     return ' of every other minute';
   }
 
+  // A stepped minute (a clean `*/n`, an offset `m/n`, or a uneven step the core
+  // enumerated to an arithmetic list) confines as "during every Nth minute"
+  // plus the step's offset/bound — the ordinal cadence, not the cardinal that
+  // reads as a separate cadence, nor a wall of enumerated ":NN" minutes.
+  const stride = minuteStride(schedule);
+
+  if (stride) {
+    return minuteStrideConfinement(stride, opts);
+  }
+
   // A minute single/range/list under the seconds lead. The minute reads as a
   // ":NN" clock-minute confinement, never "N minutes past the hour" (that is
   // the minute-lead clock-point form).
@@ -1119,10 +1244,11 @@ function hourConfinement(schedule: Schedule, opts: NormalizedOptions): string {
 
   if (hour === '*') {
     // A pinned minute confinement ("during minute :00") repeats across every
-    // hour, so the hour is named as the unit of recurrence; a stepped minute
-    // ("of every other minute") or absent minute already implies all hours.
+    // hour, so the hour is named as the unit of recurrence; a minute cadence
+    // ("of every other minute", "during every sixth minute …") or an absent
+    // minute already implies all hours, so the hour is not restated.
     const minutePinned = schedule.pattern.minute !== '*' &&
-      !isCadenceField(schedule.pattern.minute);
+      !isCadenceField(schedule.pattern.minute) && !minuteStride(schedule);
 
     return minutePinned ? ' of every hour' : '';
   }
@@ -1216,24 +1342,28 @@ function confinementEligible(schedule: Schedule,
   }
 
   if (lead.secondLead) {
-    // A minute STEP is supported only as the `*/2` "every other minute" idiom,
-    // and only where it fills the coarser field: a contiguous hour range or a
-    // single hour both close on the minute's real last fire, which the
-    // windowing renderer already speaks. The `*/2` step fills both, so it keeps
-    // the "of every other minute" confinement; other steps defer entirely. A
-    // contiguous hour range (`hour === 'range'`) is left to that windowing
-    // renderer rather than this confinement frame, which closes on the top of
-    // the next hour.
+    // A minute STEP confines as an ordinal cadence ("during every sixth minute
+    // from four minutes past the hour"), but only where it fills the coarser
+    // field: under a WILDCARD hour the step repeats every hour, so the cadence
+    // is the whole confinement. A single hour or a contiguous range closes on
+    // the minute's real last fire, which the windowing renderer already speaks,
+    // so those defer. The `*/2` step keeps its "of every other minute" idiom.
     if (minuteStep) {
-      return minute === '*/2' && schedule.shapes.hour !== 'range';
+      return minute === '*/2' ?
+        schedule.shapes.hour !== 'range' :
+        schedule.pattern.hour === '*';
+    }
+
+    // A minute list that is really an arithmetic stride confines as that same
+    // ordinal cadence when it fills a wildcard hour; under a restricted hour it
+    // keeps its existing cadence form. A short explicit minute list crossed
+    // with a discrete hour LIST is a wall of distinct clock times ("9:00 a.m.,
+    // 9:25 a.m., …"), not a single minute confinement, so it stays enumerated.
+    if (isMinuteStride(schedule)) {
+      return schedule.pattern.hour === '*';
     }
 
-    // A minute list that is really a stride keeps its cadence form; a short
-    // explicit minute list crossed with a discrete hour LIST is a wall of
-    // distinct clock times ("9:00 a.m., 9:25 a.m., …"), not a single minute
-    // confinement. Both stay with the enumerating renderer.
-    if (isMinuteStride(schedule) ||
-        schedule.shapes.minute === 'list' && schedule.shapes.hour === 'list') {
+    if (schedule.shapes.minute === 'list' && schedule.shapes.hour === 'list') {
       return false;
     }