cronli5 0.8.2 → 0.8.5

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 || {};
@@ -204,7 +215,19 @@ function renderSecondsWithinMinute(
       trailingQualifier(schedule, opts);
   }
 
-  return secondsLeadClause(schedule, opts) + ', en el minuto ' + minuteField +
+  // A second LIST or RANGE under a single minute confines that minute with the
+  // genitive "de" ("en los segundos 5 y 10 del minuto 30 de cada hora"), never
+  // the comma juxtaposition that reads as two independent schedules. A STEP
+  // second is a cadence ("cada 15 segundos") and keeps its own lead.
+  if (secondsConfinesMinute(schedule)) {
+    return secondsBareLead(schedule) + ' ' +
+      confinedMinutePhrase(schedule, opts) + trailingQualifier(schedule, opts);
+  }
+
+  // A cadence/stepped second leads straight into the locative "en el minuto …"
+  // with NO comma ("cada 15 segundos en el minuto 30 de cada hora"); the
+  // locative binds the two specs, matching the no-comma list/single form.
+  return secondsLeadClause(schedule, opts) + ' en el minuto ' + minuteField +
     ' de cada hora' + trailingQualifier(schedule, opts);
 }
 
@@ -269,6 +292,201 @@ 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;
+}
+
+// The leading seconds words for a clock-point second, WITHOUT the trailing "de
+// cada minuto" anchor: a confined second attaches to the CONFINED minute ("de
+// cada sexto minuto…"), so the generic minute anchor would be redundant. The
+// list/range/single forms mirror `secondsClause` minus that anchor.
+function secondsBareLead(schedule: Schedule): string {
+  const secondField = schedule.pattern.second;
+  const shape = schedule.shapes.second;
+
+  if (shape === 'range') {
+    const bounds = secondField.split('-');
+
+    return 'cada segundo del ' + bounds[0] + ' al ' + bounds[1];
+  }
+
+  if (shape === 'single') {
+    return 'en el segundo ' + secondField;
+  }
+
+  return 'en los segundos ' +
+    joinList(segmentWords(segmentsOf(schedule, 'second')));
+}
+
+// The CONFINED-minute genitive phrase a clock-point second attaches to, with
+// its leading connector folded in ("de cada sexto minuto a partir del minuto 4
+// de cada hora", "de los minutos 0, 15 y 30 de cada hora", "del minuto 30 de
+// cada hora"). A stepped minute reuses the ordinal cadence form; a list, range,
+// or single names the minute(s) directly. This is the seconds clause's anchor,
+// so the generic "de cada minuto" is never stacked alongside it.
+function confinedMinutePhrase(schedule: Schedule, opts: Opts): string {
+  const stride = minuteStride(schedule);
+
+  if (stride && schedule.pattern.minute !== '*/2') {
+    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 'de ' + head + tail + ' de cada hora';
+  }
+
+  if (schedule.shapes.minute === 'range') {
+    return 'de ' + minuteRangeLead(schedule.pattern.minute) + ' de cada hora';
+  }
+
+  if (schedule.shapes.minute === 'list') {
+    return 'de los minutos ' +
+      joinList(segmentWords(segmentsOf(schedule, 'minute'))) + ' de cada hora';
+  }
+
+  // A single pinned minute: "del minuto 30 de cada hora".
+  return 'del minuto ' + schedule.pattern.minute + ' de cada hora';
+}
+
+// Whether a clock-point second (list, range, or single) sits under a restricted
+// minute and a wildcard hour — the shape that must CONFINE the minute with the
+// genitive "de" rather than juxtapose it behind a comma (two independent
+// schedules). The single-second + single-minute pair folds into one coherent
+// clock point ("en el minuto 5 y el segundo 30 de cada hora") and is excluded.
+// The minute-confinement rendering for a compose-seconds plan, or null when the
+// plan is not one. A CADENCE second over a stepped minute uses the ordinal
+// cadence form; a CLOCK-POINT second (list/range/single) over any restricted
+// minute uses the genitive form anchored to the confined minute. Both bind the
+// second beneath the minute instead of juxtaposing the two behind a comma.
+// Folded into one helper so `renderComposeSeconds` carries a single branch.
+function minuteConfinementRender(
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
+  schedule: Schedule, opts: Opts
+): string | null {
+  if (isSteppedMinuteSeconds(schedule, plan)) {
+    return minuteStepConfinement(schedule, minuteStride(schedule)!, opts);
+  }
+
+  const minuteRest = plan.rest.kind === 'minuteFrequency' ||
+    plan.rest.kind === 'multipleMinutes' ||
+    plan.rest.kind === 'rangeOfMinutes';
+
+  if (minuteRest && secondsConfinesMinute(schedule)) {
+    return secondsBareLead(schedule) + ' ' +
+      confinedMinutePhrase(schedule, opts) + trailingQualifier(schedule, opts);
+  }
+
+  return null;
+}
+
+function secondsConfinesMinute(schedule: Schedule): boolean {
+  const {second, minute, hour} = schedule.shapes;
+
+  // A second LIST the core enumerated from a step (`*/15` → 0,15,30,45; `3/2` →
+  // 3,5,…) is really a stride CADENCE, spoken "cada N segundos" and confined by
+  // the cadence path, not a clock-point clause; exclude it here.
+  if (second === 'list') {
+    const values = singleValues(segmentsOf(schedule, 'second'));
+
+    if (values && arithmeticStep(values)) {
+      return false;
+    }
+  }
+
+  const clockPoint = second === 'single' || second === 'range' ||
+    second === 'list';
+
+  return clockPoint && minute !== 'wildcard' && hour === 'wildcard' &&
+    !(second === 'single' && minute === 'single');
+}
+
+// The seconds lead plus its connector for a generic compose-seconds fallback:
+// empty when the rest already owns the second (a compact clock time folding a
+// meaningful single second); a bare space when the rest is a locative "en …"
+// minute LIST/SINGLE under a wildcard hour (the locative binds the two specs,
+// so no comma); otherwise the comma that sets the seconds clause apart.
+function composeConnector(
+  schedule: Schedule,
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
+  opts: Opts
+): string {
+  if (plan.rest.kind === 'compactClockTimes' && schedule.analyses.clockSecond) {
+    return '';
+  }
+
+  const locative = (plan.rest.kind === 'multipleMinutes' ||
+    plan.rest.kind === 'singleMinute') && schedule.shapes.hour === 'wildcard';
+
+  return secondsLeadClause(schedule, opts) + (locative ? ' ' : ', ');
+}
+
 function renderComposeSeconds(
   schedule: Schedule,
   plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
@@ -312,6 +530,17 @@ function renderComposeSeconds(
     return dayFrame + ', ' + window + ', ' + cadence;
   }
 
+  // A second confines the minute restriction (open hour), never the comma
+  // juxtaposition that reads as two independent cadences: a CADENCE second over
+  // a stepped minute uses the ordinal-cadence form ("cada segundo en cada sexto
+  // minuto …"); a CLOCK-POINT second uses the genitive form anchored to the
+  // confined minute ("en los segundos 5, 10 y 15 de cada sexto minuto …").
+  const confined = minuteConfinementRender(plan, schedule, opts);
+
+  if (confined !== null) {
+    return confined;
+  }
+
   // 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"),
@@ -324,11 +553,12 @@ function renderComposeSeconds(
 
   // 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' &&
-    schedule.analyses.clockSecond;
-  const lead = restOwnsLead ? '' : secondsLeadClause(schedule, opts) + ', ';
+  // double it (empty connector). A cadence/stepped second under a minute
+  // LIST or SINGLE and a wildcard hour leads straight into the locative "en …"
+  // minute phrase with NO comma ("cada segundo en los minutos 0, 15 y 30 de
+  // cada hora") — the locative binds the two specs, matching the no-comma
+  // stepped-minute and list-tier confinements. Every other rest takes a comma.
+  const lead = composeConnector(schedule, plan, opts);
 
   return lead + render(schedule, plan.rest, 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.
@@ -335,6 +346,13 @@ function renderSecondsWithinMinute(
       units.second.gen + ' kohdalla' + trailingQualifier(schedule, opts);
   }
 
+  // A second LIST or RANGE under a single minute folds both into one shared
+  // "kohdalla" ("joka tunti 30 minuutin ja 5 ja 10 sekunnin kohdalla"), never
+  // the comma juxtaposition; a STEP second is a cadence and keeps its clause.
+  if (secondsConfinesMinute(schedule)) {
+    return secondsConfinement(schedule, opts);
+  }
+
   return secondsLeadClause(schedule, opts) + ', ' +
     atMarks(minuteField, units.minute, true) +
     trailingQualifier(schedule, opts);
@@ -404,6 +422,133 @@ 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;
+}
+
+// Whether a clock-point second (list, range, or single) sits under a restricted
+// minute and a wildcard hour — the shape that must CONFINE the minute rather
+// than juxtapose it behind a comma (two independent schedules). A second LIST
+// the core enumerated from a step (`3/2`) is really a stride cadence and stays
+// out. The single-second + single-minute pair folds into one shared "kohdalla"
+// already ("joka tunti 30 minuutin ja 15 sekunnin kohdalla") and is excluded.
+function secondsConfinesMinute(schedule: Schedule): boolean {
+  const {second, minute, hour} = schedule.shapes;
+
+  if (second === 'list') {
+    const values = singleValues(segmentsOf(schedule, 'second'));
+
+    if (values && arithmeticStep(values)) {
+      return false;
+    }
+  }
+
+  const clockPoint = second === 'single' || second === 'range' ||
+    second === 'list';
+
+  return clockPoint && minute !== 'wildcard' && hour === 'wildcard' &&
+    !(second === 'single' && minute === 'single');
+}
+
+// Whether a compose-seconds plan over a minute-cadence/list/range rest carries
+// a clock-point second that must confine the minute — the gate for the "的"/
+// shared-"kohdalla" fusion in `renderComposeSeconds`, kept out of that function
+// to hold its branch count down.
+function composeConfinesMinute(
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>, schedule: Schedule
+): boolean {
+  const minuteRest = plan.rest.kind === 'minuteFrequency' ||
+    plan.rest.kind === 'multipleMinutes' ||
+    plan.rest.kind === 'rangeOfMinutes';
+
+  return minuteRest && secondsConfinesMinute(schedule);
+}
+
+// Confine a restricted minute under a clock-point second. A STEPPED minute
+// keeps the essive ordinal cadence frame ("joka kuudentena minuuttina jokaisen
+// tunnin minuutista 4 alkaen") and the seconds trail as their postposition,
+// mirroring the open-minute "joka minuutti 5, 10 ja 15 sekunnin kohdalla". A
+// list, range, or single minute folds BOTH fields into one shared "kohdalla"
+// ("joka tunti 0, 15 ja 30 minuutin ja 5, 10 ja 15 sekunnin kohdalla"), the
+// same fusion the single-second case uses — never the comma juxtaposition.
+function secondsConfinement(
+  schedule: Schedule, opts: NormalizedOptions
+): string {
+  const stride = minuteStride(schedule);
+
+  if (stride && schedule.pattern.minute !== '*/2') {
+    return minuteStepConfinement(schedule, stride, opts);
+  }
+
+  const minuteDigits = joinList(segmentWords(segmentsOf(schedule, 'minute')));
+  const secondDigits = joinList(segmentWords(segmentsOf(schedule, 'second')));
+
+  return units.minute.mark + ' ' + minuteDigits + ' ' + units.minute.gen +
+    ' ja ' + secondDigits + ' ' + units.second.gen + ' kohdalla' +
+    trailingQualifier(schedule, opts);
+}
+
 function renderComposeSeconds(
   schedule: Schedule,
   plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
@@ -419,6 +564,24 @@ 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);
+  }
+
+  // A clock-point second (list/range/single) under a restricted minute confines
+  // that minute, never the comma juxtaposition that reads as two schedules: a
+  // stepped minute keeps its essive frame with the seconds postposition; a
+  // list, range, or single minute folds both into one shared "kohdalla".
+  if (composeConfinesMinute(plan, schedule)) {
+    return secondsConfinement(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

@@ -217,6 +217,14 @@ function renderSecondsWithinMinute(
       trailingQualifier(schedule, opts);
   }
 
+  // A second LIST or RANGE under a single minute confines that minute in the
+  // genitive ("aux secondes 5 et 10 de la minute 30 de chaque heure"), never
+  // the comma juxtaposition; a STEP second is a cadence and keeps its own lead.
+  if (secondsConfinesMinute(schedule)) {
+    return secondsBareLead(schedule) + ' ' +
+      confinedMinutePhrase(schedule) + trailingQualifier(schedule, opts);
+  }
+
   return secondsLeadClause(schedule, opts) + ', à la minute ' + minuteField +
     ' de chaque heure' + trailingQualifier(schedule, opts);
 }
@@ -279,6 +287,161 @@ 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 hour: the second clause leads, a COMMA,
+// then the minute's own STANDALONE cardinal cadence ("chaque seconde, toutes
+// les six minutes à partir de la minute 4 de chaque heure"; "aux secondes 5,
+// 10 et 15, toutes les six minutes …"). The ordinal "à la sixième minute" read
+// as a single minute (the 10th), not the every-sixth series; the standalone
+// cardinal "toutes les six minutes" reads it correctly and handles every stride
+// (offset, bounded, uneven) for free. The lead is the cadence clause for a
+// wildcard/stepped second, the bare clock-point clause for a list/range/single.
+function steppedMinuteConfinement(
+  schedule: Schedule,
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
+  lead: string,
+  opts: Opts
+): string {
+  return lead + ', ' + render(schedule, plan.rest, opts) +
+    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;
+}
+
+// The leading seconds words for a clock-point second, WITHOUT the trailing "de
+// chaque minute" anchor: a confined second attaches to the CONFINED minute ("de
+// la sixième minute…"), so the generic minute anchor would be redundant.
+function secondsBareLead(schedule: Schedule): string {
+  const secondField = schedule.pattern.second;
+  const shape = schedule.shapes.second;
+
+  if (shape === 'range') {
+    const bounds = secondField.split('-');
+
+    return 'chaque seconde de ' + bounds[0] + ' à ' + bounds[1];
+  }
+
+  if (shape === 'single') {
+    return 'à la seconde ' + secondField;
+  }
+
+  return 'aux secondes ' +
+    joinList(segmentWords(segmentsOf(schedule, 'second')));
+}
+
+// The CONFINED-minute genitive phrase a clock-point second attaches to ("des
+// minutes 0, 15 et 30 de chaque heure", "de la minute 30 de chaque heure", "de
+// chaque minute de 0 à 30 de chaque heure"). A stepped minute is handled by the
+// standalone-cadence confinement before this point; a list, range, or single
+// names the minute(s) in the genitive — so the bare seconds lead never stacks a
+// redundant "de chaque minute".
+function confinedMinutePhrase(schedule: Schedule): string {
+  if (schedule.shapes.minute === 'range') {
+    return 'de ' + minuteRangeLead(schedule.pattern.minute) +
+      ' de chaque heure';
+  }
+
+  if (schedule.shapes.minute === 'list') {
+    return 'des minutes ' +
+      joinList(segmentWords(segmentsOf(schedule, 'minute'))) +
+      ' de chaque heure';
+  }
+
+  return 'de la minute ' + schedule.pattern.minute + ' de chaque heure';
+}
+
+// Whether a clock-point second (list, range, or single) sits under a restricted
+// minute and a wildcard hour — the shape that must CONFINE the minute in the
+// genitive rather than juxtapose it behind a comma (two independent schedules).
+// A second LIST the core enumerated from a step (`3/2`) is really a stride
+// cadence and stays out. The single-second + single-minute pair folds into one
+// coherent clock point and is excluded.
+function secondsConfinesMinute(schedule: Schedule): boolean {
+  const {second, minute, hour} = schedule.shapes;
+
+  if (second === 'list') {
+    const values = singleValues(segmentsOf(schedule, 'second'));
+
+    if (values && arithmeticStep(values)) {
+      return false;
+    }
+  }
+
+  const clockPoint = second === 'single' || second === 'range' ||
+    second === 'list';
+
+  return clockPoint && minute !== 'wildcard' && hour === 'wildcard' &&
+    !(second === 'single' && minute === 'single');
+}
+
+// The minute-confinement rendering for a compose-seconds plan, or null when the
+// plan is not one. A STEPPED minute (cadence or clock-point second) leads with
+// the second clause, a comma, then the minute's own standalone cardinal
+// cadence; a CLOCK-POINT second over a LIST/RANGE/SINGLE minute uses the
+// genitive form anchored to the confined minute. Both bind the second beneath
+// the minute instead of juxtaposing the two behind a bare comma + "de chaque
+// minute". Folded into one helper so `renderComposeSeconds` carries a single
+// branch.
+function minuteConfinementRender(
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
+  schedule: Schedule, opts: Opts
+): string | null {
+  if (isSteppedMinuteSeconds(schedule, plan)) {
+    return steppedMinuteConfinement(schedule, plan,
+      secondsLeadClause(schedule, opts), opts);
+  }
+
+  const minuteRest = plan.rest.kind === 'minuteFrequency' ||
+    plan.rest.kind === 'multipleMinutes' ||
+    plan.rest.kind === 'rangeOfMinutes';
+
+  if (minuteRest && secondsConfinesMinute(schedule)) {
+    // A clock-point second over a STEPPED minute reuses the standalone cardinal
+    // cadence the same way; only a list/range/single minute keeps the genitive.
+    if (minuteStride(schedule) && schedule.pattern.minute !== '*/2') {
+      return steppedMinuteConfinement(schedule, plan,
+        secondsBareLead(schedule), opts);
+    }
+
+    return secondsBareLead(schedule) + ' ' +
+      confinedMinutePhrase(schedule) + trailingQualifier(schedule, opts);
+  }
+
+  return null;
+}
+
 function renderComposeSeconds(
   schedule: Schedule,
   plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
@@ -322,6 +485,21 @@ 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.
+  // A second confines the minute restriction (open hour), never the comma
+  // juxtaposition that reads as two independent cadences: a CADENCE second over
+  // a stepped minute uses the ordinal-cadence form ("chaque seconde à la
+  // sixième minute …"); a CLOCK-POINT second uses the genitive form anchored to
+  // the confined minute ("aux secondes 5, 10 et 15 de la sixième minute …").
+  const confined = minuteConfinementRender(plan, schedule, opts);
+
+  if (confined !== null) {
+    return confined;
+  }
+
   // 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