cronli5 0.1.4 → 0.1.6

package/src/lang/fi/index.ts

@@ -10,8 +10,8 @@
 // case-pair construction wherever digits appear.
 
 import {clockDigits, numeral} 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 {resolveDialect} from './dialects.js';
 import type {
   ClockTime, HourTimesPlan, IR, Language, NormalizedOptions, PlanNode,
@@ -63,6 +63,7 @@ interface UnitForms {
   mark: string;
   anchor: string;
   ela: string;
+  ill: string;
   gen: string;
 }
 
@@ -170,12 +171,14 @@ const units: {minute: UnitForms; second: UnitForms} = {
     mark: 'joka tunti',
     anchor: 'jokaisen tunnin',
     ela: 'minuutista',
+    ill: 'minuuttiin',
     gen: 'minuutin'
   },
   second: {
     mark: 'joka minuutti',
     anchor: 'jokaisen minuutin',
     ela: 'sekunnista',
+    ill: 'sekuntiin',
     gen: 'sekunnin'
   }
 };
@@ -296,49 +299,89 @@ function renderSecondsWithinMinute(
     atMarks(minuteField, units.minute, true) + trailingQualifier(ir, opts);
 }
 
+// A meaningful second composed over a minute-step cadence: the step leads and
+// the second anchor follows after a comma, with the hour clause interleaved
+// between them ("[step], [seconds][hour clause][trailing qualifier]"). The
+// minute-frequency phrase is reconstructed directly here so the hour clause can
+// sit between the step and the second anchor without duplicating the full
+// renderMinuteFrequency logic; its hours-first reorder is intentionally NOT
+// applied (the step-leads form is the correct shape for this construction).
+function composeSecondsOverMinuteStep(
+  ir: IR,
+  freq: Extract<PlanNode, {kind: 'minuteFrequency'}>,
+  opts: NormalizedOptions
+): string {
+  const seg = stepSegment(ir.analyses.segments.minute!);
+  const stepPhrase = stepCycle60(seg, units.minute, opts);
+
+  if (freq.hours.kind === 'during' && minuteStepIsAnchored(seg)) {
+    // The step renders as an anchored kohdalla list rather than a cadence, so
+    // the hours-first reorder applies here too: bare hours lead, minute anchors
+    // follow, then the seconds clause.
+    const bareHours = kloFromTimes(ir, freq.hours.times, opts);
+
+    return hoursFirstMinutes(bareHours, ir, opts) + ', ' +
+      secondsLeadClause(ir, opts) + trailingQualifier(ir, opts);
+  }
+
+  let hourClause = '';
+
+  if (freq.hours.kind === 'during') {
+    hourClause = ' ' + hourWindowsFromTimes(ir, freq.hours.times, opts);
+  }
+  else if (freq.hours.kind === 'window') {
+    hourClause = ' ' + hourWindow(freq.hours, opts);
+  }
+  else if (freq.hours.kind === 'step') {
+    hourClause = ' ' +
+      everyNthHour(stepSegment(ir.analyses.segments.hour!), opts);
+  }
+
+  return stepPhrase + ', ' + secondsLeadClause(ir, opts) +
+    hourClause + trailingQualifier(ir, opts);
+}
+
+// The hour-cadence rendering of a compose-seconds plan whose clock-time rest
+// would cross-multiply an hour stride under a single pinned minute, or null
+// when that does not apply (a non-clock rest, a multi-valued minute, or an
+// hour that is not a stride).
+function composeHourCadence(
+  ir: IR,
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
+  opts: NormalizedOptions
+): string | null {
+  const clockRest = plan.rest.kind === 'clockTimes' ||
+    plan.rest.kind === 'compactClockTimes';
+
+  if (!clockRest || ir.shapes.minute !== 'single') {
+    return null;
+  }
+
+  const minute = +ir.pattern.minute;
+
+  return hourCadence(ir, minute, opts) ?? hourRangeCadence(ir, minute, opts);
+}
+
 function renderComposeSeconds(
   ir: IR,
   plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
   opts: NormalizedOptions
 ): 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 ("30 sekunnin kohdalla, kahden tunnin välein"). The
+  // clock-time rest would otherwise cross-multiply the hours.
+  const cadence = composeHourCadence(ir, plan, opts);
+
+  if (cadence !== null) {
+    return cadence;
+  }
+
   // When the rest is a minute-step cadence, the step leads and the second
   // anchor follows after a comma (the comma marks the granularity boundary
-  // between the two levels, not a flat list). Build:
-  // "[step phrase], [seconds][hour clause][trailing qualifier]".
-  //
-  // The minute-frequency phrase is reconstructed directly here so the hour
-  // clause can be interleaved between the step and the second anchor without
-  // duplicating the full renderMinuteFrequency logic. The hours-first reorder
-  // that applies inside renderMinuteFrequency is intentionally NOT applied
-  // here (the step-leads form is the correct shape for this construction).
+  // between the two levels, not a flat list).
   if (plan.rest.kind === 'minuteFrequency' && ir.pattern.second !== '*') {
-    const freq = plan.rest as Extract<PlanNode, {kind: 'minuteFrequency'}>;
-    const seg = stepSegment(ir.analyses.segments.minute!);
-    const stepPhrase = stepCycle60(seg, units.minute, opts);
-    let hourClause = '';
-
-    if (freq.hours.kind === 'during' && minuteStepIsAnchored(seg)) {
-      // The step renders as an anchored kohdalla list rather than a cadence,
-      // so the hours-first reorder applies here too: bare hours lead, minute
-      // anchors follow, then the seconds clause.
-      const bareHours = kloFromTimes(ir, freq.hours.times, opts);
-
-      return hoursFirstMinutes(bareHours, ir) + ', ' +
-        secondsLeadClause(ir, opts) + trailingQualifier(ir, opts);
-    }
-    else if (freq.hours.kind === 'during' && !minuteStepIsAnchored(seg)) {
-      hourClause = ' ' + hourWindowsFromTimes(ir, freq.hours.times, opts);
-    }
-    else if (freq.hours.kind === 'window') {
-      hourClause = ' ' + hourWindow(freq.hours, opts);
-    }
-    else if (freq.hours.kind === 'step') {
-      hourClause = ' ' +
-        everyNthHour(stepSegment(ir.analyses.segments.hour!), opts);
-    }
-
-    return stepPhrase + ', ' + secondsLeadClause(ir, opts) +
-      hourClause + trailingQualifier(ir, opts);
+    return composeSecondsOverMinuteStep(ir, plan.rest, opts);
   }
 
   // A sub-minute second with the minute pinned to 0 and a specific hour: the
@@ -352,7 +395,40 @@ function renderComposeSeconds(
     return composeMinuteZero(ir, plan.rest, opts);
   }
 
-  return secondsLeadClause(ir, opts) + ', ' + render(ir, plan.rest, opts);
+  // A wildcard second under a minute */2 with a wildcard hour juxtaposes two
+  // cadences that read as contradictory ("joka sekunti, kahden minuutin
+  // välein"). Bind them as "every second of every other minute" ("joka sekunti
+  // joka toisena minuuttina"), mirroring English. Other strides, a restricted
+  // hour, and an hour cadence keep the juxtaposed form.
+  if (isEveryOtherMinuteSeconds(ir, plan)) {
+    return secondsLeadClause(ir, opts) + ' joka toisena minuuttina';
+  }
+
+  // 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 ? '' : secondsLeadClause(ir, opts) + ', ';
+
+  return lead + render(ir, plan.rest, opts);
+}
+
+// A wildcard second over an unoffset minute */2 with a wildcard hour: the two
+// cadences read as contradictory side by side, so they bind into one.
+function isEveryOtherMinuteSeconds(
+  ir: IR,
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>
+): boolean {
+  if (plan.rest.kind !== 'minuteFrequency' || ir.pattern.second !== '*' ||
+      ir.shapes.hour !== 'wildcard') {
+    return false;
+  }
+
+  const seg = stepSegment(ir.analyses.segments.minute!);
+
+  return seg.startToken === '*' && seg.interval === 2;
 }
 
 // The minute-0 confinement: bind the seconds to the explicit clock minute(s)
@@ -400,8 +476,11 @@ function secondsLeadClause(ir: IR, opts: NormalizedOptions): string {
     return atMarks(secondField, units.second, marked);
   }
 
-  return atMarks(joinList(segmentWords(ir.analyses.segments.second!)),
-    units.second, marked);
+  // An offset/uneven step the core enumerated to this list reads as a stride
+  // cadence when the fires form a long-enough progression.
+  return strideFromSegments(ir.analyses.segments.second!, units.second, opts) ??
+    atMarks(joinList(segmentWords(ir.analyses.segments.second!)),
+      units.second, marked);
 }
 
 // --- Minute renderers. ---
@@ -428,7 +507,7 @@ function renderRangeOfMinutes(
   plan: Extract<PlanNode, {kind: 'rangeOfMinutes'}>,
   opts: NormalizedOptions
 ): string {
-  return minutesList(ir) + trailingQualifier(ir, opts);
+  return minutesList(ir, opts) + trailingQualifier(ir, opts);
 }
 
 function renderMultipleMinutes(
@@ -436,21 +515,27 @@ function renderMultipleMinutes(
   plan: Extract<PlanNode, {kind: 'multipleMinutes'}>,
   opts: NormalizedOptions
 ): string {
-  return minutesList(ir) + trailingQualifier(ir, opts);
+  return minutesList(ir, opts) + trailingQualifier(ir, opts);
 }
 
-// "joka tunti 0, 15 ja 30 minuutin kohdalla" (or a dash range).
-function minutesList(ir: IR): string {
-  return atMarks(joinList(segmentWords(ir.analyses.segments.minute!)),
-    units.minute, true);
+// "joka tunti 0, 15 ja 30 minuutin kohdalla" (or a dash range). An offset/
+// uneven step the core enumerated to this list reads as a stride cadence when
+// the fires form a long-enough progression ("kahden minuutin välein
+// minuutista 3 minuuttiin 59").
+function minutesList(ir: IR, opts: NormalizedOptions): string {
+  return strideFromSegments(ir.analyses.segments.minute!, units.minute, opts) ??
+    atMarks(joinList(segmentWords(ir.analyses.segments.minute!)),
+      units.minute, true);
 }
 
 // The bare minute mark, for clauses where a specific hour follows and
 // the "joka tunti" frequency would be redundant: "0–30 minuutin
-// kohdalla".
-function bareMinutes(ir: IR): string {
-  return atMarks(joinList(segmentWords(ir.analyses.segments.minute!)),
-    units.minute, false);
+// kohdalla". A progression reads as its bounded cadence (which carries no
+// per-hour frequency to drop).
+function bareMinutes(ir: IR, opts: NormalizedOptions): string {
+  return strideFromSegments(ir.analyses.segments.minute!, units.minute, opts) ??
+    atMarks(joinList(segmentWords(ir.analyses.segments.minute!)),
+      units.minute, false);
 }
 
 // Whether a minute step renders as an anchored "kohdalla" clause rather
@@ -500,7 +585,21 @@ function hoursAreRangeIsolated(segments: Segment[]): boolean {
 // (plural genitive "minuuttien"; replaces the leading "joka tunti"). Used
 // when a range or multi-point minute list over enumerated hours renders
 // hours-first.
-function hoursFirstMinutes(hoursStr: string, ir: IR): string {
+function hoursFirstMinutes(
+  hoursStr: string,
+  ir: IR,
+  opts: NormalizedOptions
+): string {
+  // An offset/uneven step the core enumerated to this list reads as a stride
+  // cadence ("aina kahden minuutin välein minuutista 3 minuuttiin 59") when
+  // the fires form a long-enough progression, rather than the kohdalla list.
+  const stride =
+    strideFromSegments(ir.analyses.segments.minute!, units.minute, opts);
+
+  if (stride) {
+    return hoursStr + ' aina ' + stride;
+  }
+
   return hoursStr + ' aina minuuttien ' +
     joinList(segmentWords(ir.analyses.segments.minute!)) + ' kohdalla';
 }
@@ -540,13 +639,24 @@ function renderMinuteFrequency(
   const seg = stepSegment(ir.analyses.segments.minute!);
 
   if (plan.hours.kind === 'during') {
+    // A bounded or uneven hour stride reads as its endpoint-pinning cadence
+    // after the minute step ("15 minuutin välein, viiden tunnin välein klo
+    // 0–20").
+    const cadence = unevenHourCadence(ir, opts);
+
+    if (cadence !== null) {
+      return stepCycle60(seg, units.minute, opts) + ', ' + cadence +
+        trailingQualifier(ir, opts);
+    }
+
     // When the step renders as anchored ("kohdalla"), the per-hour windows
     // are redundant — use bare clock hours instead, then reorder to
     // hours-first: "klo <hours> aina minuuttien <spec> kohdalla".
     if (minuteStepIsAnchored(seg)) {
       const bareHours = kloFromTimes(ir, plan.hours.times, opts);
 
-      return hoursFirstMinutes(bareHours, ir) + trailingQualifier(ir, opts);
+      return hoursFirstMinutes(bareHours, ir, opts) +
+        trailingQualifier(ir, opts);
     }
 
     return stepCycle60(seg, units.minute, opts) + ' ' +
@@ -599,14 +709,25 @@ function renderMinutesAcrossHours(
   plan: Extract<PlanNode, {kind: 'minutesAcrossHours'}>,
   opts: NormalizedOptions
 ): string {
+  // A bounded or uneven hour stride reads as its endpoint-pinning cadence after
+  // the minute clause ("joka minuutti, viiden tunnin välein klo 0–20"), not a
+  // wall of hour windows.
+  const cadence = unevenHourCadence(ir, opts);
+
   if (plan.form === 'wildcard') {
-    return 'joka minuutti ' + hourWindowsFromTimes(ir, plan.times, opts) +
-      trailingQualifier(ir, opts);
+    return cadence ?
+      'joka minuutti, ' + cadence + trailingQualifier(ir, opts) :
+      'joka minuutti ' + hourWindowsFromTimes(ir, plan.times, opts) +
+        trailingQualifier(ir, opts);
+  }
+
+  if (cadence !== null) {
+    return bareMinutes(ir, opts) + ', ' + cadence + trailingQualifier(ir, opts);
   }
 
   // Range+isolated hours: minute-first, bare minutes, sekä klo.
   if (hoursAreRangeIsolated(ir.analyses.segments.hour!)) {
-    return bareMinutes(ir) + ' ' +
+    return bareMinutes(ir, opts) + ' ' +
       hourSegmentTimesWithSeka(ir, 0, null, opts) +
       trailingQualifier(ir, opts);
   }
@@ -616,7 +737,7 @@ function renderMinutesAcrossHours(
   // shows it).
   const hoursStr = kloFromTimes(ir, plan.times, opts);
 
-  return hoursFirstMinutes(hoursStr, ir) + trailingQualifier(ir, opts);
+  return hoursFirstMinutes(hoursStr, ir, opts) + trailingQualifier(ir, opts);
 }
 
 function renderMinuteSpanAcrossHourStep(
@@ -626,28 +747,28 @@ function renderMinuteSpanAcrossHourStep(
 ): string {
   // An hour-step plan's first hour segment is always a step segment.
   const segment = stepSegment(ir.analyses.segments.hour!);
+  // A bounded or uneven hour stride reads as its endpoint-pinning cadence; an
+  // offset-clean stride keeps its confinement / per-step phrasing.
+  const cadence = unevenHourCadence(ir, opts);
 
   // A wildcard span always sets the step off with a comma ("joka
   // minuutti, joka toinen tunti"); a restricted span joins a plain step
   // directly ("minuuteilla 0–30 joka toinen tunti").
-  // A wildcard minute (a cadence) is reached only for a clean step and is
-  // confined to every Nth hour; a restricted span is a per-hour window whose
-  // recurrence joins as a plain step.
+  // A wildcard minute (a cadence) is reached only for a clean step (a bounded
+  // or uneven step routes through minutesAcrossHours instead) and is confined
+  // to every Nth hour; a restricted span is a per-hour window + plain step.
   if (plan.form === 'wildcard') {
     return 'joka minuutti ' + everyNthHour(segment, opts) +
       trailingQualifier(ir, opts);
   }
 
-  // A bounded range-step (e.g. 9-17/2) whose fires enumerate as a klo-digit
-  // list renders hours-first. A clean or offset unbounded step (e.g. 1/6,
-  // */2) keeps minute-first with its step phrase.
-  if (segment.startToken.indexOf('-') !== -1) {
-    const hoursStr = kloList(segment.fires, opts);
-
-    return hoursFirstMinutes(hoursStr, ir) + trailingQualifier(ir, opts);
+  // A bounded or uneven stride reads as its bounded cadence after the bare
+  // minutes ("minuuteilla 0–30, kahden tunnin välein klo 9–17").
+  if (cadence !== null) {
+    return bareMinutes(ir, opts) + ', ' + cadence + trailingQualifier(ir, opts);
   }
 
-  return bareMinutes(ir) + hourStepTail(segment, opts) +
+  return bareMinutes(ir, opts) + hourStepTail(segment, opts) +
     trailingQualifier(ir, opts);
 }
 
@@ -725,7 +846,7 @@ function renderHourRange(
   // A minute range over a single hour range renders hours-first
   // ("klo 9.00–17.30 aina minuuttien 0–30 kohdalla").
   if (plan.minuteForm === 'range') {
-    return hoursFirstMinutes(window, ir) + trailingQualifier(ir, opts);
+    return hoursFirstMinutes(window, ir, opts) + trailingQualifier(ir, opts);
   }
 
   // On the hour the window joins directly ("joka tunti klo 9–17"); a
@@ -744,7 +865,7 @@ function renderHourRange(
 
   // A minute list (≥2 values) over a single hour range renders hours-first
   // ("klo 9.00–17.30 aina minuuttien 0 ja 30 kohdalla").
-  return hoursFirstMinutes(window, ir) + trailingQualifier(ir, opts);
+  return hoursFirstMinutes(window, ir, opts) + trailingQualifier(ir, opts);
 }
 
 function renderHourStep(
@@ -752,6 +873,15 @@ function renderHourStep(
   plan: Extract<PlanNode, {kind: 'hourStep'}>,
   opts: NormalizedOptions
 ): string {
+  // A bounded or uneven hour step reads as its endpoint-pinning cadence
+  // ("kahden tunnin välein klo 9–17"); an offset-clean step keeps its bare or
+  // "alkaen" cadence.
+  const cadence = unevenHourCadence(ir, opts);
+
+  if (cadence !== null) {
+    return cadence + trailingQualifier(ir, opts);
+  }
+
   return stepHours(stepSegment(ir.analyses.segments.hour!), opts) +
     trailingQualifier(ir, opts);
 }
@@ -779,6 +909,19 @@ function renderClockTimes(
   plan: Extract<PlanNode, {kind: 'clockTimes'}>,
   opts: NormalizedOptions
 ): 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, opts) ??
+      hourRangeCadence(ir, minute, opts);
+
+    if (cadence !== null) {
+      return cadence;
+    }
+  }
+
   if (plan.times.length === 1) {
     const time = plan.times[0];
 
@@ -802,6 +945,18 @@ function renderCompactClockTimes(
   plan: Extract<PlanNode, {kind: 'compactClockTimes'}>,
   opts: NormalizedOptions
 ): string {
+  // 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.)
+  if (plan.fold) {
+    const cadence = hourCadence(ir, plan.minute, opts) ??
+      hourRangeCadence(ir, plan.minute, opts);
+
+    if (cadence !== null) {
+      return cadence;
+    }
+  }
+
   const hourSegs = ir.analyses.segments.hour!;
 
   // Range+isolated hours: join the isolated hour with "sekä klo" to stop it
@@ -815,7 +970,7 @@ function renderCompactClockTimes(
           ir.analyses.clockSecond, opts);
     }
 
-    const phrase = bareMinutes(ir) + ' ' +
+    const phrase = bareMinutes(ir, opts) + ' ' +
       hourSegmentTimesWithSeka(ir, 0, null, opts) +
       trailingQualifier(ir, opts);
 
@@ -829,11 +984,16 @@ function renderCompactClockTimes(
       hourSegmentTimes(ir, plan.minute, ir.analyses.clockSecond, opts);
   }
 
-  // A minute list over purely enumerated hours (step fires, all singles) —
-  // hours-first, drop "joka tunti".
-  const hoursStr = hourSegmentTimes(ir, 0, null, opts);
-  const phrase = hoursFirstMinutes(hoursStr, ir) +
-    trailingQualifier(ir, opts);
+  // A bounded or uneven hour stride reads as its endpoint-pinning cadence after
+  // the bare minute clause ("minuuteilla 0, 25 ja 50, viiden tunnin välein klo
+  // 0–20"), not a wall of clock-time columns.
+  const cadence = unevenHourCadence(ir, opts);
+  const phrase = cadence ?
+    bareMinutes(ir, opts) + ', ' + cadence + trailingQualifier(ir, opts) :
+    // A minute list over purely enumerated hours (step fires, all singles) —
+    // hours-first, drop "joka tunti".
+    hoursFirstMinutes(hourSegmentTimes(ir, 0, null, opts), ir, opts) +
+      trailingQualifier(ir, opts);
 
   return ir.analyses.clockSecond ?
     secondsLeadClause(ir, opts) + ', ' + phrase :
@@ -864,8 +1024,82 @@ const renderers = {
 
 // --- Step phrases. ---
 
+// A step cadence to phrase over a `cycle`-long field (60 for minute/second),
+// running from `start` to `last`.
+interface Stride {
+  interval: number;
+  start: number;
+  last: number;
+  cycle: number;
+  unit: UnitForms;
+}
+
+// Speak a step cadence over a `cycle`-long field. A clean stride from the top
+// of the cycle is the bare cadence ("viiden minuutin välein"); 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 ("kuuden minuutin välein jokaisen tunnin minuutista 5 alkaen"); 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 ("kahden minuutin välein minuutista 3 minuuttiin 59"). 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, opts: NormalizedOptions): string {
+  const {interval, start, last, cycle, unit} = stride;
+  const cadence = genitive(interval, opts) + ' ' + unit.gen + ' välein';
+  const tiles = cycle % interval === 0;
+
+  if (start === 0 && tiles) {
+    return cadence;
+  }
+
+  if (start < interval && tiles) {
+    return cadence + ' ' + unit.anchor + ' ' + unit.ela + ' ' + start +
+      ' alkaen';
+  }
+
+  return cadence + ' ' + unit.ela + ' ' + start + ' ' + unit.ill + ' ' + last;
+}
+
+// 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: UnitForms,
+  opts: NormalizedOptions
+): string | null {
+  const values = singleValues(segments);
+  const step = values && arithmeticStep(values);
+
+  return step ?
+    renderStride({...step, cycle: 60, unit}, opts) :
+    null;
+}
+
+// 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;
+}
+
 // "viiden minuutin välein", "joka tunti 0 ja 31 minuutin kohdalla", or
-// "kolmen minuutin välein jokaisen tunnin minuutista 1 alkaen".
+// "kolmen minuutin välein jokaisen tunnin minuutista 1 alkaen". A step shape
+// only reaches here as a clean or uniform-offset cadence; an offset/uneven set
+// arrives as a fire list and is recognized by the list path instead.
 function stepCycle60(
   segment: StepSegment,
   unit: UnitForms,
@@ -876,21 +1110,20 @@ function stepCycle60(
   }
 
   const start = segment.startToken === '*' ? 0 : +segment.startToken;
-  const interval = segment.interval;
-  const cadence = genitive(interval, opts) + ' ' + unit.gen + ' välein';
 
-  if (start !== 0) {
-    if (segment.fires.length <= 3) {
-      return atMarks(joinList(wordList(segment.fires)), unit, true);
-    }
-
-    return cadence + ' ' + unit.anchor + ' ' + unit.ela + ' ' + start +
-      ' alkaen';
+  // A short offset cadence still lists its fires; the stride phrasing names
+  // the interval and offset only once there are enough fires to beat the list.
+  if (start !== 0 && segment.fires.length <= 3) {
+    return atMarks(joinList(wordList(segment.fires)), unit, true);
   }
 
-  // A clean stride from the top of the cycle is the bare cadence. (An uneven
-  // stride is rewritten to its fires upstream and never reaches here.)
-  return cadence;
+  return renderStride({
+    interval: segment.interval,
+    start,
+    last: segment.fires[segment.fires.length - 1],
+    cycle: 60,
+    unit
+  }, opts);
 }
 
 // "kahden tunnin välein", "klo 0, 10 ja 20", or "viiden tunnin välein
@@ -917,6 +1150,285 @@ function stepHours(segment: StepSegment, opts: NormalizedOptions): string {
   return cadence + ' klo ' + hourElatives[start] + ' alkaen';
 }
 
+// --- 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 ("kahden tunnin välein"); a clean offset
+// names only its start ("kuuden tunnin välein klo 2:sta alkaen"); a bounded or
+// non-tiling stride pins both clock-time endpoints ("kahden tunnin välein klo
+// 9–17") 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},
+  opts: NormalizedOptions
+): string {
+  const {start, interval, last} = stride;
+  const cadence = genitive(interval, opts) + ' tunnin välein';
+  const tiles = 24 % interval === 0;
+
+  if (start === 0 && tiles) {
+    return cadence;
+  }
+
+  if (start < interval && tiles) {
+    return cadence + ' klo ' + hourElatives[start] + ' alkaen';
+  }
+
+  return cadence + ' ' +
+    kloRange({hour: start, minute: 0}, {hour: last, minute: 0}, opts);
+}
+
+// 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 "alkaen" 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 = ir.analyses.segments.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
+// ("…, viiden tunnin välein klo 0–20") 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, opts: NormalizedOptions): string | null {
+  const stride = hourStride(ir);
+
+  if (!stride || offsetCleanStride(stride)) {
+    return null;
+  }
+
+  return hourStrideCadence(stride, opts);
+}
+
+// The second's status against a pinned minute: a wildcard or sub-minute step
+// fills the minute (a "minuutin ajan" 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, range, or step second is counted at its own bare "kohdalla" mark (the
+// minute-0 is the top of the hour), and a wildcard second takes a "minuutin
+// ajan" 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
+// at its bare "kohdalla" mark.
+function hourCadenceLead(ir: IR, minute: number,
+  opts: NormalizedOptions): string {
+  if (minute === 0) {
+    if (subMinuteSecond(ir)) {
+      return secondsLeadClause(ir, opts) + ' minuutin ajan';
+    }
+
+    return secondsLeadClause(ir, opts);
+  }
+
+  const minutePhrase = atMarks(String(minute), units.minute, false);
+
+  // 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 secondsLeadClause(ir, opts) + ', ' + 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. Renderer-only; the IR is unchanged.
+function hourCadence(ir: IR, minute: number,
+  opts: NormalizedOptions): 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 "alkaen" form is no shorter than the list. A bounded or uneven stride
+  // has no clean wrap, so its endpoint-pinning cadence ("viiden tunnin välein
+  // klo 0–20") 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 "minuutin ajan
+  // joka toisen tunnin aikana", reusing the every-Nth-hour idiom so the
+  // minute-0 window is never heard as the bare hour cadence.
+  const segment = ir.analyses.segments.hour![0];
+  const confined = minute === 0 && subMinuteSecond(ir) &&
+    ir.analyses.segments.hour!.length === 1 && segment.kind === 'step' &&
+    cleanHourStride(segment);
+
+  if (confined) {
+    return secondsLeadClause(ir, opts) + ' minuutin ajan ' +
+      everyNthHour(segment, opts) + trailingQualifier(ir, opts);
+  }
+
+  // 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 ("viiden
+  // tunnin välein klo 0–20").
+  if (minute === 0 && ir.pattern.second === '0') {
+    return hourStrideCadence(stride, opts) + trailingQualifier(ir, opts);
+  }
+
+  return hourCadenceLead(ir, minute, opts) + ', ' +
+    hourStrideCadence(stride, opts) + trailingQualifier(ir, opts);
+}
+
+// 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 "joka
+// N:nnen tunnin aikana" rather than enumerating its fires.
+function cleanHourStride(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;
+}
+
+// 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 = ir.analyses.segments.hour;
+
+  return !!segments && segments.some(function range(segment: Segment) {
+    return segment.kind === 'range';
+  });
+}
+
+// The hour-range window as a cadence tail at the top of each hour: a lone
+// range is the bare "klo 9–17"; a range plus a non-contiguous hour joins it
+// with "sekä klo" ("klo 9–20 sekä klo 22"), the same idiom the bare folded
+// window uses. The minute has folded into the lead, so the window closes on
+// the top of its final hour.
+function hourRangeWindowTail(ir: IR, opts: NormalizedOptions): string {
+  return ir.analyses.segments.hour!.length === 1 ?
+    hourSegmentTimes(ir, 0, null, opts) :
+    hourSegmentTimesWithSeka(ir, 0, null, opts);
+}
+
+// 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 "klo 9–17" — instead of cross-multiplying the hours into a wall of
+// clock times. The hour-RANGE analog of hourCadence. 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,
+  opts: NormalizedOptions): string | null {
+  if (minute !== 0 || !hasHourWindow(ir) || ir.pattern.second === '0') {
+    return null;
+  }
+
+  const tail = hourRangeWindowTail(ir, opts);
+
+  // A wildcard or sub-minute step second is the whole minute-0 window
+  // ("minuutin ajan", carried by hourCadenceLead), then the window — kept
+  // distinct from the bare "joka tunti klo 9–17" so the confinement is never
+  // heard as it (the hour-range analog of "minuutin ajan joka toisen tunnin
+  // aikana"). A meaningful second leads at its mark, then the window.
+  const joiner = subMinuteSecond(ir) ? ' ' : ', ';
+
+  return hourCadenceLead(ir, minute, opts) + joiner + tail +
+    trailingQualifier(ir, opts);
+}
+
 // --- Hour-time phrasing. ---
 
 // On-the-hour fires as one klo phrase: "klo 0, 10 ja 20".
@@ -944,23 +1456,32 @@ function kloFromTimes(
   return hourSegmentTimes(ir, 0, null, opts);
 }
 
-// Each fire hour as its own one-hour dash window under a single klo:
-// "klo 9.00–9.59 ja 17.00–17.59". Finnish prefers this to the English
-// "during the 9 a.m. and 5 p.m. hours" shape.
+// The hours accompanying a named-once minute clause under an hour list or
+// step. On-the-hour hours (a fires set, or a segment set with no real range)
+// are listed once — "klo 0, 5, 10, 15 ja 20" — so the minute is never repeated
+// as a per-hour span. A real hour RANGE segment is a genuine span and keeps its
+// per-segment window ("klo 8.00–18.59 ja 22.00–22.59"), mirroring the other
+// languages, which list discrete hours but keep range windows.
 function hourWindowsFromTimes(
   ir: IR,
   times: HourTimesPlan,
   opts: NormalizedOptions
 ): string {
   if (times.kind === 'fires') {
-    return 'klo ' + joinList(times.fires.map(function window(hour: number) {
-      return hourWindowDigits(hour, opts);
-    }));
+    return kloList(times.fires, opts);
+  }
+
+  const segments = ir.analyses.segments.hour!;
+
+  if (!segments.some(function ranged(segment: Segment) {
+    return segment.kind === 'range';
+  })) {
+    return kloList(hourSegmentFires(segments), opts);
   }
 
   const pieces: string[] = [];
 
-  ir.analyses.segments.hour!.forEach(function window(segment: Segment) {
+  segments.forEach(function window(segment: Segment) {
     if (segment.kind === 'range') {
       pieces.push(rangeDigits({hour: +segment.bounds[0], minute: 0},
         {hour: +segment.bounds[1], minute: 59}, opts));
@@ -978,6 +1499,23 @@ function hourWindowsFromTimes(
   return 'klo ' + joinList(pieces);
 }
 
+// The on-the-hour fires of a range-free hour segment set, in order: a step
+// segment contributes its enumerated fires, a single its one value.
+function hourSegmentFires(segments: Segment[]): number[] {
+  const hours: number[] = [];
+
+  segments.forEach(function each(segment: Segment) {
+    if (segment.kind === 'step') {
+      hours.push(...segment.fires);
+    }
+    else if (segment.kind === 'single') {
+      hours.push(+segment.value);
+    }
+  });
+
+  return hours;
+}
+
 // "9.00–9.59": one hour as a dash window, in digits.
 function hourWindowDigits(hour: number, opts: NormalizedOptions): string {
   return rangeDigits({hour, minute: 0}, {hour, minute: 59}, opts);