cronli5 0.1.5 → 0.1.7

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".
@@ -670,6 +692,25 @@ function renderMinuteSpanInHour(
 
 // Seconds composed with the rest: "in den Sekunden 0 und 30 jeder Minute, um
 // 9:05 Uhr".
+// A wildcard second under a minute */2 with a wildcard hour juxtaposes two
+// cadences that read as contradictory ("jede Sekunde, alle 2 Minuten"). Bind
+// them in the genitive ("jede Sekunde jeder zweiten Minute"), mirroring
+// English. Other strides, a restricted hour, and an hour cadence keep the
+// juxtaposed form.
+function isEveryOtherMinuteSeconds(
+  ir: IR,
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>
+): boolean {
+  if (plan.rest.kind !== 'minuteFrequency' ||
+      ir.shapes.second !== 'wildcard' || ir.shapes.hour !== 'wildcard') {
+    return false;
+  }
+
+  const minuteStep = stepSegment(ir.analyses.segments.minute);
+
+  return minuteStep.startToken === '*' && minuteStep.interval === 2;
+}
+
 function renderComposeSeconds(
   ir: IR,
   plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
@@ -682,7 +723,8 @@ function renderComposeSeconds(
   if ((plan.rest.kind === 'clockTimes' ||
       plan.rest.kind === 'compactClockTimes') &&
       ir.shapes.minute === 'single') {
-    const cadence = hourCadence(ir, +ir.pattern.minute);
+    const minute = +ir.pattern.minute;
+    const cadence = hourCadence(ir, minute) ?? hourRangeCadence(ir, minute);
 
     if (cadence !== null) {
       return cadence;
@@ -699,21 +741,21 @@ function renderComposeSeconds(
       clockMinuteGenitive(plan.rest.times, opts.style.sep);
   }
 
-  // A wildcard second under a minute */2 with a wildcard hour juxtaposes two
-  // cadences that read as contradictory ("jede Sekunde, alle 2 Minuten"). Bind
-  // them in the genitive ("jede Sekunde jeder zweiten Minute"), mirroring
-  // English. Other strides, a restricted hour, and an hour cadence keep the
-  // juxtaposed form.
-  if (plan.rest.kind === 'minuteFrequency' &&
-      ir.shapes.second === 'wildcard' && ir.shapes.hour === 'wildcard') {
-    const minuteStep = stepSegment(ir.analyses.segments.minute);
-
-    if (minuteStep.startToken === '*' && minuteStep.interval === 2) {
-      return secondsLead(ir) + ' jeder zweiten Minute';
-    }
+  // A wildcard second under a minute */2 with a wildcard hour binds in the
+  // genitive ("jede Sekunde jeder zweiten Minute").
+  if (isEveryOtherMinuteSeconds(ir, plan)) {
+    return secondsLead(ir) + ' jeder zweiten Minute';
   }
 
-  return secondsLead(ir) + ', ' + render(ir, 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
+  // clockSecond), so it still leads its own clause here.
+  const restOwnsLead = plan.rest.kind === 'compactClockTimes' &&
+    ir.analyses.clockSecond;
+  const lead = restOwnsLead ? '' : secondsLead(ir) + ', ';
+
+  return lead + render(ir, plan.rest, opts);
 }
 
 // True when a compose-seconds plan is a sub-minute second over a minute-0
@@ -752,18 +794,30 @@ function renderMinutesAcrossHours(
   opts: Opts
 ): string {
   const sep = opts.style.sep;
+  // A bounded or uneven hour stride reads as its endpoint-pinning cadence,
+  // not a wall of hour columns.
+  const cadence = unevenHourCadence(ir);
 
   // The wildcard form means every minute *during* each hour: render windows.
   if (plan.form === 'wildcard') {
-    return 'jede Minute ' + duringHours(ir, plan.times, sep);
+    return cadence ?
+      'jede Minute, ' + cadence :
+      'jede Minute ' + duringHours(ir, plan.times, sep);
+  }
+
+  const minuteLead =
+    strideFromSegments(fieldSegments(ir, 'minute'), UNITS.minute, '') ??
+    countedPhrase(ir, 'minute', 'Minute', 'Minuten');
+
+  if (cadence !== null) {
+    return minuteLead + ', ' + cadence;
   }
 
   const hours = plan.times.kind === 'fires' ?
     atHours(plan.times.fires) :
     joinList(hourSegmentParts(ir, 0, 0, sep));
 
-  return (strideFromSegments(fieldSegments(ir, 'minute'), UNITS.minute, '') ??
-    countedPhrase(ir, 'minute', 'Minute', 'Minuten')) + ', ' + hours;
+  return minuteLead + ', ' + hours;
 }
 
 // A minute clause across a stepped hour range. A wildcard minute (a cadence)
@@ -774,6 +828,12 @@ function renderMinuteSpanAcrossHourStep(
   ir: IR,
   plan: Extract<PlanNode, {kind: 'minuteSpanAcrossHourStep'}>
 ): string {
+  // A bounded or uneven hour stride reads as its endpoint-pinning cadence; an
+  // offset-clean stride keeps its "in jeder N-ten Stunde" confinement.
+  const cadence = unevenHourCadence(ir);
+
+  // A wildcard minute over a stepped hour is reached only for a clean stride (a
+  // bounded or uneven step routes through minutesAcrossHours instead).
   if (plan.form === 'wildcard') {
     return 'jede Minute ' +
       everyNthHour(stepSegment(ir.analyses.segments.hour));
@@ -782,11 +842,11 @@ function renderMinuteSpanAcrossHourStep(
   // The minute (range or list) leads; the hour trails. A clean stride confines
   // to "in jeder N-ten Stunde" — the same cadence the wildcard form and the
   // minute-step compositions use, never a juxtaposed second frequency. A
-  // bounded stride (reachable only via a range) enumerates its fires instead.
+  // bounded or uneven stride trails its endpoint-pinning cadence instead.
   const segment = stepSegment(ir.analyses.segments.hour);
-  const hours = confinedHourStride(segment) ?
+  const hours = cadence ?? (confinedHourStride(segment) ?
     everyNthHour(segment) :
-    atHours(segment.fires);
+    atHours(segment.fires));
 
   return (strideFromSegments(fieldSegments(ir, 'minute'), UNITS.minute, '') ??
     countedPhrase(ir, 'minute', 'Minute', 'Minuten')) + ', ' + hours;
@@ -805,10 +865,11 @@ function renderCompactClockTimes(
   const sep = opts.style.sep;
 
   if (plan.fold) {
-    // An hour step (or arithmetic-progression hour list) under the single
-    // pinned minute reads as a cadence, not a wall of clock times. (Returns
-    // null for an irregular list or a range, which keep folding below.)
-    const cadence = hourCadence(ir, plan.minute);
+    // An hour step or range (or arithmetic-progression hour list) under the
+    // single pinned minute reads as a cadence or window, not a wall of clock
+    // times. (Returns null for an irregular list, which keeps folding below.)
+    const cadence = hourCadence(ir, plan.minute) ??
+      hourRangeCadence(ir, plan.minute);
 
     if (cadence !== null) {
       return cadence;
@@ -821,11 +882,12 @@ function renderCompactClockTimes(
       joinList(hourSegmentParts(ir, plan.minute, ir.analyses.clockSecond, sep));
   }
 
-  // A range among the hours reads as a window; otherwise a flat hour list.
-  const hours = fieldSegments(ir, 'hour')
-    .some((segment) => segment.kind === 'range') ?
-    joinList(hourSegmentParts(ir, 0, 0, sep)) :
-    atHours(hourFires(ir));
+  // A bounded or uneven hour stride reads as its endpoint-pinning cadence; else
+  // a range among the hours reads as a window, otherwise a flat hour list.
+  const hours = unevenHourCadence(ir) ??
+    (fieldSegments(ir, 'hour').some((segment) => segment.kind === 'range') ?
+      joinList(hourSegmentParts(ir, 0, 0, sep)) :
+      atHours(hourFires(ir)));
 
   // A folded second has no single clock time to attach to here, so it leads
   // as its own clause ("in Sekunde 30, ..."). It is the bare second (not
@@ -848,17 +910,31 @@ 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') {
-    return base + ' ' + duringHours(ir, plan.hours.times, sep);
+    // 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").
+    const cadence = unevenHourCadence(ir);
+
+    return cadence ?
+      base + ', ' + cadence :
+      base + ' ' + duringHours(ir, plan.hours.times, sep);
   }
 
   if (plan.hours.kind === 'step') {
@@ -871,15 +947,50 @@ function renderMinuteFrequency(
   return base;
 }
 
-// A stepped hour field as a phrase: the cadence when clean ("alle 6 Stunden"),
-// else its discrete fires when uneven or bounded ("um 0, 5, 10, 15 und 20
-// Uhr"). Shared by the bare hour step and the minute-step compositions.
+// 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);
+
+  if (cadence !== null) {
+    return cadence;
+  }
+
   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). ---
@@ -909,12 +1020,56 @@ function hourStrideCadence(
   return cadence + ' von ' + start + ' bis ' + last + ' Uhr';
 }
 
+// An hour list's arithmetic progression, or null when its values are not a step
+// the renderer should speak as a cadence. The core rewrites a uneven hour step
+// (whose interval does not tile 24, e.g. `*/5` → 0,5,10,15,20) to its literal
+// fire list, indistinguishable in the IR from a hand-written list; the renderer
+// recovers the cadence from the values. A progression starting at zero is a
+// `*/n` step however short (0,7,14,21 is `*/7`); a non-zero progression is only
+// a step when it is too long to be a deliberate clock-time list (9,17 is two
+// named times, not a cadence). Interval one is a plain range, never a step.
+function hourListStride(
+  values: number[]
+): {start: number; interval: number; last: number} | null {
+  if (values.length < 2) {
+    return null;
+  }
+
+  const interval = values[1] - values[0];
+
+  if (interval < 2) {
+    return null;
+  }
+
+  for (let i = 2; i < values.length; i += 1) {
+    if (values[i] - values[i - 1] !== interval) {
+      return null;
+    }
+  }
+
+  if (values[0] !== 0 && values.length < 5) {
+    return null;
+  }
+
+  return {interval, last: values[values.length - 1], start: values[0]};
+}
+
+// Whether an hour stride wraps the day cleanly from within its first interval
+// (a `*/n` from the top, or a `m/n` offset with m < n that divides 24): such a
+// stride has no distinct endpoint and keeps its bare or "ab" cadence. Every
+// other stride — a uneven interval, or one starting at or past its interval (a
+// bounded `a-b/n`) — is a bounded set the cadence pins both endpoints of.
+function offsetCleanStride(
+  stride: {start: number; interval: number}
+): boolean {
+  return stride.start < stride.interval && 24 % stride.interval === 0;
+}
+
 // The hour field's stride, or null when the hour is not a cadence: a step
 // segment yields its {start, interval, last} directly; an all-single hour list
-// yields one only when its values form a long-enough arithmetic progression
-// (so an irregular list like 9,17 keeps enumerating). The IR is unchanged —
-// the renderer recognizes the stride and speaks it as a cadence instead of the
-// clock-time cross-product.
+// yields one only when its values form a step progression (so an irregular list
+// like 9,17 keeps enumerating). The IR is unchanged — the renderer recognizes
+// the stride and speaks it as a cadence, not the clock-time cross-product.
 function hourStride(
   ir: IR
 ): {start: number; interval: number; last: number} | null {
@@ -927,6 +1082,13 @@ function hourStride(
 
   if (segments.length === 1 && segments[0].kind === 'step') {
     const segment = segments[0];
+
+    // A bounded step that fires only once (e.g. `9-10/5` -> just 9) is a single
+    // value, not a stride: it has no interval to speak and no endpoint to pin.
+    if (segment.fires.length < 2) {
+      return null;
+    }
+
     const start = segment.startToken === '*' ?
       0 :
       +segment.startToken.split('-')[0];
@@ -936,9 +1098,25 @@ function hourStride(
   }
 
   const values = singleValues(segments);
-  const step = values && arithmeticStep(values);
 
-  return step || null;
+  return values && hourListStride(values);
+}
+
+// The bounded cadence for an hour stride that pins both clock-time endpoints,
+// or null when the hour is not such a stride. The core rewrites a uneven step
+// to its fire list, so a minute window/list/step crossed with it lands in the
+// enumerating list paths; there the bounded hour reads better as its cadence
+// ("…, alle 5 Stunden von 0 bis 20 Uhr") than as a wall of clock times. An
+// offset-clean stride keeps its existing confinement form, so only the
+// endpoint-bearing case routes here.
+function unevenHourCadence(ir: IR): string | null {
+  const stride = hourStride(ir);
+
+  if (!stride || offsetCleanStride(stride)) {
+    return null;
+  }
+
+  return hourStrideCadence(stride);
 }
 
 // The second's status against a pinned minute: a wildcard or sub-minute step
@@ -958,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');
@@ -972,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
@@ -994,7 +1172,13 @@ function hourCadence(ir: IR, minute: number): string | null {
 
   const fires = (stride.last - stride.start) / stride.interval + 1;
 
-  if (ir.pattern.second === '0' && fires <= maxClockTimes) {
+  // A short stride that spells out as few clock times stays an enumeration only
+  // when it wraps cleanly (an offset-clean stride with no endpoint): the bare
+  // or "ab" form is no shorter than the list. A bounded or uneven stride has no
+  // clean wrap, so its endpoint-pinning cadence ("alle 5 Stunden von 0 bis 20
+  // Uhr") reads better however short.
+  if (ir.pattern.second === '0' && fires <= maxClockTimes &&
+      offsetCleanStride(stride)) {
     return null;
   }
 
@@ -1008,19 +1192,72 @@ 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
+  // lead clause to fold in, so the bounded cadence stands on its own ("alle 5
+  // Stunden von 0 bis 20 Uhr").
+  if (minute === 0 && ir.pattern.second === '0') {
+    return hourStrideCadence(stride);
   }
 
   return hourCadenceLead(ir, minute) + ', ' + hourStrideCadence(stride);
 }
 
-// Whether an hour cadence applies to a plan with a single pinned minute — the
-// signal that the clause is a cadence, not a daily clock-time list, so the
-// "täglich" frame must not be added.
+// Whether an hour cadence or hour-range window applies to a plan with a single
+// pinned minute — the signal that the clause is a cadence/window, not a daily
+// clock-time list, so the "täglich" frame must not be added.
 function hourCadenceApplies(ir: IR): boolean {
-  return ir.shapes.minute === 'single' &&
-    hourCadence(ir, +ir.pattern.minute) !== null;
+  if (ir.shapes.minute !== 'single') {
+    return false;
+  }
+
+  const minute = +ir.pattern.minute;
+
+  return hourCadence(ir, minute) !== null ||
+    hourRangeCadence(ir, minute) !== null;
+}
+
+// Whether the hour field is a range — or a list whose segments include a
+// range — and so forms a window rather than a cross-product of clock times.
+// A pure single-value list (9,17) has no range to span and still enumerates;
+// a step is handled by hourStride/hourCadence.
+function hasHourWindow(ir: IR): boolean {
+  const segments = fieldSegments(ir, 'hour');
+
+  return !!segments && segments.some(function range(segment) {
+    return segment.kind === 'range';
+  });
+}
+
+// Render an hour range (or a list whose segments include a range) under
+// minute 0 and a meaningful second as the hour-range window — the lead clause,
+// then "von 9 bis 17 Uhr" (and any non-contiguous hour as "und um 22 Uhr") —
+// instead of cross-multiplying the hours into a wall of clock times. The
+// hour-RANGE analog of hourCadence; returns the bare clause (the day frame is
+// suppressed by hourCadenceApplies). Returns null when the hour has no range,
+// when the minute is non-zero (a real clock minute the existing window form
+// already speaks), or when a plain :00 set carries no clause. Renderer-only;
+// the IR is unchanged.
+function hourRangeCadence(ir: IR, minute: number): string | null {
+  if (minute !== 0 || !hasHourWindow(ir) || ir.pattern.second === '0') {
+    return null;
+  }
+
+  return hourCadenceLead(ir, minute) + ', ' + hourRangeWindowTail(ir);
+}
+
+// The hour-range window as a cadence tail at the top of each hour: each range
+// segment is "von X bis Y Uhr", any non-contiguous hour is "um Z Uhr", joined
+// — the same parts the bare "stündlich von 9 bis 17 Uhr" window forms, minus
+// the "stündlich" prefix the lead replaces. The minute has folded into the
+// lead, so the parts close on the top of their final hour.
+function hourRangeWindowTail(ir: IR): string {
+  // Minute 0 with a falsy second renders each part as a bare hour ("von 9 bis
+  // 17 Uhr", "um 22 Uhr"); the separator is unused in that path.
+  return joinList(hourSegmentParts(ir, 0, 0, ':'));
 }
 
 // An hourly window: "stündlich von 9 bis 17 Uhr", or every minute across it.
@@ -1029,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;
@@ -1043,9 +1283,15 @@ function renderHourRange(
     return 'stündlich ' + window;
   }
 
-  // A non-zero single minute ('lead') or a minute range leads the window.
-  return countedPhrase(ir, 'minute', 'Minute', 'Minuten') +
-    ' jeder Stunde, ' + window;
+  // A non-zero single minute ('lead') or a minute range leads the window. A
+  // non-uniform minute step the core enumerated to a fire list reads as its
+  // bounded cadence ("alle 2 Minuten von Minute 3 bis 59 jeder Stunde") instead
+  // of the wall of fires; an irregular list or a single minute keeps the
+  // counted form.
+  return (strideFromSegments(fieldSegments(ir, 'minute'), UNITS.minute,
+    'jeder Stunde') ??
+    countedPhrase(ir, 'minute', 'Minute', 'Minuten') + ' jeder Stunde') +
+    ', ' + window;
 }
 
 // One or more clock times: "um 9 Uhr", "um 14:30 Uhr", "um 9 und 17 Uhr".
@@ -1054,10 +1300,12 @@ function renderClockTimes(
   plan: Extract<PlanNode, {kind: 'clockTimes'}>,
   opts: Opts
 ): string {
-  // An hour step (or arithmetic-progression hour list) under a single pinned
-  // minute reads as a cadence rather than a cross-product of clock times.
+  // An hour step or range (or arithmetic-progression hour list) under a single
+  // pinned minute reads as a cadence or window rather than a cross-product of
+  // clock times.
   if (ir.shapes.minute === 'single') {
-    const cadence = hourCadence(ir, +ir.pattern.minute);
+    const minute = +ir.pattern.minute;
+    const cadence = hourCadence(ir, minute) ?? hourRangeCadence(ir, minute);
 
     if (cadence !== null) {
       return cadence;
@@ -1156,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 {