cronli5 0.2.0 → 0.2.1

package/src/lang/fi/index.ts

@@ -11,8 +11,10 @@
 
 import {clockDigits, numeral} from '../../core/format.js';
 import {maxClockTimes, weekdayNumbers} from '../../core/specs.js';
+import {isOpenStep} from '../../core/shapes.js';
 import {
-  arithmeticStep, orderWeekdaysForDisplay, toFieldNumber
+  arithmeticStep, hourListStride, offsetCleanStride, orderWeekdaysForDisplay,
+  segmentsOf, singleValues, stepSegment, toFieldNumber
 } from '../../core/util.js';
 import {resolveDialect} from './dialects.js';
 import type {
@@ -39,12 +41,6 @@ interface HourWindow {
   last: number;
 }
 
-// The first segment of a step field, narrowed to its step variant. Step
-// shapes always classify their (single) segment as a step.
-function stepSegment(segments: Segment[]): StepSegment {
-  return segments[0] as StepSegment;
-}
-
 // A `{hour, minute, second?}` time end for the digit/range helpers.
 interface TimeParts {
   hour: number;
@@ -313,7 +309,7 @@ function composeSecondsOverMinuteStep(
   freq: Extract<PlanNode, {kind: 'minuteFrequency'}>,
   opts: NormalizedOptions
 ): string {
-  const seg = stepSegment(ir.analyses.segments.minute!);
+  const seg = stepSegment(ir, 'minute');
   const stepPhrase = stepCycle60(seg, units.minute, opts);
 
   if (freq.hours.kind === 'during' && minuteStepIsAnchored(seg)) {
@@ -336,7 +332,7 @@ function composeSecondsOverMinuteStep(
   }
   else if (freq.hours.kind === 'step') {
     hourClause = ' ' +
-      everyNthHour(stepSegment(ir.analyses.segments.hour!), opts);
+      everyNthHour(stepSegment(ir, 'hour'), opts);
   }
 
   return stepPhrase + ', ' + secondsLeadClause(ir, opts) +
@@ -428,7 +424,7 @@ function isEveryOtherMinuteSeconds(
     return false;
   }
 
-  const seg = stepSegment(ir.analyses.segments.minute!);
+  const seg = stepSegment(ir, 'minute');
 
   return seg.startToken === '*' && seg.interval === 2;
 }
@@ -466,7 +462,7 @@ function secondsLeadClause(ir: IR, opts: NormalizedOptions): string {
 
   if (shape === 'step') {
     // A step shape always has segments whose first is a step segment.
-    return stepCycle60(stepSegment(ir.analyses.segments.second!),
+    return stepCycle60(stepSegment(ir, 'second'),
       units.second, opts);
   }
 
@@ -480,8 +476,8 @@ function secondsLeadClause(ir: IR, opts: NormalizedOptions): string {
 
   // 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(ir.analyses.segments.second!, units.second, opts) ??
-    atMarks(joinList(segmentWords(ir.analyses.segments.second!)),
+  return strideFromSegments(segmentsOf(ir, 'second'), units.second, opts) ??
+    atMarks(joinList(segmentWords(segmentsOf(ir, 'second'))),
       units.second, marked);
 }
 
@@ -525,8 +521,8 @@ function renderMultipleMinutes(
 // the fires form a long-enough progression ("kahden minuutin välein
 // minuutista 3 minuuttiin 59").
 function minutesList(ir: IR, opts: NormalizedOptions): string {
-  return strideFromSegments(ir.analyses.segments.minute!, units.minute, opts) ??
-    atMarks(joinList(segmentWords(ir.analyses.segments.minute!)),
+  return strideFromSegments(segmentsOf(ir, 'minute'), units.minute, opts) ??
+    atMarks(joinList(segmentWords(segmentsOf(ir, 'minute'))),
       units.minute, true);
 }
 
@@ -535,8 +531,8 @@ function minutesList(ir: IR, opts: NormalizedOptions): string {
 // kohdalla". A progression reads as its bounded cadence (which carries no
 // per-hour frequency to drop).
 function bareMinutes(ir: IR, opts: NormalizedOptions): string {
-  return strideFromSegments(ir.analyses.segments.minute!, units.minute, opts) ??
-    atMarks(joinList(segmentWords(ir.analyses.segments.minute!)),
+  return strideFromSegments(segmentsOf(ir, 'minute'), units.minute, opts) ??
+    atMarks(joinList(segmentWords(segmentsOf(ir, 'minute'))),
       units.minute, false);
 }
 
@@ -596,14 +592,14 @@ function hoursFirstMinutes(
   // cadence ("aina kahden minuutin välein minuutista 3 minuuttiin 59") when
   // the fires form a long-enough progression, rather than the kohdalla list.
   const stride =
-    strideFromSegments(ir.analyses.segments.minute!, units.minute, opts);
+    strideFromSegments(segmentsOf(ir, 'minute'), units.minute, opts);
 
   if (stride) {
     return hoursStr + ' aina ' + stride;
   }
 
   return hoursStr + ' aina minuuttien ' +
-    joinList(segmentWords(ir.analyses.segments.minute!)) + ' kohdalla';
+    joinList(segmentWords(segmentsOf(ir, 'minute'))) + ' kohdalla';
 }
 
 // Hour segment times for a range+isolated pattern: joins the isolated hour
@@ -617,7 +613,7 @@ function hourSegmentTimesWithSeka(
 ): string {
   const pieces: string[] = [];
 
-  ir.analyses.segments.hour!.forEach(function clock(segment: Segment) {
+  segmentsOf(ir, 'hour').forEach(function clock(segment: Segment) {
     if (segment.kind === 'range') {
       pieces.push(rangeDigits(
         {hour: +segment.bounds[0], minute, second},
@@ -638,7 +634,7 @@ function renderMinuteFrequency(
   plan: Extract<PlanNode, {kind: 'minuteFrequency'}>,
   opts: NormalizedOptions
 ): string {
-  const seg = stepSegment(ir.analyses.segments.minute!);
+  const seg = stepSegment(ir, 'minute');
 
   if (plan.hours.kind === 'during') {
     // A bounded or uneven hour stride reads as its endpoint-pinning cadence
@@ -673,7 +669,7 @@ function renderMinuteFrequency(
   }
   else if (plan.hours.kind === 'step') {
     phrase += ' ' +
-      everyNthHour(stepSegment(ir.analyses.segments.hour!), opts);
+      everyNthHour(stepSegment(ir, 'hour'), opts);
   }
 
   return phrase + trailingQualifier(ir, opts);
@@ -700,7 +696,7 @@ function renderMinuteSpanInHour(
 }
 
 // A minute window under discrete hours. Like Spanish, the wildcard form
-// re-strategizes to per-hour windows; restricted minutes drop the
+// re-plans to per-hour windows; restricted minutes drop the
 // "jokaisen tunnin" anchor, which the specific hours would contradict.
 // A range or multi-point list over enumerated hours renders hours-first
 // ("klo <hours> aina minuuttien <spec> kohdalla"); a range+isolated hour
@@ -728,7 +724,7 @@ function renderMinutesAcrossHours(
   }
 
   // Range+isolated hours: minute-first, bare minutes, sekä klo.
-  if (hoursAreRangeIsolated(ir.analyses.segments.hour!)) {
+  if (hoursAreRangeIsolated(segmentsOf(ir, 'hour'))) {
     return bareMinutes(ir, opts) + ' ' +
       hourSegmentTimesWithSeka(ir, 0, null, opts) +
       trailingQualifier(ir, opts);
@@ -748,7 +744,7 @@ function renderMinuteSpanAcrossHourStep(
   opts: NormalizedOptions
 ): string {
   // An hour-step plan's first hour segment is always a step segment.
-  const segment = stepSegment(ir.analyses.segments.hour!);
+  const segment = stepSegment(ir, 'hour');
   // A bounded or uneven hour stride reads as its endpoint-pinning cadence; an
   // offset-clean stride keeps its confinement / per-step phrasing.
   const cadence = unevenHourCadence(ir, opts);
@@ -884,7 +880,7 @@ function renderHourStep(
     return cadence + trailingQualifier(ir, opts);
   }
 
-  return stepHours(stepSegment(ir.analyses.segments.hour!), opts) +
+  return stepHours(stepSegment(ir, 'hour'), opts) +
     trailingQualifier(ir, opts);
 }
 
@@ -959,7 +955,7 @@ function renderCompactClockTimes(
     }
   }
 
-  const hourSegs = ir.analyses.segments.hour!;
+  const hourSegs = segmentsOf(ir, 'hour');
 
   // Range+isolated hours: join the isolated hour with "sekä klo" to stop it
   // reading as a range extension. For the folded path (single minute folded
@@ -1082,21 +1078,6 @@ function strideFromSegments(
     null;
 }
 
-// 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;
-}
 
 // "viiden minuutin välein", "joka tunti 0 ja 31 minuutin kohdalla", or
 // "kolmen minuutin välein jokaisen tunnin minuutista 1 alkaen". A step shape
@@ -1181,51 +1162,6 @@ function hourStrideCadence(
     kloRange({hour: start, minute: 0}, {hour: last, minute: 0}, opts);
 }
 
-// An hour list's arithmetic progression, or null when its values are not a step
-// the renderer should speak as a cadence. The core rewrites a uneven hour step
-// (whose interval does not tile 24, e.g. `*/5` → 0,5,10,15,20) to its literal
-// fire list, indistinguishable in the IR from a hand-written list; the renderer
-// recovers the cadence from the values. A progression starting at zero is a
-// `*/n` step however short (0,7,14,21 is `*/7`); a non-zero progression is only
-// a step when it is too long to be a deliberate clock-time list (9,17 is two
-// named times, not a cadence). Interval one is a plain range, never a step.
-function hourListStride(
-  values: number[]
-): {start: number; interval: number; last: number} | null {
-  if (values.length < 2) {
-    return null;
-  }
-
-  const interval = values[1] - values[0];
-
-  if (interval < 2) {
-    return null;
-  }
-
-  for (let i = 2; i < values.length; i += 1) {
-    if (values[i] - values[i - 1] !== interval) {
-      return null;
-    }
-  }
-
-  if (values[0] !== 0 && values.length < 5) {
-    return null;
-  }
-
-  return {interval, last: values[values.length - 1], start: values[0]};
-}
-
-// Whether an hour stride wraps the day cleanly from within its first interval
-// (a `*/n` from the top, or a `m/n` offset with m < n that divides 24): such a
-// stride has no distinct endpoint and keeps its bare or "alkaen" cadence. Every
-// other stride — a uneven interval, or one starting at or past its interval (a
-// bounded `a-b/n`) — is a bounded set the cadence pins both endpoints of.
-function offsetCleanStride(
-  stride: {start: number; interval: number}
-): boolean {
-  return stride.start < stride.interval && 24 % stride.interval === 0;
-}
-
 // The hour field's stride, or null when the hour is not a cadence: a step
 // segment yields its {start, interval, last} directly; an all-single hour list
 // yields one only when its values form a step progression (so an irregular list
@@ -1348,9 +1284,9 @@ function hourCadence(ir: IR, minute: number,
   // stride is a confinement, not a juxtaposed cadence: it reads "minuutin ajan
   // joka toisen tunnin aikana", reusing the every-Nth-hour idiom so the
   // minute-0 window is never heard as the bare hour cadence.
-  const segment = ir.analyses.segments.hour![0];
+  const segment = segmentsOf(ir, 'hour')[0];
   const confined = minute === 0 && subMinuteSecond(ir) &&
-    ir.analyses.segments.hour!.length === 1 && segment.kind === 'step' &&
+    segmentsOf(ir, 'hour').length === 1 && segment.kind === 'step' &&
     cleanHourStride(segment);
 
   if (confined) {
@@ -1400,7 +1336,7 @@ function hasHourWindow(ir: IR): boolean {
 // window uses. The minute has folded into the lead, so the window closes on
 // the top of its final hour.
 function hourRangeWindowTail(ir: IR, opts: NormalizedOptions): string {
-  return ir.analyses.segments.hour!.length === 1 ?
+  return segmentsOf(ir, 'hour').length === 1 ?
     hourSegmentTimes(ir, 0, null, opts) :
     hourSegmentTimesWithSeka(ir, 0, null, opts);
 }
@@ -1473,7 +1409,7 @@ function hourWindowsFromTimes(
     return kloList(times.fires, opts);
   }
 
-  const segments = ir.analyses.segments.hour!;
+  const segments = segmentsOf(ir, 'hour');
 
   if (!segments.some(function ranged(segment: Segment) {
     return segment.kind === 'range';
@@ -1534,7 +1470,7 @@ function hourSegmentTimes(
 ): string {
   const pieces: string[] = [];
 
-  ir.analyses.segments.hour!.forEach(function clock(segment: Segment) {
+  segmentsOf(ir, 'hour').forEach(function clock(segment: Segment) {
     if (segment.kind === 'step') {
       pieces.push(...segment.fires.map(function each(hour: number) {
         return timeDigits(hour, minute, second, opts);
@@ -1707,7 +1643,7 @@ function weekdayQualifier(ir: IR): string {
 
   // Weekday lists display Monday-first (Sunday last); a lone range keeps its
   // form. The IR stays canonical (Sunday=0). The helper flattens steps.
-  const segments = orderWeekdaysForDisplay(ir.analyses.segments.weekday!);
+  const segments = orderWeekdaysForDisplay(segmentsOf(ir, 'weekday'));
 
   return joinList(segments.map(function piece(segment: FlatSegment) {
     if (segment.kind === 'range') {
@@ -1723,7 +1659,7 @@ function weekdayQualifier(ir: IR): string {
 // elative–illative ranges ("kesäkuusta syyskuuhun"). The case endings
 // keep mixed lists unambiguous with no preposition bookkeeping.
 function monthPhrase(ir: IR): string {
-  const segments = flattenSteps(ir.analyses.segments.month!);
+  const segments = flattenSteps(segmentsOf(ir, 'month'));
 
   return joinList(segments.map(function piece(segment: FlatSegment) {
     if (segment.kind === 'range') {
@@ -1808,7 +1744,7 @@ function monthAnchor(ir: IR, opts: NormalizedOptions): string {
     return stepMonths(monthField, opts);
   }
 
-  const segments = flattenSteps(ir.analyses.segments.month!);
+  const segments = flattenSteps(segmentsOf(ir, 'month'));
 
   return joinList(segments.map(function genitiveOf(segment: FlatSegment) {
     // The anchor branch is only reached for non-ranged months, so every
@@ -1827,7 +1763,7 @@ function rangedMonthScope(ir: IR): string {
 // Whether the month field contains a range segment.
 function monthRanged(ir: IR): boolean {
   return ir.pattern.month !== '*' &&
-    ir.analyses.segments.month!.some(function range(segment: Segment) {
+    segmentsOf(ir, 'month').some(function range(segment: Segment) {
       return segment.kind === 'range';
     });
 }
@@ -1835,7 +1771,7 @@ function monthRanged(ir: IR): boolean {
 // The day-of-month words: "13.", "1. ja 15.", "1.–15.", with step
 // segments expanded into their fires.
 function dateWords(ir: IR): string {
-  return joinList(ir.analyses.segments.date!.flatMap(
+  return joinList(segmentsOf(ir, 'date').flatMap(
     function word(segment: Segment): string[] {
     if (segment.kind === 'range') {
       return [segment.bounds[0] + '.–' + segment.bounds[1] + '.'];
@@ -2008,13 +1944,6 @@ function segmentWords(segments: Segment[]): string[] {
   });
 }
 
-// Whether a canonical field value is an "open" step (`*/n` or `a/n`, not
-// a bounded range or a list). Open steps read as a frequency rather than
-// an enumeration.
-function isOpenStep(field: string): boolean {
-  return field.indexOf('/') !== -1 && field.indexOf('-') === -1 &&
-    field.indexOf(',') === -1;
-}
 
 // Numeric fire values as digits.
 function wordList(fires: number[]): string[] {

package/src/lang/zh/index.ts

@@ -5,12 +5,13 @@
 // day periods under `ampm`. The style contract is src/lang/zh/notes.md.
 
 import {
-  arithmeticStep, orderWeekdaysForDisplay, toFieldNumber
+  arithmeticStep, orderWeekdaysForDisplay, segmentsOf, singleValues,
+  stepSegment, 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
+  IR, Language, NormalizedOptions, PlanNode, Segment
 } from '../../core/ir.js';
 import {resolveDialect, type ChineseStyle} from './dialects.js';
 
@@ -30,16 +31,6 @@ function joinAnd(items: string[]): string {
   return items.slice(0, -1).join('、') + '和' + items[items.length - 1];
 }
 
-// A field's classified segments (empty when the field is a wildcard).
-function fieldSegments(ir: IR, field: Field): Segment[] {
-  return ir.analyses.segments[field] || [];
-}
-
-// The first segment of a step field, which the plan guarantees is step-kinded.
-function stepSegment(ir: IR, field: Field): StepSegment {
-  return fieldSegments(ir, field)[0] as StepSegment;
-}
-
 // "每N分钟" / "每分钟" — a cadence over a unit (the numeral 1 is suppressed).
 function cadence(interval: number, unit: string): string {
   return interval === 1 ? '每' + unit : '每' + interval + unit;
@@ -82,22 +73,6 @@ function renderStride(stride: Stride): string {
   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
@@ -212,7 +187,7 @@ function hourWord(hour: number): string {
 function hourFires(ir: IR): number[] {
   const fires: number[] = [];
 
-  fieldSegments(ir, 'hour').forEach(function expand(segment) {
+  segmentsOf(ir, 'hour').forEach(function expand(segment) {
     if (segment.kind === 'step') {
       fires.push(...segment.fires);
     }
@@ -302,7 +277,7 @@ function renderEveryHour(): string {
 // 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');
+  const segments = segmentsOf(ir, 'minute');
 
   if (ir.shapes.minute === 'step') {
     return stepClause(stepSegment(ir, 'minute'), '分钟', '分', '每小时');
@@ -337,7 +312,7 @@ function hourSegmentWords(segment: Segment): string[] {
 // 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 {
-  const words = fieldSegments(ir, 'hour').flatMap(hourSegmentWords);
+  const words = segmentsOf(ir, 'hour').flatMap(hourSegmentWords);
 
   return joinAnd(words);
 }
@@ -346,7 +321,7 @@ function hourList(ir: IR): string {
 // 间，", a discrete hour list gives "在H、H…，".
 function hourFrame(ir: IR): string {
   if (ir.shapes.hour === 'range') {
-    const [from, to] = (fieldSegments(ir, 'hour')[0] as
+    const [from, to] = (segmentsOf(ir, 'hour')[0] as
       Extract<Segment, {kind: 'range'}>).bounds;
 
     return '在' + hourWord(+from) + '至' + hourWord(+to) + '之间，';
@@ -490,7 +465,7 @@ function renderCompactClockTimes(ir: IR, plan: PlanNode): string {
   }
 
   const compact = plan as Extract<PlanNode, {kind: 'compactClockTimes'}>;
-  const secs = fieldSegments(ir, 'second');
+  const secs = segmentsOf(ir, 'second');
   const tail = secs.length && ir.pattern.second !== '0' ?
     '，第' + valueText(secs) + '秒' : '';
 
@@ -522,7 +497,7 @@ function renderHourRange(ir: IR, plan: PlanNode): string {
   const range = plan as Extract<PlanNode, {kind: 'hourRange'}>;
 
   if (range.minuteForm === 'lead') {
-    const minuteSegs = fieldSegments(ir, 'minute');
+    const minuteSegs = segmentsOf(ir, 'minute');
     const past = minuteSegs.length && ir.pattern.minute !== '0' ?
       minuteHourClause(ir) : '每小时';
 
@@ -533,7 +508,7 @@ function renderHourRange(ir: IR, plan: PlanNode): string {
   // A minute range is named separately ("每小时0至30分"), not folded into the end.
   if (range.minuteForm === 'range') {
     return '在' + hourWord(range.from) + '至' + hourWord(range.to) +
-      '之间，每小时' + valueList(fieldSegments(ir, 'minute'), '分') + '，每分钟';
+      '之间，每小时' + valueList(segmentsOf(ir, 'minute'), '分') + '，每分钟';
   }
 
   return '在' + hourWord(range.from) + '至' + range.to + '点' +
@@ -566,7 +541,7 @@ function renderHourStep(ir: IR): string {
 function hourStride(
   ir: IR
 ): {interval: number; start: number; last: number} | null {
-  const segments = fieldSegments(ir, 'hour');
+  const segments = segmentsOf(ir, 'hour');
 
   if (segments.length === 1 && segments[0].kind === 'step') {
     const {fires, interval} = segments[0];
@@ -702,7 +677,7 @@ function renderRangeOfMinutes(ir: IR): string {
 
 // A standalone second field: "每7秒" (step cadence) or "每分钟第4、17、42秒".
 function renderStandaloneSeconds(ir: IR): string {
-  const segs = fieldSegments(ir, 'second');
+  const segs = segmentsOf(ir, 'second');
   const first = segs[0];
 
   if (segs.length === 1 && first.kind === 'step' && first.startToken === '*') {
@@ -715,13 +690,13 @@ function renderStandaloneSeconds(ir: IR): string {
 
 // A second anchored to the minute: "每分钟第1秒", "每分钟第4、17、42秒".
 function renderSecondPastMinute(ir: IR): string {
-  return '每分钟第' + valueText(fieldSegments(ir, 'second')) + '秒';
+  return '每分钟第' + valueText(segmentsOf(ir, 'second')) + '秒';
 }
 
 // A second within a single specific minute: "每小时0分第1秒" / "…，每15秒".
 function renderSecondsWithinMinute(ir: IR): string {
   const base = '每小时' + ir.pattern.minute + '分';
-  const segs = fieldSegments(ir, 'second');
+  const segs = segmentsOf(ir, 'second');
   const first = segs[0];
 
   if (segs.length === 1 && first.kind === 'step' && first.startToken === '*') {
@@ -733,7 +708,7 @@ function renderSecondsWithinMinute(ir: IR): string {
 
 // The second clause for a composed schedule: "每秒" / "每7秒" / "第4、17、42秒".
 function secondClause(ir: IR): string {
-  const segs = fieldSegments(ir, 'second');
+  const segs = segmentsOf(ir, 'second');
 
   if (!segs.length) {
     return '每秒';
@@ -761,7 +736,7 @@ function minuteClause(ir: IR): string {
     return cadence(stepSegment(ir, 'minute').interval, UNITS.minute);
   }
 
-  return valueList(fieldSegments(ir, 'minute'), '分');
+  return valueList(segmentsOf(ir, 'minute'), '分');
 }
 
 // A single second folds into each clock time a clockTimes rest renders
@@ -838,7 +813,7 @@ function composeMinuteZeroClocks(ir: IR, sec: string): string {
   });
   // 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 nested = strideFromSegments(segmentsOf(ir, 'second'), '秒', '秒', '');
   const tail = sec === '每秒' ? '的每一秒' : '的' + (nested ?? sec);
   const core = joinAnd(clocks) + tail;
 
@@ -850,7 +825,7 @@ function composeMinuteZeroClocks(ir: IR, sec: string): string {
 // 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 segmentsOf(ir, 'hour').some(function range(segment) {
     return segment.kind === 'range';
   });
 }
@@ -924,7 +899,7 @@ function composeSecondsListed(ir: IR): string {
   // 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 === '每秒') {
-    const minuteSegs = fieldSegments(ir, 'minute');
+    const minuteSegs = segmentsOf(ir, 'minute');
     const minuteCad = strideFromSegments(minuteSegs, '分钟', '分', '') ??
       valueList(minuteSegs, '分');
 
@@ -1008,7 +983,7 @@ function monthPhrase(ir: IR): string {
     return '';
   }
 
-  const segs = fieldSegments(ir, 'month');
+  const segs = segmentsOf(ir, 'month');
   const first = segs[0];
 
   if (segs.length === 1 && first.kind === 'step' && first.interval === 2) {
@@ -1037,7 +1012,7 @@ function monthPhrase(ir: IR): string {
 // The day-of-month list. A pure list of singles shares one trailing 日
 // ("1、3、8日"); any range gives each segment its own 日 ("1至5日、10日").
 function dayList(ir: IR): string {
-  const segs = fieldSegments(ir, 'date');
+  const segs = segmentsOf(ir, 'date');
 
   if (segs.every((seg) => seg.kind === 'single')) {
     return segs.map((seg) => (seg as {value: string}).value).join('、') + '日';
@@ -1159,7 +1134,7 @@ function weekdayPhrase(
     return quartzWeekday(ir.pattern.weekday, monthPrefix);
   }
 
-  const segs = fieldSegments(ir, 'weekday');
+  const segs = segmentsOf(ir, 'weekday');
 
   if (segs.length === 1 && segs[0].kind === 'range') {
     const [from, to] = (segs[0] as Extract<Segment, {kind: 'range'}>).bounds;
@@ -1323,7 +1298,7 @@ function describe(ir: IR, opts: Opts): string {
   }
 
   // The year leads as "2030年", a range as "2030年至2032年", a list joined with 、.
-  const year = fieldSegments(ir, 'year').map(function part(seg) {
+  const year = segmentsOf(ir, 'year').map(function part(seg) {
     if (seg.kind === 'range') {
       return seg.bounds[0] + '年至' + seg.bounds[1] + '年';
     }

package/src/types.ts

@@ -59,9 +59,9 @@ export interface Cronli5Language {
   options(options?: Cronli5Options): any;
   reboot: string;
   sentence(description: string): string;
-  // Optional strategy override (see `core/ir.ts` `Language.strategy`). Opaque
+  // Optional plan override (see `core/ir.ts` `Language.plan`). Opaque
   // at this public boundary, like `describe`/`options`.
-  strategy?(content: any, base: any): any;
+  plan?(content: any, base: any): any;
 }
 
 /**

package/types/core/analyze.d.ts

@@ -9,5 +9,5 @@ declare function minuteSpan(minuteField: string): [number, number] | null;
 declare function lastMinuteFire(minuteField: string): number;
 declare function clockSecond(secondField: string): number | undefined;
 declare function analyze(pattern: Pattern): IR;
-declare function selectStrategy(content: Content): PlanNode;
-export { analyze, clockSecond, enumerateFires, enumerateStep, enumerateValues, getOccurrences, lastMinuteFire, minuteSpan, selectStrategy };
+declare function selectPlan(content: Content): PlanNode;
+export { analyze, clockSecond, enumerateFires, enumerateStep, enumerateValues, getOccurrences, lastMinuteFire, minuteSpan, selectPlan };

package/types/core/ir.d.ts

@@ -57,7 +57,7 @@ export type HourTimesPlan = {
     kind: 'segments';
 };
 /**
- * The rendering strategy the core selects for a pattern. The `kind`
+ * The rendering plan the core selects for a pattern. The `kind`
  * discriminant tells a renderer which fields are present.
  */
 export type PlanNode = {
@@ -122,8 +122,8 @@ export interface Analyses {
 }
 /**
  * The neutral content plan: the language-independent facts about a pattern,
- * carrying no phrasing decision. `analyze` produces this; `selectStrategy`
- * reads it to suggest a `plan`. The phrasing strategy is deliberately *not*
+ * carrying no phrasing decision. `analyze` produces this; `selectPlan`
+ * reads it to suggest a `plan`. The phrasing plan is deliberately *not*
  * part of the neutral content (docs/i18n-design.md §2.2).
  */
 export interface Content {
@@ -134,7 +134,7 @@ export interface Content {
 /**
  * The semantic intermediate representation a language renders: the neutral
  * `Content` plus the selected `plan`. A language may widen `plan` with its
- * own `Extra` strategy kinds via `Language.strategy`; by default there are
+ * own `Extra` plan kinds via `Language.plan`; by default there are
  * none, so `IR` is the neutral content with a core `PlanNode`.
  */
 export interface IR<Extra extends {
@@ -172,8 +172,8 @@ export interface NormalizedOptions<Style = DialectStyle> {
 }
 /**
  * The interface every language module's default export implements. `Extra`
- * lets a language add its own strategy kinds (default: none), which its
- * `strategy` override emits and its `describe` renders.
+ * lets a language add its own plan kinds (default: none), which its
+ * `plan` override emits and its `describe` renders.
  */
 export interface Language<Style = DialectStyle, Extra extends {
     kind: string;
@@ -183,5 +183,5 @@ export interface Language<Style = DialectStyle, Extra extends {
     options(options?: Cronli5Options): NormalizedOptions<Style>;
     reboot: string;
     sentence(description: string): string;
-    strategy?(content: Content, base: PlanNode): PlanNode | Extra;
+    plan?(content: Content, base: PlanNode): PlanNode | Extra;
 }

package/types/core/shapes.d.ts

@@ -3,4 +3,5 @@ declare function isPlainRange(field: string): boolean;
 declare function isPlainStep(field: string): boolean;
 declare function isDiscreteList(field: string): boolean;
 declare function isDiscreteHours(hourField: string): boolean;
-export { isDiscreteHours, isDiscreteList, isPlainRange, isPlainStep, isSingleValue };
+declare function isOpenStep(field: string): boolean;
+export { isDiscreteHours, isDiscreteList, isOpenStep, isPlainRange, isPlainStep, isSingleValue };