cronli5 0.8.0 → 0.8.3

package/dist/lang/zh.cjs

@@ -346,6 +346,9 @@ function minuteHourClause(schedule) {
 function renderMinutePast(schedule) {
   return minuteHourClause(schedule);
 }
+function withoutHourAnchor(clause) {
+  return clause.replace(/^每小时/, "");
+}
 function hourSegmentWords(segment) {
   if (segment.kind === "range") {
     return [hourWord(+segment.bounds[0]) + "\u81F3" + hourWord(+segment.bounds[1])];
@@ -373,7 +376,8 @@ function renderMinuteFrequency(schedule, plan) {
   if (hours.kind === "step" || hours.kind === "during") {
     const hourCad = unevenHourCadence(schedule);
     if (hourCad !== null) {
-      return hourCad + (hourCad.indexOf("\u81F3") === -1 ? "" : "\uFF0C") + base;
+      const minuteBase = hours.kind === "step" ? withoutHourAnchor(base) : base;
+      return hourCad + (hourCad.indexOf("\u81F3") === -1 ? "" : "\uFF0C") + minuteBase;
     }
   }
   if (hours.kind === "window" && hours.from === hours.to) {
@@ -406,9 +410,9 @@ function renderMinuteSpanAcrossHourStep(schedule, plan) {
   const hourStep = stepSegment(schedule, "hour");
   const { form } = plan;
   if (form === "list") {
-    return hourCadencePhrase(schedule) + "\uFF0C" + renderMinutePast(schedule);
+    return hourCadencePhrase(schedule) + "\uFF0C" + withoutHourAnchor(renderMinutePast(schedule));
   }
-  const minuteTail = form === "wildcard" ? "\u6BCF\u5206\u949F" : minuteHourClause(schedule) + "\uFF0C\u6BCF\u5206\u949F";
+  const minuteTail = form === "wildcard" ? "\u6BCF\u5206\u949F" : withoutHourAnchor(minuteHourClause(schedule)) + "\uFF0C\u6BCF\u5206\u949F";
   if (hourStep.startToken !== "*") {
     return hourCadencePhrase(schedule) + "\uFF0C" + minuteTail;
   }
@@ -436,7 +440,7 @@ function renderCompactClockTimes(schedule, plan) {
   const tail = secs.length && schedule.pattern.second !== "0" ? "\uFF0C\u7B2C" + valueText(secs) + "\u79D2" : "";
   if (!compact.fold) {
     const hourCad = unevenHourCadence(schedule);
-    return hourCad === null ? minuteHourClause(schedule) + "\uFF0C\u5728" + hourList(schedule) + tail : hourCad + "\uFF0C" + minuteHourClause(schedule) + tail;
+    return hourCad === null ? minuteHourClause(schedule) + "\uFF0C\u5728" + hourList(schedule) + tail : hourCad + "\uFF0C" + withoutHourAnchor(minuteHourClause(schedule)) + tail;
   }
   if (compact.minute > 0) {
     return minuteHourClause(schedule) + "\uFF0C\u5728" + hourList(schedule) + tail;
@@ -599,16 +603,27 @@ function composeSecondsOnHour(schedule, plan, opts) {
   if (composedClock && schedule.pattern.minute === "0") {
     return composeMinuteZeroClocks(schedule, sec);
   }
+  const fusedSingleMinute = composeSingleMinuteClocks(schedule, rest, sec, opts);
+  if (fusedSingleMinute !== null) {
+    return fusedSingleMinute;
+  }
   const restText = render(schedule, rest, opts);
   const secTail = clockRestCarriesSecond(rest) ? "" : sec;
   if (composedClock && isDaily(schedule)) {
     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;
 }
+function composeSingleMinuteClocks(schedule, rest, sec, opts) {
+  if (rest.kind !== "clockTimes" || schedule.shapes.minute !== "single" || clockRestCarriesSecond(rest)) {
+    return null;
+  }
+  const core = render(schedule, rest, opts) + minuteZeroSecondTail(schedule, sec);
+  return isDaily(schedule) ? "\u6BCF\u5929" + core : core;
+}
 function composeMinuteZeroClocks(schedule, sec) {
   if (hasHourWindow(schedule)) {
     return isDaily(schedule) ? "\u6BCF\u5929" + hourRangeWindow(schedule, sec) : hourRangeWindow(schedule, sec);
@@ -616,11 +631,16 @@ function composeMinuteZeroClocks(schedule, sec) {
   const clocks = hourFires(schedule).map(function clock(hour) {
     return hour === 12 ? "\u6B63\u5348" : hourWord(hour) + "0\u5206";
   });
-  const nested = strideFromSegments(segmentsOf(schedule, "second"), "\u79D2", "\u79D2", "");
-  const tail = sec === "\u6BCF\u79D2" ? "\u7684\u6BCF\u4E00\u79D2" : "\u7684" + (nested ?? sec);
-  const core = joinAnd(clocks) + tail;
+  const core = joinAnd(clocks) + minuteZeroSecondTail(schedule, sec);
   return isDaily(schedule) ? "\u6BCF\u5929" + core : core;
 }
+function minuteZeroSecondTail(schedule, sec) {
+  if (sec === "\u6BCF\u79D2") {
+    return "\u7684\u6BCF\u4E00\u79D2";
+  }
+  const nested = strideFromSegments(segmentsOf(schedule, "second"), "\u79D2", "\u79D2", "");
+  return "\u7684" + (nested ?? sec);
+}
 function hasHourWindow(schedule) {
   return segmentsOf(schedule, "hour").some(function range(segment) {
     return segment.kind === "range";
@@ -663,17 +683,39 @@ function composeSecondsListed(schedule) {
     return hourWord(hourFires(schedule)[0]) + minuteCad + "\u7684\u6BCF\u4E00\u79D2";
   }
   if (schedule.shapes.hour === "wildcard") {
-    return minutes + "\uFF0C" + sec;
+    return secondIsCadence(schedule) ? minutes + confinedSecondTail(sec) : minutes + "\uFF0C" + sec;
   }
   const hourCad = unevenHourCadence(schedule);
   if (hourCad !== null) {
-    return hourCad + "\uFF0C" + minutes + "\uFF0C" + sec;
+    return hourCad + "\uFF0C" + withoutHourAnchor(minutes) + "\uFF0C" + sec;
   }
   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 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/dist/lang/zh.js

@@ -320,6 +320,9 @@ function minuteHourClause(schedule) {
 function renderMinutePast(schedule) {
   return minuteHourClause(schedule);
 }
+function withoutHourAnchor(clause) {
+  return clause.replace(/^每小时/, "");
+}
 function hourSegmentWords(segment) {
   if (segment.kind === "range") {
     return [hourWord(+segment.bounds[0]) + "\u81F3" + hourWord(+segment.bounds[1])];
@@ -347,7 +350,8 @@ function renderMinuteFrequency(schedule, plan) {
   if (hours.kind === "step" || hours.kind === "during") {
     const hourCad = unevenHourCadence(schedule);
     if (hourCad !== null) {
-      return hourCad + (hourCad.indexOf("\u81F3") === -1 ? "" : "\uFF0C") + base;
+      const minuteBase = hours.kind === "step" ? withoutHourAnchor(base) : base;
+      return hourCad + (hourCad.indexOf("\u81F3") === -1 ? "" : "\uFF0C") + minuteBase;
     }
   }
   if (hours.kind === "window" && hours.from === hours.to) {
@@ -380,9 +384,9 @@ function renderMinuteSpanAcrossHourStep(schedule, plan) {
   const hourStep = stepSegment(schedule, "hour");
   const { form } = plan;
   if (form === "list") {
-    return hourCadencePhrase(schedule) + "\uFF0C" + renderMinutePast(schedule);
+    return hourCadencePhrase(schedule) + "\uFF0C" + withoutHourAnchor(renderMinutePast(schedule));
   }
-  const minuteTail = form === "wildcard" ? "\u6BCF\u5206\u949F" : minuteHourClause(schedule) + "\uFF0C\u6BCF\u5206\u949F";
+  const minuteTail = form === "wildcard" ? "\u6BCF\u5206\u949F" : withoutHourAnchor(minuteHourClause(schedule)) + "\uFF0C\u6BCF\u5206\u949F";
   if (hourStep.startToken !== "*") {
     return hourCadencePhrase(schedule) + "\uFF0C" + minuteTail;
   }
@@ -410,7 +414,7 @@ function renderCompactClockTimes(schedule, plan) {
   const tail = secs.length && schedule.pattern.second !== "0" ? "\uFF0C\u7B2C" + valueText(secs) + "\u79D2" : "";
   if (!compact.fold) {
     const hourCad = unevenHourCadence(schedule);
-    return hourCad === null ? minuteHourClause(schedule) + "\uFF0C\u5728" + hourList(schedule) + tail : hourCad + "\uFF0C" + minuteHourClause(schedule) + tail;
+    return hourCad === null ? minuteHourClause(schedule) + "\uFF0C\u5728" + hourList(schedule) + tail : hourCad + "\uFF0C" + withoutHourAnchor(minuteHourClause(schedule)) + tail;
   }
   if (compact.minute > 0) {
     return minuteHourClause(schedule) + "\uFF0C\u5728" + hourList(schedule) + tail;
@@ -573,16 +577,27 @@ function composeSecondsOnHour(schedule, plan, opts) {
   if (composedClock && schedule.pattern.minute === "0") {
     return composeMinuteZeroClocks(schedule, sec);
   }
+  const fusedSingleMinute = composeSingleMinuteClocks(schedule, rest, sec, opts);
+  if (fusedSingleMinute !== null) {
+    return fusedSingleMinute;
+  }
   const restText = render(schedule, rest, opts);
   const secTail = clockRestCarriesSecond(rest) ? "" : sec;
   if (composedClock && isDaily(schedule)) {
     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;
 }
+function composeSingleMinuteClocks(schedule, rest, sec, opts) {
+  if (rest.kind !== "clockTimes" || schedule.shapes.minute !== "single" || clockRestCarriesSecond(rest)) {
+    return null;
+  }
+  const core = render(schedule, rest, opts) + minuteZeroSecondTail(schedule, sec);
+  return isDaily(schedule) ? "\u6BCF\u5929" + core : core;
+}
 function composeMinuteZeroClocks(schedule, sec) {
   if (hasHourWindow(schedule)) {
     return isDaily(schedule) ? "\u6BCF\u5929" + hourRangeWindow(schedule, sec) : hourRangeWindow(schedule, sec);
@@ -590,11 +605,16 @@ function composeMinuteZeroClocks(schedule, sec) {
   const clocks = hourFires(schedule).map(function clock(hour) {
     return hour === 12 ? "\u6B63\u5348" : hourWord(hour) + "0\u5206";
   });
-  const nested = strideFromSegments(segmentsOf(schedule, "second"), "\u79D2", "\u79D2", "");
-  const tail = sec === "\u6BCF\u79D2" ? "\u7684\u6BCF\u4E00\u79D2" : "\u7684" + (nested ?? sec);
-  const core = joinAnd(clocks) + tail;
+  const core = joinAnd(clocks) + minuteZeroSecondTail(schedule, sec);
   return isDaily(schedule) ? "\u6BCF\u5929" + core : core;
 }
+function minuteZeroSecondTail(schedule, sec) {
+  if (sec === "\u6BCF\u79D2") {
+    return "\u7684\u6BCF\u4E00\u79D2";
+  }
+  const nested = strideFromSegments(segmentsOf(schedule, "second"), "\u79D2", "\u79D2", "");
+  return "\u7684" + (nested ?? sec);
+}
 function hasHourWindow(schedule) {
   return segmentsOf(schedule, "hour").some(function range(segment) {
     return segment.kind === "range";
@@ -637,17 +657,39 @@ function composeSecondsListed(schedule) {
     return hourWord(hourFires(schedule)[0]) + minuteCad + "\u7684\u6BCF\u4E00\u79D2";
   }
   if (schedule.shapes.hour === "wildcard") {
-    return minutes + "\uFF0C" + sec;
+    return secondIsCadence(schedule) ? minutes + confinedSecondTail(sec) : minutes + "\uFF0C" + sec;
   }
   const hourCad = unevenHourCadence(schedule);
   if (hourCad !== null) {
-    return hourCad + "\uFF0C" + minutes + "\uFF0C" + sec;
+    return hourCad + "\uFF0C" + withoutHourAnchor(minutes) + "\uFF0C" + sec;
   }
   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 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.0",
+  "version": "0.8.3",
   "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 {
@@ -717,6 +727,65 @@ 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;
+}
+
 function renderComposeSeconds(
   schedule: Schedule,
   plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
@@ -738,16 +807,25 @@ function renderComposeSeconds(
     }
   }
 
-  // A sub-minute second with the minute pinned to 0 and a specific hour: the
-  // clock-time rest would read "um 9 Uhr", which hides the pinned :00 (and so
-  // the one-minute confinement — 60 fires in :00, not 3,600 across the hour).
-  // Bind the seconds into the explicit clock minute in the genitive ("der
-  // Minute 9:00"); the recurring "täglich"/day frame is added in `describe`.
-  if (composeMinuteZero(schedule, plan)) {
+  // A second over a single fixed minute and a specific hour is a single fixed
+  // timestamp: the clock-time rest would float the seconds as a separate
+  // apposition ("jede Sekunde, um 9:02 Uhr"), hiding that they belong to that
+  // one minute. Bind the seconds into the explicit clock minute in the genitive
+  // ("der Minute 9:02"), the same fusion the minute-0 case ("der Minute 9:00")
+  // uses; the recurring "täglich"/day frame is added in `describe`.
+  if (composeSingleMinute(schedule, plan)) {
     return secondsLead(schedule) + ' ' +
       clockMinuteGenitive(plan.rest.times, opts.style.sep);
   }
 
+  // A stepped minute under a wildcard/stepped second + wildcard hour confines
+  // the second cadence to the ordinal minute cadence ("jede Sekunde in jeder
+  // sechsten Minute ab Minute 4 jeder Stunde"), never the comma juxtaposition
+  // that reads as two independent cadences.
+  if (isSteppedMinuteSeconds(schedule, plan)) {
+    return minuteStepConfinement(schedule, minuteStride(schedule)!);
+  }
+
   // A wildcard second under a minute */2 with a wildcard hour binds in the
   // genitive ("jede Sekunde jeder zweiten Minute").
   if (isEveryOtherMinuteSeconds(schedule, plan)) {
@@ -765,21 +843,23 @@ function renderComposeSeconds(
   return lead + render(schedule, plan.rest, opts);
 }
 
-// True when a compose-seconds plan is a sub-minute second over a minute-0
-// clock-time rest — the case that reads as the bare hour and so must surface
-// the pinned clock minute.
-function composeMinuteZero(
+// True when a compose-seconds plan is a sub-minute second over a single fixed
+// minute's clock-time rest — the single fixed timestamp whose seconds must fuse
+// to the explicit clock minute rather than float as a separate apposition.
+// Minute 0 ("der Minute 0:00") is just this with the minute being 0; any single
+// fixed minute fuses the same way.
+function composeSingleMinute(
   schedule: Schedule,
   plan: Extract<PlanNode, {kind: 'composeSeconds'}>
 ): plan is Extract<PlanNode, {kind: 'composeSeconds'}> &
   {rest: Extract<PlanNode, {kind: 'clockTimes'}>} {
   return plan.rest.kind === 'clockTimes' &&
-    plan.rest.times.every((time) => +time.minute === 0);
+    schedule.shapes.minute === 'single';
 }
 
-// The pinned clock minute in the genitive: "der Minute 9:00" for one hour,
-// "der Minuten 9:00, 10:00 und 17:00" for several — the explicit ":00" so the
-// minute-0 confinement stays visible.
+// The pinned clock minute in the genitive: "der Minute 9:02" for one hour,
+// "der Minuten 9:00, 10:00 und 17:00" for several — the explicit minute so the
+// single-fixed-minute confinement stays visible.
 function clockMinuteGenitive(
   times: {hour: number; minute: number}[],
   sep: string
@@ -940,18 +1020,22 @@ function renderMinuteFrequency(
   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
-    // 20 Uhr").
+    // 20 Uhr"). That hour step is the sole hour authority, so an offset minute
+    // cadence drops its generic "jeder Stunde" (an every-hour scope conflicting
+    // with the step); a list of specific hours keeps it.
     const cadence = unevenHourCadence(schedule);
 
     return cadence ?
-      base + ', ' + cadence :
+      stepClause(segment, UNITS.minute, '') + ', ' + cadence :
       base + ' ' + duringHours(schedule, plan.hours.times, sep);
   }
 
   if (plan.hours.kind === 'step') {
     // The plan carries a step only for a clean step (dividing the day):
-    // confine the cadence to every Nth hour ("in jeder zweiten Stunde").
-    return base + ' ' +
+    // confine the cadence to every Nth hour ("in jeder zweiten Stunde"). The
+    // hour step is the sole hour authority, so the minute cadence drops its
+    // generic "jeder Stunde".
+    return stepClause(segment, UNITS.minute, '') + ' ' +
       everyNthHour(stepSegment(schedule, 'hour'));
   }
 
@@ -1405,28 +1489,31 @@ function qualifier(schedule: Schedule, months: Months): string {
 
 // Plan kinds whose clause is a clock time: the qualifier leads them ("montags
 // um 9 Uhr"); a frequency clause trails it ("jede Minute montags"). The
-// minute-0 compose-seconds clause is anchored on a clock minute too, so the
-// qualifier leads it ("montags jede Sekunde der Minute 9:00").
+// single-fixed-minute compose-seconds clause is anchored on a clock minute too,
+// so the qualifier leads it ("montags jede Sekunde der Minute 9:00").
 const LEADING_PLANS = new Set(['clockTimes']);
 
 // True when the leading qualifier should precede the clause: a clock-time
-// plan, or the minute-0 compose-seconds clause that surfaces a clock minute.
+// plan, or the single-fixed-minute compose-seconds clause that surfaces a clock
+// minute.
 function leadsQualifier(schedule: Schedule): boolean {
-  return LEADING_PLANS.has(schedule.plan.kind) || isComposeMinuteZero(schedule);
+  return LEADING_PLANS.has(schedule.plan.kind) ||
+    isComposeSingleMinute(schedule);
 }
 
-// Whether the planned clause is the minute-0 compose-seconds confinement
-// (a sub-minute second over a minute-0 clock-time rest).
-function isComposeMinuteZero(schedule: Schedule): boolean {
+// Whether the planned clause is the single-fixed-minute compose-seconds
+// confinement (a sub-minute second over a single fixed minute's clock-time
+// rest).
+function isComposeSingleMinute(schedule: Schedule): boolean {
   return schedule.plan.kind === 'composeSeconds' &&
-    composeMinuteZero(schedule, schedule.plan);
+    composeSingleMinute(schedule, schedule.plan);
 }
 
 // True when the clause is a bare daily clock-time list and so needs the
 // "täglich" frame to read as recurring, not a one-off: clockTimes always, the
-// minute-0 compose-seconds clause (a recurring clock minute), and an uneven
-// hour step (rendered as its fire list "um 0, 5, … Uhr", not the cadence "alle
-// N Stunden"). A frequency clause already implies recurrence.
+// single-fixed-minute compose-seconds clause (a recurring clock minute), and an
+// uneven hour step (rendered as its fire list "um 0, 5, … Uhr", not the cadence
+// "alle N Stunden"). A frequency clause already implies recurrence.
 function needsDailyFrame(schedule: Schedule): boolean {
   // An hour cadence is a sub-daily frequency, not a daily clock-time list, so
   // it must not take the "täglich" frame ("alle 2 Stunden", not "täglich alle
@@ -1435,7 +1522,7 @@ function needsDailyFrame(schedule: Schedule): boolean {
     return false;
   }
 
-  if (schedule.plan.kind === 'clockTimes' || isComposeMinuteZero(schedule)) {
+  if (schedule.plan.kind === 'clockTimes' || isComposeSingleMinute(schedule)) {
     return true;
   }