cronli5 0.8.0 → 0.8.3

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
@@ -476,6 +555,16 @@ function minutesList(schedule: Schedule, opts: Opts): string {
     joinList(segmentWords(segmentsOf(schedule, 'minute'))) + ' de chaque heure';
 }
 
+// Strip the generic "de chaque heure" 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 chaque heure" — alongside a stepped hour it reads as a
+// conflicting every-hour scope ("de chaque heure, toutes les quatre heures").
+// 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 chaque heure$/, '');
+}
+
 // "chaque minute de 0 à 30". The standalone renderer adds "de chaque heure";
 // when an hour qualifier follows ("..., à 9 h", "..., toutes les deux heures")
 // it would contradict, so it is not baked in here.
@@ -550,8 +639,10 @@ function renderMinuteFrequency(
   }
   else if (plan.hours.kind === 'step') {
     // A clean stride is a confinement ("les heures paires", or the active-hour
-    // list), never a juxtaposed cadence ("toutes les deux heures").
-    phrase += ', ' + stepHourSpan(stepSegment(schedule, 'hour'), opts);
+    // list), never a juxtaposed cadence ("toutes les deux heures"). The hour
+    // step scopes the hours, so an offset cadence drops "de chaque heure".
+    phrase = withoutHourAnchor(phrase) + ', ' +
+      stepHourSpan(stepSegment(schedule, 'hour'), opts);
   }
 
   return phrase + trailingQualifier(schedule, opts);
@@ -635,10 +726,10 @@ function renderMinuteSpanAcrossHourStep(
 
   // A minute list keeps the same cadence clause as the range; only its lead
   // differs ("aux minutes 5 et 30 de chaque heure" vs "chaque minute de 0 à
-  // 30").
-  const lead = plan.form === 'list' ?
+  // 30"). The hour step scopes the hours, so the lead drops "de chaque heure".
+  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);
@@ -991,10 +1082,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 chaque heure" (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/pt/index.ts

@@ -144,6 +144,16 @@ const nthWeekdayMasculine =
 const nthWeekdayFeminine =
   [null, 'primeira', 'segunda', 'terceira', 'quarta', 'quinta'];
 
+// Portuguese ordinals (masculine) for a stepped-minute cadence under a seconds
+// lead ("a cada segundo no sexto minuto"). The interval-2 step keeps its own
+// idiom and never reaches here, so the colliding "segundo" is unused; a lookup
+// miss falls back to the cardinal-with-"no" form, which still confines.
+const stepOrdinals: Record<number, string> = {
+  3: 'terceiro', 4: 'quarto', 5: 'quinto', 6: 'sexto', 7: 'sétimo',
+  8: 'oitavo', 9: 'nono', 10: 'décimo', 12: 'décimo segundo',
+  15: 'décimo quinto', 20: 'vigésimo', 30: 'trigésimo'
+};
+
 // --- Contractions (the principal es->pt divergence). ---
 //
 // Portuguese fuses a preposition with the following article wherever es emitted
@@ -413,6 +423,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 ("a cada segundo no
+// sexto minuto a partir do minuto 4 de cada hora"), never the comma
+// juxtaposition that reads as two independent cadences. The cadence is ORDINAL
+// ("no sexto minuto") — the cardinal "a cada seis minutos" 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 ?
+    'no ' + ordinal + ' minuto' :
+    'a cada ' + numero(stride.interval, opts) + ' minutos';
+
+  const tail = chooseStride({...stride, cycle: 60}, {
+    bare: () => '',
+    offset: () => ' a partir do minuto ' + stride.start,
+    bounded: () => ' do minuto ' + stride.start + ' ao ' + stride.last
+  });
+
+  return secondsLeadClause(schedule, opts) + ' ' + head + tail +
+    ' de cada hora' + 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'}>,
@@ -456,6 +527,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 ("a cada segundo no sexto
+  // minuto a partir do 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 ("a cada segundo, a cada dois
   // minutos"). Bind them with the genitive "de" ("a cada segundo de cada dois
@@ -616,6 +695,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, a cada quatro 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$/, '');
+}
+
 // "a cada minuto do 0 ao 30". The standalone renderer adds "de cada hora";
 // when an hour qualifier follows ("..., às 09:00", "..., a cada duas horas")
 // it would contradict, so it is not baked in here.
@@ -746,8 +835,10 @@ function renderMinuteFrequency(
   }
   else if (plan.hours.kind === 'step') {
     // A clean stride is a confinement ("as horas pares", or the active-hour
-    // list), never a juxtaposed cadence ("a cada duas horas").
-    phrase += ', ' + stepHourSpan(stepSegment(schedule, 'hour'), opts);
+    // list), never a juxtaposed cadence ("a cada duas 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);
@@ -832,9 +923,10 @@ function renderMinuteSpanAcrossHourStep(
 
   // A minute list keeps the same cadence clause as the range; only its lead
   // differs ("nos minutos 5 e 30 de cada hora" vs "a cada minuto do 0 ao 30").
-  const lead = plan.form === 'list' ?
+  // 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);
@@ -1423,10 +1515,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/zh/index.ts

@@ -327,6 +327,16 @@ function renderMinutePast(schedule: Schedule): string {
   return minuteHourClause(schedule);
 }
 
+// Strip the generic "每小时" (every-hour) anchor that leads a minute clause.
+// Under an hour STEP the hour cadence is the sole hour authority, so the minute
+// clause must not also assert "每小时" — alongside a stepped hour ("每4小时…每小
+// 时…") it reads as a conflicting every-hour scope. An hour WINDOW and an
+// unrestricted hour keep "每小时" (the window already names the hours; an open
+// hour has no other hour statement).
+function withoutHourAnchor(clause: string): string {
+  return clause.replace(/^每小时/, '');
+}
+
 // One hour segment as clock words by its form: a range is a span ("9点至20点"),
 // a single is one clock word ("22点"), a step keeps its fires enumerated as
 // clock words ("9点、11点、13点"). A range stated as a list element should read
@@ -383,7 +393,14 @@ function renderMinuteFrequency(schedule: Schedule, plan: PlanNode): string {
     const hourCad = unevenHourCadence(schedule);
 
     if (hourCad !== null) {
-      return hourCad + (hourCad.indexOf('至') === -1 ? '' : '，') + base;
+      // An hour STEP is the sole hour authority, so an offset minute cadence
+      // drops its leading "每小时" ("每4小时从5分起每10分钟"); a discrete hour
+      // list (during) keeps it. Only the step path reaches a non-null cadence
+      // here — an irregular list falls through to the enumerated frame below.
+      const minuteBase = hours.kind === 'step' ?
+        withoutHourAnchor(base) : base;
+
+      return hourCad + (hourCad.indexOf('至') === -1 ? '' : '，') + minuteBase;
     }
   }
 
@@ -445,15 +462,17 @@ function renderMinuteSpanAcrossHourStep(
   const {form} = plan as Extract<PlanNode, {kind: 'minuteSpanAcrossHourStep'}>;
 
   // A minute list reads as the hour cadence plus the minute list ("每2小时，
-  // 每小时0、25、50分"; offset "从1点起每2小时，每小时5分和30分"), the same compaction
-  // the wildcard/range minute already uses, rather than the enumerated hours.
+  // 0、25、50分"; offset "从1点起每2小时，5分和30分"), the same compaction the
+  // wildcard/range minute already uses, rather than the enumerated hours. The
+  // hour cadence scopes the hours, so the minute clause drops its "每小时".
   if (form === 'list') {
-    return hourCadencePhrase(schedule) + '，' + renderMinutePast(schedule);
+    return hourCadencePhrase(schedule) + '，' +
+      withoutHourAnchor(renderMinutePast(schedule));
   }
 
   const minuteTail = form === 'wildcard' ?
     '每分钟' :
-    minuteHourClause(schedule) + '，每分钟';
+    withoutHourAnchor(minuteHourClause(schedule)) + '，每分钟';
 
   // An offset or non-tiling stride (2/6 fires at 2,8,14,20) reads as its
   // cadence ("从2点起每6小时"). A wildcard minute hangs off it with a comma; a
@@ -518,9 +537,13 @@ function renderCompactClockTimes(schedule: Schedule, plan: PlanNode): string {
   if (!compact.fold) {
     const hourCad = unevenHourCadence(schedule);
 
+    // A bounded/uneven hour step leads as the cadence and is the sole hour
+    // authority, so the minute clause drops its generic "每小时" every-hour
+    // scope; an enumerated hour list (hourCad null) names specific hours and
+    // keeps the anchor.
     return hourCad === null ?
       minuteHourClause(schedule) + '，在' + hourList(schedule) + tail :
-      hourCad + '，' + minuteHourClause(schedule) + tail;
+      hourCad + '，' + withoutHourAnchor(minuteHourClause(schedule)) + tail;
   }
 
   // A single pinned minute past 0 leads with its clause; a pinned 0 folds into
@@ -870,6 +893,15 @@ function composeSecondsOnHour(
     return composeMinuteZeroClocks(schedule, sec);
   }
 
+  // A single fixed (non-zero) minute under enumerated clock times fuses the
+  // seconds onto the composed clock time the same way ("0点2分的每一秒").
+  const fusedSingleMinute =
+    composeSingleMinuteClocks(schedule, rest, sec, opts);
+
+  if (fusedSingleMinute !== null) {
+    return fusedSingleMinute;
+  }
+
   const restText = render(schedule, rest, opts);
   const secTail = clockRestCarriesSecond(rest) ? '' : sec;
 
@@ -877,15 +909,42 @@ function composeSecondsOnHour(
     return '每天' + restText + secTail;
   }
 
-  // A stated minute (e.g. minute 0 under a sub-minute second) takes the same
-  // "，" connector the listed-minute path uses.
+  // A stated single minute (minute 0 under an open hour) confines the second
+  // beneath it with "的" when the second is a cadence ("每小时0分的每一秒"), the
+  // same fusion the other pinned-minute paths use; the bare comma ("每小时0分，
+  // 每秒") reads as two independent cadences. A single/list/range second is a
+  // clock-point, not a cadence, so it keeps the "，" connector.
   if (rest.kind === 'singleMinute') {
-    return restText + '，' + sec;
+    return secondIsCadence(schedule) ?
+      restText + confinedSecondTail(sec) : restText + '，' + sec;
   }
 
   return restText + secTail;
 }
 
+// A single fixed (non-zero) minute under enumerated clock times: each clock
+// point already names the minute ("0点2分", "9点5分和17点5分"), so bind the
+// seconds to it with "的" — the same fusion the minute-0 ("0分的每一秒") and
+// minute-step ("5、20…分的每一秒") cases use — rather than leaving a bare
+// trailing "每秒" that floats as a second, unlinked adverbial. A single second
+// already folded into each clock time ("9点5分30秒") is not re-appended. The
+// compactClockTimes window form states its minute separately ("每小时5分") and
+// keeps its own seconds clause, so it does not qualify (returns null). minute 0
+// is handled by composeMinuteZeroClocks before this point.
+function composeSingleMinuteClocks(
+  schedule: Schedule, rest: PlanNode, sec: string, opts: Opts
+): string | null {
+  if (rest.kind !== 'clockTimes' || schedule.shapes.minute !== 'single' ||
+      clockRestCarriesSecond(rest)) {
+    return null;
+  }
+
+  const core =
+    render(schedule, rest, opts) + minuteZeroSecondTail(schedule, sec);
+
+  return isDaily(schedule) ? '每天' + core : core;
+}
+
 // A minute pinned to 0 under specific clock hours (not a compacted cadence): a
 // bare clock word ("9点") would hide the :00 and leave the second dangling
 // ("…9点每秒"), reading as the whole hour. Fuse the seconds with the explicit
@@ -907,14 +966,24 @@ function composeMinuteZeroClocks(schedule: Schedule, sec: string): string {
     // midnight (凌晨0点) and other hours still need it to pin the minute.
     return hour === 12 ? '正午' : hourWord(hour) + '0分';
   });
-  // A pinned minute makes the seconds' own "每分钟" anchor misleading (it is a
-  // single minute, not every minute), so the stride here drops it.
+  const core = joinAnd(clocks) + minuteZeroSecondTail(schedule, sec);
+
+  return isDaily(schedule) ? '每天' + core : core;
+}
+
+// The "的"-fused second tail for a clock time that already names a single pinned
+// minute ("…的每一秒" for a wildcard second, else "…的" + the second's clause).
+// A pinned minute makes the seconds' own "每分钟" anchor misleading (it is a
+// single minute, not every minute), so a stride here drops it.
+function minuteZeroSecondTail(schedule: Schedule, sec: string): string {
+  if (sec === '每秒') {
+    return '的每一秒';
+  }
+
   const nested =
     strideFromSegments(segmentsOf(schedule, 'second'), '秒', '秒', '');
-  const tail = sec === '每秒' ? '的每一秒' : '的' + (nested ?? sec);
-  const core = joinAnd(clocks) + tail;
 
-  return isDaily(schedule) ? '每天' + core : core;
+  return '的' + (nested ?? sec);
 }
 
 // Whether the hour field is a range — or a list whose segments include a
@@ -1004,18 +1073,75 @@ function composeSecondsListed(schedule: Schedule): string {
   }
 
   if (schedule.shapes.hour === 'wildcard') {
-    return minutes + '，' + sec;
+    // A wildcard or stepped second is a cadence; the bare comma ("每小时30分，
+    // 每秒") reads as two independent cadences, so fuse the second beneath the
+    // stated minute(s) with "的" ("每小时30分的每一秒"), the same confinement the
+    // minute-stride and pinned-clock paths use. A single/list/range second is a
+    // clock-point, not a cadence, so it keeps the comma.
+    return secondIsCadence(schedule) ?
+      minutes + confinedSecondTail(sec) : minutes + '，' + sec;
   }
 
   const hourCad = unevenHourCadence(schedule);
 
   if (hourCad !== null) {
-    return hourCad + '，' + minutes + '，' + sec;
+    // An hour STEP cadence is the sole hour authority, so the minute clause
+    // drops its "每小时" ("每2小时，0至30分，每秒"); a discrete hour list keeps it
+    // (it falls through to the hourFrame branch below with a null cadence).
+    return hourCad + '，' + withoutHourAnchor(minutes) + '，' + sec;
   }
 
   return hourFrame(schedule) + minutes + '，' + sec;
 }
 
+// Whether the minute field is a stepped cadence (a clean `*/n`, an offset
+// `m/n`, or a uneven step the core enumerated to an arithmetic fire list). The
+// shape the seconds-wildcard confinement below fuses with "的".
+function isMinuteStride(schedule: Schedule): boolean {
+  if (schedule.shapes.minute === 'step') {
+    return true;
+  }
+
+  const values = singleValues(segmentsOf(schedule, 'minute'));
+
+  return values !== null && arithmeticStep(values) !== null;
+}
+
+// Whether the second is a CADENCE (wildcard "每秒" or a clean step "每N秒") rather
+// than a clock-point (a single/list/range). A cadence second under a stated
+// minute fuses beneath it with "的"; a clock-point keeps the "，" connector.
+function secondIsCadence(schedule: Schedule): boolean {
+  return schedule.pattern.second === '*' || schedule.shapes.second === 'step';
+}
+
+// The "的"-fused second tail for a clause that already states its minute(s):
+// "的每一秒" for a wildcard second, else "的" + the second's own cadence clause.
+// The fusion binds the second beneath the minute rather than leaving a bare
+// trailing "每秒" that reads as a second, independent cadence.
+function confinedSecondTail(sec: string): string {
+  return sec === '每秒' ? '的每一秒' : '的' + sec;
+}
+
+// Whether a compose-seconds plan is a stepped minute under a cadence second and
+// wildcard hour — the shape the "的"-fused confinement below handles, kept
+// distinct from the */2 even-minutes idiom and the composed-clock paths.
+function isSteppedMinuteSeconds(
+  schedule: Schedule, composedClock: boolean
+): boolean {
+  return !composedClock && schedule.shapes.hour === 'wildcard' &&
+    secondIsCadence(schedule) && schedule.pattern.minute !== '*/2' &&
+    isMinuteStride(schedule);
+}
+
+// A stepped minute under a cadence second and wildcard hour: fuse the minute
+// cadence and the second cadence with "的" ("每小时从4分起每6分钟的每一秒"), never
+// the comma juxtaposition ("…每6分钟，每秒") that reads as two independent
+// cadences. The minute clause carries the offset/bound ("从4分起" / "，至58分").
+function minuteStrideConfinement(schedule: Schedule): string {
+  return minuteHourClause(schedule) +
+    confinedSecondTail(secondClause(schedule));
+}
+
 // Seconds composed with the minute/hour structure, dispatched on the minute.
 // A single minute over a composed clock-time rest (the core already joined the
 // lone hour and minute into "N点M分") keeps that composition, attaching the
@@ -1028,6 +1154,13 @@ function renderComposeSeconds(
   const composedClock =
     rest.kind === 'clockTimes' || rest.kind === 'compactClockTimes';
 
+  // A stepped minute under a cadence second and wildcard hour confines the
+  // second beneath the minute cadence with "的", never the comma that reads as
+  // two independent cadences. The */2 step keeps its own "每偶数分钟" idiom.
+  if (isSteppedMinuteSeconds(schedule, composedClock)) {
+    return minuteStrideConfinement(schedule);
+  }
+
   if (schedule.pattern.minute === '0' ||
     composedClock && schedule.shapes.minute === 'single') {
     return composeSecondsOnHour(schedule, plan, opts);