cronli5 0.2.0 → 0.3.1

package/src/lang/en/index.ts

@@ -1,15 +1,20 @@
-// The English language module: renders an analyzed cron pattern (the IR
+// The English language module: renders an analyzed cron pattern (the Schedule
 // produced by core `analyze`) as idiomatic English. All words live here;
-// the core stays semantic, and this module's only input is the IR.
+// the core stays semantic, and this module's only input is the Schedule.
 // See docs/i18n-design.md.
 
-import {arithmeticStep, orderWeekdaysForDisplay} from '../../core/util.js';
+import {
+  arithmeticStep, hourListStride, offsetCleanStride,
+  renderStride as chooseStride, segmentsOf, singleValues, stepSegment
+} from '../../core/cadence.js';
+import {orderWeekdaysForDisplay} from '../../core/weekday.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';
 import type {
-  HourTimesPlan, IR, Language, NormalizedOptions, PlanNode, Segment
-} from '../../core/ir.js';
+  HourTimesPlan, Schedule, Language, NormalizedOptions, PlanNode, Segment
+} from '../../core/schedule.js';
 import {resolveDialect} from './dialects.js';
 
 // The plan node of a given kind: the discriminated-union member a renderer
@@ -33,6 +38,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
@@ -128,96 +144,224 @@ function normalizeOptions(options?: Cronli5Options): NormalizedOptions {
   };
 }
 
-// Render an analyzed cron pattern (the IR) as English.
-function describe(ir: IR, opts: NormalizedOptions): string {
+// Render an analyzed cron pattern (the Schedule) as English.
+function describe(schedule: Schedule, opts: NormalizedOptions): string {
+  // A dense pattern — a seconds cadence stacked on a minutes cadence under an
+  // hours cadence — reads coarse-to-fine with the second nested under the
+  // minute, leading with the calendar anchor; it preempts the fine-to-coarse
+  // run-on the per-plan composer would otherwise produce.
+  const dense = denseCadence(schedule, opts);
+
+  if (dense !== null) {
+    return applyYear(dense, schedule, opts);
+  }
+
   // A finer leading cadence puts each coarser field in the confinement frame,
   // overriding the per-plan juxtaposed-cadence and duration-frame forms.
-  const body = confinement(ir, opts) ?? render(ir, ir.plan, opts);
+  const body = confinement(schedule, opts) ??
+    render(schedule, schedule.plan, opts);
 
   // A day union scopes the whole clause by its month, which leads the
   // description ("in June <time> whenever the day is …"); the time/cadence and
   // the trailing condition are already in `body`.
-  const lead = isDayUnion(ir, opts) ? dayUnionMonthLead(ir, opts) : '';
+  const lead = isDayUnion(schedule, opts) ?
+    dayUnionMonthLead(schedule, opts) : '';
 
-  return applyYear(lead + body, ir, opts);
+  return applyYear(lead + body, schedule, opts);
 }
 
 // Render one plan node. `composeSeconds` recurses with its `rest` plan.
-function render(ir: IR, plan: PlanNode, opts: NormalizedOptions): string {
+function render(schedule: Schedule, plan: PlanNode,
+  opts: NormalizedOptions): string {
   // The dispatch table keys each renderer to its own plan kind; the lookup
   // by `plan.kind` cannot prove the node matches the renderer's narrowed
   // parameter, so the call is made through a kind-agnostic signature.
   const renderer = renderers[plan.kind] as
-    (ir: IR, plan: PlanNode, opts: NormalizedOptions) => string;
+    (schedule: Schedule, plan: PlanNode, opts: NormalizedOptions) => string;
+
+  return renderer(schedule, plan, opts);
+}
+
+// --- Dense multi-cadence restructure. ---
+
+// Whether a field's shape is a true cadence — a repeating pattern (step, range,
+// or enumerated list), not a wildcard or a single pinned value. A dense pattern
+// stacks one of these in the second, the minute, and the hour.
+function isCadenceShape(shape: Schedule['shapes'][keyof Schedule['shapes']]):
+  boolean {
+  return shape === 'step' || shape === 'range' || shape === 'list';
+}
+
+// A dense pattern is a seconds cadence stacked on a minutes cadence under an
+// hours cadence: three independent cadences whose flat fine-to-coarse run-on
+// reads as a robotic list. It is recognized only on the `composeSeconds` plan
+// (a meaningful second over a coarser rest), with all three of second, minute,
+// and hour a cadence, and no day union (which owns its own leading-month
+// structure). The hour may take any cadence shape — a stride, a range window,
+// or a list/range-with-outlier — each rendered in its own existing leaf form
+// inside the restructured frame. A `clockTimes` rest is excluded: there the
+// minute and hour fold into a named clock-time enumeration ("every 15 seconds
+// of 9:00 a.m., 9:25 a.m., …"), a compact form already better than a run-on, so
+// it is left as is. Restricted to the default dialect's voice — the same scope
+// as the confinement frame — so other dialects and the compact `short` form
+// keep their established phrasing.
+function isDenseCadence(schedule: Schedule, opts: NormalizedOptions): boolean {
+  if (!opts.style.untilWindow || opts.short ||
+      schedule.plan.kind !== 'composeSeconds' ||
+      schedule.plan.rest.kind === 'clockTimes' ||
+      isDayUnion(schedule, opts)) {
+    return false;
+  }
 
-  return renderer(ir, plan, opts);
-}
+  const {shapes} = schedule;
 
-// --- Seconds renderers. ---
+  return isCadenceShape(shapes.second) && isCadenceShape(shapes.minute) &&
+    isCadenceShape(shapes.hour);
+}
 
-function renderEverySecond(ir: IR, plan: PlanOf<'everySecond'>,
+// The coarse hour cadence as a standalone fragment: a stride reads as its
+// bounded/bare cadence ("every five hours from midnight through 8 p.m.", "every
+// six hours"); a plain range reads as its window ("from 8 a.m. through 6
+// p.m."), the non-continuous form a stepped minute uses inside the range; a
+// list or range-with-outlier reads as its "during the … hours" frame (the same
+// phrasing the confinement form produces, just hoisted into the dense lead).
+function denseHourFragment(schedule: Schedule,
   opts: NormalizedOptions): string {
-  return 'every second' + trailingQualifier(ir, opts);
+  const stride = hourStride(schedule);
+
+  if (stride) {
+    return hourStrideCadence(stride, opts);
+  }
+
+  if (schedule.shapes.hour === 'range') {
+    // A plain range hour, whose single range segment carries the window bounds.
+    const segment = segmentsOf(schedule, 'hour').find(function range(part) {
+      return part.kind === 'range';
+    }) as Extract<Segment, {kind: 'range'}>;
+
+    return rangeWindow({
+      continuous: false,
+      from: +segment.bounds[0],
+      throughMinute: 0,
+      to: +segment.bounds[1]
+    }, opts);
+  }
+
+  // A list or range-with-outlier hour ("9-20,22") reads as the discrete
+  // "during the <times> hours" frame, the same construction the hour
+  // confinement uses for these shapes.
+  return 'during the ' +
+    hourSegmentTimes(schedule, {minute: 0, second: null}, false, opts) +
+    ' hours';
 }
 
-function renderStandaloneSeconds(ir: IR, plan: PlanOf<'standaloneSeconds'>,
+// The minute cadence as a standalone fragment, counted past the hour: a step is
+// its stride phrase, a range its "every minute from M through K" lead, and a
+// list its stride-or-enumeration.
+function denseMinuteFragment(schedule: Schedule,
   opts: NormalizedOptions): string {
-  return secondsLeadClause(ir, opts) + trailingQualifier(ir, opts);
+  if (schedule.shapes.minute === 'step') {
+    return stepCycle60(stepSegment(schedule, 'minute'), 'minute', 'hour', opts);
+  }
+
+  if (schedule.shapes.minute === 'range') {
+    return minuteRangeLead(schedule.pattern.minute, opts);
+  }
+
+  // A minute list has segments; an offset/uneven step the core enumerated to a
+  // list reads as a stride when its fires form a progression.
+  return strideFromSegments(segmentsOf(schedule, 'minute'), 'minute', 'hour',
+    opts) ?? listPastThe(segmentWords(segmentsOf(schedule, 'minute'), opts),
+    'minute', 'hour', opts);
 }
 
-function renderSecondPastMinute(ir: IR, plan: PlanOf<'secondPastMinute'>,
+// Assemble the dense form, or null when the pattern is not dense. The calendar
+// anchor leads ("on the last weekday of the month, …"), the cadences run
+// coarse-to-fine (hour, then minute), and the second nests under the minute
+// ("…, and within each of those minutes, every second …"). Each fragment is
+// today's leaf phrasing, reordered and nested but otherwise unchanged.
+function denseCadence(schedule: Schedule,
+  opts: NormalizedOptions): string | null {
+  if (!isDenseCadence(schedule, opts)) {
+    return null;
+  }
+
+  const hour = denseHourFragment(schedule, opts);
+  const minute = denseMinuteFragment(schedule, opts);
+  const second = secondsClause(schedule, 'minute', opts);
+  const nested = hour + ', ' + minute +
+    ', and within each of those minutes, ' + second;
+
+  // A trailing day qualifier (" on the last weekday of the month") leads the
+  // dense form instead; with no anchor the hour cadence leads alone.
+  const anchor = trailingQualifier(schedule, opts).trim();
+
+  return anchor ? anchor + ', ' + nested : nested;
+}
+
+// --- Seconds renderers. ---
+
+function renderEverySecond(schedule: Schedule, plan: PlanOf<'everySecond'>,
   opts: NormalizedOptions): string {
-  const secondField = ir.pattern.second;
+  return 'every second' + trailingQualifier(schedule, opts);
+}
+
+function renderStandaloneSeconds(schedule: Schedule,
+  plan: PlanOf<'standaloneSeconds'>, opts: NormalizedOptions): string {
+  return secondsLeadClause(schedule, opts) + trailingQualifier(schedule, opts);
+}
+
+function renderSecondPastMinute(schedule: Schedule,
+  plan: PlanOf<'secondPastMinute'>, opts: NormalizedOptions): string {
+  const secondField = schedule.pattern.second;
 
   return getNumber(secondField, opts) + ' ' +
     pluralize(secondField, 'second') +
-    ' past the minute, every minute' + trailingQualifier(ir, opts);
+    ' past the minute, every minute' + trailingQualifier(schedule, opts);
 }
 
 // A meaningful second combined with a single specific minute (and an open
 // hour). A single second folds into the minute anchor ("30 minutes and 15
 // seconds past the hour, every hour"); a list, range, or step leads with
 // its own clause.
-function renderSecondsWithinMinute(ir: IR, plan: PlanOf<'secondsWithinMinute'>,
-  opts: NormalizedOptions): string {
-  const minuteField = ir.pattern.minute;
+function renderSecondsWithinMinute(schedule: Schedule,
+  plan: PlanOf<'secondsWithinMinute'>, opts: NormalizedOptions): string {
+  const minuteField = schedule.pattern.minute;
   const minuteWord = getNumber(minuteField, opts);
   const minuteUnit = pluralize(minuteField, 'minute');
 
   if (plan.singleSecond) {
-    const secondField = ir.pattern.second;
+    const secondField = schedule.pattern.second;
 
     return minuteWord + ' ' + minuteUnit + ' and ' +
       getNumber(secondField, opts) + ' ' + pluralize(secondField, 'second') +
-      ' past the hour, every hour' + trailingQualifier(ir, opts);
+      ' past the hour, every hour' + trailingQualifier(schedule, opts);
   }
 
-  return secondsLeadClause(ir, opts) + ', ' + minuteWord + ' ' +
+  return secondsLeadClause(schedule, opts) + ', ' + minuteWord + ' ' +
     minuteUnit + ' past the hour, every hour' +
-    trailingQualifier(ir, opts);
+    trailingQualifier(schedule, opts);
 }
 
 // The hour-cadence rendering of a compose-seconds plan whose clock-time rest
 // would cross-multiply an hour stride under a single pinned minute, or null
 // when that does not apply (a non-clock rest, a multi-valued minute, or an
 // hour that is not a stride).
-function composeHourCadence(ir: IR, plan: PlanOf<'composeSeconds'>,
+function composeHourCadence(schedule: Schedule, plan: PlanOf<'composeSeconds'>,
   opts: NormalizedOptions): string | null {
   const clockRest = plan.rest.kind === 'clockTimes' ||
     plan.rest.kind === 'compactClockTimes';
 
-  if (!clockRest || ir.shapes.minute !== 'single') {
+  if (!clockRest || schedule.shapes.minute !== 'single') {
     return null;
   }
 
-  const minute = +ir.pattern.minute;
+  const minute = +schedule.pattern.minute;
 
-  return hourCadence(ir, minute, opts) ?? hourRangeCadence(ir, minute, opts);
+  return hourCadence(schedule, minute, opts) ??
+    hourRangeCadence(schedule, 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 ==
@@ -231,23 +375,24 @@ function composeHourCadence(ir: IR, plan: PlanOf<'composeSeconds'>,
 // form, never collapsing to the bare hour (which once repeated it, "9 a.m.,
 // 9 a.m."). A non-zero pinned minute is an unambiguous clock time the compact
 // "of 9:05 a.m." form reads as the minute, never the hour.
-function clockTimesConfinement(ir: IR, rest: PlanOf<'clockTimes'>,
-  opts: NormalizedOptions): string {
-  if (+rest.times[0].minute === 0 && ir.shapes.minute === 'single') {
-    return secondsLeadClause(ir, opts) + ' for one minute at ' +
-      durationHours(ir, rest, opts);
+function clockTimesConfinement(schedule: Schedule,
+  rest: PlanOf<'clockTimes'>, opts: NormalizedOptions): string {
+  if (+rest.times[0].minute === 0 && schedule.shapes.minute === 'single') {
+    return secondsLeadClause(schedule, opts) + ' for one minute at ' +
+      durationHours(schedule, rest, opts);
   }
 
-  return secondsLeadClause(ir, opts) + ' of ' + clockTimesOf(ir, rest, opts);
+  return secondsLeadClause(schedule, opts) + ' of ' +
+    clockTimesOf(schedule, rest, opts);
 }
 
-function renderComposeSeconds(ir: IR, plan: PlanOf<'composeSeconds'>,
-  opts: NormalizedOptions): string {
+function renderComposeSeconds(schedule: Schedule,
+  plan: PlanOf<'composeSeconds'>, opts: NormalizedOptions): string {
   // An hour step (or arithmetic-progression hour list) under a single pinned
   // minute is a cadence, not a wall of clock times: speak the second/minute
   // lead, then the hour cadence ("at 30 seconds past the hour, every two
   // hours"). The clock-time rest would otherwise cross-multiply the hours.
-  const cadence = composeHourCadence(ir, plan, opts);
+  const cadence = composeHourCadence(schedule, plan, opts);
 
   if (cadence !== null) {
     return cadence;
@@ -256,8 +401,9 @@ function renderComposeSeconds(ir: IR, plan: PlanOf<'composeSeconds'>,
   // A wildcard or stepped second under a fixed minute across one or more
   // specific hours confines the seconds to the clock time(s).
   if (plan.rest.kind === 'clockTimes' &&
-      (ir.shapes.second === 'wildcard' || ir.shapes.second === 'step')) {
-    return clockTimesConfinement(ir, plan.rest, opts);
+      (schedule.shapes.second === 'wildcard' ||
+        schedule.shapes.second === 'step')) {
+    return clockTimesConfinement(schedule, plan.rest, opts);
   }
 
   // A wildcard second under a */2 minute step with a wildcard hour binds
@@ -265,12 +411,12 @@ function renderComposeSeconds(ir: IR, plan: PlanOf<'composeSeconds'>,
   // the natural English for an interval of 2, and "of" joins the two without
   // the ambiguity of a comma, which reads as two independent cadences.
   // Scoped to */2 only; other step sizes keep the comma form.
-  if (ir.shapes.second === 'wildcard' &&
+  if (schedule.shapes.second === 'wildcard' &&
       plan.rest.kind === 'minuteFrequency' &&
       plan.rest.hours.kind === 'none' &&
-      ir.pattern.minute === '*/2') {
+      schedule.pattern.minute === '*/2') {
     return 'every second of every other minute' +
-      trailingQualifier(ir, opts);
+      trailingQualifier(schedule, opts);
   }
 
   // A compact clock-time rest folds a meaningful SINGLE second into its own
@@ -278,22 +424,22 @@ function renderComposeSeconds(ir: IR, plan: PlanOf<'composeSeconds'>,
   // double it. A wildcard or stepped second is not folded there (no
   // clockSecond), so it still leads its own clause here.
   const restOwnsLead = plan.rest.kind === 'compactClockTimes' &&
-    ir.analyses.clockSecond;
-  const lead = restOwnsLead ? '' : secondsLeadClause(ir, opts) + ', ';
+    schedule.analyses.clockSecond;
+  const lead = restOwnsLead ? '' : secondsLeadClause(schedule, opts) + ', ';
 
-  return lead + render(ir, plan.rest, opts);
+  return lead + render(schedule, plan.rest, opts);
 }
 
 // The bare-hour words for a minute-0 duration confinement, joined and followed
 // by the trailing day qualifier: "9 a.m. and 11 a.m., every day", "midnight,
 // 2 a.m., …, every day". The hour reads as its word (noon/midnight included),
 // never "H:00", since the "for one minute" frame already carries the minute.
-function durationHours(ir: IR, plan: PlanOf<'clockTimes'>,
+function durationHours(schedule: Schedule, plan: PlanOf<'clockTimes'>,
   opts: NormalizedOptions): string {
   const hours = plan.times.map(function clock(time) {
     return getTime({hour: time.hour, minute: 0}, opts);
   });
-  const trail = dayQualifier(ir, leadingWords, opts);
+  const trail = dayQualifier(schedule, leadingWords, opts);
 
   return joinList(hours, opts) + (trail && ', ' + trail);
 }
@@ -301,7 +447,7 @@ function durationHours(ir: IR, plan: PlanOf<'clockTimes'>,
 // The clock times for a non-zero pinned-minute compose-seconds rest, joined
 // and followed by the trailing day qualifier: "9:05 a.m. and 11:05 a.m.,
 // every day". The non-zero minute reads as a clock time, never the hour.
-function clockTimesOf(ir: IR, plan: PlanOf<'clockTimes'>,
+function clockTimesOf(schedule: Schedule, plan: PlanOf<'clockTimes'>,
   opts: NormalizedOptions): string {
   const times = plan.times.map(function clock(time) {
     return getTime({
@@ -311,7 +457,7 @@ function clockTimesOf(ir: IR, plan: PlanOf<'clockTimes'>,
       explicit: true
     }, opts);
   });
-  const trail = dayQualifier(ir, leadingWords, opts);
+  const trail = dayQualifier(schedule, leadingWords, opts);
 
   return joinList(times, opts) + (trail && ', ' + trail);
 }
@@ -319,8 +465,9 @@ function clockTimesOf(ir: IR, plan: PlanOf<'clockTimes'>,
 // The leading clause describing a second field relative to the minute,
 // e.g. "at 5 and 10 seconds past the minute" or "every second from zero
 // through 30 past the minute".
-function secondsLeadClause(ir: IR, opts: NormalizedOptions): string {
-  return secondsClause(ir, 'minute', opts);
+function secondsLeadClause(schedule: Schedule,
+  opts: NormalizedOptions): string {
+  return secondsClause(schedule, 'minute', opts);
 }
 
 // The second clause counted against an arbitrary anchor. The anchor is
@@ -328,10 +475,10 @@ function secondsLeadClause(ir: IR, opts: NormalizedOptions): string {
 // pinned minute 0 into the hour and counts the second "past the hour"
 // instead ("at 30 seconds past the hour", "every second from 0 through 10
 // past the hour"), so the minute-0 confinement is stated, not dropped.
-function secondsClause(ir: IR, anchor: string,
+function secondsClause(schedule: Schedule, anchor: string,
   opts: NormalizedOptions): string {
-  const secondField = ir.pattern.second;
-  const shape = ir.shapes.second;
+  const secondField = schedule.pattern.second;
+  const shape = schedule.shapes.second;
 
   if (secondField === '*') {
     return 'every second';
@@ -340,7 +487,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(schedule, 'second'),
       'second', anchor, opts);
   }
 
@@ -360,76 +507,85 @@ 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(schedule, 'second'), 'second', anchor,
+    opts) ?? listPastThe(segmentWords(segmentsOf(schedule, 'second'), opts),
     'second', anchor, opts);
 }
 
 // --- Minute renderers. ---
 
-function renderEveryMinute(ir: IR, plan: PlanOf<'everyMinute'>,
+function renderEveryMinute(schedule: Schedule, plan: PlanOf<'everyMinute'>,
   opts: NormalizedOptions): string {
-  return 'every minute' + trailingQualifier(ir, opts);
+  return 'every minute' + trailingQualifier(schedule, opts);
 }
 
-function renderSingleMinute(ir: IR, plan: PlanOf<'singleMinute'>,
+function renderSingleMinute(schedule: Schedule, plan: PlanOf<'singleMinute'>,
   opts: NormalizedOptions): string {
-  const minuteField = ir.pattern.minute;
+  const minuteField = schedule.pattern.minute;
 
   return getNumber(minuteField, opts) + ' ' +
     pluralize(minuteField, 'minute') +
-    ' past the hour, every hour' + trailingQualifier(ir, opts);
+    ' past the hour, every hour' + trailingQualifier(schedule, opts);
 }
 
-function renderRangeOfMinutes(ir: IR, plan: PlanOf<'rangeOfMinutes'>,
-  opts: NormalizedOptions): string {
-  return minuteRangeLead(ir.pattern.minute, opts) +
-    trailingQualifier(ir, opts);
+function renderRangeOfMinutes(schedule: Schedule,
+  plan: PlanOf<'rangeOfMinutes'>, opts: NormalizedOptions): string {
+  return minuteRangeLead(schedule.pattern.minute, opts) +
+    trailingQualifier(schedule, opts);
 }
 
-function renderMultipleMinutes(ir: IR, plan: PlanOf<'multipleMinutes'>,
-  opts: NormalizedOptions): string {
+function renderMultipleMinutes(schedule: Schedule,
+  plan: PlanOf<'multipleMinutes'>, opts: NormalizedOptions): string {
   // A multiple-minutes plan is selected only for a minute list, which has
   // 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(schedule, 'minute'), 'minute', 'hour', opts);
 
-  return (stride ?? listPastThe(segmentWords(ir.analyses.segments.minute!,
-    opts), 'minute', 'hour', opts)) + trailingQualifier(ir, opts);
+  return (stride ?? listPastThe(segmentWords(segmentsOf(schedule, 'minute'),
+    opts), 'minute', 'hour', opts)) + trailingQualifier(schedule, opts);
 }
 
 // A repeating minute step, qualified by the active hour window(s).
-function renderMinuteFrequency(ir: IR, plan: PlanOf<'minuteFrequency'>,
-  opts: NormalizedOptions): string {
+function renderMinuteFrequency(schedule: Schedule,
+  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(schedule, 'minute'),
     'minute', 'hour', opts);
 
   if (plan.hours.kind === 'during') {
     // A uneven hour stride confines the minute cadence to its own bounded hour
     // cadence ("every 15 minutes, every five hours from midnight through 8
     // p.m."); an irregular hour list still names each hour's window.
-    const cadence = unevenHourCadence(ir, opts);
+    const cadence = unevenHourCadence(schedule, opts);
 
     phrase += cadence ?
       ', ' + cadence :
       ' during the ' +
-        hourTimesFromPlan(ir, plan.hours.times, false, opts) + ' hours';
+        hourTimesFromPlan(schedule, 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(schedule, 'hour'), opts);
   }
 
-  return phrase + trailingQualifier(ir, opts);
+  return phrase + trailingQualifier(schedule, opts);
 }
 
 // A minute wildcard or plain range under a single specific hour fires
@@ -437,43 +593,43 @@ function renderMinuteFrequency(ir: IR, plan: PlanOf<'minuteFrequency'>,
 // whole hour, so it reads as that hour itself ("every minute of the 9 a.m.
 // hour") rather than a synthesized "from H:00 through H:59" range the source
 // never stated; a plain range is a real window and keeps "from … through …".
-function renderMinuteSpanInHour(ir: IR, plan: PlanOf<'minuteSpanInHour'>,
-  opts: NormalizedOptions): string {
-  if (ir.pattern.minute === '*') {
+function renderMinuteSpanInHour(schedule: Schedule,
+  plan: PlanOf<'minuteSpanInHour'>, opts: NormalizedOptions): string {
+  if (schedule.pattern.minute === '*') {
     return 'every minute of the ' +
       getTime({hour: plan.hour, minute: 0}, opts) + ' hour' +
-      trailingQualifier(ir, opts);
+      trailingQualifier(schedule, opts);
   }
 
   return 'every minute from ' +
     getTime({hour: plan.hour, minute: plan.span[0]}, opts) +
     through(opts) + getTime({hour: plan.hour, minute: plan.span[1]}, opts) +
-    trailingQualifier(ir, opts);
+    trailingQualifier(schedule, opts);
 }
 
 // A minute window combined with discrete hours fires within that window
 // during each hour.
-function renderMinutesAcrossHours(ir: IR, plan: PlanOf<'minutesAcrossHours'>,
-  opts: NormalizedOptions): string {
+function renderMinutesAcrossHours(schedule: Schedule,
+  plan: PlanOf<'minutesAcrossHours'>, opts: NormalizedOptions): string {
   // A uneven hour stride reads as a cadence, not a wall of hour columns: the
   // minute lead, then "every N hours from X through Y".
-  const cadence = unevenHourCadence(ir, opts);
+  const cadence = unevenHourCadence(schedule, opts);
 
   if (plan.form === 'wildcard') {
     if (cadence !== null) {
-      return 'every minute, ' + cadence + trailingQualifier(ir, opts);
+      return 'every minute, ' + cadence + trailingQualifier(schedule, opts);
     }
 
     return 'every minute during the ' +
-      hourTimesFromPlan(ir, plan.times, false, opts) + ' hours' +
-      trailingQualifier(ir, opts);
+      hourTimesFromPlan(schedule, plan.times, false, opts) + ' hours' +
+      trailingQualifier(schedule, opts);
   }
 
   if (plan.form === 'range') {
-    const lead = minuteRangeLead(ir.pattern.minute, opts);
+    const lead = minuteRangeLead(schedule.pattern.minute, opts);
 
     if (cadence !== null) {
-      return lead + ', ' + cadence + trailingQualifier(ir, opts);
+      return lead + ', ' + cadence + trailingQualifier(schedule, opts);
     }
 
     // A plain minute range is a cadence, so an hour list confines it with the
@@ -484,30 +640,31 @@ function renderMinutesAcrossHours(ir: IR, plan: PlanOf<'minutesAcrossHours'>,
     // hour, at 9 a.m."), never the plural "hours" confinement.
     if (singleHourFire(plan.times)) {
       return lead + ', at ' +
-        hourTimesFromPlan(ir, plan.times, true, opts) +
-        trailingQualifier(ir, opts);
+        hourTimesFromPlan(schedule, plan.times, true, opts) +
+        trailingQualifier(schedule, opts);
     }
 
     return lead + ' during the ' +
-      hourTimesFromPlan(ir, plan.times, false, opts) + ' hours' +
-      trailingQualifier(ir, opts);
+      hourTimesFromPlan(schedule, plan.times, false, opts) + ' hours' +
+      trailingQualifier(schedule, opts);
   }
 
   // The 'list' form is a minute list, which has segments; an offset/uneven
   // 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(schedule, 'minute'), 'minute', 'hour',
+      opts) ??
+      listPastThe(segmentWords(segmentsOf(schedule, 'minute'), opts),
         'minute', 'hour', opts);
 
   if (cadence !== null) {
-    return lead + ', ' + cadence + trailingQualifier(ir, opts);
+    return lead + ', ' + cadence + trailingQualifier(schedule, opts);
   }
 
-  const times = hourTimesFromPlan(ir, plan.times, true, opts);
+  const times = hourTimesFromPlan(schedule, plan.times, true, opts);
 
-  return lead + ', at ' + times + trailingQualifier(ir, opts);
+  return lead + ', at ' + times + trailingQualifier(schedule, opts);
 }
 
 // Spelled ordinals for "during every Nth hour" — the clean hour-step
@@ -530,34 +687,35 @@ function everyNthHour(segment: StepSegment, opts: NormalizedOptions): string {
 // A minute wildcard or plain range under an hour step. A wildcard minute (a
 // cadence) is reached only for a clean step and is confined to every Nth hour;
 // a plain range is a per-hour window whose recurrence trails as its own clause.
-function renderMinuteSpanAcrossHourStep(ir: IR,
+function renderMinuteSpanAcrossHourStep(schedule: Schedule,
   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(schedule, '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
   // confines to every Nth hour without a bounded-cadence case here.
   if (plan.form === 'wildcard') {
     return 'every minute ' + everyNthHour(segment, opts) +
-      trailingQualifier(ir, opts);
+      trailingQualifier(schedule, opts);
   }
 
   // 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(schedule, 'minute'), 'minute', 'hour',
+      opts) ??
+      listPastThe(segmentWords(segmentsOf(schedule, 'minute'), opts),
         'minute', 'hour', opts) :
-    minuteRangeLead(ir.pattern.minute, opts);
+    minuteRangeLead(schedule.pattern.minute, opts);
   // A bounded or uneven hour step reads as its endpoint-pinning cadence after
   // the minute lead, not a wall of clock-time columns; an offset-clean step
   // keeps its existing per-step phrasing.
-  const cadence = unevenHourCadence(ir, opts);
+  const cadence = unevenHourCadence(schedule, opts);
 
   return lead + ', ' +
-    (cadence ?? stepHours(segment, opts)) + trailingQualifier(ir, opts);
+    (cadence ?? stepHours(segment, opts)) + trailingQualifier(schedule, opts);
 }
 
 // Lead phrase for a plain minute range: "every minute from <a> through <b>
@@ -573,60 +731,60 @@ function minuteRangeLead(minuteField: string,
 
 // --- Hour renderers. ---
 
-function renderEveryHour(ir: IR, plan: PlanOf<'everyHour'>,
+function renderEveryHour(schedule: Schedule, plan: PlanOf<'everyHour'>,
   opts: NormalizedOptions): string {
-  return 'every hour' + trailingQualifier(ir, opts);
+  return 'every hour' + trailingQualifier(schedule, opts);
 }
 
 // An hour range fires within a window: on the hour it reads "every hour
 // from 9 a.m. through 5 p.m."; a minute wildcard or range fires every
 // minute; a discrete minute anchors as a lead clause.
-function renderHourRange(ir: IR, plan: PlanOf<'hourRange'>,
+function renderHourRange(schedule: Schedule, plan: PlanOf<'hourRange'>,
   opts: NormalizedOptions): string {
   const window = hourWindow(boundedWindow(plan), opts);
 
   if (plan.minuteForm === 'wildcard') {
-    return 'every minute ' + window + trailingQualifier(ir, opts);
+    return 'every minute ' + window + trailingQualifier(schedule, opts);
   }
 
   if (plan.minuteForm === 'range') {
-    return minuteRangeLead(ir.pattern.minute, opts) + ', ' + window +
-      trailingQualifier(ir, opts);
+    return minuteRangeLead(schedule.pattern.minute, opts) + ', ' + window +
+      trailingQualifier(schedule, opts);
   }
 
-  return rangeMinuteLead(ir, opts) + ' ' + window +
-    trailingQualifier(ir, opts);
+  return rangeMinuteLead(schedule, opts) + ' ' + window +
+    trailingQualifier(schedule, opts);
 }
 
 // Lead phrase for a discrete minute within an hour range: on-the-hour
 // reads "every hour"; otherwise the minute list anchors it.
-function rangeMinuteLead(ir: IR, opts: NormalizedOptions): string {
-  if (ir.pattern.minute === '0') {
+function rangeMinuteLead(schedule: Schedule, opts: NormalizedOptions): string {
+  if (schedule.pattern.minute === '0') {
     return 'every hour';
   }
 
   // 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(schedule, 'minute'), 'minute', 'hour',
+    opts) ?? listPastThe(segmentWords(segmentsOf(schedule, 'minute'), opts),
     'minute', 'hour', opts);
 }
 
-function renderHourStep(ir: IR, plan: PlanOf<'hourStep'>,
+function renderHourStep(schedule: Schedule, plan: PlanOf<'hourStep'>,
   opts: NormalizedOptions): string {
   // A bounded or uneven hour step reads as its endpoint-pinning cadence ("every
   // two hours from 9 a.m. through 5 p.m."), the same form the compound paths
   // speak; an offset-clean step keeps its bare or "from M" cadence.
-  const cadence = unevenHourCadence(ir, opts);
+  const cadence = unevenHourCadence(schedule, opts);
 
   if (cadence !== null) {
-    return cadence + trailingQualifier(ir, opts);
+    return cadence + trailingQualifier(schedule, opts);
   }
 
   // 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) +
-    trailingQualifier(ir, opts);
+  return stepHours(stepSegment(schedule, 'hour'), opts) +
+    trailingQualifier(schedule, opts);
 }
 
 // The hour-range plan as a window. The close lands on the top of the final
@@ -634,31 +792,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,24 +835,31 @@ 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
 // a day-level qualifier, e.g. "every day at 9 a.m. and 9:30 a.m.".
-function renderClockTimes(ir: IR, plan: PlanOf<'clockTimes'>,
+function renderClockTimes(schedule: Schedule, plan: PlanOf<'clockTimes'>,
   opts: NormalizedOptions): string {
   // An hour step or range (or arithmetic-progression hour list) under a
   // single pinned minute reads as a cadence or window rather than a
   // cross-product of clock times.
-  if (ir.shapes.minute === 'single') {
-    const minute = +ir.pattern.minute;
-    const cadence = hourCadence(ir, minute, opts) ??
-      hourRangeCadence(ir, minute, opts);
+  if (schedule.shapes.minute === 'single') {
+    const minute = +schedule.pattern.minute;
+    const cadence = hourCadence(schedule, minute, opts) ??
+      hourRangeCadence(schedule, minute, opts);
 
     if (cadence !== null) {
       return cadence;
@@ -700,28 +876,28 @@ function renderClockTimes(ir: IR, plan: PlanOf<'clockTimes'>,
     }, opts);
   });
 
-  return interpretDayQualifier(ir, opts) + 'at ' + joinList(times, opts) +
-    dayUnionTrail(ir, opts);
+  return interpretDayQualifier(schedule, opts) + 'at ' + joinList(times, opts) +
+    dayUnionTrail(schedule, opts);
 }
 
 // The trailing day-union condition for a clock-time form (which leads with its
 // time, not a day qualifier), or an empty string when the pattern is not a day
 // union. The cadence renderers carry this through `trailingQualifier` instead.
-function dayUnionTrail(ir: IR, opts: NormalizedOptions): string {
-  return isDayUnion(ir, opts) ? dayUnionCondition(ir, opts) : '';
+function dayUnionTrail(schedule: Schedule, opts: NormalizedOptions): string {
+  return isDayUnion(schedule, opts) ? dayUnionCondition(schedule, opts) : '';
 }
 
 // Compact form for a clock-time set past the enumeration cap. A single
 // minute folds into per-segment hour windows; a minute list leads with its
 // own clause instead of cross-multiplying into a wall of times.
-function renderCompactClockTimes(ir: IR, plan: PlanOf<'compactClockTimes'>,
-  opts: NormalizedOptions): string {
+function renderCompactClockTimes(schedule: Schedule,
+  plan: PlanOf<'compactClockTimes'>, opts: NormalizedOptions): string {
   if (plan.fold) {
     // An hour step or range (or arithmetic-progression hour list) under the
     // single pinned minute reads as a cadence or window, not a wall of clock
     // times. (Returns null for an irregular list, which keeps folding below.)
-    const cadence = hourCadence(ir, +plan.minute, opts) ??
-      hourRangeCadence(ir, +plan.minute, opts);
+    const cadence = hourCadence(schedule, +plan.minute, opts) ??
+      hourRangeCadence(schedule, +plan.minute, opts);
 
     if (cadence !== null) {
       return cadence;
@@ -729,113 +905,109 @@ 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(schedule, 'hour').some(function range(segment) {
       return segment.kind === 'range';
     });
 
     // A contiguous hour range reads with the hour-range frame ("every
     // hour from X through Y"), not a clock-time span ("at X through Y").
-    if (hasRange && !ir.analyses.clockSecond) {
-      return foldedHourWindows(ir, plan, opts) + trailingQualifier(ir, opts);
+    if (hasRange && !schedule.analyses.clockSecond) {
+      return foldedHourWindows(schedule, plan, opts) +
+        trailingQualifier(schedule, opts);
     }
 
-    const fold = {minute: plan.minute, second: ir.analyses.clockSecond};
+    const fold = {minute: plan.minute, second: schedule.analyses.clockSecond};
 
-    return interpretDayQualifier(ir, opts) + 'at ' +
-      hourSegmentTimes(ir, fold, true, opts) + dayUnionTrail(ir, opts);
+    return interpretDayQualifier(schedule, opts) + 'at ' +
+      hourSegmentTimes(schedule, fold, true, opts) +
+      dayUnionTrail(schedule, opts);
   }
 
   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(schedule, 'minute'), 'minute', 'hour',
+      opts) ??
+      listPastThe(segmentWords(segmentsOf(schedule, 'minute'), opts),
         'minute', 'hour', opts);
   // A uneven hour stride reads as a cadence after the minute lead, not a wall
   // of clock-time columns.
-  const cadence = unevenHourCadence(ir, opts);
+  const cadence = unevenHourCadence(schedule, opts);
   const phrase = cadence ?
-    minuteLead + ', ' + cadence + trailingQualifier(ir, opts) :
+    minuteLead + ', ' + cadence + trailingQualifier(schedule, opts) :
     minuteLead +
-    ', at ' + hourSegmentTimes(ir, {minute: 0, second: null}, true, opts) +
-    trailingQualifier(ir, opts);
+    ', at ' +
+    hourSegmentTimes(schedule, {minute: 0, second: null}, true, opts) +
+    trailingQualifier(schedule, opts);
 
   // A single non-zero second cannot fold into the per-minute clause, so it
   // leads with its own.
-  return ir.analyses.clockSecond ?
-    secondsLeadClause(ir, opts) + ', ' + phrase :
+  return schedule.analyses.clockSecond ?
+    secondsLeadClause(schedule, opts) + ', ' + phrase :
     phrase;
 }
 
 // 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").
-function foldedHourWindows(ir: IR, plan: PlanOf<'compactClockTimes'>,
-  opts: NormalizedOptions): string {
+// appended by `outlierTail` ("and at Z").
+function foldedHourWindows(schedule: Schedule,
+  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(schedule).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(schedule, '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);
+  const phrase = rangeMinuteLead(schedule, 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(schedule: Schedule): number[] {
   const hours: number[] = [];
-  let pureStrays = true;
 
   // Reached only under discrete hours, which carry segments.
-  ir.analyses.segments.hour!.forEach(function classify(segment) {
+  segmentsOf(schedule, '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. ---
@@ -864,19 +1036,19 @@ function isCadenceField(token: string): boolean {
 // the pattern has no cadence lead (the finest restricted field is a clock-point
 // single/range/list). The seconds lead when restricted as a cadence; otherwise
 // the minute leads when the second is a plain :00 and the minute is a cadence.
-function leadingCadence(ir: IR, opts: NormalizedOptions):
+function leadingCadence(schedule: Schedule, opts: NormalizedOptions):
   {text: string; secondLead: boolean} | null {
-  const {second, minute} = ir.pattern;
+  const {second, minute} = schedule.pattern;
 
   if (isCadenceField(second)) {
-    return {secondLead: true, text: secondsClause(ir, 'minute', opts)};
+    return {secondLead: true, text: secondsClause(schedule, 'minute', opts)};
   }
 
   if (second === '0' && isCadenceField(minute)) {
     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(schedule, 'minute'),
         'minute', 'hour', opts);
 
     return {secondLead: false, text};
@@ -889,8 +1061,9 @@ function leadingCadence(ir: IR, opts: NormalizedOptions):
 // confinement: "during minute :NN", "during minutes :NN through :MM", "during
 // minutes :NN and :MM". A clean minute step reads "of every other minute". A
 // wildcard minute is redundant under the seconds cadence and drops (empty).
-function minuteConfinement(ir: IR, opts: NormalizedOptions): string {
-  const minute = ir.pattern.minute;
+function minuteConfinement(schedule: Schedule,
+  opts: NormalizedOptions): string {
+  const minute = schedule.pattern.minute;
 
   if (minute === '*') {
     return '';
@@ -905,13 +1078,13 @@ 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(schedule, 'minute');
 
-  if (ir.shapes.minute === 'single') {
+  if (schedule.shapes.minute === 'single') {
     return ' during minute :' + pad(minute);
   }
 
-  if (ir.shapes.minute === 'range') {
+  if (schedule.shapes.minute === 'range') {
     const bounds = minute.split('-');
 
     return ' during minutes :' + pad(bounds[0]) + through(opts) + ':' +
@@ -932,15 +1105,15 @@ function minuteConfinement(ir: IR, opts: NormalizedOptions): string {
 // ("of the midnight hour"). A clean hour step is "of every other hour"; a range
 // reuses the until-window; a list or stepped range reads "during the … hours".
 // A wildcard hour drops (empty).
-function hourConfinement(ir: IR, opts: NormalizedOptions): string {
-  const hour = ir.pattern.hour;
+function hourConfinement(schedule: Schedule, opts: NormalizedOptions): string {
+  const hour = schedule.pattern.hour;
 
   if (hour === '*') {
     // A pinned minute confinement ("during minute :00") repeats across every
     // hour, so the hour is named as the unit of recurrence; a stepped minute
     // ("of every other minute") or absent minute already implies all hours.
-    const minutePinned = ir.pattern.minute !== '*' &&
-      !isCadenceField(ir.pattern.minute);
+    const minutePinned = schedule.pattern.minute !== '*' &&
+      !isCadenceField(schedule.pattern.minute);
 
     return minutePinned ? ' of every hour' : '';
   }
@@ -949,10 +1122,10 @@ function hourConfinement(ir: IR, opts: NormalizedOptions): string {
     return hour === '*/2' ? ' of every other hour' : '';
   }
 
-  if (ir.shapes.hour === 'single') {
+  if (schedule.shapes.hour === 'single') {
     const h = +hour;
 
-    if (ir.shapes.minute === 'step') {
+    if (schedule.shapes.minute === 'step') {
       return ' from ' + getTime({hour: h, minute: 0}, opts) + ' until ' +
         getTime({hour: (h + 1) % 24, minute: 0}, opts);
     }
@@ -960,93 +1133,98 @@ function hourConfinement(ir: IR, opts: NormalizedOptions): string {
     // A pinned minute confinement already named the minute, so the hour reads
     // as a plain clock point; a wildcard or absent minute makes the hour the
     // unit of recurrence ("of the midnight hour").
-    if (ir.pattern.minute !== '*' && !isCadenceField(ir.pattern.minute)) {
+    if (schedule.pattern.minute !== '*' &&
+      !isCadenceField(schedule.pattern.minute)) {
       return ' at ' + getTime({hour: h, minute: 0}, opts);
     }
 
     return ' of the ' + getTime({hour: h, minute: 0}, opts) + ' hour';
   }
 
-  if (ir.shapes.hour === 'range') {
+  if (schedule.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: schedule.pattern.minute === '*',
+      from: +bounds[0],
+      throughMinute: 0,
+      to: +bounds[1]
+    }, opts);
   }
 
   // An hour list or stepped range reads "during the <times> hours".
   return ' during the ' +
-    hourSegmentTimes(ir, {minute: 0, second: null}, false, opts) + ' hours';
-}
-
-// Whether the hour field reads as a contiguous window — a real range whose
-// close depends on the finer field's last fire. A finer STEP cadence does not
-// fill the closing hour ("from 9 a.m. until 5:45 p.m."), so that window is left
-// to the existing windowing renderer rather than the confinement frame, which
-// closes on the top of the next hour ("until 6 p.m.").
-function isContiguousHourRange(ir: IR): boolean {
-  return ir.shapes.hour === 'range';
+    hourSegmentTimes(schedule, {minute: 0, second: null}, false, opts) +
+    ' hours';
 }
 
 // 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").
-function confinableHour(ir: IR): boolean {
-  if (ir.shapes.hour !== 'step') {
+// 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(schedule: Schedule): boolean {
+  if (schedule.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(schedule, 'hour');
 
-  return ir.pattern.hour === '*/2' || segment.startToken.indexOf('-') !== -1;
+  return schedule.pattern.hour === '*/2' ||
+    segment.startToken.indexOf('-') !== -1;
 }
 
 // Whether a minute list is really a stride the existing renderer speaks as a
 // cadence ("every two minutes from 3 through 59"): such a progression is not a
 // short explicit ":NN" confinement, so it defers.
-function isMinuteStride(ir: IR): boolean {
-  if (ir.shapes.minute !== 'list') {
+function isMinuteStride(schedule: Schedule): boolean {
+  if (schedule.shapes.minute !== 'list') {
     return false;
   }
 
-  const values = singleValues(ir.analyses.segments.minute!);
+  const values = singleValues(segmentsOf(schedule, '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.
-function confinementEligible(ir: IR,
+// 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(schedule: Schedule,
   lead: {secondLead: boolean}): boolean {
-  const {minute, hour} = ir.pattern;
+  const {minute, hour} = schedule.pattern;
   const minuteStep = isCadenceField(minute) && minute !== '*';
 
   // A non-`*/2` hour stride keeps the existing cadence form.
-  if (!confinableHour(ir)) {
+  if (!confinableHour(schedule)) {
     return false;
   }
 
   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
-    // the "of every other minute" confinement; other steps defer entirely.
+    // the "of every other minute" confinement; other steps defer entirely. A
+    // contiguous hour range (`hour === 'range'`) is left to that windowing
+    // renderer rather than this confinement frame, which closes on the top of
+    // the next hour.
     if (minuteStep) {
-      return minute === '*/2' && !isContiguousHourRange(ir);
+      return minute === '*/2' && schedule.shapes.hour !== 'range';
     }
 
     // A minute list that is really a stride keeps its cadence form; a short
     // explicit minute list crossed with a discrete hour LIST is a wall of
     // distinct clock times ("9:00 a.m., 9:25 a.m., …"), not a single minute
     // confinement. Both stay with the enumerating renderer.
-    if (isMinuteStride(ir) ||
-        ir.shapes.minute === 'list' && ir.shapes.hour === 'list') {
+    if (isMinuteStride(schedule) ||
+        schedule.shapes.minute === 'list' && schedule.shapes.hour === 'list') {
       return false;
     }
 
@@ -1054,7 +1232,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.
@@ -1062,13 +1240,15 @@ function confinementEligible(ir: IR,
     return true;
   }
 
-  return ir.shapes.hour === 'single' && minute === '*/2';
+  return schedule.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.
-function confinement(ir: IR, opts: NormalizedOptions): string | null {
+// 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(schedule: Schedule,
+  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
   // keep their established juxtaposed-cadence / duration-frame phrasing.
@@ -1079,20 +1259,20 @@ function confinement(ir: IR, opts: NormalizedOptions): string | null {
   // With nothing coarser to confine (minute and hour both wildcard), the bare
   // cadence renderers already speak the pattern ("every second", "every
   // minute"); the confinement frame only applies once a coarser field is set.
-  if (ir.pattern.minute === '*' && ir.pattern.hour === '*') {
+  if (schedule.pattern.minute === '*' && schedule.pattern.hour === '*') {
     return null;
   }
 
-  const lead = leadingCadence(ir, opts);
+  const lead = leadingCadence(schedule, opts);
 
-  if (!lead || !confinementEligible(ir, lead)) {
+  if (!lead || !confinementEligible(schedule, lead)) {
     return null;
   }
 
-  const minutePart = lead.secondLead ? minuteConfinement(ir, opts) : '';
+  const minutePart = lead.secondLead ? minuteConfinement(schedule, opts) : '';
 
-  return lead.text + minutePart + hourConfinement(ir, opts) +
-    trailingQualifier(ir, opts);
+  return lead.text + minutePart + hourConfinement(schedule, opts) +
+    trailingQualifier(schedule, opts);
 }
 
 // The plan dispatch table.
@@ -1132,47 +1312,30 @@ const renderers = {
 function renderStride(stride: Stride, opts: NormalizedOptions): string {
   const {interval, start, last, cycle, unit, anchor} = stride;
   const cadence = 'every ' + getNumber(interval, opts) + ' ' + unit + 's';
-  const tiles = cycle % interval === 0;
 
-  if (start === 0 && tiles) {
-    return cadence;
-  }
+  return chooseStride({start, interval, cycle}, {
+    bare: () => cadence,
 
-  if (start < interval && tiles) {
     // A clean wrap from a non-zero offset: name the start, no endpoint.
-    return cadence + ' from ' + getNumber(start, opts) + ' ' +
-      pluralize(start, unit) + ' past the ' + anchor;
-  }
-
-  // A bounded, non-wrapping set: pin both endpoints. Each bound is a value, so
-  // it reads as a digit, matching the range idiom ("from 0 through 30").
-  const num = seriesNumber();
+    offset: () => cadence + ' from ' + getNumber(start, opts) + ' ' +
+      pluralize(start, unit) + ' past the ' + anchor,
 
-  return cadence + ' from ' + num(start) + through(opts) + num(last) + ' ' +
-    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[] = [];
+    // A bounded, non-wrapping set: pin both endpoints. Each bound is a value,
+    // so it reads as a digit, matching the range idiom ("from 0 through 30").
+    bounded: () => {
+      const num = seriesNumber();
 
-  for (const segment of segments) {
-    if (segment.kind !== 'single') {
-      return null;
+      return cadence + ' from ' + num(start) + through(opts) + num(last) + ' ' +
+        pluralize(last, unit) + ' past the ' + anchor;
     }
-
-    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.
+// enumerates an offset/uneven step to this fire list; the Schedule 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, anchor: string,
   opts: NormalizedOptions): string | null {
   const values = singleValues(segments);
@@ -1255,29 +1418,14 @@ function hourStrideCadence(stride: {start: number; interval: number;
   last: number}, opts: NormalizedOptions): string {
   const {start, interval, last} = stride;
   const cadence = 'every ' + getNumber(interval, opts) + ' hours';
-  const tiles = 24 % interval === 0;
-
-  if (start === 0 && tiles) {
-    return cadence;
-  }
 
-  if (start < interval && tiles) {
-    return cadence + ' from ' + getTime({hour: start, minute: 0}, opts);
-  }
-
-  return cadence + ' from ' + getTime({hour: start, minute: 0}, opts) +
-    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;
+  return chooseStride({start, interval, cycle: 24}, {
+    bare: () => cadence,
+    offset: () => cadence + ' from ' + getTime({hour: start, minute: 0}, opts),
+    bounded: () =>
+      cadence + ' from ' + getTime({hour: start, minute: 0}, opts) +
+      through(opts) + getTime({hour: last, minute: 0}, opts)
+  });
 }
 
 // The bounded cadence for an hour stride that pins both clock-time endpoints,
@@ -1287,8 +1435,9 @@ function offsetCleanStride(
 // ("…, every five hours from midnight through 8 p.m.") than as a wall of
 // clock-time columns. An offset-clean stride keeps its existing confinement
 // form, so only the endpoint-bearing case routes here.
-function unevenHourCadence(ir: IR, opts: NormalizedOptions): string | null {
-  const stride = hourStride(ir);
+function unevenHourCadence(schedule: Schedule,
+  opts: NormalizedOptions): string | null {
+  const stride = hourStride(schedule);
 
   if (!stride || offsetCleanStride(stride)) {
     return null;
@@ -1297,51 +1446,17 @@ 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
-// list like 9,17 keeps enumerating). The IR is unchanged — the renderer
+// list like 9,17 keeps enumerating). The Schedule is unchanged — the renderer
 // recognizes the stride and speaks it as a cadence instead of the clock-time
 // cross-product.
-function hourStride(ir: IR):
+function hourStride(schedule: Schedule):
   {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(schedule, 'hour');
 
   if (segments.length === 1 && segments[0].kind === 'step') {
     const segment = segments[0];
@@ -1368,8 +1483,8 @@ function hourStride(ir: IR):
 // The second's status against a pinned minute: a wildcard or sub-minute step
 // fills the minute (a "for one minute" frame at minute 0); a single 0 is just
 // the top of the minute (no clause); anything else needs its own clause.
-function subMinuteSecond(ir: IR): boolean {
-  return ir.pattern.second === '*' || ir.shapes.second === 'step';
+function subMinuteSecond(schedule: Schedule): boolean {
+  return schedule.pattern.second === '*' || schedule.shapes.second === 'step';
 }
 
 // The lead clause for an hour-cadence rendering: the second and the pinned
@@ -1379,14 +1494,14 @@ function subMinuteSecond(ir: IR): boolean {
 // minute" frame (the whole minute-0 window). A non-zero minute is a real
 // clock minute: the second leads with its own "past the minute" clause (if
 // any), then the minute reads "M minutes past the hour".
-function hourCadenceLead(ir: IR, minute: number,
+function hourCadenceLead(schedule: Schedule, minute: number,
   opts: NormalizedOptions): string {
   if (minute === 0) {
-    if (subMinuteSecond(ir)) {
-      return secondsClause(ir, 'minute', opts) + ' for one minute';
+    if (subMinuteSecond(schedule)) {
+      return secondsClause(schedule, 'minute', opts) + ' for one minute';
     }
 
-    return secondsClause(ir, 'hour', opts);
+    return secondsClause(schedule, 'hour', opts);
   }
 
   const minutePhrase = getNumber(minute, opts) + ' ' +
@@ -1394,11 +1509,11 @@ function hourCadenceLead(ir: IR, minute: number,
 
   // A single 0 second is just the top of the minute, so the minute leads
   // alone; any other second prefixes its own clause.
-  if (ir.pattern.second === '0') {
+  if (schedule.pattern.second === '0') {
     return minutePhrase;
   }
 
-  return secondsClause(ir, 'minute', opts) + ', ' + minutePhrase;
+  return secondsClause(schedule, 'minute', opts) + ', ' + minutePhrase;
 }
 
 // Render an hour step (or arithmetic-progression hour list) under a single
@@ -1410,10 +1525,10 @@ function hourCadenceLead(ir: IR, minute: number,
 // but a plain :00) makes every clock time three digit-groups, 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. Renderer-only;
-// the IR is unchanged.
-function hourCadence(ir: IR, minute: number,
+// the Schedule is unchanged.
+function hourCadence(schedule: Schedule, minute: number,
   opts: NormalizedOptions): string | null {
-  const stride = hourStride(ir);
+  const stride = hourStride(schedule);
 
   if (!stride) {
     return null;
@@ -1426,7 +1541,7 @@ function hourCadence(ir: IR, minute: number,
   // or "from M" form is no shorter than the list, so the list reads fine. A
   // bounded or uneven stride has no clean wrap, so its endpoint-pinning cadence
   // ("every five hours from midnight through 8 p.m.") reads better however few.
-  if (ir.pattern.second === '0' && fires <= maxClockTimes &&
+  if (schedule.pattern.second === '0' && fires <= maxClockTimes &&
       offsetCleanStride(stride)) {
     return null;
   }
@@ -1436,33 +1551,33 @@ function hourCadence(ir: IR, minute: number,
   // minute during every other hour", matching the "every minute during every
   // other hour" idiom and keeping it distinct from the bare hour-step form
   // ("every two hours") so the minute-0 confinement is never heard as it.
-  const minuteZeroStride = minute === 0 && subMinuteSecond(ir) &&
-    cleanStrideSegment(ir);
+  const minuteZeroStride = minute === 0 && subMinuteSecond(schedule) &&
+    cleanStrideSegment(schedule);
 
   if (minuteZeroStride) {
-    return secondsClause(ir, 'minute', opts) + ' for one minute ' +
-      everyNthHour(minuteZeroStride, opts) + trailingQualifier(ir, opts);
+    return secondsClause(schedule, 'minute', opts) + ' for one minute ' +
+      everyNthHour(minuteZeroStride, opts) + trailingQualifier(schedule, opts);
   }
 
   // A plain top-of-the-hour fire (minute 0 with no meaningful second) has no
   // lead clause to fold in, so the bounded cadence stands on its own ("every
   // five hours from midnight through 8 p.m."); only a real minute or second
   // prefixes its clause.
-  if (minute === 0 && ir.pattern.second === '0') {
-    return hourStrideCadence(stride, opts) + trailingQualifier(ir, opts);
+  if (minute === 0 && schedule.pattern.second === '0') {
+    return hourStrideCadence(stride, opts) + trailingQualifier(schedule, opts);
   }
 
-  return hourCadenceLead(ir, minute, opts) + ', ' +
-    hourStrideCadence(stride, opts) + trailingQualifier(ir, opts);
+  return hourCadenceLead(schedule, minute, opts) + ', ' +
+    hourStrideCadence(stride, opts) + trailingQualifier(schedule, opts);
 }
 
 // The hour step segment when the hour is a clean stride with an idiomatic
 // ordinal ("every other", "every sixth"), suitable for the "during every Nth
 // hour" confinement frame; null otherwise (an uneven stride, a bounded step,
 // or an arithmetic-progression list, which keep the bounded cadence form).
-function cleanStrideSegment(ir: IR): StepSegment | null {
+function cleanStrideSegment(schedule: Schedule): StepSegment | null {
   // Reached only after hourStride confirmed a stride, so hour segments exist.
-  const segments = ir.analyses.segments.hour!;
+  const segments = segmentsOf(schedule, 'hour');
   const segment = segments.length === 1 && segments[0];
 
   if (!segment || segment.kind !== 'step' ||
@@ -1479,38 +1594,44 @@ function cleanStrideSegment(ir: IR): StepSegment | null {
 // A pure single-value list (9,17) has no range to span and still enumerates;
 // a step is handled by hourStride/hourCadence, so a field whose only segments
 // are steps and singles is left alone here.
-function hasHourWindow(ir: IR): boolean {
+function hasHourWindow(schedule: Schedule): 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(schedule, '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.
-function hourRangeWindowTail(ir: IR, opts: NormalizedOptions): string {
+// 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(schedule: Schedule,
+  opts: NormalizedOptions): string {
   const windows: string[] = [];
-  const outliers = collectHourOutliers(ir);
+  const outlierHours = collectHourOutliers(schedule);
 
   // Reached only after hasHourWindow, so hour segments exist.
-  ir.analyses.segments.hour!.forEach(function classify(segment) {
+  segmentsOf(schedule, '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
@@ -1519,21 +1640,21 @@ function hourRangeWindowTail(ir: IR, opts: NormalizedOptions): string {
 // the hours into a wall of clock times. Returns null when the hour has no
 // range (a pure single-value list, a single hour, or a step, which other
 // paths own), or when a plain :00 set is short enough that enumeration is no
-// longer than the window. Renderer-only; the IR is unchanged.
-function hourRangeCadence(ir: IR, minute: number,
+// longer than the window. Renderer-only; the Schedule is unchanged.
+function hourRangeCadence(schedule: Schedule, minute: number,
   opts: NormalizedOptions): string | null {
   // Scoped to minute 0: the minute folds into the lead and every hour fires
   // at the top, so the window closes cleanly on the final hour. A non-zero
   // pinned minute is a real clock minute the existing clock-time window form
   // already speaks ("9:30:15 a.m. through 8:30:15 p.m."), unchanged.
-  if (minute !== 0 || !hasHourWindow(ir)) {
+  if (minute !== 0 || !hasHourWindow(schedule)) {
     return null;
   }
 
   // A plain top-of-minute second (:00) carries no clause: the existing
   // hour-range and folded-window renderers already speak that window, so this
   // path only forms a window when there is a meaningful second to lead with.
-  if (ir.pattern.second === '0') {
+  if (schedule.pattern.second === '0') {
     return null;
   }
 
@@ -1543,14 +1664,15 @@ function hourRangeCadence(ir: IR, minute: number,
   // uses). This is kept distinct from the bare minute-0 window ("every hour
   // from 9 a.m. through 5 p.m.") so the one-minute confinement is never heard
   // as it — the hour-range analog of "for one minute during every other hour".
-  if (subMinuteSecond(ir)) {
-    return secondsClause(ir, 'minute', opts) + ' for one minute during the ' +
-      hourSegmentTimes(ir, {minute: 0, second: null}, false, opts) +
-      ' hours' + trailingQualifier(ir, opts);
+  if (subMinuteSecond(schedule)) {
+    return secondsClause(schedule, 'minute', opts) +
+      ' for one minute during the ' +
+      hourSegmentTimes(schedule, {minute: 0, second: null}, false, opts) +
+      ' hours' + trailingQualifier(schedule, opts);
   }
 
-  return hourCadenceLead(ir, minute, opts) + ', ' +
-    hourRangeWindowTail(ir, opts) + trailingQualifier(ir, opts);
+  return hourCadenceLead(schedule, minute, opts) + ', ' +
+    hourRangeWindowTail(schedule, opts) + trailingQualifier(schedule, opts);
 }
 
 // --- List and segment phrasing. ---
@@ -1666,13 +1788,13 @@ function singleHourFire(times: HourTimesPlan): boolean {
 // The hour times accompanying a window phrase: enumerated fires up to the
 // cap, segment rendering past it (decided by the core). `atContext` marks
 // an "at <times>" frame (vs "during the <times> hours").
-function hourTimesFromPlan(ir: IR, times: HourTimesPlan, atContext: boolean,
-  opts: NormalizedOptions): string {
+function hourTimesFromPlan(schedule: Schedule, times: HourTimesPlan,
+  atContext: boolean, opts: NormalizedOptions): string {
   if (times.kind === 'fires') {
     return hourTimes(times.fires, opts);
   }
 
-  return hourSegmentTimes(ir, {minute: 0, second: null}, atContext, opts);
+  return hourSegmentTimes(schedule, {minute: 0, second: null}, atContext, opts);
 }
 
 // The hour values an hour segment covers: a range's bounds, a step's
@@ -1688,13 +1810,13 @@ function segmentHours(segment: Segment): (string | number)[] {
 // Clock times for the hour field rendered segment by segment, so ranges
 // read as windows ("9:30 a.m. through 8:30 p.m.") rather than an
 // enumeration. The minute (and optional second) fold into each time.
-function hourSegmentTimes(ir: IR,
+function hourSegmentTimes(schedule: Schedule,
   fold: {minute: number | string; second: number | null | undefined},
   atContext: boolean, opts: NormalizedOptions): string {
   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(schedule, 'hour');
   const plain = mixedTwelve(segments.flatMap(function entries(segment) {
     return segmentHours(segment).map(function entry(hour) {
       return {hour: +hour, minute, second};
@@ -1802,47 +1924,49 @@ const leadingWords: QualifierWords = {
 
 // A trailing day-level qualifier for bare frequencies, e.g. " on Monday".
 // Returns an empty string when no date, month, or weekday is set.
-function trailingQualifier(ir: IR, opts: NormalizedOptions): string {
+function trailingQualifier(schedule: Schedule,
+  opts: NormalizedOptions): string {
   // A day union reframes both day fields as a trailing condition clause; the
   // month leads the whole description (applied in `describe`), so it is not
   // part of the trailing qualifier here.
-  if (isDayUnion(ir, opts)) {
-    return dayUnionCondition(ir, opts);
+  if (isDayUnion(schedule, opts)) {
+    return dayUnionCondition(schedule, opts);
   }
 
-  const phrase = dayQualifier(ir, trailingWords, opts);
+  const phrase = dayQualifier(schedule, trailingWords, opts);
 
   return phrase && ' ' + phrase;
 }
 
 // Build the day-level qualifier that precedes a specific time, e.g.
 // "every day ", "every Friday ", or "on January 13 ".
-function interpretDayQualifier(ir: IR, opts: NormalizedOptions): string {
+function interpretDayQualifier(schedule: Schedule,
+  opts: NormalizedOptions): string {
   // A day union puts the time first ("at midnight whenever the day is …"), so
   // the leading position contributes no day phrase; the condition clause is
   // appended after the time by the clock renderer.
-  if (isDayUnion(ir, opts)) {
+  if (isDayUnion(schedule, opts)) {
     return '';
   }
 
-  return dayQualifier(ir, leadingWords, opts) + ' ';
+  return dayQualifier(schedule, leadingWords, opts) + ' ';
 }
 
 // The day-level qualifier phrase (date, month, and weekday), or
 // `words.all` when all three are wildcards. `words` supplies the
 // connectives that differ between the trailing and leading positions.
-function dayQualifier(ir: IR, words: QualifierWords,
+function dayQualifier(schedule: Schedule, words: QualifierWords,
   opts: NormalizedOptions): string {
-  const pattern = ir.pattern;
+  const pattern = schedule.pattern;
 
   // Standard cron fires when day-of-month OR day-of-week matches, when
   // both are restricted.
   if (pattern.date !== '*' && pattern.weekday !== '*') {
-    return dateOrWeekday(ir, opts);
+    return dateOrWeekday(schedule, opts);
   }
 
   if (pattern.date !== '*') {
-    return datePhrase(ir, words, opts);
+    return datePhrase(schedule, words, opts);
   }
 
   // A weekday qualifier, optionally scoped to a month ("on Monday in
@@ -1854,46 +1978,47 @@ function dayQualifier(ir: IR, words: QualifierWords,
     // the "of the month" recurrence a concrete month makes redundant; a plain
     // weekday name takes the ordinary " in <month>" scope.
     if (quartzWeekday) {
-      return monthScopeForRecurrence(quartzWeekday, ir, opts);
+      return monthScopeForRecurrence(quartzWeekday, schedule, opts);
     }
 
     const weekdays = words.weekday +
-      weekdayPhrase(ir, words.recurringWeekday, opts);
+      weekdayPhrase(schedule, words.recurringWeekday, opts);
 
-    return weekdays + monthScope(ir, opts);
+    return weekdays + monthScope(schedule, opts);
   }
 
   if (pattern.month !== '*') {
-    return words.month + monthName(ir, opts);
+    return words.month + monthName(schedule, opts);
   }
 
   return words.all;
 }
 
 // The date portion of a day qualifier (the weekday is a wildcard).
-function datePhrase(ir: IR, words: QualifierWords,
+function datePhrase(schedule: Schedule, words: QualifierWords,
   opts: NormalizedOptions): string {
-  const pattern = ir.pattern;
+  const pattern = schedule.pattern;
   const quartzDate = quartzDatePhrase(pattern.date, opts);
 
   if (quartzDate) {
-    return monthScopeForRecurrence(quartzDate, ir, opts);
+    return monthScopeForRecurrence(quartzDate, schedule, opts);
   }
 
   if (isOpenStep(pattern.date)) {
     return monthScopeForRecurrence(
-      words.stepDate + stepDates(pattern.date), ir, opts);
+      words.stepDate + stepDates(pattern.date), schedule, opts);
   }
 
-  if (pattern.month !== '*' && !monthFoldsIntoDate(ir)) {
-    return 'on the ' + dateOrdinals(ir, opts) + monthScope(ir, opts);
+  if (pattern.month !== '*' && !monthFoldsIntoDate(schedule)) {
+    return 'on the ' + dateOrdinals(schedule, opts) +
+      monthScope(schedule, opts);
   }
 
   if (pattern.month !== '*') {
-    return 'on ' + monthDatePhrase(ir, opts);
+    return 'on ' + monthDatePhrase(schedule, opts);
   }
 
-  return 'on the ' + dateOrdinals(ir, opts);
+  return 'on the ' + dateOrdinals(schedule, opts);
 }
 
 // Whether the month can fold into a calendar date ("on June 1"): flat name
@@ -1902,10 +2027,10 @@ function datePhrase(ir: IR, words: QualifierWords,
 // "(June) through (September 1)" — and the "every odd/even-numbered month"
 // frequency phrase has no name to place before the date; both scope the date
 // instead ("on the 1st in June through September").
-function monthFoldsIntoDate(ir: IR): boolean {
-  return !oddEvenMonth(ir.pattern.month) &&
+function monthFoldsIntoDate(schedule: Schedule): boolean {
+  return !oddEvenMonth(schedule.pattern.month) &&
     // Reached only with a restricted month, which has segments.
-    ir.analyses.segments.month!.every(function flat(segment) {
+    segmentsOf(schedule, 'month').every(function flat(segment) {
       return segment.kind !== 'range';
     });
 }
@@ -1921,17 +2046,18 @@ function monthFoldsIntoDate(ir: IR): boolean {
 // and `dayUnionCondition`), not inside the trailing/leading qualifier. Scoped
 // to the until-window dialect; every other dialect and the `short` form keep
 // the established "on <dom> or on <dow>" phrasing.
-function isDayUnion(ir: IR, opts: NormalizedOptions): boolean {
-  return ir.pattern.date !== '*' && ir.pattern.weekday !== '*' &&
+function isDayUnion(schedule: Schedule, opts: NormalizedOptions): boolean {
+  return schedule.pattern.date !== '*' && schedule.pattern.weekday !== '*' &&
     !!opts.style.untilWindow && !opts.short;
 }
 
 // The trailing condition clause for a day union, e.g. " whenever the day is
 // the 1st or a Friday". The day predicates are flattened into one or-list so
 // the union reads as a single set of matching days.
-function dayUnionCondition(ir: IR, opts: NormalizedOptions): string {
-  const pieces = [...dayUnionDatePieces(ir, opts),
-    ...dayUnionWeekdayPieces(ir, opts)];
+function dayUnionCondition(schedule: Schedule,
+  opts: NormalizedOptions): string {
+  const pieces = [...dayUnionDatePieces(schedule, opts),
+    ...dayUnionWeekdayPieces(schedule, opts)];
 
   return ' whenever the day is ' + joinOr(pieces, opts);
 }
@@ -1939,12 +2065,13 @@ function dayUnionCondition(ir: IR, opts: NormalizedOptions): string {
 // The leading "in <month> " scope for a day union, or an empty string when the
 // month is a wildcard. The month scopes the whole union, so it leads the clause
 // rather than attaching to either day half.
-function dayUnionMonthLead(ir: IR, opts: NormalizedOptions): string {
-  if (ir.pattern.month === '*') {
+function dayUnionMonthLead(schedule: Schedule,
+  opts: NormalizedOptions): string {
+  if (schedule.pattern.month === '*') {
     return '';
   }
 
-  return 'in ' + monthName(ir, opts) + ' ';
+  return 'in ' + monthName(schedule, opts) + ' ';
 }
 
 // The day-of-month half of a union as a flat list of predicate pieces. A
@@ -1952,8 +2079,9 @@ function dayUnionMonthLead(ir: IR, opts: NormalizedOptions): string {
 // `*/2`-style step is the parity idiom ("an odd-numbered day"); a plain field
 // reads each segment as "the <ordinal>" or "from the <ordinal> through the
 // <ordinal>".
-function dayUnionDatePieces(ir: IR, opts: NormalizedOptions): string[] {
-  const dateField = ir.pattern.date;
+function dayUnionDatePieces(schedule: Schedule,
+  opts: NormalizedOptions): string[] {
+  const dateField = schedule.pattern.date;
   const quartz = quartzDatePhrase(dateField, opts);
 
   if (quartz) {
@@ -1971,7 +2099,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(schedule, 'date').forEach(function expand(segment) {
     if (segment.kind === 'range') {
       pieces.push('from the ' + getOrdinal(segment.bounds[0]) + through(opts) +
         'the ' + getOrdinal(segment.bounds[1]));
@@ -1994,8 +2122,9 @@ function dayUnionDatePieces(ir: IR, opts: NormalizedOptions): string[] {
 // through-Friday range is the "a weekday" idiom; every other weekday names each
 // day with the indefinite article ("a Friday", "a Sunday"), so each reads as a
 // kind of day the union can match.
-function dayUnionWeekdayPieces(ir: IR, opts: NormalizedOptions): string[] {
-  const weekdayField = ir.pattern.weekday;
+function dayUnionWeekdayPieces(schedule: Schedule,
+  opts: NormalizedOptions): string[] {
+  const weekdayField = schedule.pattern.weekday;
   const quartz = quartzWeekdayPhrase(weekdayField, opts);
 
   if (quartz) {
@@ -2004,11 +2133,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(schedule, 'weekday').forEach(function expand(segment) {
     if (segment.kind === 'range' &&
         segment.bounds[0] === '1' && segment.bounds[1] === '5') {
       pieces.push('a weekday');
@@ -2059,26 +2188,27 @@ function oddEvenDay(dateField: string): string | null {
 // names itself on the weekday ("or on Friday in June"), keeping both halves
 // scoped; otherwise (a Quartz date, an open day step, a month range, or the
 // odd/even frequency) it trails the whole or as ", in <month>".
-function dateOrWeekday(ir: IR, opts: NormalizedOptions): string {
-  const pattern = ir.pattern;
+function dateOrWeekday(schedule: Schedule, opts: NormalizedOptions): string {
+  const pattern = schedule.pattern;
   // The day-of-month-OR-day-of-week union is out of scope for the recurring
   // plural (it is reframed elsewhere): the weekday half stays singular here.
   const weekdayPart = quartzWeekdayPhrase(pattern.weekday, opts) ||
-    'on ' + weekdayPhrase(ir, false, opts);
+    'on ' + weekdayPhrase(schedule, false, opts);
 
-  if (pattern.month !== '*' && monthFoldsIntoDate(ir) &&
+  if (pattern.month !== '*' && monthFoldsIntoDate(schedule) &&
       !quartzDatePhrase(pattern.date, opts) && !isOpenStep(pattern.date)) {
-    return 'on ' + monthDatePhrase(ir, opts) + ' or ' + weekdayPart +
-      ' in ' + monthName(ir, opts);
+    return 'on ' + monthDatePhrase(schedule, opts) + ' or ' + weekdayPart +
+      ' in ' + monthName(schedule, opts);
   }
 
-  return datePart(ir, opts) + ' or ' + weekdayPart + orMonthScope(ir, opts);
+  return datePart(schedule, opts) + ' or ' + weekdayPart +
+    orMonthScope(schedule, opts);
 }
 
 // The day-of-month half of an or-day phrase, without any month scope (the
 // month scopes the whole or, applied by the caller).
-function datePart(ir: IR, opts: NormalizedOptions): string {
-  const pattern = ir.pattern;
+function datePart(schedule: Schedule, opts: NormalizedOptions): string {
+  const pattern = schedule.pattern;
   const quartzDate = quartzDatePhrase(pattern.date, opts);
 
   if (quartzDate) {
@@ -2089,18 +2219,18 @@ function datePart(ir: IR, opts: NormalizedOptions): string {
     return stepDates(pattern.date);
   }
 
-  return 'on the ' + dateOrdinals(ir, opts);
+  return 'on the ' + dateOrdinals(schedule, opts);
 }
 
 // A trailing month scope for the whole or, set off by a comma so it reads
 // over both day halves ("…or on Friday, in June"); empty when the month is a
 // wildcard.
-function orMonthScope(ir: IR, opts: NormalizedOptions): string {
-  if (ir.pattern.month === '*') {
+function orMonthScope(schedule: Schedule, opts: NormalizedOptions): string {
+  if (schedule.pattern.month === '*') {
     return '';
   }
 
-  return ', in ' + monthName(ir, opts);
+  return ', in ' + monthName(schedule, opts);
 }
 
 // The day-qualifier phrase for a Quartz date field (e.g. "on the last day
@@ -2157,16 +2287,16 @@ function quartzWeekdayPhrase(weekdayField: string,
 // reads as if the 13 belongs to January alone. The day is reattached to the
 // whole list with the possessive "the <ordinal> of <months>", which names the
 // same day across every month unambiguously.
-function monthDatePhrase(ir: IR, opts: NormalizedOptions): string {
-  const month = monthName(ir, opts);
+function monthDatePhrase(schedule: Schedule, opts: NormalizedOptions): string {
+  const month = monthName(schedule, 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(schedule, 'date'),
     opts.style.ordinals ? getOrdinal : cardinalDay, opts);
 
-  if (opts.style.dayFirst && ir.shapes.date === 'single' &&
-      ir.shapes.month !== 'single') {
-    return 'the ' + getOrdinal(ir.pattern.date) + ' of ' + month;
+  if (opts.style.dayFirst && schedule.shapes.date === 'single' &&
+      schedule.shapes.month !== 'single') {
+    return 'the ' + getOrdinal(schedule.pattern.date) + ' of ' + month;
   }
 
   return opts.style.dayFirst ? days + ' ' + month : month + ' ' + days;
@@ -2179,12 +2309,12 @@ function cardinalDay(value: number | string): string {
 
 // A trailing " in <month>" scope, or an empty string when the month is a
 // wildcard.
-function monthScope(ir: IR, opts: NormalizedOptions): string {
-  if (ir.pattern.month === '*') {
+function monthScope(schedule: Schedule, opts: NormalizedOptions): string {
+  if (schedule.pattern.month === '*') {
     return '';
   }
 
-  return ' in ' + monthName(ir, opts);
+  return ' in ' + monthName(schedule, opts);
 }
 
 // Scope a phrase that ends in the recurrence "of the month" (the Quartz last-
@@ -2195,25 +2325,27 @@ function monthScope(ir: IR, opts: NormalizedOptions): string {
 // distributes the recurrence across the span and keeps it, rephrased as "of
 // each month from <first> through <last>". A month list is left as-is (the
 // recurrence stays, scoped "in <names>"), and a wildcard month adds nothing.
-function monthScopeForRecurrence(phrase: string, ir: IR,
+function monthScopeForRecurrence(phrase: string, schedule: Schedule,
   opts: NormalizedOptions): string {
-  if (ir.pattern.month === '*') {
+  if (schedule.pattern.month === '*') {
     return phrase;
   }
 
   const carriesRecurrence = phrase.indexOf(' of the month') !== -1;
 
-  if (carriesRecurrence && ir.shapes.month === 'range') {
+  if (carriesRecurrence && schedule.shapes.month === 'range') {
     return phrase.replace(' of the month', ' of each month') + ' from ' +
-      monthName(ir, opts);
+      monthName(schedule, opts);
   }
 
   if (carriesRecurrence &&
-      (ir.shapes.month === 'single' || ir.shapes.month === 'step')) {
-    return phrase.replace(' of the month', '') + ' in ' + monthName(ir, opts);
+      (schedule.shapes.month === 'single' ||
+        schedule.shapes.month === 'step')) {
+    return phrase.replace(' of the month', '') + ' in ' +
+      monthName(schedule, opts);
   }
 
-  return phrase + ' in ' + monthName(ir, opts);
+  return phrase + ' in ' + monthName(schedule, opts);
 }
 
 // Frequency phrase for an open day-of-month step, e.g. "every other day of
@@ -2236,17 +2368,17 @@ function stepDates(dateField: string): string {
 
 // Render the date field's segments as suffixed ordinals. Open steps are
 // handled separately as a frequency phrase.
-function dateOrdinals(ir: IR, opts: NormalizedOptions): string {
+function dateOrdinals(schedule: Schedule, opts: NormalizedOptions): string {
   // Reached only with a restricted date, which has segments.
-  return renderSegments(ir.analyses.segments.date!, getOrdinal, opts);
+  return renderSegments(segmentsOf(schedule, 'date'), getOrdinal, opts);
 }
 
 // Render the month field as names. There are few, named months, so a step
 // enumerates them ("January, April, July, and October") rather than reading as
 // a frequency — except interval 2, which reads as "every odd/even-numbered
 // month".
-function monthName(ir: IR, opts: NormalizedOptions): string {
-  const oddEven = oddEvenMonth(ir.pattern.month);
+function monthName(schedule: Schedule, opts: NormalizedOptions): string {
+  const oddEven = oddEvenMonth(schedule.pattern.month);
 
   if (oddEven) {
     return oddEven;
@@ -2254,7 +2386,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(schedule, 'month'), function name(value) {
     return getMonth(value, opts);
   }, opts);
 }
@@ -2288,12 +2420,12 @@ function oddEvenMonth(monthField: string): string | null {
 // keeps the singular idiom ("on Monday through Friday") so its through-
 // connective stays unmistakable, and a leading time-anchored form ("every
 // Monday") is never recurring here.
-function weekdayPhrase(ir: IR, recurring: boolean,
+function weekdayPhrase(schedule: Schedule, recurring: boolean,
   opts: NormalizedOptions): string {
   // 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!);
+  // display Monday-first (Sunday last) so a weekend reads naturally; the
+  // Schedule stays canonical (Sunday=0) and ranges keep their form.
+  const segments = orderWeekdaysForDisplay(segmentsOf(schedule, 'weekday'));
   const hasRange = segments.some(function range(segment) {
     return segment.kind === 'range';
   });
@@ -2345,21 +2477,13 @@ 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
 // explicitly supplied year is always rendered.
-function applyYear(description: string, ir: IR,
+function applyYear(description: string, schedule: Schedule,
   opts: NormalizedOptions): string {
-  const yearField = ir.pattern.year;
+  const yearField = schedule.pattern.year;
 
   if (yearField === '*') {
     return description;
@@ -2375,7 +2499,7 @@ function applyYear(description: string, ir: IR,
   const label = yearLabel(yearField, opts);
 
   if (yearField.indexOf('-') === -1 && yearField.indexOf(',') === -1 &&
-      ir.pattern.date !== '*' && description.indexOf(' at ') !== -1) {
+      schedule.pattern.date !== '*' && description.indexOf(' at ') !== -1) {
     // US dates take a comma before the year ("January 1, 2030"); UK dates
     // do not ("1 January 2030").
     const yearGlue = opts.style.dayFirst ? ' ' : ', ';
@@ -2545,7 +2669,7 @@ function getWeekday(d: number | string, opts: NormalizedOptions): string {
   return (weekday && weekday[opts.short ? 1 : 0]) as string;
 }
 
-// The English language module: the IR renderer plus the language-owned
+// The English language module: the Schedule renderer plus the language-owned
 // strings and option normalization.
 const en: Language = {
   describe,