cronli5 0.1.4 → 0.1.6

package/src/lang/de/index.ts

@@ -2,8 +2,8 @@
 // German. Anchored to Duden; see notes.md for the decisions.
 
 import {pad} from '../../core/format.js';
-import {weekdayNumbers} from '../../core/specs.js';
-import {toFieldNumber} from '../../core/util.js';
+import {maxClockTimes, weekdayNumbers} from '../../core/specs.js';
+import {arithmeticStep, toFieldNumber} from '../../core/util.js';
 import type {Cronli5Options} from '../../types.js';
 import type {
   Field, HourTimesPlan, IR, Language, NormalizedOptions, PlanNode, Segment
@@ -22,6 +22,19 @@ interface Unit {
   singular: string;
 }
 
+// A step cadence to phrase: the `interval` repeats over a `cycle`-long field
+// (60 for minute/second), running from `start` to `last`. `anchor` is the
+// scope clause ("jeder Stunde"); an empty anchor lets the caller supply its
+// own trailing scope, dropping the tail.
+interface Stride {
+  interval: number;
+  start: number;
+  last: number;
+  cycle: number;
+  unit: Unit;
+  anchor: string;
+}
+
 const UNITS: Record<'second' | 'minute' | 'hour', Unit> = {
   hour: {every: 'jede', plural: 'Stunden', singular: 'Stunde'},
   minute: {every: 'jede', plural: 'Minuten', singular: 'Minute'},
@@ -51,6 +64,98 @@ function cleanStep(segment: StepSegment, cycle: number): boolean {
     cycle % segment.interval === 0;
 }
 
+// Speak a step cadence over a `cycle`-long field (60 for minute/second). A
+// clean stride from the top of the cycle is the bare cadence ("alle 15
+// Minuten"); a uniform offset (start within the first interval, the interval
+// still dividing the cycle) names only its start, since it wraps cleanly with
+// no distinct endpoint ("alle 6 Minuten ab Minute 5 jeder Stunde"); a
+// non-uniform stride (start >= interval, or an interval that does not divide
+// the cycle) pins both endpoints so the bounded, non-wrapping set reads
+// unambiguously ("alle 2 Minuten von Minute 3 bis 59 jeder Stunde"). This is
+// the one phrasing for every step the renderer speaks, whether the core kept
+// it a step shape (a clean cadence) or enumerated it to a fire list (an
+// offset/uneven set the list path recognizes as a progression).
+function renderStride(stride: Stride): string {
+  const {interval, start, last, cycle, unit, anchor} = stride;
+  const cadence = everyN(interval, unit);
+  const tiles = cycle % interval === 0;
+
+  if (start === 0 && tiles) {
+    return cadence;
+  }
+
+  // A context that supplies its own trailing scope passes an empty anchor, so
+  // the cadence keeps its endpoints but drops the "jeder Stunde" tail.
+  const tail = anchor ? ' ' + anchor : '';
+
+  if (start < interval && tiles) {
+    return cadence + ' ab ' + unit.singular + ' ' + start + tail;
+  }
+
+  return cadence + ' von ' + unit.singular + ' ' + start + ' bis ' + last +
+    tail;
+}
+
+// A step *shape* segment as its cadence ("alle 6 Minuten ab Minute 5 jeder
+// Stunde"). A bounded sub-range step (`a-b/n`) is not a whole-cycle stride, so
+// it lists its fires; a short offset cadence (three fires or fewer) also lists,
+// since the list is no longer than the cadence. Everything else routes through
+// `renderStride`. The uneven whole-cycle step (interval not dividing the cycle)
+// never reaches here as a step shape — the core enumerates it to a fire list,
+// which the list path recognizes instead.
+function stepClause(segment: StepSegment, unit: Unit, anchor: string): string {
+  const start = segment.startToken === '*' ? 0 : +segment.startToken;
+  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 renderStride({
+    interval: segment.interval,
+    start,
+    last: segment.fires[segment.fires.length - 1],
+    cycle: 60,
+    unit,
+    anchor
+  });
+}
+
+// The sorted numeric values a field's segments cover, or null if any segment
+// is not a discrete single (a range or sub-step is not a plain fire list).
+function singleValues(segments: Segment[]): number[] | null {
+  const values: number[] = [];
+
+  for (const segment of segments) {
+    if (segment.kind !== 'single') {
+      return null;
+    }
+
+    values.push(+segment.value);
+  }
+
+  return values;
+}
+
+// Speak a minute/second field's enumerated fires as a step cadence when they
+// form an arithmetic progression long enough to beat the list (the core
+// enumerates an offset/uneven step to this fire list; the IR is unchanged, so
+// the renderer recognizes the progression). Returns null for a non-progression
+// or a too-short list, leaving the caller to enumerate.
+function strideFromSegments(
+  segments: Segment[],
+  unit: Unit,
+  anchor: string
+): string | null {
+  const values = singleValues(segments);
+  const step = values && arithmeticStep(values);
+
+  return step ?
+    renderStride({...step, cycle: 60, unit, anchor}) :
+    null;
+}
+
 type NameToken = string | number;
 type NameSegment =
   | {kind: 'single'; value: NameToken}
@@ -142,6 +247,20 @@ function everyNthHour(segment: StepSegment): string {
   return start === 0 ? base : base + ' ab ' + start + ' Uhr';
 }
 
+// Whether an hour step is a clean stride over the whole day — unbounded,
+// dividing 24, and starting within the first interval — so it confines to "in
+// jeder N-ten Stunde" rather than enumerating its fires. Mirrors the core's
+// cleanHourStride: an offset like 1/2 qualifies; bounded (9-17/2) does not.
+function confinedHourStride(segment: StepSegment): boolean {
+  if (segment.startToken.indexOf('-') !== -1) {
+    return false;
+  }
+
+  const start = segment.startToken === '*' ? 0 : +segment.startToken;
+
+  return 24 % segment.interval === 0 && start < segment.interval;
+}
+
 // The Quartz weekday stem (`5L`, `MON#2`) is not number-canonicalized in the
 // core, so it may still be a name token; resolve it via the core's index.
 function weekdayNoun(token: string): string {
@@ -344,17 +463,30 @@ function countedPhrase(
 // The seconds clause: "alle 30 Sekunden" for a step, else "in Sekunde 15
 // jeder Minute".
 function secondsLead(ir: IR): string {
+  return secondsClause(ir, 'jeder Minute');
+}
+
+// The second clause counted against an arbitrary anchor. The anchor is "jeder
+// Minute" in the standalone seconds path; the hour-cadence path folds a pinned
+// minute 0 into the hour and counts the second "jeder Stunde" instead ("in
+// Sekunde 30 jeder Stunde"), so the minute-0 confinement is stated, not
+// dropped.
+function secondsClause(ir: IR, anchor: string): string {
   if (ir.pattern.second === '*') {
     return 'jede Sekunde';
   }
 
   const segments = ir.analyses.segments.second;
 
-  if (ir.shapes.second === 'step' && cleanStep(stepSegment(segments), 60)) {
-    return everyN(stepSegment(segments).interval, UNITS.second);
+  // A step shape speaks its cadence directly; an offset/uneven step the core
+  // enumerated to a list is recognized as a progression. Both fall back to the
+  // counted list (a short or irregular set).
+  if (ir.shapes.second === 'step') {
+    return stepClause(stepSegment(segments), UNITS.second, anchor);
   }
 
-  return countedPhrase(ir, 'second', 'Sekunde', 'Sekunden') + ' jeder Minute';
+  return strideFromSegments(segments as Segment[], UNITS.second, anchor) ??
+    countedPhrase(ir, 'second', 'Sekunde', 'Sekunden') + ' ' + anchor;
 }
 
 // A clock time that always shows its minutes: "9:00", "9:30".
@@ -476,9 +608,17 @@ function renderSeconds(ir: IR): string {
 }
 
 // The minute-past-the-hour clause: "in Minute 5 jeder Stunde", "in den
-// Minuten 5, 10 und 30 jeder Stunde".
+// Minuten 5, 10 und 30 jeder Stunde". An offset/uneven step the core
+// enumerated to this list reads as a stride cadence when the fires form a
+// long-enough progression ("alle 2 Minuten von Minute 3 bis 59 jeder Stunde").
+function minutePastClause(ir: IR): string {
+  return strideFromSegments(fieldSegments(ir, 'minute'), UNITS.minute,
+    'jeder Stunde') ??
+    countedPhrase(ir, 'minute', 'Minute', 'Minuten') + ' jeder Stunde';
+}
+
 function renderMinutePast(ir: IR): string {
-  return countedPhrase(ir, 'minute', 'Minute', 'Minuten') + ' jeder Stunde';
+  return minutePastClause(ir);
 }
 
 // A specific minute and second: "in Minute 0 und Sekunde 30 jeder Stunde".
@@ -530,11 +670,45 @@ 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'}>,
   opts: Opts
 ): string {
+  // An hour step (or arithmetic-progression hour list) under a single pinned
+  // minute is a cadence, not a wall of clock times: the second/minute lead,
+  // then the hour cadence ("in Sekunde 30 jeder Stunde, alle 2 Stunden"). The
+  // clock-time rest would otherwise cross-multiply the hours.
+  if ((plan.rest.kind === 'clockTimes' ||
+      plan.rest.kind === 'compactClockTimes') &&
+      ir.shapes.minute === 'single') {
+    const minute = +ir.pattern.minute;
+    const cadence = hourCadence(ir, minute) ?? hourRangeCadence(ir, minute);
+
+    if (cadence !== null) {
+      return cadence;
+    }
+  }
+
   // 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).
@@ -545,7 +719,21 @@ function renderComposeSeconds(
       clockMinuteGenitive(plan.rest.times, opts.style.sep);
   }
 
-  return secondsLead(ir) + ', ' + render(ir, plan.rest, opts);
+  // 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';
+  }
+
+  // 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
@@ -584,34 +772,62 @@ 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 countedPhrase(ir, 'minute', 'Minute', 'Minuten') + ', ' + hours;
+  return minuteLead + ', ' + hours;
 }
 
 // A minute clause across a stepped hour range. A wildcard minute (a cadence)
 // is reached only for a clean step and is confined to every Nth hour ("jede
-// Minute in jeder zweiten Stunde"); a plain range is a per-hour window whose
-// recurrence trails ("in den Minuten 0 bis 30, alle 2 Stunden").
+// Minute in jeder zweiten Stunde"); a range or list leads with its minutes and
+// trails the same cadence ("in den Minuten 0 bis 30, in jeder zweiten Stunde").
 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));
   }
 
-  return countedPhrase(ir, 'minute', 'Minute', 'Minuten') + ', ' +
-    hourStepPhrase(ir);
+  // 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 or uneven stride trails its endpoint-pinning cadence instead.
+  const segment = stepSegment(ir.analyses.segments.hour);
+  const hours = cadence ?? (confinedHourStride(segment) ?
+    everyNthHour(segment) :
+    atHours(segment.fires));
+
+  return (strideFromSegments(fieldSegments(ir, 'minute'), UNITS.minute, '') ??
+    countedPhrase(ir, 'minute', 'Minute', 'Minuten')) + ', ' + hours;
 }
 
 // Compact minutes across discrete hours: "in den Minuten 5 und 10, um 9, 17,
@@ -627,6 +843,16 @@ function renderCompactClockTimes(
   const sep = opts.style.sep;
 
   if (plan.fold) {
+    // 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;
+    }
+
     const hourly = fieldSegments(ir, 'hour')
       .some((segment) => segment.kind === 'range');
 
@@ -634,11 +860,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
@@ -647,7 +874,8 @@ function renderCompactClockTimes(
     countedPhrase(ir, 'second', 'Sekunde', 'Sekunden') + ', ' : '';
 
   return lead +
-    countedPhrase(ir, 'minute', 'Minute', 'Minuten') + ', ' + hours;
+    (strideFromSegments(fieldSegments(ir, 'minute'), UNITS.minute, '') ??
+    countedPhrase(ir, 'minute', 'Minute', 'Minuten')) + ', ' + hours;
 }
 
 // A repeating minute step, optionally within an hour window: "alle 5
@@ -660,9 +888,7 @@ function renderMinuteFrequency(
   const segment = stepSegment(ir.analyses.segments.minute);
   const sep = opts.style.sep;
   const clean = cleanStep(segment, 60);
-  const base = clean ?
-    everyN(segment.interval, UNITS.minute) :
-    countedPhrase(ir, 'minute', 'Minute', 'Minuten') + ' jeder Stunde';
+  const base = stepClause(segment, UNITS.minute, 'jeder Stunde');
 
   if (plan.hours.kind === 'window') {
     const window = hourWindow(plan.hours.from, plan.hours.to, plan.hours.last,
@@ -672,7 +898,14 @@ function renderMinuteFrequency(
   }
 
   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') {
@@ -685,10 +918,16 @@ 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: an offset-clean stride is its bare or "ab"
+// cadence; 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.
 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) ?
@@ -696,6 +935,273 @@ function hourStepPhrase(ir: IR): string {
     atHours(segment.fires);
 }
 
+// --- Hour-step cadence (the 24-cycle analog of renderStride). ---
+
+// Speak an hour stride as a cadence with clock-time bounds: a clean stride
+// from midnight is the bare cadence ("alle 2 Stunden"); a clean offset names
+// only its start ("alle 6 Stunden ab 2 Uhr"); a bounded or non-tiling stride
+// pins both clock-time endpoints ("alle 2 Stunden von 9 bis 17 Uhr") so the
+// bounded set reads unambiguously. Used wherever an hour step (or
+// arithmetic-progression hour list) would otherwise be cross-multiplied into a
+// wall of clock times.
+function hourStrideCadence(
+  stride: {start: number; interval: number; last: number}
+): string {
+  const {start, interval, last} = stride;
+  const cadence = everyN(interval, UNITS.hour);
+  const tiles = 24 % interval === 0;
+
+  if (start === 0 && tiles) {
+    return cadence;
+  }
+
+  if (start < interval && tiles) {
+    return cadence + ' ab ' + start + ' Uhr';
+  }
+
+  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 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 {
+  const segments = fieldSegments(ir, 'hour');
+
+  // A wildcard hour carries no segments (no discrete hours to stride over).
+  if (!segments) {
+    return null;
+  }
+
+  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];
+
+    return {interval: segment.interval, last: segment.fires[
+      segment.fires.length - 1], start};
+  }
+
+  const values = singleValues(segments);
+
+  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
+// fills the minute (a "für eine Minute" frame at minute 0); a single 0 is just
+// the top of the minute (no clause); anything else needs its own clause.
+function subMinuteSecond(ir: IR): boolean {
+  return ir.pattern.second === '*' || ir.shapes.second === 'step';
+}
+
+// The lead clause for an hour-cadence rendering: the second and the pinned
+// minute, before the hour cadence. A pinned minute 0 folds in — a single,
+// list, or range second is counted "jeder Stunde" (the minute-0 is the top of
+// the hour), and a wildcard or sub-minute step second takes a "für eine
+// Minute" frame (the whole minute-0 window). A non-zero minute is a real clock
+// minute: the second leads with its own clause (if any), then the minute reads
+// "in Minute M".
+function hourCadenceLead(ir: IR, minute: number): string {
+  if (minute === 0) {
+    if (subMinuteSecond(ir)) {
+      return secondsClause(ir, 'jeder Minute') + ' für eine Minute';
+    }
+
+    return secondsClause(ir, 'jeder Stunde');
+  }
+
+  const minutePhrase = 'in Minute ' + minute;
+
+  // A single 0 second is just the top of the minute, so the minute leads
+  // alone; any other second prefixes its own clause.
+  if (ir.pattern.second === '0') {
+    return minutePhrase;
+  }
+
+  return secondsClause(ir, 'jeder Minute') + ', ' + minutePhrase;
+}
+
+// Render an hour step (or arithmetic-progression hour list) under a single
+// pinned minute and a second as a cadence — the lead clause, then the hour
+// cadence — instead of cross-multiplying the hours into a wall of clock times.
+// Returns null when the hour is not a stride (an irregular list, a single
+// hour, or a range), or when the cross-product is short enough that
+// enumeration is no longer than the cadence: a meaningful second makes every
+// clock time three digit-groups, so any stride is worth compacting; otherwise
+// the stride must exceed the clock-time cap, the same point at which the core
+// itself stops enumerating. The renderer returns the bare clause; the day
+// frame is composed in `describe`. Renderer-only; the IR is unchanged.
+function hourCadence(ir: IR, minute: number): string | null {
+  const stride = hourStride(ir);
+
+  if (!stride) {
+    return null;
+  }
+
+  const fires = (stride.last - stride.start) / stride.interval + 1;
+
+  // 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;
+  }
+
+  // A wildcard or sub-minute step second confined to minute 0 of a clean hour
+  // stride is a confinement, not a juxtaposed cadence: it reads "für eine
+  // Minute in jeder zweiten Stunde", reusing the every-Nth-hour idiom so the
+  // minute-0 window is never heard as the bare hour cadence.
+  const segment = fieldSegments(ir, 'hour')[0];
+  const confined = minute === 0 && subMinuteSecond(ir) &&
+    fieldSegments(ir, 'hour').length === 1 && segment.kind === 'step' &&
+    confinedHourStride(segment);
+
+  if (confined) {
+    return secondsClause(ir, 'jeder Minute') + ' 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 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 {
+  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.
 function renderHourRange(
   ir: IR,
@@ -716,9 +1222,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".
@@ -727,6 +1239,18 @@ function renderClockTimes(
   plan: Extract<PlanNode, {kind: 'clockTimes'}>,
   opts: Opts
 ): string {
+  // 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 minute = +ir.pattern.minute;
+    const cadence = hourCadence(ir, minute) ?? hourRangeCadence(ir, minute);
+
+    if (cadence !== null) {
+      return cadence;
+    }
+  }
+
   return 'um ' + timesPhrase(plan.times, opts.style.sep);
 }
 
@@ -808,6 +1332,13 @@ function isComposeMinuteZero(ir: IR): boolean {
 // 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(ir: IR): 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
+  // 2 Stunden").
+  if (hourCadenceApplies(ir)) {
+    return false;
+  }
+
   if (ir.plan.kind === 'clockTimes' || isComposeMinuteZero(ir)) {
     return true;
   }