cronli5 0.8.2 → 0.8.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cronli5",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "description": "Cron Like I'm Five: A Cron to English Utility",
   "repository": {
     "type": "git",

package/src/lang/de/index.ts

@@ -223,6 +223,16 @@ const stepOrdinals: {[interval: number]: string} = {
   12: 'zwölften'
 };
 
+// Dative ordinals for "in jeder N-ten Minute" — the step intervals a minute
+// cadence can take. The interval-2 step keeps its own "jeder zweiten Minute"
+// idiom and never reaches the confinement helper; a lookup miss falls back to
+// the cardinal "alle N Minuten" form, which still confines.
+const minuteStepOrdinals: {[interval: number]: string} = {
+  3: 'dritten', 4: 'vierten', 5: 'fünften', 6: 'sechsten', 7: 'siebten',
+  8: 'achten', 9: 'neunten', 10: 'zehnten', 12: 'zwölften',
+  15: 'fünfzehnten', 20: 'zwanzigsten', 30: 'dreißigsten'
+};
+
 // Confine a cadence to a clean hour stride: "in jeder zweiten Stunde", with
 // the start named when it is not midnight ("…ab 1 Uhr" for an odd stride).
 function everyNthHour(segment: StepSegment): string {
@@ -717,6 +727,65 @@ function isEveryOtherMinuteSeconds(
   return minuteStep.startToken === '*' && minuteStep.interval === 2;
 }
 
+// The minute field's step stride for the confinement frame, or null when the
+// minute is not a stepped cadence. A `step`-shaped field reads its segment; a
+// `list`-shaped field the core enumerated from a uneven step (`2/7` → 2,9,…,58)
+// recovers the progression from its values.
+function minuteStride(
+  schedule: Schedule
+): {start: number; interval: number; last: number} | null {
+  if (schedule.shapes.minute === 'step') {
+    const segment = stepSegment(schedule, 'minute');
+    const start = segment.startToken === '*' ? 0 : +segment.startToken;
+
+    return {interval: segment.interval, last:
+      segment.fires[segment.fires.length - 1], start};
+  }
+
+  const values = singleValues(segmentsOf(schedule, 'minute'));
+
+  return values && arithmeticStep(values);
+}
+
+// A stepped minute under a wildcard/stepped second and wildcard hour: bind the
+// second cadence to the minute cadence as a CONFINEMENT ("jede Sekunde in jeder
+// sechsten Minute ab Minute 4 jeder Stunde"), never the comma juxtaposition
+// that reads as two independent cadences. The cadence is ORDINAL ("in jeder
+// sechsten Minute") — the cardinal "alle 6 Minuten" is what fuels the misread —
+// and the start/bound mirror the standalone minute cadence.
+function minuteStepConfinement(
+  schedule: Schedule,
+  stride: {start: number; interval: number; last: number}
+): string {
+  const ordinal = minuteStepOrdinals[stride.interval];
+  const head = ordinal ?
+    'in jeder ' + ordinal + ' Minute' :
+    'alle ' + stride.interval + ' Minuten';
+
+  const tail = chooseStride({...stride, cycle: 60}, {
+    bare: () => '',
+    offset: () => ' ab Minute ' + stride.start,
+    bounded: () => ' von Minute ' + stride.start + ' bis ' + stride.last
+  });
+
+  return secondsLead(schedule) + ' ' + head + tail + ' jeder Stunde';
+}
+
+// Whether a stepped minute fills a wildcard hour under a wildcard/stepped
+// second — the shape the confinement frame above handles.
+function isSteppedMinuteSeconds(
+  schedule: Schedule,
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>
+): boolean {
+  return (plan.rest.kind === 'minuteFrequency' ||
+    plan.rest.kind === 'multipleMinutes') &&
+    (schedule.shapes.second === 'wildcard' ||
+      schedule.shapes.second === 'step') &&
+    schedule.shapes.hour === 'wildcard' &&
+    schedule.pattern.minute !== '*/2' &&
+    minuteStride(schedule) !== null;
+}
+
 function renderComposeSeconds(
   schedule: Schedule,
   plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
@@ -749,6 +818,14 @@ function renderComposeSeconds(
       clockMinuteGenitive(plan.rest.times, opts.style.sep);
   }
 
+  // A stepped minute under a wildcard/stepped second + wildcard hour confines
+  // the second cadence to the ordinal minute cadence ("jede Sekunde in jeder
+  // sechsten Minute ab Minute 4 jeder Stunde"), never the comma juxtaposition
+  // that reads as two independent cadences.
+  if (isSteppedMinuteSeconds(schedule, plan)) {
+    return minuteStepConfinement(schedule, minuteStride(schedule)!);
+  }
+
   // A wildcard second under a minute */2 with a wildcard hour binds in the
   // genitive ("jede Sekunde jeder zweiten Minute").
   if (isEveryOtherMinuteSeconds(schedule, plan)) {

package/src/lang/en/index.ts

@@ -677,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 {
@@ -1078,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).
@@ -1119,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' : '';
   }
@@ -1216,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 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 === '*';
     }
 
-    // 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') {
+    if (schedule.shapes.minute === 'list' && schedule.shapes.hour === 'list') {
       return false;
     }
 

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"),

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).

package/src/lang/fr/index.ts

@@ -127,6 +127,16 @@ const weekdayNames = [
 const nthWeekdayMasculine =
   [null, 'premier', 'deuxième', 'troisième', 'quatrième', 'cinquième'];
 
+// French ordinals (gender-neutral "-ième") for a stepped-minute cadence under a
+// seconds lead ("à la sixième minute"). The interval-2 step keeps its own
+// idiom and never reaches here; a lookup miss falls back to the cardinal-with-
+// preposition form, which still confines (see `minuteStepConfinement`).
+const stepOrdinals: Record<number, string> = {
+  3: 'troisième', 4: 'quatrième', 5: 'cinquième', 6: 'sixième',
+  7: 'septième', 8: 'huitième', 9: 'neuvième', 10: 'dixième',
+  12: 'douzième', 15: 'quinzième', 20: 'vingtième', 30: 'trentième'
+};
+
 // Normalize raw user options.
 function normalizeOptions(options?: Cronli5Options): Opts {
   options = options || {};
@@ -279,6 +289,67 @@ 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 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 ("chaque seconde à la
+// sixième minute à partir de la minute 4 de chaque heure"), never the comma
+// juxtaposition that reads as two independent cadences. The cadence is ORDINAL
+// ("à la sixième minute") — the cardinal "toutes les six minutes" is what fuels
+// the misread — and the start/bound mirror the standalone minute cadence.
+function minuteStepConfinement(
+  schedule: Schedule,
+  stride: {start: number; interval: number; last: number},
+  opts: Opts
+): string {
+  const ordinal = stepOrdinals[stride.interval];
+  const head = ordinal ?
+    'à la ' + ordinal + ' minute' :
+    'à la minute toutes les ' + numero(stride.interval, opts);
+
+  const tail = chooseStride({...stride, cycle: 60}, {
+    bare: () => '',
+    offset: () => ' à partir de la minute ' + stride.start,
+    bounded: () => ' de la minute ' + stride.start + ' à ' + stride.last
+  });
+
+  return secondsLeadClause(schedule, opts) + ' ' + head + tail +
+    ' de chaque heure' + 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.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'}>,
@@ -322,6 +393,14 @@ function renderComposeSeconds(
     return dayFrame + ', ' + window + ', ' + cadence;
   }
 
+  // A stepped minute under a wildcard/stepped second + wildcard hour confines
+  // the second cadence to the ordinal minute cadence ("chaque seconde à la
+  // sixième minute à partir de la minute 4 de chaque heure"), 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 ("chaque seconde, toutes les deux
   // minutes"). Bind them with the genitive "de" ("chaque seconde de chaque