cronli5 0.1.0 → 0.1.2

package/dist/lang/zh.cjs

@@ -197,7 +197,8 @@ function hourFrame(ir) {
   return "\u5728" + hourList(ir) + "\uFF0C";
 }
 function renderMinuteFrequency(ir, plan) {
-  const base = cadence(stepSegment(ir, "minute").interval, UNITS.minute);
+  const minuteStep = stepSegment(ir, "minute");
+  const base = minuteStep.startToken === "*" ? cadence(minuteStep.interval, UNITS.minute) : renderMinutePast(ir);
   const { hours } = plan;
   if (hours.kind === "step") {
     return cadence(stepSegment(ir, "hour").interval, UNITS.hour) + base;
@@ -265,9 +266,6 @@ function renderHourStep(ir) {
   if (segment.fires.length <= 2) {
     return joinAnd(segment.fires.map(hourWord));
   }
-  if (24 % segment.interval !== 0) {
-    return "\u4ECE" + hourWord(segment.fires[0]) + "\u8D77\uFF0C" + cadence(segment.interval, UNITS.hour);
-  }
   return cadence(segment.interval, UNITS.hour);
 }
 function renderRangeOfMinutes(ir) {
@@ -320,15 +318,12 @@ function composeSecondsOnHour(ir, plan, opts) {
   const sec = secondClause(ir);
   const { rest } = plan;
   const restText = render(ir, rest, opts);
-  if (rest.kind === "everyHour") {
-    return sec + "\uFF0C\u6BCF\u5C0F\u65F6";
-  }
-  if (rest.kind === "hourStep") {
-    return sec + "\uFF0C" + restText;
-  }
   if ((rest.kind === "clockTimes" || rest.kind === "compactClockTimes") && isDaily(ir)) {
     return "\u6BCF\u5929" + restText + sec;
   }
+  if (rest.kind === "singleMinute") {
+    return restText + "\uFF0C" + sec;
+  }
   return restText + sec;
 }
 function composeSecondsCadence(ir) {
@@ -348,17 +343,12 @@ function composeSecondsCadence(ir) {
 function composeSecondsListed(ir) {
   const sec = secondClause(ir);
   const minutes = "\u6BCF\u5C0F\u65F6" + valueList(fieldSegments(ir, "minute"), "\u5206");
-  const minuteSegs = fieldSegments(ir, "minute");
   if (ir.shapes.hour === "wildcard") {
     return minutes + "\uFF0C" + sec;
   }
   if (isHourCadence(ir)) {
     return cadence(stepSegment(ir, "hour").interval, UNITS.hour) + "\uFF0C" + minutes + "\uFF0C" + sec;
   }
-  if (ir.shapes.hour === "range" && minuteSegs.length === 1 && minuteSegs[0].kind === "range") {
-    const [from, to] = fieldSegments(ir, "hour")[0].bounds;
-    return "\u5728" + hourWord(+from) + "\u81F3" + to + "\u70B9" + minuteSegs[0].bounds[1] + "\u5206\u4E4B\u95F4\uFF0C" + sec;
-  }
   return hourFrame(ir) + minutes + "\uFF0C" + sec;
 }
 function renderComposeSeconds(ir, plan, opts) {

package/dist/lang/zh.js

@@ -171,7 +171,8 @@ function hourFrame(ir) {
   return "\u5728" + hourList(ir) + "\uFF0C";
 }
 function renderMinuteFrequency(ir, plan) {
-  const base = cadence(stepSegment(ir, "minute").interval, UNITS.minute);
+  const minuteStep = stepSegment(ir, "minute");
+  const base = minuteStep.startToken === "*" ? cadence(minuteStep.interval, UNITS.minute) : renderMinutePast(ir);
   const { hours } = plan;
   if (hours.kind === "step") {
     return cadence(stepSegment(ir, "hour").interval, UNITS.hour) + base;
@@ -239,9 +240,6 @@ function renderHourStep(ir) {
   if (segment.fires.length <= 2) {
     return joinAnd(segment.fires.map(hourWord));
   }
-  if (24 % segment.interval !== 0) {
-    return "\u4ECE" + hourWord(segment.fires[0]) + "\u8D77\uFF0C" + cadence(segment.interval, UNITS.hour);
-  }
   return cadence(segment.interval, UNITS.hour);
 }
 function renderRangeOfMinutes(ir) {
@@ -294,15 +292,12 @@ function composeSecondsOnHour(ir, plan, opts) {
   const sec = secondClause(ir);
   const { rest } = plan;
   const restText = render(ir, rest, opts);
-  if (rest.kind === "everyHour") {
-    return sec + "\uFF0C\u6BCF\u5C0F\u65F6";
-  }
-  if (rest.kind === "hourStep") {
-    return sec + "\uFF0C" + restText;
-  }
   if ((rest.kind === "clockTimes" || rest.kind === "compactClockTimes") && isDaily(ir)) {
     return "\u6BCF\u5929" + restText + sec;
   }
+  if (rest.kind === "singleMinute") {
+    return restText + "\uFF0C" + sec;
+  }
   return restText + sec;
 }
 function composeSecondsCadence(ir) {
@@ -322,17 +317,12 @@ function composeSecondsCadence(ir) {
 function composeSecondsListed(ir) {
   const sec = secondClause(ir);
   const minutes = "\u6BCF\u5C0F\u65F6" + valueList(fieldSegments(ir, "minute"), "\u5206");
-  const minuteSegs = fieldSegments(ir, "minute");
   if (ir.shapes.hour === "wildcard") {
     return minutes + "\uFF0C" + sec;
   }
   if (isHourCadence(ir)) {
     return cadence(stepSegment(ir, "hour").interval, UNITS.hour) + "\uFF0C" + minutes + "\uFF0C" + sec;
   }
-  if (ir.shapes.hour === "range" && minuteSegs.length === 1 && minuteSegs[0].kind === "range") {
-    const [from, to] = fieldSegments(ir, "hour")[0].bounds;
-    return "\u5728" + hourWord(+from) + "\u81F3" + to + "\u70B9" + minuteSegs[0].bounds[1] + "\u5206\u4E4B\u95F4\uFF0C" + sec;
-  }
   return hourFrame(ir) + minutes + "\uFF0C" + sec;
 }
 function renderComposeSeconds(ir, plan, opts) {

package/package.json

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

package/src/core/analyze.ts

@@ -269,10 +269,13 @@ function planSeconds(
     return null;
   }
 
+  // The second makes the cadence sub-minute, so a minute of 0 is a real
+  // restriction that must be stated, not absorbed into an hourly idiom (which
+  // would silently drop it). Route minute 0 to the minute-explicit forms.
   return {
     kind: 'composeSeconds',
-    rest: planMinutes(pattern, shapes, analyses) ||
-      planHours(pattern, shapes, analyses)
+    rest: planMinutes(pattern, shapes, analyses, true) ||
+      planHours(pattern, shapes, analyses, true)
   };
 }
 
@@ -303,7 +306,8 @@ function planStandaloneSeconds(
 function planMinutes(
   pattern: Pattern,
   shapes: Shapes,
-  analyses: Analyses
+  analyses: Analyses,
+  subMinuteSecond = false
 ): PlanNode | undefined {
   if (shapes.minute === 'step') {
     return {
@@ -333,7 +337,7 @@ function planMinutes(
   }
 
   if (pattern.hour === '*') {
-    return planMinutesUnderOpenHour(pattern, shapes);
+    return planMinutesUnderOpenHour(pattern, shapes, subMinuteSecond);
   }
 }
 
@@ -451,7 +455,8 @@ function planMinutesAcrossHours(
 // Minute strategies that only stand on their own under a wildcard hour.
 function planMinutesUnderOpenHour(
   pattern: Pattern,
-  shapes: Shapes
+  shapes: Shapes,
+  subMinuteSecond: boolean
 ): PlanNode | undefined {
   if (shapes.minute === 'range') {
     return {kind: 'rangeOfMinutes'};
@@ -465,56 +470,89 @@ function planMinutesUnderOpenHour(
     return {kind: 'everyMinute'};
   }
 
-  if (pattern.minute !== '0') {
+  // Minute 0 normally defers to "every hour" so a standalone `0 * * * *`
+  // stays terse; under a sub-minute second it must be stated, so name it.
+  if (pattern.minute !== '0' || subMinuteSecond) {
     return {kind: 'singleMinute'};
   }
 }
 
-// Hour strategies: the chain's last resort always produces a plan.
+// Hour strategies: 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.
 function planHours(
   pattern: Pattern,
   shapes: Shapes,
-  analyses: Analyses
+  analyses: Analyses,
+  subMinuteSecond = false
 ): PlanNode {
-  if (shapes.hour === 'range') {
-    const bounds = pattern.hour.split('-');
-    let minuteForm: 'lead' | 'wildcard' | 'range' = 'lead';
-
-    if (pattern.minute === '*') {
-      minuteForm = 'wildcard';
-    }
-    else if (shapes.minute === 'range') {
-      minuteForm = 'range';
-    }
+  const absorbsMinuteZero = subMinuteSecond && pattern.minute === '0';
 
-    return {
-      from: +bounds[0],
-      kind: 'hourRange',
-      last: analyses.lastMinuteFire,
-      minuteForm,
-      to: +bounds[1]
-    };
+  if (shapes.hour === 'range' && !absorbsMinuteZero) {
+    return planHourRange(pattern, shapes, analyses);
   }
 
-  if (shapes.hour === 'step' && pattern.minute === '0') {
+  if (shapes.hour === 'step' && pattern.minute === '0' && !subMinuteSecond) {
     return {kind: 'hourStep'};
   }
 
-  if (pattern.hour === '*') {
+  if (pattern.hour === '*' && !absorbsMinuteZero) {
     return {kind: 'everyHour'};
   }
 
-  return planClockTimes(pattern, analyses);
+  // When minute 0 must be stated, enumerate the on-the-hour times explicitly:
+  // the compact fold of a contiguous hour range would otherwise restate the
+  // hour-range idiom ("every hour from X through Y") and re-drop the :00.
+  return planClockTimes(pattern, analyses, absorbsMinuteZero);
+}
+
+// The hour-range plan: a window from the first hour through the last. The
+// minute clause leads (a single fire or a list), fires every minute (a range),
+// or fills the window (a wildcard). A multi-valued minute (list or range)
+// closes the window on the bare hour, stating its minutes separately; a single
+// fire or a wildcard names an exact closing minute (its fire, or the wildcard's
+// last :59) — otherwise the glued last fire reads as a continuous span.
+function planHourRange(
+  pattern: Pattern,
+  shapes: Shapes,
+  analyses: Analyses
+): PlanNode {
+  const bounds = pattern.hour.split('-');
+  let minuteForm: 'lead' | 'wildcard' | 'range' = 'lead';
+
+  if (pattern.minute === '*') {
+    minuteForm = 'wildcard';
+  }
+  else if (shapes.minute === 'range') {
+    minuteForm = 'range';
+  }
+
+  const multiValued = shapes.minute === 'range' || shapes.minute === 'list';
+
+  return {
+    boundMinute: multiValued ? null : analyses.lastMinuteFire,
+    from: +bounds[0],
+    kind: 'hourRange',
+    last: analyses.lastMinuteFire,
+    minuteForm,
+    to: +bounds[1]
+  };
 }
 
 // Enumerated clock times up to the cap; past it, a compact form (a single
 // minute folds into hour-segment windows; a minute list leads with its own
-// clause).
-function planClockTimes(pattern: Pattern, analyses: Analyses): PlanNode {
+// clause). `enumerate` forces the explicit list past the cap, used when a
+// minute restriction must be named rather than folded into an hour idiom.
+function planClockTimes(
+  pattern: Pattern,
+  analyses: Analyses,
+  enumerate = false
+): PlanNode {
   const hours = enumerateFires(pattern.hour, 0, 23);
   const minutes = enumerateValues(pattern.minute);
 
-  if (hours.length * minutes.length > maxClockTimes) {
+  if (!enumerate && hours.length * minutes.length > maxClockTimes) {
     return {
       fold: minutes.length === 1,
       kind: 'compactClockTimes',

package/src/core/ir.ts

@@ -78,6 +78,12 @@ export type PlanNode =
       from: number;
       to: number;
       last: number;
+      // The minute to show on the closing bound, or `null` to close on the
+      // bare hour with the minutes stated separately. A single fire or a
+      // wildcard names an exact closing minute (the fire, or `:59`); a minute
+      // list or range would otherwise glue its last fire onto the bound and
+      // read as a continuous span, so it closes bare instead.
+      boundMinute: number | null;
       minuteForm: 'lead' | 'wildcard' | 'range';
     }
   | {kind: 'hourStep'}

package/src/core/normalize.ts

@@ -4,10 +4,20 @@
 
 import {fieldOrder, fieldSpecs} from './specs.js';
 import type {CronLike, FieldSpec} from './specs.js';
-import type {Pattern} from './ir.js';
+import type {Field, Pattern} from './ir.js';
 import {includes, toFieldNumber, unique} from './util.js';
 import {isQuartzDate, isQuartzWeekday} from './validate.js';
 
+// The fixed-cycle time fields: their step intervals are measured against a
+// closed cycle (60 seconds, 60 minutes, 24 hours), so a step is a true
+// "every N" cadence only when it tiles that cycle. The calendar fields
+// (date/month/weekday) have variable cycles and keep their step form.
+const timeFieldCycle: Partial<Record<Field, number>> = {
+  hour: 24,
+  minute: 60,
+  second: 60
+};
+
 // Quartz aliases: `?` reads "no specific value" (equivalent to `*`) in the
 // date and weekday fields, and a bare `L` weekday means Saturday.
 function applyQuartzAliases(cronPattern: CronLike): void {
@@ -40,7 +50,7 @@ function normalizeCronPattern(cronPattern: CronLike): Pattern {
       return;
     }
 
-    cronPattern[field] = normalizeField(value, fieldSpecs[field]);
+    cronPattern[field] = normalizeField(value, field, fieldSpecs[field]);
   });
 
   // Every field is now a canonical string.
@@ -48,17 +58,20 @@ function normalizeCronPattern(cronPattern: CronLike): Pattern {
 }
 
 // Canonicalize a single validated field value to a string.
-function normalizeField(value: string, spec: FieldSpec): string {
+function normalizeField(value: string, field: Field, spec: FieldSpec): string {
   const stringValue = '' + value;
 
   if (stringValue === '*') {
     return stringValue;
   }
 
+  const cycle = timeFieldCycle[field];
   const segments = stringValue.split(',').map(function canonical(segment) {
-    return collapseDegenerateRange(
-      collapseOnceStep(collapseUnitStep(segment, spec), spec), spec);
-  });
+    return enumerateNonUniformStep(
+      collapseDegenerateRange(
+        collapseOnceStep(collapseUnitStep(segment, spec), spec), spec),
+      spec, cycle);
+  }).join(',').split(',');
 
   // A full-cycle segment covers the whole field.
   if (segments.indexOf('*') !== -1) {
@@ -115,6 +128,41 @@ function collapseOnceStep(segment: string, spec: FieldSpec): string {
   return start === '*' ? '' + spec.min : start;
 }
 
+// An unbounded step in a fixed-cycle time field is a true "every N" cadence
+// only when it tiles the cycle: the interval divides it evenly and the start
+// falls within the first interval (`*/15`, `5/6`). A step that fails either
+// test fires at irregular points within the cycle, so it reads as the literal
+// 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(
+  segment: string,
+  spec: FieldSpec,
+  cycle: number | undefined
+): string {
+  const parts = segment.split('/');
+
+  if (typeof cycle !== 'number' || parts.length !== 2 ||
+      includes(parts[0], '-')) {
+    return segment;
+  }
+
+  const interval = +parts[1];
+  const start = parts[0] === '*' ? spec.min : toFieldNumber(parts[0]);
+
+  if (cycle % interval === 0 && start < interval) {
+    return segment;
+  }
+
+  const fires = [];
+
+  for (let value = start; value <= (spec.top as number); value += interval) {
+    fires.push(value);
+  }
+
+  return fires.join(',');
+}
+
 // A degenerate range (`9-9`) fires once, so it reads as its single value.
 // A stepped degenerate range (`9-9/5`) likewise fires only at its start.
 function collapseDegenerateRange(segment: string, spec: FieldSpec): string {

package/src/lang/de/index.ts

@@ -462,7 +462,9 @@ function duringHours(ir: IR, times: HourTimesPlan, sep: string): string {
     return joinList(windows);
   }
 
-  return 'in den Stunden von ' + joinList(times.fires.map(String)) + ' Uhr';
+  // A discrete set of hours is a list, not a range, so it takes no "von"
+  // (which would read as "von X bis Y"); it mirrors the minute list form.
+  return 'in den Stunden ' + joinList(times.fires.map(String)) + ' Uhr';
 }
 
 // --- Renderers. ---
@@ -657,7 +659,11 @@ function renderHourRange(
   plan: Extract<PlanNode, {kind: 'hourRange'}>,
   opts: Opts
 ): string {
-  const window = hourWindow(plan.from, plan.to, plan.last, opts.style.sep);
+  // A bare close (`boundMinute` null) lands on the top of the final hour
+  // (minute 0), matching the minute-0 baseline, with the minutes stated
+  // separately; a single fire or wildcard names an exact closing minute.
+  const window = hourWindow(plan.from, plan.to, plan.boundMinute ?? 0,
+    opts.style.sep);
 
   if (plan.minuteForm === 'wildcard') {
     return 'jede Minute ' + window;
@@ -814,7 +820,10 @@ const de: Language<GermanStyle> = {
   fallback: 'ein unlesbares Cron-Muster',
   options: normalizeOptions,
   reboot: 'beim Systemstart',
-  sentence: (description) => 'Läuft ' + description + '.'
+  // A description ending in a German ordinal already carries its period
+  // ("…am 8."), so closing the sentence must not double it.
+  sentence: (description) =>
+    'Läuft ' + description + (description.endsWith('.') ? '' : '.')
 };
 
 export default de;

package/src/lang/en/index.ts

@@ -376,7 +376,7 @@ function renderEveryHour(ir: IR, plan: PlanOf<'everyHour'>,
 // minute; a discrete minute anchors as a lead clause.
 function renderHourRange(ir: IR, plan: PlanOf<'hourRange'>,
   opts: NormalizedOptions): string {
-  const window = hourWindow(plan, opts);
+  const window = hourWindow(boundedWindow(plan), opts);
 
   if (plan.minuteForm === 'wildcard') {
     return 'every minute ' + window + trailingQualifier(ir, opts);
@@ -411,6 +411,14 @@ function renderHourStep(ir: IR, plan: PlanOf<'hourStep'>,
     trailingQualifier(ir, opts);
 }
 
+// The hour-range plan as a window whose closing minute honors `boundMinute`:
+// a bare close (`null`) lands on the top of the final hour (`:00`), matching
+// the minute-0 baseline, with the minutes stated separately elsewhere.
+function boundedWindow(plan: PlanOf<'hourRange'>):
+  {from: number; to: number; last: number} {
+  return {from: plan.from, last: plan.boundMinute ?? 0, to: plan.to};
+}
+
 // An hour window phrase, e.g. "from 9 a.m. through 5:45 p.m.". Windows
 // open at the top of the first hour and close at the minute field's last
 // fire within the final hour.
@@ -539,7 +547,10 @@ const renderers = {
 // Phrase a `start/interval` step segment for a field that cycles every 60
 // units (seconds and minutes). `unit` is the singular noun and `anchor` is
 // the larger unit the values are counted against. Interval-one steps never
-// arrive here: normalization collapses them to ranges or `*`.
+// arrive here: normalization collapses them to ranges or `*`. Nor do uneven
+// steps that fail to tile the cycle: normalization rewrites those to the
+// literal list of their fires, so only a clean cadence (interval dividing
+// 60, start within the first interval) reaches a step renderer.
 function stepCycle60(segment: StepSegment, unit: string,
   anchor: string, opts: NormalizedOptions): string {
   // A bounded start (`a-b/n`) applies the interval within the range.
@@ -551,6 +562,8 @@ function stepCycle60(segment: StepSegment, unit: string,
   const interval = segment.interval;
 
   if (start !== 0) {
+    // A short offset cadence lists its fires; a longer one names the
+    // interval and its starting offset ("every six minutes from five …").
     if (segment.fires.length <= 3) {
       return listPastThe(numberWords(segment.fires, opts), unit, anchor,
         opts);
@@ -561,18 +574,8 @@ function stepCycle60(segment: StepSegment, unit: string,
       ' past the ' + anchor;
   }
 
-  // A step reads as a natural cadence ("every N minutes") only when it
-  // divides the cycle evenly, mirroring the hour field's `24 % n` rule.
-  if (60 % interval === 0) {
-    return 'every ' + getNumber(interval, opts) + ' ' + unit + 's';
-  }
-
-  if (segment.fires.length <= 2) {
-    return listPastThe(numberWords(segment.fires, opts), unit, anchor, opts);
-  }
-
-  return 'every ' + getNumber(interval, opts) + ' ' + unit +
-    's past the ' + anchor;
+  // A clean stride from the top of the cycle is the bare cadence.
+  return 'every ' + getNumber(interval, opts) + ' ' + unit + 's';
 }
 
 // Phrase a `start/interval` step segment for the hour field (cycles every
@@ -586,18 +589,18 @@ function stepHours(segment: StepSegment, opts: NormalizedOptions): string {
   const start = segment.startToken === '*' ? 0 : +segment.startToken;
   const interval = segment.interval;
 
-  if (start === 0 && 24 % interval === 0) {
+  // A clean stride from midnight is the bare cadence. (An uneven stride is
+  // rewritten to its fires upstream and never reaches here.)
+  if (start === 0) {
     return 'every ' + getNumber(interval, opts) + ' hours';
   }
 
+  // A short offset cadence lists its fires; a longer one names the interval
+  // and its start ("every three hours from 2 a.m.").
   if (segment.fires.length <= 3) {
     return 'at ' + hourTimes(segment.fires, opts);
   }
 
-  if (start === 0) {
-    return 'every ' + getNumber(interval, opts) + ' hours from midnight';
-  }
-
   return 'every ' + getNumber(interval, opts) + ' hours from ' +
     getTime({hour: start, minute: 0}, opts);
 }

package/src/lang/es/index.ts

@@ -525,7 +525,7 @@ function renderHourRange(
   plan: Extract<PlanNode, {kind: 'hourRange'}>,
   opts: Opts
 ): string {
-  const window = hourWindow(plan, opts);
+  const window = hourWindow(boundedWindow(plan), opts);
 
   if (plan.minuteForm === 'wildcard') {
     return 'cada minuto ' + window + trailingQualifier(ir, opts);
@@ -558,6 +558,15 @@ function renderHourStep(
     trailingQualifier(ir, opts);
 }
 
+// The hour-range plan as a window whose closing minute honors `boundMinute`:
+// a bare close (`null`) lands on the top of the final hour (minute 0),
+// matching the minute-0 baseline, with the minutes stated separately.
+function boundedWindow(
+  plan: Extract<PlanNode, {kind: 'hourRange'}>
+): {from: number; to: number; last: number} {
+  return {from: plan.from, last: plan.boundMinute ?? 0, to: plan.to};
+}
+
 // "de las 9:00 a las 17:45": a window from the top of the first hour to
 // the minute field's last fire within the final hour.
 function hourWindow(
@@ -1006,17 +1015,9 @@ function stepCycle60(
       unit + ' ' + start + ' de cada ' + anchor;
   }
 
-  if (60 % interval === 0) {
-    return 'cada ' + numero(interval, opts) + ' ' + unit + 's';
-  }
-
-  if (segment.fires.length <= 2) {
-    return 'en los ' + unit + 's ' + joinList(wordList(segment.fires)) +
-      ' de cada ' + anchor;
-  }
-
-  return 'cada ' + numero(interval, opts) + ' ' + unit + 's de cada ' +
-    anchor;
+  // A clean stride from the top of the cycle is the bare cadence. (An uneven
+  // stride is rewritten to its fires upstream and never reaches here.)
+  return 'cada ' + numero(interval, opts) + ' ' + unit + 's';
 }
 
 // "cada seis horas", "a las 9:00, a las 11:00 y a la 1:00", or "cada
@@ -1029,7 +1030,9 @@ function stepHours(segment: StepSegment, opts: Opts): string {
   const start = segment.startToken === '*' ? 0 : +segment.startToken;
   const interval = segment.interval;
 
-  if (start === 0 && 24 % interval === 0) {
+  // A clean stride from midnight is the bare cadence. (An uneven stride is
+  // rewritten to its fires upstream and never reaches here.)
+  if (start === 0) {
     return 'cada ' + numero(interval, opts) + ' horas';
   }
 
@@ -1037,10 +1040,6 @@ function stepHours(segment: StepSegment, opts: Opts): string {
     return groupClockTimesByArticle(atTimes(segment.fires, opts));
   }
 
-  if (start === 0) {
-    return 'cada ' + numero(interval, opts) + ' horas desde medianoche';
-  }
-
   return 'cada ' + numero(interval, opts) + ' horas a partir de ' +
     timePhrase(start, 0, null, opts);
 }