cronli5 0.8.0 → 0.8.3

package/src/lang/en/index.ts

@@ -581,8 +581,11 @@ function renderMinuteFrequency(schedule: Schedule,
   else if (plan.hours.kind === 'step') {
     // The plan carries a step only for a clean stride (dividing the day),
     // which confines the cadence to every Nth hour; a stepped hour field's
-    // first segment is a step segment.
-    phrase += ' ' +
+    // first segment is a step segment. The hour step scopes the hours, so an
+    // offset cadence drops "past the hour" and joins with a comma.
+    const bound = withoutHourAnchor(phrase);
+
+    phrase = bound + (bound === phrase ? ' ' : ', ') +
       everyNthHour(stepSegment(schedule, 'hour'), opts);
   }
 
@@ -674,6 +677,67 @@ const stepOrdinals: Record<number, string> = {
   2: 'other', 3: 'third', 4: 'fourth', 6: 'sixth', 8: 'eighth', 12: 'twelfth'
 };
 
+// Spelled ordinals for "every Nth minute" — the step intervals a minute
+// cadence can take (2 reads idiomatically as "other"). A lookup miss falls back
+// to the suffixed numeric ordinal, so an unusually large interval still reads.
+const spelledOrdinals: Record<number, string> = {
+  2: 'other', 3: 'third', 4: 'fourth', 5: 'fifth', 6: 'sixth', 7: 'seventh',
+  8: 'eighth', 9: 'ninth', 10: 'tenth', 11: 'eleventh', 12: 'twelfth',
+  15: 'fifteenth', 20: 'twentieth', 30: 'thirtieth'
+};
+
+// The ordinal word for a cadence interval ("sixth", "seventh"), spelled where
+// known and suffixed-numeric ("13th") otherwise.
+function ordinalWord(interval: number): string {
+  return spelledOrdinals[interval] ?? getOrdinal(interval);
+}
+
+// A stepped minute under a seconds lead reads as a CONFINEMENT of that cadence,
+// not a juxtaposed clause (a comma there reads as two independent cadences) nor
+// a wall of enumerated minutes: "during every Nth minute" plus the step's
+// offset/bound. The cadence is ORDINAL ("every sixth minute"); the cardinal
+// ("every six minutes") is the form that reads as a separate cadence. The
+// offset/bound mirrors the standalone minute cadence: a clean stride from the
+// top names no offset, an offset-clean stride names only its start ("from four
+// minutes past the hour"), and an uneven one pins both endpoints ("from 2
+// through 58 minutes past the hour").
+function minuteStrideConfinement(stride: {start: number; interval: number;
+  last: number}, opts: NormalizedOptions): string {
+  const base = ' during every ' + ordinalWord(stride.interval) + ' minute';
+
+  return chooseStride({...stride, cycle: 60}, {
+    bare: () => base,
+    offset: () => base + ' from ' + getNumber(stride.start, opts) + ' ' +
+      pluralize(stride.start, 'minute') + ' past the hour',
+    bounded: () => {
+      const num = seriesNumber();
+
+      return base + ' from ' + num(stride.start) + through(opts) +
+        num(stride.last) + ' ' + pluralize(stride.last, 'minute') +
+        ' past the hour';
+    }
+  });
+}
+
+// The minute field's step stride for the confinement frame, or null when the
+// minute is not a stepped cadence. A `step`-shaped field (`*/6`) reads its
+// segment directly; a `list`-shaped field the core enumerated from an uneven
+// step (`2/7` → 2,9,…,58) recovers the progression from its values.
+function minuteStride(schedule: Schedule):
+  {start: number; interval: number; last: number} | null {
+  if (schedule.shapes.minute === 'step') {
+    const segment = stepSegment(schedule, 'minute');
+    const start = segment.startToken === '*' ? 0 : +segment.startToken;
+
+    return {interval: segment.interval, last:
+      segment.fires[segment.fires.length - 1], start};
+  }
+
+  const values = singleValues(segmentsOf(schedule, 'minute'));
+
+  return values && arithmeticStep(values);
+}
+
 // Confine a cadence to a clean hour stride: "during every other hour", with
 // the start named when it is not midnight ("…from 1 a.m." for an odd stride).
 function everyNthHour(segment: StepSegment, opts: NormalizedOptions): string {
@@ -703,13 +767,14 @@ function renderMinuteSpanAcrossHourStep(schedule: Schedule,
   }
 
   // A minute list keeps the same cadence clause; only its lead differs. An
-  // offset/uneven step the core enumerated to that list reads as a stride.
-  const lead = plan.form === 'list' ?
+  // offset/uneven step the core enumerated to that list reads as a stride. The
+  // hour step scopes the hours, so the lead drops its generic "past the hour".
+  const lead = withoutHourAnchor(plan.form === 'list' ?
     strideFromSegments(segmentsOf(schedule, 'minute'), 'minute', 'hour',
       opts) ??
       listPastThe(segmentWords(segmentsOf(schedule, 'minute'), opts),
         'minute', 'hour', opts) :
-    minuteRangeLead(schedule.pattern.minute, opts);
+    minuteRangeLead(schedule.pattern.minute, opts));
   // A bounded or uneven hour step reads as its endpoint-pinning cadence after
   // the minute lead, not a wall of clock-time columns; an offset-clean step
   // keeps its existing per-step phrasing.
@@ -932,10 +997,14 @@ function renderCompactClockTimes(schedule: Schedule,
       listPastThe(segmentWords(segmentsOf(schedule, 'minute'), opts),
         'minute', 'hour', opts);
   // A uneven hour stride reads as a cadence after the minute lead, not a wall
-  // of clock-time columns.
+  // of clock-time columns. The hour step is the sole hour authority there, so
+  // the minute lead drops its generic "past the hour" (an every-hour scope that
+  // would conflict with the step); the clock-time branch keeps it, naming
+  // specific hours rather than a step.
   const cadence = unevenHourCadence(schedule, opts);
   const phrase = cadence ?
-    minuteLead + ', ' + cadence + trailingQualifier(schedule, opts) :
+    withoutHourAnchor(minuteLead) + ', ' + cadence +
+      trailingQualifier(schedule, opts) :
     minuteLead +
     ', at ' +
     hourSegmentTimes(schedule, {minute: 0, second: null}, true, opts) +
@@ -1070,12 +1139,22 @@ function minuteConfinement(schedule: Schedule,
     return '';
   }
 
-  if (isCadenceField(minute)) {
-    // The gate admits only the `*/2` "every other minute" step here; other
-    // minute steps defer to the existing renderer.
+  if (minute === '*/2') {
+    // The `*/2` clean step reads idiomatically as "every other minute" with no
+    // offset; other minute steps take the ordinal stride-cadence below.
     return ' of every other minute';
   }
 
+  // A stepped minute (a clean `*/n`, an offset `m/n`, or a uneven step the core
+  // enumerated to an arithmetic list) confines as "during every Nth minute"
+  // plus the step's offset/bound — the ordinal cadence, not the cardinal that
+  // reads as a separate cadence, nor a wall of enumerated ":NN" minutes.
+  const stride = minuteStride(schedule);
+
+  if (stride) {
+    return minuteStrideConfinement(stride, opts);
+  }
+
   // A minute single/range/list under the seconds lead. The minute reads as a
   // ":NN" clock-minute confinement, never "N minutes past the hour" (that is
   // the minute-lead clock-point form).
@@ -1111,10 +1190,11 @@ function hourConfinement(schedule: Schedule, opts: NormalizedOptions): string {
 
   if (hour === '*') {
     // A pinned minute confinement ("during minute :00") repeats across every
-    // hour, so the hour is named as the unit of recurrence; a stepped minute
-    // ("of every other minute") or absent minute already implies all hours.
+    // hour, so the hour is named as the unit of recurrence; a minute cadence
+    // ("of every other minute", "during every sixth minute …") or an absent
+    // minute already implies all hours, so the hour is not restated.
     const minutePinned = schedule.pattern.minute !== '*' &&
-      !isCadenceField(schedule.pattern.minute);
+      !isCadenceField(schedule.pattern.minute) && !minuteStride(schedule);
 
     return minutePinned ? ' of every hour' : '';
   }
@@ -1208,24 +1288,28 @@ function confinementEligible(schedule: Schedule,
   }
 
   if (lead.secondLead) {
-    // A minute STEP is supported only as the `*/2` "every other minute" idiom,
-    // and only where it fills the coarser field: a contiguous hour range or a
-    // single hour both close on the minute's real last fire, which the
-    // windowing renderer already speaks. The `*/2` step fills both, so it keeps
-    // the "of every other minute" confinement; other steps defer entirely. A
-    // contiguous hour range (`hour === 'range'`) is left to that windowing
-    // renderer rather than this confinement frame, which closes on the top of
-    // the next hour.
+    // A minute STEP confines as an ordinal cadence ("during every sixth minute
+    // from four minutes past the hour"), but only where it fills the coarser
+    // field: under a WILDCARD hour the step repeats every hour, so the cadence
+    // is the whole confinement. A single hour or a contiguous range closes on
+    // the minute's real last fire, which the windowing renderer already speaks,
+    // so those defer. The `*/2` step keeps its "of every other minute" idiom.
     if (minuteStep) {
-      return minute === '*/2' && schedule.shapes.hour !== 'range';
+      return minute === '*/2' ?
+        schedule.shapes.hour !== 'range' :
+        schedule.pattern.hour === '*';
     }
 
-    // A minute list that is really a stride keeps its cadence form; a short
-    // explicit minute list crossed with a discrete hour LIST is a wall of
-    // distinct clock times ("9:00 a.m., 9:25 a.m., …"), not a single minute
-    // confinement. Both stay with the enumerating renderer.
-    if (isMinuteStride(schedule) ||
-        schedule.shapes.minute === 'list' && schedule.shapes.hour === 'list') {
+    // A minute list that is really an arithmetic stride confines as that same
+    // ordinal cadence when it fills a wildcard hour; under a restricted hour it
+    // keeps its existing cadence form. A short explicit minute list crossed
+    // with a discrete hour LIST is a wall of distinct clock times ("9:00 a.m.,
+    // 9:25 a.m., …"), not a single minute confinement, so it stays enumerated.
+    if (isMinuteStride(schedule)) {
+      return schedule.pattern.hour === '*';
+    }
+
+    if (schedule.shapes.minute === 'list' && schedule.shapes.hour === 'list') {
       return false;
     }
 
@@ -1748,6 +1832,15 @@ function listPastThe(words: (string | number)[], unit: string, anchor: string,
     anchor;
 }
 
+// Strip the generic "past the hour" anchor from a minute-cadence lead. When the
+// hour field is restricted (a step or window), the hour clause is the sole hour
+// authority, so the cadence must not also assert "every hour" — "past the hour"
+// alongside a stepped/windowed hour reads as a conflicting every-hour scope. An
+// unrestricted hour keeps the anchor (it is the only hour statement there).
+function withoutHourAnchor(lead: string): string {
+  return lead.replace(/ past the hour$/, '');
+}
+
 // A clock time reads as a word ("noon"/"midnight") only at exact 12:00 or
 // 0:00 with no minute or second.
 function wordTime(hour: number | string, minute: number | string,

package/src/lang/es/index.ts

@@ -115,6 +115,17 @@ const weekdayNames = [
 const nthWeekdayNames =
   [null, 'primer', 'segundo', 'tercer', 'cuarto', 'quinto'];
 
+// Spanish ordinals (masculine) for a stepped-minute cadence under a seconds
+// lead ("cada sexto minuto"). The interval-2 step never reaches here — it keeps
+// its own "de cada dos minutos" idiom — so the colliding "segundo" is unused.
+// A lookup miss falls back to the cardinal-with-"cada" form, which still
+// confines (see `minuteStepOrdinal`).
+const stepOrdinals: Record<number, string> = {
+  3: 'tercer', 4: 'cuarto', 5: 'quinto', 6: 'sexto', 7: 'séptimo',
+  8: 'octavo', 9: 'noveno', 10: 'décimo', 12: 'duodécimo', 15: 'decimoquinto',
+  20: 'vigésimo', 30: 'trigésimo'
+};
+
 // Normalize raw user options.
 function normalizeOptions(options?: Cronli5Options): Opts {
   options = options || {};
@@ -269,6 +280,71 @@ function isPinnedMinuteSeconds(
       schedule.shapes.second === 'step');
 }
 
+// The minute field's step stride for the confinement frame, or null when the
+// minute is not a stepped cadence. A `step`-shaped field (`*/6`) reads its
+// segment; a `list`-shaped field the core enumerated from a uneven step (`2/7`
+// → 2,9,…,58) recovers the progression from its values.
+function minuteStride(
+  schedule: Schedule
+): {start: number; interval: number; last: number} | null {
+  if (schedule.shapes.minute === 'step') {
+    const segment = stepSegment(schedule, 'minute');
+    const start = segment.startToken === '*' ? 0 : +segment.startToken;
+
+    return {interval: segment.interval, last:
+      segment.fires[segment.fires.length - 1], start};
+  }
+
+  const values = singleValues(segmentsOf(schedule, 'minute'));
+
+  return values && arithmeticStep(values);
+}
+
+// A stepped minute under a wildcard second and wildcard hour: bind the second
+// cadence to the minute cadence as a CONFINEMENT ("cada segundo en cada sexto
+// minuto a partir del minuto 4 de cada hora"), never the comma juxtaposition
+// that reads as two independent cadences. The cadence is ORDINAL ("cada sexto
+// minuto") — the cardinal "cada seis minutos" is what fuels the misread — and
+// the start/bound mirror the standalone minute cadence: a clean step from the
+// top names no offset, an offset-clean stride names only its start, and a
+// uneven one pins both endpoints ("del minuto 2 al 58"). An interval the
+// ordinal table does not cover keeps the cardinal "cada N" after "en", which
+// still confines.
+function minuteStepConfinement(
+  schedule: Schedule,
+  stride: {start: number; interval: number; last: number},
+  opts: Opts
+): string {
+  const ordinal = stepOrdinals[stride.interval];
+  const head = ordinal ?
+    'cada ' + ordinal + ' minuto' :
+    'cada ' + numero(stride.interval, opts) + ' minutos';
+
+  const tail = chooseStride({...stride, cycle: 60}, {
+    bare: () => '',
+    offset: () => ' a partir del minuto ' + stride.start,
+    bounded: () => ' del minuto ' + stride.start + ' al ' + stride.last
+  });
+
+  return secondsLeadClause(schedule, opts) + ' en ' + head + tail +
+    ' de cada hora' + trailingQualifier(schedule, opts);
+}
+
+// Whether a stepped minute fills a wildcard hour under a wildcard second — the
+// shape the confinement frame above handles.
+function isSteppedMinuteSeconds(
+  schedule: Schedule,
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>
+): boolean {
+  return (plan.rest.kind === 'minuteFrequency' ||
+    plan.rest.kind === 'multipleMinutes') &&
+    (schedule.shapes.second === 'wildcard' ||
+      schedule.shapes.second === 'step') &&
+    schedule.shapes.hour === 'wildcard' &&
+    schedule.pattern.minute !== '*/2' &&
+    minuteStride(schedule) !== null;
+}
+
 function renderComposeSeconds(
   schedule: Schedule,
   plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
@@ -312,6 +388,14 @@ function renderComposeSeconds(
     return dayFrame + ', ' + window + ', ' + cadence;
   }
 
+  // A stepped minute under a wildcard second + wildcard hour confines the
+  // second cadence to the ordinal minute cadence ("cada segundo en cada sexto
+  // minuto a partir del minuto 4 de cada hora"), never the comma juxtaposition
+  // that reads as two independent cadences.
+  if (isSteppedMinuteSeconds(schedule, plan)) {
+    return minuteStepConfinement(schedule, minuteStride(schedule)!, opts);
+  }
+
   // A wildcard second under a minute */2 with a wildcard hour juxtaposes two
   // cadences that read as contradictory ("cada segundo, cada dos minutos").
   // Bind them with the genitive "de" ("cada segundo de cada dos minutos"),
@@ -467,6 +551,16 @@ function minutesList(schedule: Schedule, opts: Opts): string {
     joinList(segmentWords(segmentsOf(schedule, 'minute'))) + ' de cada hora';
 }
 
+// Strip the generic "de cada hora" anchor from a minute-cadence lead. Under an
+// hour STEP the hour clause is the sole hour authority, so the cadence must not
+// also assert "de cada hora" — alongside a stepped hour it reads as a
+// conflicting every-hour scope ("de cada hora, cada cuatro horas"). An hour
+// WINDOW and an unrestricted hour keep the anchor (the window already names the
+// hours; an open hour has no other hour statement).
+function withoutHourAnchor(lead: string): string {
+  return lead.replace(/ de cada hora$/, '');
+}
+
 // "cada minuto del 0 al 30". The standalone renderer adds "de cada hora";
 // when an hour qualifier follows ("..., a las 09:00", "..., cada dos
 // horas") it would contradict, so it is not baked in here.
@@ -594,8 +688,10 @@ function renderMinuteFrequency(
   }
   else if (plan.hours.kind === 'step') {
     // A clean stride is a confinement ("las horas pares", or the active-hour
-    // list), never a juxtaposed cadence ("cada dos horas").
-    phrase += ', ' + stepHourSpan(stepSegment(schedule, 'hour'), opts);
+    // list), never a juxtaposed cadence ("cada dos horas"). The hour step
+    // scopes the hours, so an offset cadence drops "de cada hora".
+    phrase = withoutHourAnchor(phrase) + ', ' +
+      stepHourSpan(stepSegment(schedule, 'hour'), opts);
   }
 
   return phrase + trailingQualifier(schedule, opts);
@@ -680,10 +776,10 @@ function renderMinuteSpanAcrossHourStep(
 
   // A minute list keeps the same cadence clause as the range; only its lead
   // differs ("en los minutos 5 y 30 de cada hora" vs "cada minuto del 0 al
-  // 30").
-  const lead = plan.form === 'list' ?
+  // 30"). The hour step scopes the hours, so the lead drops "de cada hora".
+  const lead = withoutHourAnchor(plan.form === 'list' ?
     minutesList(schedule, opts) :
-    minuteRangeLead(schedule.pattern.minute);
+    minuteRangeLead(schedule.pattern.minute));
 
   return lead + ', ' +
     (cadence ?? stepHours(segment, opts)) + trailingQualifier(schedule, opts);
@@ -1271,10 +1367,13 @@ function renderCompactClockTimes(
   }
 
   // A uneven hour stride reads as a cadence after the minute lead, not a wall
-  // of clock-time columns.
+  // of clock-time columns. That hour step is the sole hour authority, so the
+  // minute lead drops its generic "de cada hora" (an every-hour scope that
+  // would conflict with the step); the clock-time branch keeps it, naming
+  // specific hours rather than a step.
   const cadence = unevenHourCadence(schedule, opts);
   const phrase = cadence ?
-    minutesList(schedule, opts) + ', ' + cadence +
+    withoutHourAnchor(minutesList(schedule, opts)) + ', ' + cadence +
       trailingQualifier(schedule, opts) :
     minutesList(schedule, opts) + ', ' +
       hourContextTimes(schedule, opts) + trailingQualifier(schedule, opts);

package/src/lang/fi/index.ts

@@ -123,6 +123,17 @@ const nthWeekdayNames: (string | null)[] = [
   'viidentenä'
 ];
 
+// Essive ordinals for "joka N:ntenä minuuttina" — the step intervals a minute
+// cadence can take. The interval-2 step keeps its own "joka toisena minuuttina"
+// idiom and never reaches the confinement helper; a lookup miss falls back to
+// the genitive "N minuutin välein" cadence, which still confines.
+const minuteStepOrdinals: {[interval: number]: string} = {
+  3: 'kolmantena', 4: 'neljäntenä', 5: 'viidentenä', 6: 'kuudentena',
+  7: 'seitsemäntenä', 8: 'kahdeksantena', 9: 'yhdeksäntenä',
+  10: 'kymmenentenä', 12: 'kahdentenatoista', 15: 'viidentenätoista',
+  20: 'kahdentenakymmenentenä', 30: 'kolmantenakymmenentenä'
+};
+
 // Weekdays as stored inflected forms (SUN..SAT): distributive -isin,
 // elative, illative, and essive. Consonant gradation (keskiviikko →
 // keskiviikosta) makes stem+suffix logic wrong; store the forms.
@@ -404,6 +415,71 @@ function composeHourCadence(
     hourRangeCadence(schedule, minute, opts);
 }
 
+// The minute field's step stride for the confinement frame, or null when the
+// minute is not a stepped cadence. A `step`-shaped field reads its segment; a
+// `list`-shaped field the core enumerated from a uneven step (`2/7` → 2,9,…,58)
+// recovers the progression from its values.
+function minuteStride(
+  schedule: Schedule
+): {start: number; interval: number; last: number} | null {
+  if (schedule.shapes.minute === 'step') {
+    const segment = stepSegment(schedule, 'minute');
+    const start = segment.startToken === '*' ? 0 : +segment.startToken;
+
+    return {interval: segment.interval, last:
+      segment.fires[segment.fires.length - 1], start};
+  }
+
+  const values = singleValues(segmentsOf(schedule, 'minute'));
+
+  return values && arithmeticStep(values);
+}
+
+// A stepped minute under a wildcard/stepped second and wildcard hour: bind the
+// second cadence to the minute cadence as a CONFINEMENT ("joka sekunti joka
+// kuudentena minuuttina jokaisen tunnin minuutista 4 alkaen"), never the comma
+// juxtaposition that reads as two independent cadences. The cadence is ORDINAL
+// ("joka kuudentena minuuttina") — the cardinal "kuuden minuutin välein" is
+// what fuels the misread — and the start/bound mirror the standalone minute
+// cadence: an offset-clean stride names only its start, a uneven one pins both
+// endpoints ("minuutista 2 minuuttiin 58").
+function minuteStepConfinement(
+  schedule: Schedule,
+  stride: {start: number; interval: number; last: number},
+  opts: NormalizedOptions
+): string {
+  const ordinalForm = minuteStepOrdinals[stride.interval];
+  const minute = units.minute;
+  const head = ordinalForm ?
+    ' joka ' + ordinalForm + ' minuuttina' :
+    ' ' + genitive(stride.interval, opts) + ' ' + minute.gen + ' välein';
+
+  const tail = chooseStride({...stride, cycle: 60}, {
+    bare: () => '',
+    offset: () => ' ' + minute.anchor + ' ' + minute.ela + ' ' +
+      stride.start + ' alkaen',
+    bounded: () => ' ' + minute.ela + ' ' + stride.start + ' ' +
+      minute.ill + ' ' + stride.last
+  });
+
+  return secondsLeadClause(schedule, opts) + head + tail +
+    trailingQualifier(schedule, opts);
+}
+
+// Whether a stepped minute fills a wildcard hour under a wildcard/stepped
+// second — the shape the confinement frame above handles.
+function isSteppedMinuteSeconds(
+  schedule: Schedule,
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>
+): boolean {
+  return (plan.rest.kind === 'minuteFrequency' ||
+    plan.rest.kind === 'multipleMinutes') &&
+    (schedule.pattern.second === '*' || schedule.shapes.second === 'step') &&
+    schedule.shapes.hour === 'wildcard' &&
+    schedule.pattern.minute !== '*/2' &&
+    minuteStride(schedule) !== null;
+}
+
 function renderComposeSeconds(
   schedule: Schedule,
   plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
@@ -419,6 +495,16 @@ function renderComposeSeconds(
     return cadence;
   }
 
+  // A stepped minute under a wildcard/stepped second + wildcard hour confines
+  // the second cadence to the ordinal minute cadence ("joka sekunti joka
+  // kuudentena minuuttina jokaisen tunnin minuutista 4 alkaen"), never the
+  // comma juxtaposition that reads as two independent cadences. Checked before
+  // the general minute-step compose path, which keeps the comma form under a
+  // restricted hour.
+  if (isSteppedMinuteSeconds(schedule, plan)) {
+    return minuteStepConfinement(schedule, minuteStride(schedule)!, opts);
+  }
+
   // 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).
@@ -426,15 +512,15 @@ function renderComposeSeconds(
     return composeSecondsOverMinuteStep(schedule, plan.rest, opts);
   }
 
-  // A sub-minute second with the minute pinned to 0 and a specific hour: the
-  // clock-time rest would read "klo 9", dropping the pinned :00 and so the
-  // one-minute confinement (60 fires in :00, not 3,600 across the hour). Bind
-  // the seconds to the explicit clock minute with the "minuutin HH.00 aikana"
-  // frame (an "of"/during form, never a range) and trail the day qualifier
-  // ("joka sekunti minuutin 9.00 aikana, joka päivä").
-  if (plan.rest.kind === 'clockTimes' &&
-      plan.rest.times.every((time) => +time.minute === 0)) {
-    return composeMinuteZero(schedule, plan.rest, opts);
+  // A second over a single fixed minute and a specific hour is a single fixed
+  // timestamp: the clock-time rest would float the seconds as a separate clause
+  // ("joka sekunti, joka päivä klo 9.02"), hiding that they belong to that one
+  // minute. Bind the seconds to the explicit clock minute with the "minuutin
+  // HH.MM aikana" frame (an "of"/during form, never a range) and trail the day
+  // qualifier ("joka sekunti minuutin 9.02 aikana, joka päivä") — the same
+  // fusion the minute-0 case ("minuutin 9.00 aikana") uses.
+  if (plan.rest.kind === 'clockTimes' && schedule.shapes.minute === 'single') {
+    return composeSingleMinute(schedule, plan.rest, opts);
   }
 
   // A wildcard second under a minute */2 with a wildcard hour juxtaposes two
@@ -473,11 +559,13 @@ function isEveryOtherMinuteSeconds(
   return seg.startToken === '*' && seg.interval === 2;
 }
 
-// The minute-0 confinement: bind the seconds to the explicit clock minute(s)
-// in the "minuutin/minuuttien HH.00 aikana" frame (an "of"/during form, never
-// a range — a range would round-trip back to the whole hour) and trail the day
-// qualifier ("joka sekunti minuutin 9.00 aikana, joka päivä").
-function composeMinuteZero(
+// The single-fixed-minute confinement: bind the seconds to the explicit clock
+// minute(s) in the "minuutin/minuuttien HH.MM aikana" frame (an "of"/during
+// form, never a range — a range would round-trip back to the whole hour) and
+// trail the day qualifier ("joka sekunti minuutin 9.02 aikana, joka päivä").
+// Minute 0 ("minuutin 9.00 aikana") is just this with the minute being 0; any
+// single fixed minute fuses the same way.
+function composeSingleMinute(
   schedule: Schedule,
   rest: Extract<PlanNode, {kind: 'clockTimes'}>,
   opts: NormalizedOptions
@@ -695,8 +783,10 @@ function renderMinuteFrequency(
     const cadence = unevenHourCadence(schedule, opts);
 
     if (cadence !== null) {
-      return stepCycle60(seg, units.minute, opts) + ', ' + cadence +
-        trailingQualifier(schedule, opts);
+      // The hour step is the sole hour authority, so an offset minute cadence
+      // drops its generic "jokaisen tunnin" every-hour scope.
+      return withoutHourAnchor(stepCycle60(seg, units.minute, opts)) + ', ' +
+        cadence + trailingQualifier(schedule, opts);
     }
 
     // When the step renders as anchored ("kohdalla"), the per-hour windows
@@ -714,13 +804,16 @@ function renderMinuteFrequency(
       trailingQualifier(schedule, opts);
   }
 
-  let phrase = stepCycle60(seg, units.minute, opts);
+  const phraseBase = stepCycle60(seg, units.minute, opts);
+  let phrase = phraseBase;
 
   if (plan.hours.kind === 'window') {
     phrase += ' ' + hourWindow(plan.hours, opts);
   }
   else if (plan.hours.kind === 'step') {
-    phrase += ' ' +
+    // The hour step is the sole hour authority, so the minute cadence drops its
+    // generic "jokaisen tunnin" every-hour scope.
+    phrase = withoutHourAnchor(phraseBase) + ' ' +
       everyNthHour(stepSegment(schedule, 'hour'), opts);
   }
 
@@ -1167,6 +1260,16 @@ function stepCycle60(
   }, opts);
 }
 
+// Strip the generic "jokaisen tunnin" anchor from an offset minute-cadence
+// lead. When the hour field is a restricted step, the hour clause is the sole
+// hour authority, so the cadence must not also assert "jokaisen tunnin" (every
+// hour) — alongside a stepped hour it conflicts as an every-hour scope.
+// An unrestricted hour, and an hour WINDOW, keep the anchor (the window names
+// the hours without an every-hour-of-the-day conflict).
+function withoutHourAnchor(lead: string): string {
+  return lead.replace(' ' + units.minute.anchor + ' ', ' ');
+}
+
 // "kahden tunnin välein", "klo 0, 10 ja 20", or "viiden tunnin välein
 // klo 1 alkaen".
 function stepHours(segment: StepSegment, opts: NormalizedOptions): string {