cronli5 0.8.3 → 0.8.5

package/src/lang/fi/index.ts

@@ -346,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);
@@ -480,6 +487,68 @@ function isSteppedMinuteSeconds(
     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'}>,
@@ -505,6 +574,14 @@ function renderComposeSeconds(
     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

@@ -127,16 +127,6 @@ 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 || {};
@@ -227,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);
 }
@@ -309,30 +307,22 @@ function minuteStride(
   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(
+// 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,
-  stride: {start: number; interval: number; last: number},
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
+  lead: string,
   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);
+  return lead + ', ' + render(schedule, plan.rest, opts) +
+    trailingQualifier(schedule, opts);
 }
 
 // Whether a stepped minute fills a wildcard hour under a wildcard/stepped
@@ -350,6 +340,108 @@ function isSteppedMinuteSeconds(
     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'}>,
@@ -397,8 +489,15 @@ function renderComposeSeconds(
   // 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 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

package/src/lang/pt/index.ts

@@ -144,16 +144,6 @@ 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
@@ -358,6 +348,14 @@ function renderSecondsWithinMinute(
       trailingQualifier(schedule, opts);
   }
 
+  // A second LIST or RANGE under a single minute confines that minute in the
+  // genitive ("nos segundos 5 e 10 do minuto 30 de cada hora"), 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) + ', no minuto ' + minuteField +
     ' de cada hora' + trailingQualifier(schedule, opts);
 }
@@ -444,29 +442,21 @@ function minuteStride(
 }
 
 // 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(
+// second clause leads, a COMMA, then the minute's own STANDALONE cardinal
+// cadence ("a cada segundo, a cada seis minutos a partir do minuto 4 de cada
+// hora"; "nos segundos 5, 10 e 15, a cada seis minutos …"). The ordinal "no
+// sexto minuto" read as a single minute (the 10th), not the every-sixth series;
+// the standalone cardinal "a cada seis minutos" 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 otherwise.
+function steppedMinuteConfinement(
   schedule: Schedule,
-  stride: {start: number; interval: number; last: number},
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
+  lead: string,
   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);
+  return lead + ', ' + render(schedule, plan.rest, opts) +
+    trailingQualifier(schedule, opts);
 }
 
 // Whether a stepped minute fills a wildcard hour under a wildcard/stepped
@@ -484,6 +474,108 @@ function isSteppedMinuteSeconds(
     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 ("do
+// sexto minuto…"), 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 'a cada segundo do ' + bounds[0] + ' ao ' + bounds[1];
+  }
+
+  if (shape === 'single') {
+    return 'no segundo ' + secondField;
+  }
+
+  return 'nos segundos ' +
+    joinList(segmentWords(segmentsOf(schedule, 'second')));
+}
+
+// The CONFINED-minute genitive phrase a clock-point second attaches to ("dos
+// minutos 0, 15 e 30 de cada hora", "do minuto 30 de cada hora", "de cada
+// minuto do 0 ao 30 de cada hora"). A stepped minute is handled by the
+// standalone-cadence confinement before this point; a list, range, or single
+// names the minute(s) — so the bare seconds lead never stacks a redundant "de
+// cada minuto".
+function confinedMinutePhrase(schedule: Schedule): string {
+  if (schedule.shapes.minute === 'range') {
+    // `minuteRangeLead` is "a cada minuto do 0 ao 30"; the genitive "de"
+    // absorbs its leading "a" ("de cada minuto …", not "de a cada minuto").
+    const range = minuteRangeLead(schedule.pattern.minute).replace(/^a /u, '');
+
+    return 'de ' + range + ' de cada hora';
+  }
+
+  if (schedule.shapes.minute === 'list') {
+    return 'dos minutos ' +
+      joinList(segmentWords(segmentsOf(schedule, 'minute'))) + ' de cada hora';
+  }
+
+  return 'do 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 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 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 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'}>,
@@ -527,12 +619,15 @@ 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 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 ("a cada segundo no sexto
+  // minuto …"); a CLOCK-POINT second uses the genitive form anchored to the
+  // confined minute ("nos segundos 5, 10 e 15 do 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

package/src/lang/zh/index.ts

@@ -833,8 +833,12 @@ function secondClause(schedule: Schedule): string {
 
   const first = segs[0];
 
-  if (segs.length === 1 && first.kind === 'step' && first.startToken === '*') {
-    return cadence(first.interval, UNITS.second);
+  // A STEP-shaped second reads as its stride cadence ("每6秒"), whether written
+  // "*/6" or the offset-clean "0/6" — both fire 0,6,…,54 — never the enumerated
+  // "第0、6、…、54秒". stepClause routes a clean/offset-clean stride through the
+  // bare cadence and only lists a bounded `a-b/n` or a short offset.
+  if (segs.length === 1 && first.kind === 'step') {
+    return stepClause(first, '秒', '秒', '每分钟');
   }
 
   // An offset/uneven step the core enumerated to this list reads as a stride
@@ -1044,6 +1048,13 @@ function composeSecondsCadence(schedule: Schedule): string {
       }
     }
 
+    // A CLOCK-POINT second (a single/list/range, not a stride cadence) under a
+    // clean minute step fuses beneath the minute with "的" ("每6分钟的第30秒"),
+    // never the comma that reads as two independent schedules.
+    if (!secondIsCadence(schedule) && !secondIsStride(schedule)) {
+      return minuteClause(schedule) + '的' + sec;
+    }
+
     return sec + '，' + minuteClause(schedule);
   }
 
@@ -1073,13 +1084,14 @@ function composeSecondsListed(schedule: Schedule): string {
   }
 
   if (schedule.shapes.hour === 'wildcard') {
-    // 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;
+    // The minute(s) are stated and the hour is open, so the second — whether a
+    // cadence ("每秒"/"每N秒") or a clock-point ("第5、10、15秒") — fuses beneath
+    // the minute(s) with "的" ("每小时30分的每一秒", "每小时0、15、30分的第5、10、15
+    // 秒"). The bare comma ("…，第5、10、15秒") reads as two independent schedules.
+    // A second STRIDE the core enumerated to a list ("3/2" → "每2秒，至59秒") is a
+    // bounded cadence with its own trailing "，至N秒"; it keeps the comma.
+    return secondIsStride(schedule) ?
+      minutes + '，' + sec : minutes + confinedSecondTail(sec);
   }
 
   const hourCad = unevenHourCadence(schedule);
@@ -1114,6 +1126,20 @@ function secondIsCadence(schedule: Schedule): boolean {
   return schedule.pattern.second === '*' || schedule.shapes.second === 'step';
 }
 
+// Whether a second LIST is really a stride the core enumerated from a step
+// ("3/2" → 3,5,…,59), spoken as a bounded cadence ("每2秒，至59秒") with its own
+// trailing comma — not a clock-point list ("第5、10、15秒"). Such a stride keeps
+// its comma form rather than fusing beneath the minute with "的".
+function secondIsStride(schedule: Schedule): boolean {
+  if (schedule.shapes.second !== 'list') {
+    return false;
+  }
+
+  const values = singleValues(segmentsOf(schedule, 'second'));
+
+  return values !== null && arithmeticStep(values) !== null;
+}
+
 // 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