cronli5 0.2.0 → 0.2.1

package/src/lang/en/index.ts

@@ -3,7 +3,11 @@
 // the core stays semantic, and this module's only input is the IR.
 // See docs/i18n-design.md.
 
-import {arithmeticStep, orderWeekdaysForDisplay} from '../../core/util.js';
+import {
+  arithmeticStep, hourListStride, offsetCleanStride, orderWeekdaysForDisplay,
+  segmentsOf, singleValues, stepSegment
+} from '../../core/util.js';
+import {isOpenStep} from '../../core/shapes.js';
 import {maxClockTimes} from '../../core/specs.js';
 import {clockDigits, numeral, pad} from '../../core/format.js';
 import type {Cronli5Options} from '../../types.js';
@@ -33,6 +37,17 @@ interface Stride {
   anchor: string;
 }
 
+// A contiguous hour range to phrase as a window. `from`/`to` are the bounding
+// hours; `throughMinute` is the close minute used by the "through" span;
+// `continuous` is true only when the run fills every minute of the final hour
+// (a wildcard minute), which earns the default dialect's until-window.
+interface HourWindowSpec {
+  from: number;
+  to: number;
+  throughMinute: number | string;
+  continuous: boolean;
+}
+
 // A clock-time entry assembled for rendering. Hour/minute/second arrive as
 // numbers or as raw field tokens (a range bound or single value is a
 // string); `plain` suppresses the noon/midnight words. `explicit` forces the
@@ -215,9 +230,6 @@ function composeHourCadence(ir: IR, plan: PlanOf<'composeSeconds'>,
   return hourCadence(ir, minute, opts) ?? hourRangeCadence(ir, minute, opts);
 }
 
-// A meaningful second under minute/hour shapes the earlier strategies
-// deferred on: the second leads with its own clause and the rest of the
-// pattern follows.
 // A wildcard or stepped second under a fixed minute across one or more specific
 // hours. The clock-time rest collapses the pinned minute into the hour, and on
 // the clock a pinned minute-0 reads as the whole hour ("9 a.m." spoken ==
@@ -340,7 +352,7 @@ function secondsClause(ir: IR, anchor: string,
   if (shape === 'step') {
     // The plan reached this clause only for a stepped second field, whose
     // first segment is always a step segment.
-    return stepCycle60(ir.analyses.segments.second![0] as StepSegment,
+    return stepCycle60(stepSegment(ir, 'second'),
       'second', anchor, opts);
   }
 
@@ -360,8 +372,8 @@ function secondsClause(ir: IR, anchor: string,
   // A non-wildcard second under the list/step path always has segments. An
   // offset/uneven step the core enumerated to a fire list reads as a stride
   // cadence when those fires form a long-enough progression.
-  return strideFromSegments(ir.analyses.segments.second!, 'second', anchor,
-    opts) ?? listPastThe(segmentWords(ir.analyses.segments.second!, opts),
+  return strideFromSegments(segmentsOf(ir, 'second'), 'second', anchor,
+    opts) ?? listPastThe(segmentWords(segmentsOf(ir, 'second'), opts),
     'second', anchor, opts);
 }
 
@@ -393,9 +405,9 @@ function renderMultipleMinutes(ir: IR, plan: PlanOf<'multipleMinutes'>,
   // segments. An offset/uneven step the core enumerated to this list reads as
   // a stride cadence when the fires form a long-enough progression.
   const stride =
-    strideFromSegments(ir.analyses.segments.minute!, 'minute', 'hour', opts);
+    strideFromSegments(segmentsOf(ir, 'minute'), 'minute', 'hour', opts);
 
-  return (stride ?? listPastThe(segmentWords(ir.analyses.segments.minute!,
+  return (stride ?? listPastThe(segmentWords(segmentsOf(ir, 'minute'),
     opts), 'minute', 'hour', opts)) + trailingQualifier(ir, opts);
 }
 
@@ -404,7 +416,7 @@ function renderMinuteFrequency(ir: IR, plan: PlanOf<'minuteFrequency'>,
   opts: NormalizedOptions): string {
   // A minute-frequency plan is selected only for a stepped minute field,
   // which has segments.
-  let phrase = stepCycle60(ir.analyses.segments.minute![0] as StepSegment,
+  let phrase = stepCycle60(stepSegment(ir, 'minute'),
     'minute', 'hour', opts);
 
   if (plan.hours.kind === 'during') {
@@ -419,14 +431,23 @@ function renderMinuteFrequency(ir: IR, plan: PlanOf<'minuteFrequency'>,
         hourTimesFromPlan(ir, plan.hours.times, false, opts) + ' hours';
   }
   else if (plan.hours.kind === 'window') {
-    phrase += ' ' + hourWindow(plan.hours, opts);
+    // A minute-frequency cadence ("every 15 minutes") fills the hours from a
+    // STEPPED minute, never a wildcard one, so its run is not continuous to the
+    // top of the next hour: the default dialect reads "through <last hour>" and
+    // every other dialect closes on the step's last fire (`last`).
+    phrase += ' ' + rangeWindow({
+      continuous: false,
+      from: plan.hours.from,
+      throughMinute: plan.hours.last,
+      to: plan.hours.to
+    }, opts);
   }
   else if (plan.hours.kind === 'step') {
     // The plan carries a step only for a clean stride (dividing the day),
     // which confines the cadence to every Nth hour; a stepped hour field's
     // first segment is a step segment.
     phrase += ' ' +
-      everyNthHour(ir.analyses.segments.hour![0] as StepSegment, opts);
+      everyNthHour(stepSegment(ir, 'hour'), opts);
   }
 
   return phrase + trailingQualifier(ir, opts);
@@ -497,8 +518,8 @@ function renderMinutesAcrossHours(ir: IR, plan: PlanOf<'minutesAcrossHours'>,
   // step enumerated to that list reads as a stride. A list is a set of
   // discrete fire minutes, not a cadence, so it keeps the "at <times>" frame.
   const lead =
-    strideFromSegments(ir.analyses.segments.minute!, 'minute', 'hour', opts) ??
-      listPastThe(segmentWords(ir.analyses.segments.minute!, opts),
+    strideFromSegments(segmentsOf(ir, 'minute'), 'minute', 'hour', opts) ??
+      listPastThe(segmentWords(segmentsOf(ir, 'minute'), opts),
         'minute', 'hour', opts);
 
   if (cadence !== null) {
@@ -534,7 +555,7 @@ function renderMinuteSpanAcrossHourStep(ir: IR,
   plan: PlanOf<'minuteSpanAcrossHourStep'>, opts: NormalizedOptions): string {
   // This plan is reached only under a stepped hour field, whose first
   // segment is a step segment.
-  const segment = ir.analyses.segments.hour![0] as StepSegment;
+  const segment = stepSegment(ir, 'hour');
 
   // A wildcard minute over a stepped hour is reached only for a clean stride
   // (a bounded or uneven step routes through minutesAcrossHours instead), so it
@@ -547,8 +568,8 @@ function renderMinuteSpanAcrossHourStep(ir: IR,
   // A minute list keeps the same cadence clause; only its lead differs. An
   // offset/uneven step the core enumerated to that list reads as a stride.
   const lead = plan.form === 'list' ?
-    strideFromSegments(ir.analyses.segments.minute!, 'minute', 'hour', opts) ??
-      listPastThe(segmentWords(ir.analyses.segments.minute!, opts),
+    strideFromSegments(segmentsOf(ir, 'minute'), 'minute', 'hour', opts) ??
+      listPastThe(segmentWords(segmentsOf(ir, 'minute'), opts),
         'minute', 'hour', opts) :
     minuteRangeLead(ir.pattern.minute, opts);
   // A bounded or uneven hour step reads as its endpoint-pinning cadence after
@@ -607,8 +628,8 @@ function rangeMinuteLead(ir: IR, opts: NormalizedOptions): string {
 
   // A non-"0" minute here is a discrete list, which has segments; an
   // offset/uneven step enumerated to that list reads as a stride.
-  return strideFromSegments(ir.analyses.segments.minute!, 'minute', 'hour',
-    opts) ?? listPastThe(segmentWords(ir.analyses.segments.minute!, opts),
+  return strideFromSegments(segmentsOf(ir, 'minute'), 'minute', 'hour',
+    opts) ?? listPastThe(segmentWords(segmentsOf(ir, 'minute'), opts),
     'minute', 'hour', opts);
 }
 
@@ -625,7 +646,7 @@ function renderHourStep(ir: IR, plan: PlanOf<'hourStep'>,
 
   // An hour-step plan is selected only for a stepped hour field, whose
   // first segment is a step segment.
-  return stepHours(ir.analyses.segments.hour![0] as StepSegment, opts) +
+  return stepHours(stepSegment(ir, 'hour'), opts) +
     trailingQualifier(ir, opts);
 }
 
@@ -634,31 +655,42 @@ function renderHourStep(ir: IR, plan: PlanOf<'hourStep'>,
 // a wildcard minute, which fills every minute and states no separate clause.
 // A pinned/listed/ranged minute is named in its own lead clause, so folding it
 // into the close too would read as a span ("through 5:05 p.m.") that
-// contradicts the minute clause; the window stays bare ("through 5 p.m.").
+// contradicts the minute clause; the window stays bare ("through 5 p.m."). The
+// same wildcard minute is what makes the run CONTINUOUS to the top of the next
+// hour, so it also drives the until-window choice in `rangeWindow`.
 function boundedWindow(plan: PlanOf<'hourRange'>):
-  {from: number; to: number; last: number} {
-  const last = plan.minuteForm === 'wildcard' ? plan.boundMinute ?? 0 : 0;
+  {from: number; to: number; closeMinute: number; continuous: boolean} {
+  const continuous = plan.minuteForm === 'wildcard';
+  const closeMinute = continuous ? plan.boundMinute ?? 0 : 0;
 
-  return {from: plan.from, last, to: plan.to};
+  return {from: plan.from, closeMinute, to: plan.to, continuous};
 }
 
 // A contiguous hour range as a window phrase. The default English dialect
-// reads a MULTI-hour range as an up-to-but-not-including window — "from 9 a.m.
-// until 6 p.m." (the close is the top of the hour after the last, the sense
-// English uses for time windows: 9-17 runs until 6 p.m.); 23 wraps to
-// midnight. Every other dialect (and the compact `short` form) keeps the
-// "through <last fire>" span, closing on the minute field's last fire within
-// the final hour. A single-hour sub-hour window (`from === to`, e.g. */15 9
-// firing 9:00 through 9:45) is NOT a multi-hour range: its close is a real
-// fire inside the hour, so it always keeps "through" — naming "until 10 a.m."
-// would overstate the span past the last fire.
-function rangeWindow(from: number, to: number, throughMinute: number | string,
+// reads a MULTI-hour range whose run is CONTINUOUS to the top of the next hour
+// as an up-to-but-not-including window — "from 9 a.m. until 6 p.m." (the close
+// is the top of the hour after the last, the sense English uses for time
+// windows: 9-17 runs until 6 p.m.); 23 wraps to midnight. The run is continuous
+// only when the minute is wildcard, so every minute of the final hour fires; a
+// restricted minute fires at discrete points (e.g. only `:00`), so the run
+// stops within the final hour and the default dialect reverts to the bare
+// "through <last hour>" span (the minute is named in its own lead clause, so
+// the close stays on the top of the final hour rather than restating a last
+// fire). Every other dialect (and the compact `short` form) always speaks the
+// span, closing on the minute field's last fire within the final hour. A
+// single-hour sub-hour window (`from === to`, e.g. */15 9 firing 9:00 through
+// 9:45) is NOT a multi-hour range: its close is a real fire inside the hour, so
+// it always keeps "through" — naming "until 10 a.m." would overstate the span
+// past the last fire.
+function rangeWindow(window: HourWindowSpec,
   opts: NormalizedOptions): string {
+  const {from, to, throughMinute, continuous} = window;
   const open = 'from ' + getTime({hour: from, minute: 0}, opts);
 
   if (opts.style.untilWindow && !opts.short && from !== to) {
-    return open + ' until ' +
-      getTime({hour: (to + 1) % 24, minute: 0}, opts);
+    return continuous ?
+      open + ' until ' + getTime({hour: (to + 1) % 24, minute: 0}, opts) :
+      open + through(opts) + getTime({hour: to, minute: 0}, opts);
   }
 
   return open + through(opts) +
@@ -666,11 +698,18 @@ function rangeWindow(from: number, to: number, throughMinute: number | string,
 }
 
 // An hour window phrase, e.g. "from 9 a.m. through 5:45 p.m." (or "from 9 a.m.
-// until 6 p.m." in the default dialect). Windows open at the top of the first
-// hour and close at the minute field's last fire within the final hour.
-function hourWindow(window: {from: number; to: number; last: number},
+// until 6 p.m." in the default dialect, when the minute is wildcard). Windows
+// open at the top of the first hour and close at the minute field's last fire
+// within the final hour.
+function hourWindow(
+  window: {from: number; to: number; closeMinute: number; continuous: boolean},
   opts: NormalizedOptions): string {
-  return rangeWindow(window.from, window.to, window.last, opts);
+  return rangeWindow({
+    continuous: window.continuous,
+    from: window.from,
+    throughMinute: window.closeMinute,
+    to: window.to
+  }, opts);
 }
 
 // Expand a discrete set of hours and minutes into clock times prefixed by
@@ -729,7 +768,7 @@ function renderCompactClockTimes(ir: IR, plan: PlanOf<'compactClockTimes'>,
 
     // A compact clock-time plan is reached only for discrete hours, which
     // have segments.
-    const hasRange = ir.analyses.segments.hour!.some(function range(segment) {
+    const hasRange = segmentsOf(ir, 'hour').some(function range(segment) {
       return segment.kind === 'range';
     });
 
@@ -748,8 +787,8 @@ function renderCompactClockTimes(ir: IR, plan: PlanOf<'compactClockTimes'>,
   const minuteLead =
     // The non-fold branch is a minute list, which has segments. An
     // offset/uneven step enumerated to that list reads as a stride.
-    strideFromSegments(ir.analyses.segments.minute!, 'minute', 'hour', opts) ??
-      listPastThe(segmentWords(ir.analyses.segments.minute!, opts),
+    strideFromSegments(segmentsOf(ir, 'minute'), 'minute', 'hour', opts) ??
+      listPastThe(segmentWords(segmentsOf(ir, 'minute'), opts),
         'minute', 'hour', opts);
   // A uneven hour stride reads as a cadence after the minute lead, not a wall
   // of clock-time columns.
@@ -770,72 +809,63 @@ function renderCompactClockTimes(ir: IR, plan: PlanOf<'compactClockTimes'>,
 // A folded hour field that includes a contiguous range reads with the
 // hour-range frame: a shared minute lead ("every hour" / "at 30 minutes
 // past the hour"), each range as a window, and any non-contiguous hour
-// appended by `outlierTail` (the default until-window form reads "plus Z";
-// every other dialect keeps "and at Z").
+// appended by `outlierTail` ("and at Z").
 function foldedHourWindows(ir: IR, plan: PlanOf<'compactClockTimes'>,
   opts: NormalizedOptions): string {
   const minute = plan.minute;
   const windows: string[] = [];
-  const outliers = collectHourOutliers(ir);
-  const times = outliers.hours.map(function time(hour) {
+  const times = collectHourOutliers(ir).map(function time(hour) {
     return getTime({hour, minute}, opts);
   });
 
-  // Reached only via the fold branch under discrete hours, which have
-  // segments.
-  ir.analyses.segments.hour!.forEach(function classify(segment) {
+  // Reached only via the fold branch under discrete hours, which have segments.
+  // A folded minute is a discrete pin/list, never a wildcard, so the run is not
+  // continuous to the top of the next hour: the window is not an until-window.
+  segmentsOf(ir, 'hour').forEach(function classify(segment) {
     if (segment.kind === 'range') {
-      windows.push(rangeWindow(+segment.bounds[0], +segment.bounds[1],
-        minute, opts));
+      windows.push(rangeWindow({
+        continuous: false,
+        from: +segment.bounds[0],
+        throughMinute: minute,
+        to: +segment.bounds[1]
+      }, opts));
     }
   });
 
   const phrase = rangeMinuteLead(ir, opts) + ' ' + joinList(windows, opts);
 
-  return phrase + outlierTail(times, outliers.pureStrays, opts);
+  return phrase + outlierTail(times, opts);
 }
 
-// The hours outside a contiguous run — every non-range segment's values — and
-// whether they are all STRAY single values (no step fires). A step beside a run
-// contributes a whole cadence's worth of fires, not a lone outlier, so the
-// "plus" idiom does not fit and the additive list keeps "and at".
-function collectHourOutliers(ir: IR):
-  {hours: number[]; pureStrays: boolean} {
+// The hours outside a contiguous run — every non-range segment's values, with
+// a step contributing its whole fire set.
+function collectHourOutliers(ir: IR): number[] {
   const hours: number[] = [];
-  let pureStrays = true;
 
   // Reached only under discrete hours, which carry segments.
-  ir.analyses.segments.hour!.forEach(function classify(segment) {
+  segmentsOf(ir, 'hour').forEach(function classify(segment) {
     if (segment.kind === 'step') {
       hours.push(...segment.fires);
-      pureStrays = false;
     }
     else if (segment.kind !== 'range') {
       hours.push(+segment.value);
     }
   });
 
-  return {hours, pureStrays};
+  return hours;
 }
 
-// Join the outlier hour times that follow a contiguous-run window. When the run
-// rendered as the leading until-window ("from 9 a.m. until 9 p.m.") and the
-// outlier is a single stray value, it reads "plus 10 p.m." — an additive idiom
-// for the one hour that breaks the run. A step beside the run is a full cadence
-// of fires, not a lone outlier, so it keeps the enumerating "and at"; so does
-// every other dialect (and the compact `short` form), which renders the run as
-// a "through <last fire>" span rather than the until-window.
-function outlierTail(times: string[], pureStrays: boolean,
-  opts: NormalizedOptions): string {
+// Join the outlier hour times that follow a contiguous-run window — the hours
+// outside the run, enumerated as "and at 10 p.m.". (A fold always carries a
+// restricted minute, so its run reads the "through" span, never the
+// until-window; the additive "plus" idiom that paired with the until-window no
+// longer applies here.)
+function outlierTail(times: string[], opts: NormalizedOptions): string {
   if (!times.length) {
     return '';
   }
 
-  const connector = pureStrays && opts.style.untilWindow && !opts.short ?
-    ' plus ' :
-    ' and at ';
-
-  return connector + joinList(times, opts);
+  return ' and at ' + joinList(times, opts);
 }
 
 // --- Confinement frame. ---
@@ -876,7 +906,7 @@ function leadingCadence(ir: IR, opts: NormalizedOptions):
     const text = minute === '*' ?
       'every minute' :
       // A clean minute step's first segment is a step segment.
-      stepCycle60(ir.analyses.segments.minute![0] as StepSegment,
+      stepCycle60(stepSegment(ir, 'minute'),
         'minute', 'hour', opts);
 
     return {secondLead: false, text};
@@ -905,7 +935,7 @@ function minuteConfinement(ir: IR, opts: NormalizedOptions): string {
   // A minute single/range/list under the seconds lead. The minute reads as a
   // ":NN" clock-minute confinement, never "N minutes past the hour" (that is
   // the minute-lead clock-point form).
-  const segments = ir.analyses.segments.minute!;
+  const segments = segmentsOf(ir, 'minute');
 
   if (ir.shapes.minute === 'single') {
     return ' during minute :' + pad(minute);
@@ -970,7 +1000,15 @@ function hourConfinement(ir: IR, opts: NormalizedOptions): string {
   if (ir.shapes.hour === 'range') {
     const bounds = hour.split('-');
 
-    return ' ' + rangeWindow(+bounds[0], +bounds[1], 0, opts);
+    // The until-window holds only when the run is continuous to the top of the
+    // next hour — a wildcard minute fills every minute of the final hour; a
+    // confined minute (":00", a step) stops within it, reading "through".
+    return ' ' + rangeWindow({
+      continuous: ir.pattern.minute === '*',
+      from: +bounds[0],
+      throughMinute: 0,
+      to: +bounds[1]
+    }, opts);
   }
 
   // An hour list or stepped range reads "during the <times> hours".
@@ -989,17 +1027,17 @@ function isContiguousHourRange(ir: IR): boolean {
 
 // Whether an hour field is confinement-eligible. An OPEN hour stride — a clean
 // `*/n`, an offset `m/n`, or a uneven step — reads as a cadence ("every three
-// hours from 2 a.m."), and only the `*/2` form has a blessed confinement idiom
-// ("of every other hour"), so other open steps defer. A BOUNDED stepped range
-// (`a-b/n`, e.g. `9-17/2`) is a discrete set of named hours the confinement
-// frame speaks as a list ("during the 9 a.m., 11 a.m., … hours").
+// hours from 2 a.m."), and only the `*/2` form has a dedicated confinement
+// idiom ("of every other hour"), so other open steps defer. A BOUNDED stepped
+// range (`a-b/n`, e.g. `9-17/2`) is a discrete set of named hours the
+// confinement frame speaks as a list ("during the 9 a.m., 11 a.m., … hours").
 function confinableHour(ir: IR): boolean {
   if (ir.shapes.hour !== 'step') {
     return true;
   }
 
   // Reached only under a stepped hour, whose first segment is a step segment.
-  const segment = ir.analyses.segments.hour![0] as StepSegment;
+  const segment = stepSegment(ir, 'hour');
 
   return ir.pattern.hour === '*/2' || segment.startToken.indexOf('-') !== -1;
 }
@@ -1012,15 +1050,15 @@ function isMinuteStride(ir: IR): boolean {
     return false;
   }
 
-  const values = singleValues(ir.analyses.segments.minute!);
+  const values = singleValues(segmentsOf(ir, 'minute'));
 
   return values !== null && arithmeticStep(values) !== null;
 }
 
-// Whether the pattern is in the panel-blessed confinement shape-set. The frame
-// covers a finer leading cadence (seconds, or minute under a :00 second) with
-// each coarser field as a confinement; shapes outside the blessed set defer to
-// the existing renderers, which already produce the blessed phrasing for them.
+// Whether the pattern is in the confinement frame's supported shape-set. The
+// frame covers a finer leading cadence (seconds, or minute under a :00 second)
+// with each coarser field as a confinement; shapes outside it defer to the
+// existing renderers, which already produce that phrasing for them.
 function confinementEligible(ir: IR,
   lead: {secondLead: boolean}): boolean {
   const {minute, hour} = ir.pattern;
@@ -1032,7 +1070,7 @@ function confinementEligible(ir: IR,
   }
 
   if (lead.secondLead) {
-    // A minute STEP is blessed only as the `*/2` "every other minute" idiom,
+    // A minute STEP is supported only as the `*/2` "every other minute" idiom,
     // and only where it fills the coarser field: a contiguous hour range or a
     // single hour both close on the minute's real last fire, which the
     // windowing renderer already speaks. The `*/2` step fills both, so it keeps
@@ -1054,7 +1092,7 @@ function confinementEligible(ir: IR,
   }
 
   // A minute-LEAD cadence (second :00). The existing renderers already produce
-  // the blessed phrasing for a single/range/list hour and for a non-`*/2` hour
+  // that phrasing for a single/range/list hour and for a non-`*/2` hour
   // step; the confinement frame only changes the `*/2` hour ("of every other
   // hour") and the single hour under an "every other minute" step ("from
   // midnight until 1 a.m."). Everything else defers.
@@ -1065,9 +1103,10 @@ function confinementEligible(ir: IR,
   return ir.shapes.hour === 'single' && minute === '*/2';
 }
 
-// Whether the pattern reads with the confinement frame: a finer leading
-// cadence with each coarser field as a confinement. Routed to from the cadence
-// renderers in place of the older juxtaposed-cadence and duration-frame forms.
+// Render the pattern with the confinement frame: a finer leading cadence with
+// each coarser field as a confinement, or null when it does not apply. Routed
+// to from the cadence renderers in place of the older juxtaposed-cadence and
+// duration-frame forms.
 function confinement(ir: IR, opts: NormalizedOptions): string | null {
   // The confinement frame is scoped to the default (US) dialect, the one that
   // carries the until-window; every other dialect and the compact `short` form
@@ -1152,22 +1191,6 @@ function renderStride(stride: Stride, opts: NormalizedOptions): string {
     pluralize(last, unit) + ' past the ' + anchor;
 }
 
-// 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
@@ -1269,17 +1292,6 @@ function hourStrideCadence(stride: {start: number; interval: number;
     through(opts) + getTime({hour: last, minute: 0}, opts);
 }
 
-// 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 "from M" 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 bounded cadence for an hour stride that pins both clock-time endpoints,
 // or null when the hour is not such a stride. The core rewrites a uneven step
 // to its fire list, so a minute window/list/step crossed with it lands in the
@@ -1297,40 +1309,6 @@ function unevenHourCadence(ir: IR, opts: NormalizedOptions): string | null {
   return hourStrideCadence(stride, 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 one is
-// only a step when it is too long to be a deliberate clock-time list (e.g.
-// 9,17 is two named times, not a cadence), the same length the minute/second
-// list path uses. 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]};
-}
-
 // 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
@@ -1341,7 +1319,7 @@ function hourStride(ir: IR):
   {start: number; interval: number; last: number} | null {
   // Reached only from the clock-time paths, which run under discrete hours
   // and so always carry hour segments.
-  const segments = ir.analyses.segments.hour!;
+  const segments = segmentsOf(ir, 'hour');
 
   if (segments.length === 1 && segments[0].kind === 'step') {
     const segment = segments[0];
@@ -1462,7 +1440,7 @@ function hourCadence(ir: IR, minute: number,
 // or an arithmetic-progression list, which keep the bounded cadence form).
 function cleanStrideSegment(ir: IR): StepSegment | null {
   // Reached only after hourStride confirmed a stride, so hour segments exist.
-  const segments = ir.analyses.segments.hour!;
+  const segments = segmentsOf(ir, 'hour');
   const segment = segments.length === 1 && segments[0];
 
   if (!segment || segment.kind !== 'step' ||
@@ -1482,35 +1460,40 @@ function cleanStrideSegment(ir: IR): StepSegment | null {
 function hasHourWindow(ir: IR): boolean {
   // Reached only from the clock-time paths, which run under discrete hours
   // and so always carry hour segments.
-  return ir.analyses.segments.hour!.some(function range(segment) {
+  return segmentsOf(ir, 'hour').some(function range(segment) {
     return segment.kind === 'range';
   });
 }
 
 // The hour-range window as a cadence tail at the top of each hour: each range
-// segment is a window ("every hour from 9 a.m. until 9 p.m."), and any
-// non-contiguous single hour is appended by `outlierTail` ("plus 10 p.m." in
-// the default until-window form, "and at 10 p.m." elsewhere). The minute has
-// already folded into the lead, so the window closes on the top of its final
-// hour. Mirrors foldedHourWindows but pinned to minute 0.
+// segment is a window ("every hour from 9 a.m. through 8 p.m."), and any
+// non-contiguous single hour is appended by `outlierTail` ("and at 10 p.m.").
+// The minute has already folded into the "every hour" lead — a single pinned
+// minute, never a wildcard — so the run is not continuous to the top of the
+// next hour and the window keeps "through". Mirrors foldedHourWindows but
+// pinned to minute 0.
 function hourRangeWindowTail(ir: IR, opts: NormalizedOptions): string {
   const windows: string[] = [];
-  const outliers = collectHourOutliers(ir);
+  const outlierHours = collectHourOutliers(ir);
 
   // Reached only after hasHourWindow, so hour segments exist.
-  ir.analyses.segments.hour!.forEach(function classify(segment) {
+  segmentsOf(ir, 'hour').forEach(function classify(segment) {
     if (segment.kind === 'range') {
-      windows.push(rangeWindow(+segment.bounds[0], +segment.bounds[1], 0,
-        opts));
+      windows.push(rangeWindow({
+        continuous: false,
+        from: +segment.bounds[0],
+        throughMinute: 0,
+        to: +segment.bounds[1]
+      }, opts));
     }
   });
 
   const phrase = 'every hour ' + joinList(windows, opts);
-  const times = outliers.hours.map(function time(hour) {
+  const times = outlierHours.map(function time(hour) {
     return getTime({hour, minute: 0}, opts);
   });
 
-  return phrase + outlierTail(times, outliers.pureStrays, opts);
+  return phrase + outlierTail(times, opts);
 }
 
 // Render an hour range (or a list whose segments include a range) under a
@@ -1694,7 +1677,7 @@ function hourSegmentTimes(ir: IR,
   const {minute, second} = fold;
   // Hour-segment rendering is reached only under discrete hours, which have
   // segments.
-  const segments = ir.analyses.segments.hour!;
+  const segments = segmentsOf(ir, 'hour');
   const plain = mixedTwelve(segments.flatMap(function entries(segment) {
     return segmentHours(segment).map(function entry(hour) {
       return {hour: +hour, minute, second};
@@ -1905,7 +1888,7 @@ function datePhrase(ir: IR, words: QualifierWords,
 function monthFoldsIntoDate(ir: IR): boolean {
   return !oddEvenMonth(ir.pattern.month) &&
     // Reached only with a restricted month, which has segments.
-    ir.analyses.segments.month!.every(function flat(segment) {
+    segmentsOf(ir, 'month').every(function flat(segment) {
       return segment.kind !== 'range';
     });
 }
@@ -1971,7 +1954,7 @@ function dayUnionDatePieces(ir: IR, opts: NormalizedOptions): string[] {
   // spreads its enumerated fires as separate "the <ordinal>" alternatives.
   const pieces: string[] = [];
 
-  ir.analyses.segments.date!.forEach(function expand(segment) {
+  segmentsOf(ir, 'date').forEach(function expand(segment) {
     if (segment.kind === 'range') {
       pieces.push('from the ' + getOrdinal(segment.bounds[0]) + through(opts) +
         'the ' + getOrdinal(segment.bounds[1]));
@@ -2004,11 +1987,11 @@ function dayUnionWeekdayPieces(ir: IR, opts: NormalizedOptions): string[] {
 
   // The union predicate keeps the canonical Sunday-first order (0…6) rather
   // than the weekend-last display order: as a flat or-list of day kinds, the
-  // numeric order reads as naturally as any other and matches the reviewed
-  // spec ("a Sunday, a Tuesday, a Thursday, or a Saturday").
+  // numeric order reads as naturally as any other in a flat or-list ("a
+  // Sunday, a Tuesday, a Thursday, or a Saturday").
   const pieces: string[] = [];
 
-  ir.analyses.segments.weekday!.forEach(function expand(segment) {
+  segmentsOf(ir, 'weekday').forEach(function expand(segment) {
     if (segment.kind === 'range' &&
         segment.bounds[0] === '1' && segment.bounds[1] === '5') {
       pieces.push('a weekday');
@@ -2161,7 +2144,7 @@ function monthDatePhrase(ir: IR, opts: NormalizedOptions): string {
   const month = monthName(ir, opts);
   // A month-day phrase is reached only with a restricted date, which has
   // segments.
-  const days = renderSegments(ir.analyses.segments.date!,
+  const days = renderSegments(segmentsOf(ir, 'date'),
     opts.style.ordinals ? getOrdinal : cardinalDay, opts);
 
   if (opts.style.dayFirst && ir.shapes.date === 'single' &&
@@ -2238,7 +2221,7 @@ function stepDates(dateField: string): string {
 // handled separately as a frequency phrase.
 function dateOrdinals(ir: IR, opts: NormalizedOptions): string {
   // Reached only with a restricted date, which has segments.
-  return renderSegments(ir.analyses.segments.date!, getOrdinal, opts);
+  return renderSegments(segmentsOf(ir, 'date'), getOrdinal, opts);
 }
 
 // Render the month field as names. There are few, named months, so a step
@@ -2254,7 +2237,7 @@ function monthName(ir: IR, opts: NormalizedOptions): string {
 
   // A restricted month has segments; open steps of interval 3+ enumerate their
   // fires here too.
-  return renderSegments(ir.analyses.segments.month!, function name(value) {
+  return renderSegments(segmentsOf(ir, 'month'), function name(value) {
     return getMonth(value, opts);
   }, opts);
 }
@@ -2293,7 +2276,7 @@ function weekdayPhrase(ir: IR, recurring: boolean,
   // Reached only with a restricted weekday, which has segments. Weekday lists
   // display Monday-first (Sunday last) so a weekend reads naturally; the IR
   // stays canonical (Sunday=0) and ranges keep their form.
-  const segments = orderWeekdaysForDisplay(ir.analyses.segments.weekday!);
+  const segments = orderWeekdaysForDisplay(segmentsOf(ir, 'weekday'));
   const hasRange = segments.some(function range(segment) {
     return segment.kind === 'range';
   });
@@ -2345,14 +2328,6 @@ function renderSegments(segments: Segment[],
   return joinList(pieces, opts);
 }
 
-// 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;
-}
-
 // --- Years. ---
 
 // Append or fold the year field into a finished description. An