cronli5 0.2.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cronli5",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Cron Like I'm Five: A Cron to English Utility",
   "repository": {
     "type": "git",

package/src/core/analyze.ts

@@ -1,20 +1,21 @@
 // Semantic analysis of canonical fields: fire enumeration, windows, shape
-// classification, and description-strategy selection (the `plan`). The
-// resulting IR is descriptive. Language modules handle rendering into
+// classification, and description-plan selection (the `plan`). The
+// resulting Schedule is descriptive. Language modules handle rendering into
 // words (docs/i18n-design.md §2.2).
 
 import {fieldOrder, fieldSpecs, maxClockTimes} from './specs.js';
 import type {FieldSpec} from './specs.js';
 import type {
-  Analyses, ClockTime, Content, Field, HourTimesPlan, HoursPlan, IR, Pattern,
-  PlanNode, Segment, Shape, Shapes
-} from './ir.js';
+  Analyses, ClockTime, Field, HourTimesPlan, HoursPlan, Pattern,
+  PlanNode, Schedule, ScheduleFacts, Segment, Shape, Shapes
+} from './schedule.js';
 import {includes, toFieldNumber, unique} from './util.js';
 import {isDiscreteHours, isDiscreteList, isPlainRange, isSingleValue}
   from './shapes.js';
 import {isQuartzDate, isQuartzWeekday} from './validate.js';
 
-// List the values a `start/interval` step fires on within [0, max].
+// List the values a `start/interval` step fires on from `start` up to `max`,
+// stepping by `interval`.
 function getOccurrences(
   start: number,
   interval: number,
@@ -197,8 +198,8 @@ function fieldSegments(
 }
 
 // Analyze a prepared (parsed, validated, normalized) cron pattern into the
-// IR a language module renders from.
-function analyze(pattern: Pattern): IR {
+// Schedule a language module renders from.
+function analyze(pattern: Pattern): Schedule {
   const shapes = {} as Shapes;
   const segments = {} as Analyses['segments'];
 
@@ -215,18 +216,18 @@ function analyze(pattern: Pattern): IR {
     segments
   };
 
-  const content: Content = {analyses, pattern, shapes};
+  const facts: ScheduleFacts = {analyses, pattern, shapes};
 
-  return {...content, plan: selectStrategy(content)};
+  return {...facts, plan: selectPlan(facts)};
 }
 
-// Select the description strategy from the neutral content. This is the
-// core's *suggestion*: a language may override it via `Language.strategy`
-// without re-deriving it (the content-plan / overridable-strategy split).
+// Select the description plan from the neutral facts. This is the
+// core's *suggestion*: a language may override it via `Language.plan`
+// without re-deriving it (the facts / overridable-plan split).
 // The selection mirrors the interpreter chain ordering exactly; renderers
 // must not re-derive it.
-function selectStrategy(content: Content): PlanNode {
-  const {analyses, pattern, shapes} = content;
+function selectPlan(facts: ScheduleFacts): PlanNode {
+  const {analyses, pattern, shapes} = facts;
 
   if (pattern.second !== '0') {
     const seconds = planSeconds(pattern, shapes, analyses);
@@ -240,7 +241,7 @@ function selectStrategy(content: Content): PlanNode {
     planHours(pattern, shapes, analyses);
 }
 
-// Seconds strategies, or null when the second folds into the clock time
+// Seconds plans, or null when the second folds into the clock time
 // downstream (a single second under discrete minutes and hours).
 function planSeconds(
   pattern: Pattern,
@@ -301,8 +302,8 @@ function planStandaloneSeconds(
   return {kind: 'standaloneSeconds'};
 }
 
-// Minute strategies, in the interpreter-chain order, or null to defer to
-// the hour strategies.
+// Minute plans, in the interpreter-chain order, or null to defer to
+// the hour plans.
 function planMinutes(
   pattern: Pattern,
   shapes: Shapes,
@@ -459,7 +460,7 @@ function planMinutesAcrossHours(
   return null;
 }
 
-// Minute strategies that only stand on their own under a wildcard hour.
+// Minute plans that only stand on their own under a wildcard hour.
 function planMinutesUnderOpenHour(
   pattern: Pattern,
   shapes: Shapes,
@@ -484,7 +485,7 @@ function planMinutesUnderOpenHour(
   }
 }
 
-// Hour strategies: the chain's last resort always produces a plan. Under a
+// Hour plans: the chain's last resort always produces a plan. Under a
 // sub-minute second a minute of 0 is a real restriction, so the absorbing
 // idioms (hour range, hour step, every hour) are skipped for it and the hour
 // is enumerated as clock times instead, stating the :00.
@@ -591,4 +592,4 @@ function hourTimesPlan(hourField: string): HourTimesPlan {
 }
 
 export {analyze, clockSecond, enumerateFires, enumerateStep,
-  enumerateValues, getOccurrences, lastMinuteFire, minuteSpan, selectStrategy};
+  enumerateValues, getOccurrences, lastMinuteFire, minuteSpan, selectPlan};

package/src/core/cadence.ts

@@ -0,0 +1,164 @@
+// Cadence analysis: recognizing arithmetic progressions and step strides in a
+// field's values, and the segment accessors renderers use to reach them.
+// Output-neutral and language-agnostic; renderers speak the cadence they find.
+
+import type {Field, Schedule, Segment} from './schedule.js';
+
+// A step segment of a classified field, carrying its `fires`/`interval`/
+// `startToken`. The plan only routes step-shaped fields to step phrasing,
+// where the first segment is always a step segment.
+type StepSegment = Extract<Segment, {kind: 'step'}>;
+
+// Recognize an arithmetic progression in a sorted, distinct numeric set: a
+// run of length >= 5 whose consecutive gaps are all equal and >= 2. Returns
+// its {start, interval, last}; null for anything shorter, with a gap of one
+// (a plain run, which reads as a range), or irregular. Output-neutral and
+// language-agnostic: renderers use it to speak a bounded/offset step cadence
+// ("every N from M [through K]") instead of enumerating the fires. The set is
+// the field's full value list, which the core has already sorted and deduped.
+function arithmeticStep(values: number[]):
+  {start: number; interval: number; last: number} | null {
+  if (values.length < 5) {
+    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;
+    }
+  }
+
+  return {start: values[0], interval, last: values[values.length - 1]};
+}
+
+// A field's classified segments, or an empty list when the field is a
+// wildcard or Quartz shape (no segments). Renderers reach a non-empty list
+// only on the field shapes the analysis segmented; the empty fallback keeps
+// callers that touch a possibly-unsegmented field (a `.map`/`.forEach`) safe.
+function segmentsOf(schedule: Schedule, field: Field): Segment[] {
+  return schedule.analyses.segments[field] ?? [];
+}
+
+// The first segment of a step field, narrowed to its step variant. The plan
+// only routes step shapes here, whose (single) segment always classifies as a
+// step; this asserts what the analysis guarantees but the type cannot express.
+function stepSegment(schedule: Schedule, field: Field): StepSegment {
+  return segmentsOf(schedule, field)[0] as StepSegment;
+}
+
+// The sorted numeric values a field's segments cover, or null if any segment
+// is not a discrete single (a range or sub-step is not a plain fire list).
+function singleValues(segments: Segment[]): number[] | null {
+  const values: number[] = [];
+
+  for (const segment of segments) {
+    if (segment.kind !== 'single') {
+      return null;
+    }
+
+    values.push(+segment.value);
+  }
+
+  return values;
+}
+
+// Whether an hour stride wraps the day cleanly from within its first interval
+// (a `*/n` from the top, or a `m/n` offset with m < n that divides 24): such a
+// stride has no distinct endpoint and keeps its bare or "from M" cadence. Every
+// other stride — a uneven interval, or one starting at or past its interval (a
+// bounded `a-b/n`) — is a bounded set the cadence pins both endpoints of.
+function offsetCleanStride(
+  stride: {start: number; interval: number}
+): boolean {
+  return stride.start < stride.interval && 24 % stride.interval === 0;
+}
+
+// The three branches of the stride/cadence decision tree, supplied by a
+// renderer as its own words. The core picks the branch; the language owns the
+// prose. `bare` is the clean cadence ("every N <unit>"); `offset` names only
+// the start (a clean wrap with no distinct endpoint); `bounded` pins both
+// endpoints (a non-wrapping set). Each is a thunk so the renderer evaluates
+// only the branch the core selects (e.g. a stateful bound formatter is never
+// constructed for the bare case). The words differ per language — case
+// inflection, a measure word, a trailing idiom — so the leaves stay here, not
+// in core.
+interface StrideParts {
+  bare(): string;
+  offset(): string;
+  bounded(): string;
+}
+
+// Choose the stride/cadence branch for a step over a `cycle`-long field and
+// emit the renderer's words for it. A clean stride from the top of the cycle
+// is the bare cadence; a uniform offset (start within the first interval, the
+// interval still tiling the cycle) names only its start, since it wraps cleanly
+// with no distinct endpoint; a non-uniform stride (start >= interval, or an
+// interval that does not tile the cycle) pins both endpoints so the bounded,
+// non-wrapping set reads unambiguously. This is the one decision tree every
+// renderer's `renderStride`/`hourStrideCadence` shared (cycle 60 for
+// minute/second, 24 for the hour); the branch lives here once, the prose in
+// each language's `parts`.
+function renderStride(
+  spec: {start: number; interval: number; cycle: number},
+  parts: StrideParts
+): string {
+  const {start, interval, cycle} = spec;
+  const tiles = cycle % interval === 0;
+
+  if (start === 0 && tiles) {
+    return parts.bare();
+  }
+
+  if (start < interval && tiles) {
+    return parts.offset();
+  }
+
+  return parts.bounded();
+}
+
+// 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 Schedule 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]};
+}
+
+export {
+  arithmeticStep, hourListStride, offsetCleanStride, renderStride, segmentsOf,
+  singleValues, stepSegment
+};
+export type {StrideParts};

package/src/core/index.ts

@@ -4,7 +4,7 @@
 // See docs/i18n-design.md.
 
 import {applyQuartzAliases, normalizeCronPattern} from './normalize.js';
-import type {NormalizedOptions, Pattern} from './ir.js';
+import type {NormalizedOptions, Pattern} from './schedule.js';
 import {parseCronPattern} from './parse.js';
 import type {CronPattern} from '../types.js';
 import {validateCronPattern} from './validate.js';
@@ -24,5 +24,7 @@ function prepare(cronPattern: CronPattern, opts: NormalizedOptions): Pattern {
 export {prepare};
 export * from './specs.js';
 export * from './util.js';
+export * from './weekday.js';
+export * from './cadence.js';
 export * from './shapes.js';
 export * from './analyze.js';

package/src/core/normalize.ts

@@ -4,7 +4,7 @@
 
 import {fieldOrder, fieldSpecs} from './specs.js';
 import type {CronLike, FieldSpec} from './specs.js';
-import type {Field, Pattern} from './ir.js';
+import type {Field, Pattern} from './schedule.js';
 import {includes, toFieldNumber, unique} from './util.js';
 import {isQuartzDate, isQuartzWeekday} from './validate.js';
 
@@ -68,7 +68,7 @@ function normalizeField(value: string, field: Field, spec: FieldSpec): string {
   const cycle = timeFieldCycle[field];
   const segments = stringValue.split(',').map(function canonical(segment) {
     return canonicalizeTokens(collapseFullSpanRange(
-      enumerateNonUniformStep(
+      enumerateIfNonUniform(
         collapseFullSpanStep(
           collapseDegenerateRange(
             collapseOnceStep(collapseUnitStep(segment, spec), spec), spec),
@@ -172,7 +172,7 @@ function collapseOnceStep(segment: string, spec: FieldSpec): string {
 // list of those fires (`*/7` is `0,7,14,…`), the same as if it were written
 // out. Calendar fields (no `cycle`), bounded steps (`9-17/2`, a per-window
 // stride), and non-step segments are left untouched.
-function enumerateNonUniformStep(
+function enumerateIfNonUniform(
   segment: string,
   spec: FieldSpec,
   cycle: number | undefined

package/src/core/parse.ts

@@ -2,7 +2,7 @@
 
 import {macros} from './specs.js';
 import type {CronLike} from './specs.js';
-import type {NormalizedOptions} from './ir.js';
+import type {NormalizedOptions} from './schedule.js';
 import type {CronPattern, CronPatternObject} from '../types.js';
 
 // Take a cron pattern as a cron pattern string, an array of cron fields, a

package/src/core/{ir.ts → schedule.ts}

@@ -1,8 +1,7 @@
-// An Intermediate Representation (`IR`) is the semantic contract between
-// the core and a language renderer. The core (parse → validate →
-// normalize → analyze) produces an IR, then a language module renders it to
-// prose. These shapes are what any new language module interacts with. See
-// docs/i18n-design.md.
+// A `Schedule` is the semantic contract between the core and a language
+// renderer. The core (parse → validate → normalize → analyze) produces a
+// `Schedule`, then a language module renders it to prose. These shapes are
+// what any new language module interacts with. See docs/i18n-design.md.
 
 import type {Cronli5Options} from '../types.js';
 
@@ -42,8 +41,7 @@ export type HoursPlan =
   | {kind: 'none'}
   | {kind: 'step'}
   | {kind: 'window'; from: number; to: number; last: number}
-  | {kind: 'during'; times: HourTimesPlan}
-  | {kind: 'single'; from: number; to: number; last: number};
+  | {kind: 'during'; times: HourTimesPlan};
 
 /** Hour times: enumerated fires, or deferred to per-segment rendering. */
 export type HourTimesPlan =
@@ -51,7 +49,7 @@ export type HourTimesPlan =
   | {kind: 'segments'};
 
 /**
- * The rendering strategy the core selects for a pattern. The `kind`
+ * The rendering plan the core selects for a pattern. The `kind`
  * discriminant tells a renderer which fields are present.
  */
 export type PlanNode =
@@ -99,24 +97,25 @@ export interface Analyses {
 }
 
 /**
- * The neutral content plan: the language-independent facts about a pattern,
- * carrying no phrasing decision. `analyze` produces this; `selectStrategy`
- * reads it to suggest a `plan`. The phrasing strategy is deliberately *not*
- * part of the neutral content (docs/i18n-design.md §2.2).
+ * The neutral schedule facts: the language-independent facts about a pattern,
+ * carrying no phrasing decision. `analyze` produces this; `selectPlan`
+ * reads it to suggest a `plan`. The phrasing plan is deliberately *not*
+ * part of the neutral facts (docs/i18n-design.md §2.2).
  */
-export interface Content {
+export interface ScheduleFacts {
   pattern: Pattern;
   shapes: Shapes;
   analyses: Analyses;
 }
 
 /**
- * The semantic intermediate representation a language renders: the neutral
- * `Content` plus the selected `plan`. A language may widen `plan` with its
- * own `Extra` strategy kinds via `Language.strategy`; by default there are
- * none, so `IR` is the neutral content with a core `PlanNode`.
+ * The semantic schedule a language renders: the neutral `ScheduleFacts`
+ * plus the selected `plan`. A language may widen `plan` with its own
+ * `Extra` plan kinds via `Language.plan`; by default there are none, so
+ * `Schedule` is the neutral facts with a core `PlanNode`.
  */
-export interface IR<Extra extends {kind: string} = never> extends Content {
+export interface Schedule<Extra extends {kind: string} = never>
+  extends ScheduleFacts {
   plan: PlanNode | Extra;
 }
 
@@ -156,23 +155,23 @@ export interface NormalizedOptions<Style = DialectStyle> {
 
 /**
  * The interface every language module's default export implements. `Extra`
- * lets a language add its own strategy kinds (default: none), which its
- * `strategy` override emits and its `describe` renders.
+ * lets a language add its own plan kinds (default: none), which its
+ * `plan` override emits and its `describe` renders.
  */
 export interface Language<
   Style = DialectStyle,
   Extra extends {kind: string} = never
 > {
-  describe(ir: IR<Extra>, opts: NormalizedOptions<Style>): string;
+  describe(schedule: Schedule<Extra>, opts: NormalizedOptions<Style>): string;
   fallback: string;
   options(options?: Cronli5Options): NormalizedOptions<Style>;
   reboot: string;
   // Wrap a rendered description into a complete standalone sentence (the CLI
   // form); each language owns its lead verb and punctuation.
   sentence(description: string): string;
-  // Optionally override the core's suggested strategy. Receives the neutral
-  // `content` and the core's suggestion (`base`), so overriding is a thin
+  // Optionally override the core's suggested plan. Receives the neutral
+  // `facts` and the core's suggestion (`base`), so overriding is a thin
   // remap, not a re-derivation. Omitted by languages that accept the core's
   // choice (all of en/de/es/fi today).
-  strategy?(content: Content, base: PlanNode): PlanNode | Extra;
+  plan?(facts: ScheduleFacts, base: PlanNode): PlanNode | Extra;
 }

package/src/core/shapes.ts

@@ -37,5 +37,12 @@ function isDiscreteHours(hourField: string): boolean {
   return hourField !== '*' && !isPlainRange(hourField) &&
     !isPlainStep(hourField);
 }
-export {isDiscreteHours, isDiscreteList, isPlainRange, isPlainStep,
+
+// Whether a field 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;
+}
+export {isDiscreteHours, isDiscreteList, isOpenStep, isPlainRange, isPlainStep,
   isSingleValue};

package/src/core/specs.ts

@@ -1,6 +1,6 @@
 // Field specifications, macros, and core policy constants.
 
-import type {Field} from './ir.js';
+import type {Field} from './schedule.js';
 
 /**
  * A parsed but not-yet-canonical cron pattern: every field present, values

package/src/core/util.ts

@@ -1,7 +1,6 @@
-// Small shared utilities for the core.
-
-import type {Segment} from './ir.js';
+// Generic pure helpers shared across the core.
 
+// Whether a string contains a substring (coercing numbers to strings).
 function includes(str: string | number, sub: string): boolean {
   return ('' + str).indexOf(sub) !== -1;
 }
@@ -18,82 +17,6 @@ function isNonNegativeInteger(value: string): boolean {
   return digits.test(value);
 }
 
-// Recognize an arithmetic progression in a sorted, distinct numeric set: a
-// run of length >= 5 whose consecutive gaps are all equal and >= 2. Returns
-// its {start, interval, last}; null for anything shorter, with a gap of one
-// (a plain run, which reads as a range), or irregular. Output-neutral and
-// language-agnostic: renderers use it to speak a bounded/offset step cadence
-// ("every N from M [through K]") instead of enumerating the fires. The set is
-// the field's full value list, which the core has already sorted and deduped.
-function arithmeticStep(values: number[]):
-  {start: number; interval: number; last: number} | null {
-  if (values.length < 5) {
-    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;
-    }
-  }
-
-  return {start: values[0], interval, last: values[values.length - 1]};
-}
-
-// The display sort key for a canonical weekday number: Monday (1) first,
-// Sunday (0) last. The IR keeps Sunday=0 canonical; this is display-only.
-function weekdayDisplayKey(value: number): number {
-  return value === 0 ? 7 : value;
-}
-
-// A weekday display segment: a single day or a (possibly wrap) range. Steps
-// are flattened away into singles before sorting, so the result is only these
-// two kinds; each renderer turns them into names exactly as it does today.
-type WeekdaySegment =
-  | {kind: 'single'; value: string}
-  | {kind: 'range'; bounds: [string, string]};
-
-// Reorder weekday segments Monday-first (Sunday last) for display, so a weekend
-// list reads "Saturday and Sunday" rather than the canonical Sunday-first
-// "Sunday and Saturday". Display-only: the IR / canonical order is unchanged (a
-// fresh array is returned). A step expands to its fires as singles so the days
-// sort into the list; a range stays one unit and keeps its own bounds order (a
-// wrap range is not reordered into a list), sorting by its opening bound — so a
-// lone range sorts to a one-element list and is unchanged. The sort is stable,
-// so equal opening days keep input order.
-function orderWeekdaysForDisplay(segments: Segment[]): WeekdaySegment[] {
-  const flattened: WeekdaySegment[] = segments.flatMap(function flat(segment) {
-    return segment.kind === 'step' ?
-      segment.fires.map(function single(value): WeekdaySegment {
-        return {kind: 'single', value: '' + value};
-      }) :
-      [segment];
-  });
-
-  function key(segment: WeekdaySegment): number {
-    return segment.kind === 'range' ?
-      weekdayDisplayKey(+segment.bounds[0]) :
-      weekdayDisplayKey(+segment.value);
-  }
-
-  return flattened
-    .map(function index(segment, position): [WeekdaySegment, number] {
-      return [segment, position];
-    })
-    .sort(function byDisplayKey(a, b): number {
-      return key(a[0]) - key(b[0]) || a[1] - b[1];
-    })
-    .map(function unwrap(pair): WeekdaySegment {
-      return pair[0];
-    });
-}
-
 // Resolve a numeric or named field token (e.g. '5' or 'FRI') to its number.
 function toFieldNumber(
   token: string,
@@ -103,7 +26,5 @@ function toFieldNumber(
   // weekday) reach here. They always have an associated `numberMap`.
   return isNonNegativeInteger(token) ? +token : numberMap![token.toUpperCase()];
 }
-export {
-  arithmeticStep, includes, isNonNegativeInteger, orderWeekdaysForDisplay,
-  toFieldNumber, unique
-};
+
+export {includes, isNonNegativeInteger, toFieldNumber, unique};

package/src/core/validate.ts

@@ -1,9 +1,9 @@
-// Loosely alidate a cron-like object against the field specifications,
+// Loosely validate a cron-like object against the field specifications,
 // including Quartz tokens and wrap-around range rules.
 
 import {fieldOrder, fieldSpecs} from './specs.js';
 import type {CronLike, FieldSpec} from './specs.js';
-import type {Field} from './ir.js';
+import type {Field} from './schedule.js';
 import {includes, isNonNegativeInteger, toFieldNumber} from './util.js';
 
 // Validate every field of a cron-like object, throwing on the first

package/src/core/weekday.ts

@@ -0,0 +1,54 @@
+// Weekday display ordering: present weekdays Monday-first (Sunday last),
+// independent of the Schedule's canonical Sunday=0 order. Display-only.
+
+import type {Segment} from './schedule.js';
+
+// The display sort key for a canonical weekday number: Monday (1) first,
+// Sunday (0) last. The Schedule keeps Sunday=0 canonical; this is display-only.
+function weekdayDisplayKey(value: number): number {
+  return value === 0 ? 7 : value;
+}
+
+// A weekday display segment: a single day or a (possibly wrap) range. Steps
+// are flattened away into singles before sorting, so the result is only these
+// two kinds; each renderer turns them into names exactly as it does today.
+type WeekdaySegment =
+  | {kind: 'single'; value: string}
+  | {kind: 'range'; bounds: [string, string]};
+
+// Reorder weekday segments Monday-first (Sunday last) for display, so a weekend
+// list reads "Saturday and Sunday" rather than the canonical Sunday-first
+// "Sunday and Saturday". Display-only: the Schedule / canonical order is
+// unchanged (a fresh array is returned). A step expands to its fires as singles
+// so the days sort into the list; a range stays one unit and keeps its own
+// bounds order (a wrap range is not reordered into a list), sorting by its
+// opening bound — so a lone range sorts to a one-element list and is unchanged.
+// The sort is stable, so equal opening days keep input order.
+function orderWeekdaysForDisplay(segments: Segment[]): WeekdaySegment[] {
+  const flattened: WeekdaySegment[] = segments.flatMap(function flat(segment) {
+    return segment.kind === 'step' ?
+      segment.fires.map(function single(value): WeekdaySegment {
+        return {kind: 'single', value: '' + value};
+      }) :
+      [segment];
+  });
+
+  function key(segment: WeekdaySegment): number {
+    return segment.kind === 'range' ?
+      weekdayDisplayKey(+segment.bounds[0]) :
+      weekdayDisplayKey(+segment.value);
+  }
+
+  return flattened
+    .map(function index(segment, position): [WeekdaySegment, number] {
+      return [segment, position];
+    })
+    .sort(function byDisplayKey(a, b): number {
+      return key(a[0]) - key(b[0]) || a[1] - b[1];
+    })
+    .map(function unwrap(pair): WeekdaySegment {
+      return pair[0];
+    });
+}
+
+export {orderWeekdaysForDisplay};

package/src/cronli5.ts

@@ -28,7 +28,7 @@
 //     patterns always parse seconds first and year last)
 
 import {analyze, prepare} from './core/index.js';
-import type {NormalizedOptions} from './core/ir.js';
+import type {NormalizedOptions} from './core/schedule.js';
 import type {CronPattern, Cronli5Language, Cronli5Options}
   from './types.js';
 import en from './lang/en/index.js';
@@ -79,13 +79,13 @@ function interpretCronPattern(
     return lang.reboot;
   }
 
-  // Analyze into the neutral content + the core's suggested plan, then let the
-  // language optionally override the strategy before rendering. A language
-  // without a `strategy` hook renders the core's suggestion unchanged.
-  const ir = analyze(prepare(cronPattern, opts));
-  const plan = lang.strategy ? lang.strategy(ir, ir.plan) : ir.plan;
+  // Analyze into the neutral facts + the core's suggested plan, then let the
+  // language optionally override the plan before rendering. A language
+  // without a `plan` hook renders the core's suggestion unchanged.
+  const schedule = analyze(prepare(cronPattern, opts));
+  const plan = lang.plan ? lang.plan(schedule, schedule.plan) : schedule.plan;
 
-  return lang.describe({...ir, plan}, opts);
+  return lang.describe({...schedule, plan}, opts);
 }
 
 export default cronli5;