cronli5 0.1.4 → 0.1.6

package/src/lang/zh/index.ts

@@ -4,8 +4,8 @@
 // big-endian dates, 每 for recurrence, 24-hour clock with 凌晨0点/正午 anchors,
 // day periods under `ampm`. The style contract is src/lang/zh/notes.md.
 
-import {toFieldNumber} from '../../core/util.js';
-import {monthNumbers, weekdayNumbers} from '../../core/specs.js';
+import {arithmeticStep, toFieldNumber} from '../../core/util.js';
+import {maxClockTimes, monthNumbers, weekdayNumbers} from '../../core/specs.js';
 import type {Cronli5Options} from '../../types.js';
 import type {
   Field, IR, Language, NormalizedOptions, PlanNode, Segment
@@ -43,6 +43,108 @@ function cadence(interval: number, unit: string): string {
   return interval === 1 ? '每' + unit : '每' + interval + unit;
 }
 
+// A step cadence to phrase over a `cycle`-long field (60 for minute/second),
+// running from `start` to `last`. `unit` is the cadence noun ("分钟"/"秒"),
+// `mark` the bound measure word ("分"/"秒"), `anchor` the larger frame
+// ("每小时"/"每分钟").
+interface Stride {
+  interval: number;
+  start: number;
+  last: number;
+  cycle: number;
+  unit: string;
+  mark: string;
+  anchor: string;
+}
+
+// Speak a step cadence over a `cycle`-long field. A clean stride from the top
+// of the cycle is the bare cadence ("每2分钟"); a uniform offset (start within
+// the first interval, the interval still dividing the cycle) names only its
+// start, since it wraps cleanly with no distinct endpoint ("每小时从5分起每6分
+// 钟"); a non-uniform stride (start >= interval, or an interval that does not
+// divide the cycle) pins both endpoints so the bounded, non-wrapping set reads
+// unambiguously ("每小时从3分起每2分钟，至59分"). This is the one phrasing for
+// every step the renderer speaks, whether the core kept it a step shape (a
+// clean cadence) or enumerated it to a fire list (an offset/uneven set the
+// list path recognizes as a progression).
+function renderStride(stride: Stride): string {
+  const {interval, start, last, cycle, unit, mark, anchor} = stride;
+  const tiles = cycle % interval === 0;
+
+  if (start === 0 && tiles) {
+    return cadence(interval, unit);
+  }
+
+  const lead = anchor + '从' + start + mark + '起' + cadence(interval, unit);
+
+  return start < interval && tiles ? lead : lead + '，至' + last + mark;
+}
+
+// The sorted numeric values a field's segments cover, or null if any segment
+// is not a discrete single (a range or sub-step is not a plain fire list).
+function singleValues(segments: Segment[]): number[] | null {
+  const values: number[] = [];
+
+  for (const segment of segments) {
+    if (segment.kind !== 'single') {
+      return null;
+    }
+
+    values.push(+segment.value);
+  }
+
+  return values;
+}
+
+// Speak a minute/second field's enumerated fires as a step cadence when they
+// form an arithmetic progression long enough to beat the list (the core
+// enumerates an offset/uneven step to this fire list; the IR is unchanged, so
+// the renderer recognizes the progression). Returns null for a non-progression
+// or a too-short list, leaving the caller to enumerate.
+function strideFromSegments(
+  segments: Segment[],
+  unit: string,
+  mark: string,
+  anchor: string
+): string | null {
+  const values = singleValues(segments);
+  const step = values && arithmeticStep(values);
+
+  return step ?
+    renderStride({...step, cycle: 60, unit, mark, anchor}) :
+    null;
+}
+
+// A step *shape* segment as its cadence ("每小时从5分起每6分钟"). A bounded
+// sub-range step (`a-b/n`) is not a whole-cycle stride, so it lists its fires;
+// a short offset cadence (three fires or fewer) also lists, since the list is
+// no longer than the cadence. Everything else routes through `renderStride`.
+// The uneven whole-cycle step never reaches here as a step shape — the core
+// enumerates it to a fire list, which the list path recognizes instead.
+function stepClause(
+  segment: StepSegment,
+  unit: string,
+  mark: string,
+  anchor: string
+): string {
+  const start = segment.startToken === '*' ? 0 : +segment.startToken;
+  const short = start !== 0 && segment.fires.length <= 3;
+
+  if (segment.startToken.indexOf('-') !== -1 || short) {
+    return anchor + segment.fires.join('、') + mark;
+  }
+
+  return renderStride({
+    interval: segment.interval,
+    start,
+    last: segment.fires[segment.fires.length - 1],
+    cycle: 60,
+    unit,
+    mark,
+    anchor
+  });
+}
+
 // The day period a 12-hour clock prepends under `ampm` (notes.md boundaries).
 function dayPeriod(hour: number): string {
   if (hour < 6) {
@@ -193,13 +295,49 @@ function renderEveryHour(): string {
 }
 
 // A minute anchored to the hour: "每小时1分", "每小时5分和30分", "每小时0至30分".
+// A regular step reads as a stride cadence ("每小时从3分起每2分钟，至59分"),
+// whether the core kept it a step shape (a uniform offset divides 60) or
+// enumerated it to a fire list (an offset/uneven set) — both route through the
+// stride; a short or irregular set keeps the enumerated "每小时…分" list.
+function minuteHourClause(ir: IR): string {
+  const segments = fieldSegments(ir, 'minute');
+
+  if (ir.shapes.minute === 'step') {
+    return stepClause(stepSegment(ir, 'minute'), '分钟', '分', '每小时');
+  }
+
+  return strideFromSegments(segments, '分钟', '分', '每小时') ??
+    '每小时' + valueList(segments, '分');
+}
+
 function renderMinutePast(ir: IR): string {
-  return '每小时' + valueList(fieldSegments(ir, 'minute'), '分');
+  return minuteHourClause(ir);
+}
+
+// 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
+// as the span the source wrote, not the hours it expands to — the same choice
+// en/es/de/fi make ("from 9 a.m. through 8 p.m. and at 10 p.m.").
+function hourSegmentWords(segment: Segment): string[] {
+  if (segment.kind === 'range') {
+    return [hourWord(+segment.bounds[0]) + '至' + hourWord(+segment.bounds[1])];
+  }
+
+  if (segment.kind === 'step') {
+    return segment.fires.map(hourWord);
+  }
+
+  return [hourWord(+segment.value)];
 }
 
-// The hour list as clock words: "9点、11点和13点".
+// The hour field as clock words, by segment form: "9点、11点和13点" for a list
+// of singles, "9点至20点和22点" for a range plus a single. Each segment renders
+// as the operator the source wrote (range → span), not its expanded fires.
 function hourList(ir: IR): string {
-  return joinAnd(hourFires(ir).map(hourWord));
+  const words = fieldSegments(ir, 'hour').flatMap(hourSegmentWords);
+
+  return joinAnd(words);
 }
 
 // A frame that confines a cadence to active hours: a range gives "在F点至T点之
@@ -218,21 +356,22 @@ function hourFrame(ir: IR): string {
 // A repeating minute step, optionally confined to active hours.
 function renderMinuteFrequency(ir: IR, plan: PlanNode): string {
   const minuteStep = stepSegment(ir, 'minute');
-  // A "每N分钟" cadence is only faithful from the top of the hour; an offset
-  // step (5/6 fires at :05,:11,…) enumerates its fires instead.
-  const base = minuteStep.startToken === '*' ?
-    cadence(minuteStep.interval, UNITS.minute) :
-    renderMinutePast(ir);
+  // A clean stride is the bare "每N分钟" cadence; an offset step keeps its start
+  // ("每小时从5分起每6分钟"). A short offset cadence still lists its fires.
+  const base = stepClause(minuteStep, UNITS.minute, '分', '每小时');
   const {hours} = plan as Extract<PlanNode, {kind: 'minuteFrequency'}>;
 
-  if (hours.kind === 'step') {
-    const hourStep = stepSegment(ir, 'hour');
+  // An hour stride (a clean step, or an offset/non-tiling progression the core
+  // kept a step shape or enumerated to a list) leads the minute cadence:
+  // "每2小时每5分钟", "从2点起每6小时每15分钟". A clean cadence concatenates as
+  // before; a bounded cadence ends on "至K点", so a comma keeps that endpoint
+  // from gluing onto the minute clause ("从9点起每2小时，至17点，每2分钟").
+  if (hours.kind === 'step' || hours.kind === 'during') {
+    const hourCad = hourCadencePhrase(ir);
 
-    // "每N小时" is only faithful from midnight; an offset step (2/6 fires at
-    // 2,8,14,20) enumerates its hours instead.
-    return hourStep.startToken === '*' ?
-      cadence(hourStep.interval, UNITS.hour) + base :
-      '在' + hourList(ir) + '，' + base;
+    if (hourCad !== null) {
+      return hourCad + (hourCad.indexOf('至') === -1 ? '' : '，') + base;
+    }
   }
 
   if (hours.kind === 'single' ||
@@ -268,16 +407,20 @@ function renderMinuteSpanInHour(ir: IR, plan: PlanNode): string {
 }
 
 // A minute clause across discrete hours. A wildcard minute reads "在9点、11点…，
-// 每分钟"; a ranged/listed minute names it: "9点和17点，每小时0至30分，每分钟".
+// 每分钟"; a ranged/listed minute names it: "9点和17点，每小时0至30分，每分钟". An
+// hour progression reads as its cadence ("从9点起每2小时，至17点，每分钟") rather
+// than the enumerated hours, the same idiom the minute field uses.
 function renderMinutesAcrossHours(ir: IR, plan: PlanNode): string {
   const {form} = plan as Extract<PlanNode, {kind: 'minutesAcrossHours'}>;
+  const hourCad = hourCadencePhrase(ir);
 
   if (form === 'wildcard') {
-    return '在' + hourList(ir) + '，每分钟';
+    return hourCad === null ?
+      '在' + hourList(ir) + '，每分钟' :
+      hourCad + '，每分钟';
   }
 
-  return hourList(ir) + '，每小时' +
-    valueList(fieldSegments(ir, 'minute'), '分') + '，每分钟';
+  return (hourCad ?? hourList(ir)) + '，' + minuteHourClause(ir) + '，每分钟';
 }
 
 // A minute clause across a stepped hour field. A wildcard minute reads "每2小时
@@ -285,16 +428,23 @@ function renderMinutesAcrossHours(ir: IR, plan: PlanNode): string {
 function renderMinuteSpanAcrossHourStep(ir: IR, plan: PlanNode): string {
   const hourStep = stepSegment(ir, 'hour');
   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.
+  if (form === 'list') {
+    return hourCadencePhrase(ir) + '，' + renderMinutePast(ir);
+  }
+
   const minuteTail = form === 'wildcard' ?
     '每分钟' :
-    '每小时' + valueList(fieldSegments(ir, 'minute'), '分') + '，每分钟';
+    minuteHourClause(ir) + '，每分钟';
 
-  // An offset stride (2/6 fires at 2,8,14,20) enumerates its hours like a
-  // discrete list; "每N小时" is faithful only from midnight.
+  // 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
+  // named minute follows the cadence and its own comma.
   if (hourStep.startToken !== '*') {
-    return form === 'wildcard' ?
-      '在' + hourList(ir) + '，' + minuteTail :
-      hourList(ir) + '，' + minuteTail;
+    return hourCadencePhrase(ir) + '，' + minuteTail;
   }
 
   // A step-2 hour from midnight IS exactly the even hours; name them so, rather
@@ -312,6 +462,14 @@ function renderMinuteSpanAcrossHourStep(ir: IR, plan: PlanNode): string {
 
 // Discrete clock times: "9点", "9点和17点".
 function renderClockTimes(ir: IR, plan: PlanNode, opts: Opts): string {
+  // An hour step (or arithmetic-progression hour list) under a single pinned
+  // minute reads as a cadence rather than a cross-product of clock times.
+  const cad = hourCadenceText(ir);
+
+  if (cad !== null) {
+    return cad;
+  }
+
   const {times} = plan as Extract<PlanNode, {kind: 'clockTimes'}>;
 
   return joinAnd(times.map((t) => clockTime(t.hour, t.minute, t.second, opts)));
@@ -320,14 +478,38 @@ function renderClockTimes(ir: IR, plan: PlanNode, opts: Opts): string {
 // Compact clock times past the cap: the hour list (the minute is folded in),
 // with a fixed second appended ("…，第30秒").
 function renderCompactClockTimes(ir: IR, plan: PlanNode): string {
-  const {minute} = plan as Extract<PlanNode, {kind: 'compactClockTimes'}>;
+  // An hour step (or arithmetic-progression hour list) under the single pinned
+  // minute reads as a cadence, not a wall of clock times. (Returns null for an
+  // irregular list or a range, which keep enumerating below.)
+  const cad = hourCadenceText(ir);
+
+  if (cad !== null) {
+    return cad;
+  }
+
+  const compact = plan as Extract<PlanNode, {kind: 'compactClockTimes'}>;
   const secs = fieldSegments(ir, 'second');
   const tail = secs.length && ir.pattern.second !== '0' ?
     '，第' + valueText(secs) + '秒' : '';
 
-  if (minute > 0) {
-    return '每小时' + valueList(fieldSegments(ir, 'minute'), '分') +
-      '，在' + hourList(ir) + tail;
+  // A multi-valued minute (`fold` false) names its whole set, never just its
+  // first fire — a list starting at 0 ("*/25" -> :00,:25,:50) must keep the
+  // minute clause, not drop it because the leading fire is 0. The hour reads as
+  // its bounded cadence when its fires form a progression ("从0点起每5小时，至20
+  // 点"), composed after the minute set, the same idiom the stepped-hour path
+  // uses; an irregular hour list keeps enumerating with the "在…" frame.
+  if (!compact.fold) {
+    const hourCad = hourCadencePhrase(ir);
+
+    return hourCad === null ?
+      minuteHourClause(ir) + '，在' + hourList(ir) + tail :
+      hourCad + '，' + minuteHourClause(ir) + tail;
+  }
+
+  // A single pinned minute past 0 leads with its clause; a pinned 0 folds into
+  // the hour times (the :00 is implicit).
+  if (compact.minute > 0) {
+    return minuteHourClause(ir) + '，在' + hourList(ir) + tail;
   }
 
   return hourList(ir) + tail;
@@ -340,7 +522,7 @@ function renderHourRange(ir: IR, plan: PlanNode): string {
   if (range.minuteForm === 'lead') {
     const minuteSegs = fieldSegments(ir, 'minute');
     const past = minuteSegs.length && ir.pattern.minute !== '0' ?
-      '每小时' + valueList(minuteSegs, '分') : '每小时';
+      minuteHourClause(ir) : '每小时';
 
     return '在' + hourWord(range.from) + '至' + hourWord(range.to) +
       '之间，' + past;
@@ -356,27 +538,149 @@ function renderHourRange(ir: IR, plan: PlanNode): string {
     range.last + '分之间，每分钟';
 }
 
-// A stepped hour field: "每2小时", or its two fires as clock words when the
-// stride fires only twice. An uneven stride (one that does not divide 24) is
-// rewritten to its fire list upstream and never reaches here.
+// A stepped hour field as its cadence: "每2小时" (clean), "从1点起每2小时"
+// (offset), "从9点起每2小时，至17点" (bounded). A stride that fires only twice
+// reads instead as its two clock words ("凌晨0点和正午", "8点和20点"), shorter and
+// clearer than a cadence for a pair.
 function renderHourStep(ir: IR): string {
   const segment = stepSegment(ir, 'hour');
 
-  if (segment.startToken !== '*') {
-    return hourList(ir);
-  }
-
-  // A step that fires only twice reads as two clock times ("凌晨0点和正午").
   if (segment.fires.length <= 2) {
     return joinAnd(segment.fires.map(hourWord));
   }
 
-  return cadence(segment.interval, UNITS.hour);
+  return hourCadencePhrase(ir) as string;
+}
+
+// --- Hour-step cadence (the 24-cycle analog of renderStride). ---
+
+// The hour field's stride, or null when the hour is not a cadence: a step
+// segment yields its {interval, start, last}; an all-single hour list yields
+// one only when its values form a long-enough arithmetic progression (so an
+// irregular list, or a too-short one like 9,17, keeps enumerating). An offset
+// (start > 0) or non-tiling (interval ∤ 24) stride is still a cadence — Chinese
+// names its start and endpoint ("从M点起每N小时，至K点"), the same idiom the
+// minute field already uses — so it is no longer rejected. The IR is unchanged.
+function hourStride(
+  ir: IR
+): {interval: number; start: number; last: number} | null {
+  const segments = fieldSegments(ir, 'hour');
+
+  if (segments.length === 1 && segments[0].kind === 'step') {
+    const {fires, interval} = segments[0];
+
+    return {interval, start: fires[0], last: fires[fires.length - 1]};
+  }
+
+  const values = singleValues(segments);
+
+  return values && arithmeticStep(values);
+}
+
+// The hour field's cadence phrase ("每2小时", "从1点起每2小时", "从0点起每5小时，
+// 至20点"), or null when the hour is not a single arithmetic progression (an
+// irregular list, a range, or a too-short list keeps enumerating). The 24-cycle
+// analog of strideFromSegments — it routes the stride through the one phrasing
+// renderStride speaks, so a clean, offset, or non-tiling hour stride all read
+// as the cadence the equivalent minute step does.
+function hourCadencePhrase(ir: IR): string | null {
+  const stride = hourStride(ir);
+
+  return stride && renderStride({
+    ...stride, cycle: 24, unit: UNITS.hour, mark: '点', anchor: ''
+  });
+}
+
+// Render an hour step (or arithmetic-progression hour list) under a single
+// pinned minute and a second as a cadence — the hour cadence plus the
+// minute/second — instead of cross-multiplying the hours into a wall of clock
+// times. Returns null when the hour is not a stride, when the cross-product is
+// short enough that enumeration is no longer than the cadence (a meaningful
+// second makes every clock time carry a second, so any stride is worth
+// compacting; otherwise the stride must exceed the clock-time cap, the same
+// point at which the core itself stops enumerating), or when the cadence is
+// bounded ("…，至K点"): a trailing minute fused onto its endpoint ("至20点0分")
+// would read as a clock time, so a bounded stride keeps enumerating its fused
+// clock times here, naming the cadence only where no minute follows it (the
+// bare hour field). Renderer-only; the IR is unchanged.
+function hourCadence(ir: IR): string | null {
+  const stride = hourStride(ir);
+
+  if (!stride) {
+    return null;
+  }
+
+  const fires = (stride.last - stride.start) / stride.interval + 1;
+
+  if (ir.pattern.second === '0' && fires <= maxClockTimes) {
+    return null;
+  }
+
+  const prefix = hourCadencePhrase(ir) as string;
+
+  // A bounded cadence cannot carry a fused minute unambiguously; enumerate.
+  if (prefix.indexOf('至') !== -1) {
+    return null;
+  }
+
+  const minute = +ir.pattern.minute;
+  const subMinute = ir.pattern.second === '*' || ir.shapes.second === 'step';
+
+  // A wildcard or sub-minute step second confined to minute 0 of the even-hour
+  // stride is a confinement, not a juxtaposed cadence. Reuse the even-hours
+  // idiom ("在偶数小时0分的每一秒") so the form does NOT contain the bare "每2小时"
+  // and can never be misread as the absorbing hour cadence (the same reason en
+  // says "for one minute during every other hour", not "every two hours"). The
+  // idiom exists only for the even-hour stride (interval 2 from midnight);
+  // another stride keeps enumerating (return null) rather than coin a
+  // misleading "…小时…" form.
+  if (minute === 0 && subMinute) {
+    return stride.interval === 2 && stride.start === 0 ?
+      '在偶数小时0分' + secondTail(ir) : null;
+  }
+
+  // A pinned minute 0 folds into the cadence with the explicit "0分" so the
+  // confinement stays visible ("每2小时0分的第30秒"); a non-zero minute is a real
+  // clock minute named after the cadence ("每2小时5分的每一秒"). A plain :00
+  // second adds nothing.
+  if (minute === 0) {
+    return prefix + '0分' + secondTail(ir);
+  }
+
+  return ir.pattern.second === '0' ?
+    prefix + minute + '分' :
+    prefix + minute + '分' + secondTail(ir);
+}
+
+// The cadence a clock-point core (clockTimes/compactClockTimes/composeSeconds)
+// renders an hour stride to, or null. A bare hour stride (minute 0 on the plain
+// :00 second) is the cadence phrase itself — "每2小时", "从0点起每5小时，至20点" —
+// so a short non-tiling stride like */5, which hourCadence keeps enumerating
+// (no minute to fold, nothing to disambiguate), still reads as the cadence. A
+// pinned minute or meaningful second folds into the cadence via hourCadence.
+function hourCadenceText(ir: IR): string | null {
+  if (ir.shapes.minute !== 'single') {
+    return null;
+  }
+
+  if (+ir.pattern.minute === 0 && ir.pattern.second === '0') {
+    return hourCadencePhrase(ir);
+  }
+
+  return hourCadence(ir);
+}
+
+// The fused second tail for an hour cadence: "的每一秒" for a wildcard second,
+// else "的" + the second's own clause ("的第30秒", "的每15秒").
+function secondTail(ir: IR): string {
+  const sec = secondClause(ir);
+
+  return sec === '每秒' ? '的每一秒' : '的' + sec;
 }
 
 // A continuous minute range fires every minute within it: "每小时0至30分，每分钟".
 function renderRangeOfMinutes(ir: IR): string {
-  return '每小时' + valueList(fieldSegments(ir, 'minute'), '分') + '，每分钟';
+  return minuteHourClause(ir) + '，每分钟';
 }
 
 // A standalone second field: "每7秒" (step cadence) or "每分钟第4、17、42秒".
@@ -388,7 +692,8 @@ function renderStandaloneSeconds(ir: IR): string {
     return cadence(first.interval, UNITS.second);
   }
 
-  return '每分钟第' + valueText(segs) + '秒';
+  return strideFromSegments(segs, '秒', '秒', '每分钟') ??
+    '每分钟第' + valueText(segs) + '秒';
 }
 
 // A second anchored to the minute: "每分钟第1秒", "每分钟第4、17、42秒".
@@ -423,7 +728,10 @@ function secondClause(ir: IR): string {
     return cadence(first.interval, UNITS.second);
   }
 
-  return '第' + valueText(segs) + '秒';
+  // An offset/uneven step the core enumerated to this list reads as a stride
+  // cadence when the fires form a long-enough progression.
+  return strideFromSegments(segs, '秒', '秒', '每分钟') ??
+    '第' + valueText(segs) + '秒';
 }
 
 // The minute clause for a composed (seconds) schedule.
@@ -439,41 +747,46 @@ function minuteClause(ir: IR): string {
   return valueList(fieldSegments(ir, 'minute'), '分');
 }
 
-// Whether the hour field is a true "every N hours" cadence (vs discrete fires
-// like 9-17/2, whose start token is a number).
-function isHourCadence(ir: IR): boolean {
-  return ir.shapes.hour === 'step' &&
-    stepSegment(ir, 'hour').startToken === '*';
+// A single second folds into each clock time a clockTimes rest renders
+// ("9点5分30秒"), so it is already spoken; appending the second clause again
+// would double it. A wildcard/list/range second does not fold, so it still
+// leads its own clause after the clock times.
+function clockRestCarriesSecond(rest: PlanNode): boolean {
+  return rest.kind === 'clockTimes' &&
+    rest.times.some((time) => Boolean(time.second));
 }
 
 // minute = 0 ("on the hour"): render the rest schedule and attach the second.
 function composeSecondsOnHour(ir: IR, plan: PlanNode, opts: Opts): string {
   const sec = secondClause(ir);
   const {rest} = plan as Extract<PlanNode, {kind: 'composeSeconds'}>;
+  const composedClock =
+    rest.kind === 'clockTimes' || rest.kind === 'compactClockTimes';
 
-  // The minute is pinned to 0 under a specific hour: 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 clock minute ("9点0分
-  // 的每一秒"), so the one-minute confinement (60 fires in :00, not 3,600
-  // across the hour) stays visible. The daily frame leads with 每天; a weekday
-  // or date qualifier is added by describe().
-  if ((rest.kind === 'clockTimes' || rest.kind === 'compactClockTimes') &&
-    ir.pattern.minute === '0') {
-    const clocks = hourFires(ir).map(function clock(hour): string {
-      return hourWord(hour) + '0分';
-    });
-    const tail = sec === '每秒' ? '的每一秒' : '的' + sec;
-    const core = joinAnd(clocks) + tail;
+  // An hour step (or arithmetic-progression hour list) under a single pinned
+  // minute reads as a cadence, not a wall of clock times ("每2小时0分的第30秒").
+  // hourCadence folds in the second itself, so it is returned whole, never the
+  // rest-plus-second fall-through that would double the second clause. The
+  // cadence is sub-daily (no 每天); a qualifier is added by describe().
+  if (composedClock) {
+    const hourCad = hourCadence(ir);
+
+    if (hourCad !== null) {
+      return hourCad;
+    }
+  }
 
-    return isDaily(ir) ? '每天' + core : core;
+  // The minute is pinned to 0 under specific hours that did not compact to a
+  // cadence: fuse the seconds with each explicit clock minute.
+  if (composedClock && ir.pattern.minute === '0') {
+    return composeMinuteZeroClocks(ir, sec);
   }
 
   const restText = render(ir, rest, opts);
+  const secTail = clockRestCarriesSecond(rest) ? '' : sec;
 
-  if (rest.kind === 'clockTimes' || rest.kind === 'compactClockTimes') {
-    if (isDaily(ir)) {
-      return '每天' + restText + sec;
-    }
+  if (composedClock && isDaily(ir)) {
+    return '每天' + restText + secTail;
   }
 
   // A stated minute (e.g. minute 0 under a sub-minute second) takes the same
@@ -482,7 +795,64 @@ function composeSecondsOnHour(ir: IR, plan: PlanNode, opts: Opts): string {
     return restText + '，' + sec;
   }
 
-  return restText + sec;
+  return restText + secTail;
+}
+
+// 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
+// clock minute ("9点0分的每一秒"), so the one-minute confinement (60 fires in
+// :00, not 3,600 across the hour) stays visible. The daily frame leads with
+// 每天; a weekday or date qualifier is added by describe().
+function composeMinuteZeroClocks(ir: IR, sec: string): string {
+  // An hour RANGE (or a list whose segments include a range) reads as the span
+  // the source wrote ("9点至17点"), not the wall of clock words it expands to —
+  // the hour-RANGE analog of the hour-step cadence. A pure single-value list
+  // (9,17) has no range to span and keeps enumerating below.
+  if (hasHourWindow(ir)) {
+    return isDaily(ir) ? '每天' + hourRangeWindow(ir, sec) :
+      hourRangeWindow(ir, sec);
+  }
+
+  const clocks = hourFires(ir).map(function clock(hour): string {
+    // Noon's word (正午) already pins 12:00, so the "0分" is redundant for it;
+    // 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 nested = strideFromSegments(fieldSegments(ir, 'second'), '秒', '秒', '');
+  const tail = sec === '每秒' ? '的每一秒' : '的' + (nested ?? sec);
+  const core = joinAnd(clocks) + tail;
+
+  return isDaily(ir) ? '每天' + core : core;
+}
+
+// Whether the hour field is a range — or a list whose segments include a
+// range — and so forms a window ("9点至17点") rather than a wall of clock
+// words. A pure single-value list (9,17) has no range to span; a step is
+// handled by hourStride/hourCadence.
+function hasHourWindow(ir: IR): boolean {
+  return fieldSegments(ir, 'hour').some(function range(segment) {
+    return segment.kind === 'range';
+  });
+}
+
+// The hour-range window under a pinned minute 0 and a meaningful or wildcard
+// second: the hour span list ("9点至17点", "9点至20点和22点") plus the second.
+// A wildcard or sub-minute step second pins the explicit "0分" so the
+// one-minute confinement stays visible ("9点至17点0分的每一秒"), distinct from
+// the bare hourly window ("在9点至17点之间，每小时"); a single/list/range second
+// reads as a clock-point span with the second appended ("9点至17点，第30秒"),
+// matching the folded compact form for the same shape.
+function hourRangeWindow(ir: IR, sec: string): string {
+  const span = hourList(ir);
+
+  if (ir.pattern.second === '*' || ir.shapes.second === 'step') {
+    return span + '0分' + (sec === '每秒' ? '的每一秒' : '的' + sec);
+  }
+
+  return span + '，' + sec;
 }
 
 // Wildcard or stepped minute: hang the "每分钟/每N分钟每秒" tail off the hour.
@@ -490,8 +860,13 @@ function composeSecondsCadence(ir: IR): string {
   const sec = secondClause(ir);
   const tail = minuteClause(ir) + sec;
 
-  if (isHourCadence(ir)) {
-    return cadence(stepSegment(ir, 'hour').interval, UNITS.hour) + '的' + tail;
+  const hourCad = hourCadencePhrase(ir);
+
+  if (hourCad !== null) {
+    // The cadence absorbs the tail with "的" ("每2小时的每分钟每秒",
+    // "从1点起每2小时的每分钟每秒"); a bounded cadence ends on "至K点", so its tail
+    // takes a comma to keep that endpoint from reading as a fused clock time.
+    return hourCad + (hourCad.indexOf('至') === -1 ? '的' : '，') + tail;
   }
 
   if (ir.shapes.hour === 'single') {
@@ -499,6 +874,18 @@ function composeSecondsCadence(ir: IR): string {
   }
 
   if (ir.shapes.hour === 'wildcard') {
+    // "每秒，每2分钟" juxtaposes two cadences that read as contradictory. A
+    // step-2 minute from the top of the hour IS exactly the even minutes; bind
+    // the every-second cadence to them ("每偶数分钟的每一秒") rather than listing
+    // the two side by side. Other strides keep the juxtaposed form.
+    if (ir.shapes.minute === 'step' && sec === '每秒') {
+      const minuteStep = stepSegment(ir, 'minute');
+
+      if (minuteStep.startToken === '*' && minuteStep.interval === 2) {
+        return '每偶数分钟的每一秒';
+      }
+    }
+
     return sec + '，' + minuteClause(ir);
   }
 
@@ -511,23 +898,30 @@ function composeSecondsCadence(ir: IR): string {
 // last fire onto the window end ("…17点30分") and reading as a continuous span.
 function composeSecondsListed(ir: IR): string {
   const sec = secondClause(ir);
-  const minutes = '每小时' + valueList(fieldSegments(ir, 'minute'), '分');
+  const minutes = minuteHourClause(ir);
 
   // A single restricted hour with an every-second cadence fuses the clock time
   // with its minutes — "凌晨0点5、20、35、50分的每一秒" — rather than the "每小时"
   // that falsely implies every hour. A non-wildcard second keeps the list form.
+  // A non-uniform minute step the core enumerated to a fire list reads as its
+  // stride cadence ("凌晨0点从3分起每2分钟，至59分的每一秒"); the hour fuses, so the
+  // stride drops its "每小时" anchor. A short or irregular set keeps the list.
   if (ir.shapes.hour === 'single' && sec === '每秒') {
-    return hourWord(hourFires(ir)[0]) +
-      valueList(fieldSegments(ir, 'minute'), '分') + '的每一秒';
+    const minuteSegs = fieldSegments(ir, 'minute');
+    const minuteCad = strideFromSegments(minuteSegs, '分钟', '分', '') ??
+      valueList(minuteSegs, '分');
+
+    return hourWord(hourFires(ir)[0]) + minuteCad + '的每一秒';
   }
 
   if (ir.shapes.hour === 'wildcard') {
     return minutes + '，' + sec;
   }
 
-  if (isHourCadence(ir)) {
-    return cadence(stepSegment(ir, 'hour').interval, UNITS.hour) + '，' +
-      minutes + '，' + sec;
+  const hourCad = hourCadencePhrase(ir);
+
+  if (hourCad !== null) {
+    return hourCad + '，' + minutes + '，' + sec;
   }
 
   return hourFrame(ir) + minutes + '，' + sec;
@@ -861,14 +1255,27 @@ function composeWindow(ir: IR, core: string): string {
   return qualifier(ir) + core;
 }
 
+// Whether an hour cadence applies — a single pinned minute over an hour stride
+// (clean, offset, or non-tiling) — so the clock-point plans take the cadence
+// frame, not the daily one.
+function hourCadenceApplies(ir: IR): boolean {
+  return hourCadenceText(ir) !== null;
+}
+
 function describe(ir: IR, opts: Opts): string {
   const {kind} = ir.plan;
   const core = render(ir, ir.plan, opts);
   let composed = core;
 
+  // An hour step (or arithmetic-progression hour list) under a single pinned
+  // minute is a sub-daily cadence, not a daily clock point — it takes the
+  // cadence frame (no 每天), like the bare "每2小时" form.
+  if (hourCadenceApplies(ir)) {
+    composed = composeCadence(ir, core);
+  }
   // A compact clock list with a minute past the hour ("每小时5分…") reads as a
   // cadence, not a daily clock point — no 每天.
-  if (kind === 'clockTimes' ||
+  else if (kind === 'clockTimes' ||
     kind === 'compactClockTimes' && ir.pattern.minute === '0') {
     composed = composePoint(ir, core);
   }