cronli5 0.1.2 → 0.1.4

package/dist/lang/zh.js

@@ -175,7 +175,8 @@ function renderMinuteFrequency(ir, plan) {
   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;
+    const hourStep = stepSegment(ir, "hour");
+    return hourStep.startToken === "*" ? cadence(hourStep.interval, UNITS.hour) + base : "\u5728" + hourList(ir) + "\uFF0C" + base;
   }
   if (hours.kind === "single" || hours.kind === "window" && hours.from === hours.to) {
     return "\u5728" + hourWord(hours.from) + "\u81F3" + hours.from + "\u70B9" + hours.last + "\u5206\u4E4B\u95F4\uFF0C" + base;
@@ -190,6 +191,9 @@ function renderMinuteFrequency(ir, plan) {
 }
 function renderMinuteSpanInHour(ir, plan) {
   const span = plan;
+  if (ir.pattern.minute === "*") {
+    return hourWord(span.hour) + "\u7684\u6BCF\u4E00\u5206\u949F";
+  }
   return "\u5728" + hourWord(span.hour) + "\u81F3" + span.hour + "\u70B9" + span.span[1] + "\u5206\u4E4B\u95F4\uFF0C\u6BCF\u5206\u949F";
 }
 function renderMinutesAcrossHours(ir, plan) {
@@ -200,12 +204,17 @@ function renderMinutesAcrossHours(ir, plan) {
   return hourList(ir) + "\uFF0C\u6BCF\u5C0F\u65F6" + valueList(fieldSegments(ir, "minute"), "\u5206") + "\uFF0C\u6BCF\u5206\u949F";
 }
 function renderMinuteSpanAcrossHourStep(ir, plan) {
-  const cad = cadence(stepSegment(ir, "hour").interval, UNITS.hour);
+  const hourStep = stepSegment(ir, "hour");
   const { form } = plan;
-  if (form === "wildcard") {
-    return cad + "\u5185\uFF0C\u6BCF\u5206\u949F";
+  const minuteTail = form === "wildcard" ? "\u6BCF\u5206\u949F" : "\u6BCF\u5C0F\u65F6" + valueList(fieldSegments(ir, "minute"), "\u5206") + "\uFF0C\u6BCF\u5206\u949F";
+  if (hourStep.startToken !== "*") {
+    return form === "wildcard" ? "\u5728" + hourList(ir) + "\uFF0C" + minuteTail : hourList(ir) + "\uFF0C" + minuteTail;
   }
-  return cad + "\uFF0C\u6BCF\u5C0F\u65F6" + valueList(fieldSegments(ir, "minute"), "\u5206") + "\uFF0C\u6BCF\u5206\u949F";
+  if (hourStep.interval === 2 && form === "wildcard") {
+    return "\u5728\u5076\u6570\u5C0F\u65F6\uFF0C" + minuteTail;
+  }
+  const cad = cadence(hourStep.interval, UNITS.hour);
+  return form === "wildcard" ? cad + "\u5185\uFF0C" + minuteTail : cad + "\uFF0C" + minuteTail;
 }
 function renderClockTimes(ir, plan, opts) {
   const { times } = plan;
@@ -291,9 +300,19 @@ function isHourCadence(ir) {
 function composeSecondsOnHour(ir, plan, opts) {
   const sec = secondClause(ir);
   const { rest } = plan;
+  if ((rest.kind === "clockTimes" || rest.kind === "compactClockTimes") && ir.pattern.minute === "0") {
+    const clocks = hourFires(ir).map(function clock(hour) {
+      return hourWord(hour) + "0\u5206";
+    });
+    const tail = sec === "\u6BCF\u79D2" ? "\u7684\u6BCF\u4E00\u79D2" : "\u7684" + sec;
+    const core = joinAnd(clocks) + tail;
+    return isDaily(ir) ? "\u6BCF\u5929" + core : core;
+  }
   const restText = render(ir, rest, opts);
-  if ((rest.kind === "clockTimes" || rest.kind === "compactClockTimes") && isDaily(ir)) {
-    return "\u6BCF\u5929" + restText + sec;
+  if (rest.kind === "clockTimes" || rest.kind === "compactClockTimes") {
+    if (isDaily(ir)) {
+      return "\u6BCF\u5929" + restText + sec;
+    }
   }
   if (rest.kind === "singleMinute") {
     return restText + "\uFF0C" + sec;
@@ -317,6 +336,9 @@ function composeSecondsCadence(ir) {
 function composeSecondsListed(ir) {
   const sec = secondClause(ir);
   const minutes = "\u6BCF\u5C0F\u65F6" + valueList(fieldSegments(ir, "minute"), "\u5206");
+  if (ir.shapes.hour === "single" && sec === "\u6BCF\u79D2") {
+    return hourWord(hourFires(ir)[0]) + valueList(fieldSegments(ir, "minute"), "\u5206") + "\u7684\u6BCF\u4E00\u79D2";
+  }
   if (ir.shapes.hour === "wildcard") {
     return minutes + "\uFF0C" + sec;
   }
@@ -326,10 +348,13 @@ function composeSecondsListed(ir) {
   return hourFrame(ir) + minutes + "\uFF0C" + sec;
 }
 function renderComposeSeconds(ir, plan, opts) {
-  if (ir.pattern.minute === "0") {
+  const { rest } = plan;
+  const composedClock = rest.kind === "clockTimes" || rest.kind === "compactClockTimes";
+  if (ir.pattern.minute === "0" || composedClock && ir.shapes.minute === "single") {
     return composeSecondsOnHour(ir, plan, opts);
   }
-  if (ir.pattern.minute === "*" || ir.shapes.minute === "step") {
+  const minuteCadence = ir.pattern.minute === "*" || ir.shapes.minute === "step" && stepSegment(ir, "minute").startToken === "*";
+  if (minuteCadence) {
     return composeSecondsCadence(ir);
   }
   return composeSecondsListed(ir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cronli5",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Cron Like I'm Five: A Cron to English Utility",
   "repository": {
     "type": "git",
@@ -62,6 +62,7 @@
     "docs": "node --import tsx scripts/docs.mjs",
     "fuzz": "node --import tsx scripts/fuzz-lang.mjs",
     "lint": "eslint src test cli.js eslint.config.js scripts tooling/scripts",
+    "metamorphic": "node --import tsx tooling/scripts/metamorphic.mjs",
     "lint:fix": "eslint src test cli.js eslint.config.js scripts tooling/scripts --fix",
     "test": "mocha",
     "types": "tsc -p tsconfig.types.json",

package/src/core/normalize.ts

@@ -67,10 +67,13 @@ function normalizeField(value: string, field: Field, spec: FieldSpec): string {
 
   const cycle = timeFieldCycle[field];
   const segments = stringValue.split(',').map(function canonical(segment) {
-    return enumerateNonUniformStep(
-      collapseDegenerateRange(
-        collapseOnceStep(collapseUnitStep(segment, spec), spec), spec),
-      spec, cycle);
+    return canonicalizeTokens(collapseFullSpanRange(
+      enumerateNonUniformStep(
+        collapseFullSpanStep(
+          collapseDegenerateRange(
+            collapseOnceStep(collapseUnitStep(segment, spec), spec), spec),
+          spec),
+        spec, cycle), spec), spec);
   }).join(',').split(',');
 
   // A full-cycle segment covers the whole field.
@@ -83,6 +86,40 @@ function normalizeField(value: string, field: Field, spec: FieldSpec): string {
   }).join(',');
 }
 
+// Rewrite a segment's value tokens to their canonical numbers: a name
+// (`MON`, `JAN`) becomes its index, and a weekday `7` (Sunday again, above
+// `top`) folds to the field minimum (`0`). Applied to every token position —
+// a single, both range bounds, and a step's start — so a normalized field
+// never carries a surface name or the 7-for-Sunday alias. `*` and Quartz
+// tokens (resolved earlier) are left untouched. Output is unchanged: a
+// renderer maps the number back to its own name.
+function canonicalizeTokens(segment: string, spec: FieldSpec): string {
+  // Only the named fields (month, weekday) carry name tokens or the
+  // weekday `7`-for-Sunday alias; every other field is already numeric.
+  if (!spec.numbers) {
+    return segment;
+  }
+
+  const parts = segment.split('/');
+  const start = parts[0].split('-').map(function fold(token) {
+    return canonicalizeToken(token, spec);
+  }).join('-');
+
+  return parts.length === 2 ? start + '/' + parts[1] : start;
+}
+
+// A single token to its canonical number string (`*` passes through).
+function canonicalizeToken(token: string, spec: FieldSpec): string {
+  if (token === '*') {
+    return token;
+  }
+
+  const number = toFieldNumber(token, spec.numbers);
+
+  // A value above `top` (weekday 7) is the field minimum again.
+  return '' + (number > (spec.top as number) ? spec.min : number);
+}
+
 // An interval-one step enumerates every value from its start, so it reads
 // as the equivalent range: `1/1` is `1-59` and `5-30/1` is `5-30`. A start
 // at the bottom of the cycle covers the whole field (`0/1` is `*`).
@@ -163,6 +200,59 @@ function enumerateNonUniformStep(
   return fires.join(',');
 }
 
+// A step whose range part covers the whole field (`0-59/2`, `0-23/2`) strides
+// across the entire cycle, so the bound adds nothing — it reads as the
+// unbounded `*/N` step (which the cycle test then renders as "every N" or its
+// fires). Partial-range steps (`9-17/2`) keep their window.
+function collapseFullSpanStep(segment: string, spec: FieldSpec): string {
+  const parts = segment.split('/');
+
+  if (parts.length !== 2 || !includes(parts[0], '-')) {
+    return segment;
+  }
+
+  return collapseFullSpanRange(parts[0], spec) === '*' ?
+    '*/' + parts[1] :
+    segment;
+}
+
+// A plain range whose enumerated values cover the whole field imposes no
+// restriction, so it reads identically to `*` (`0-59` minute, `0-23` hour,
+// `1-31` date, `1-12` month, and every seven-day weekday range — `0-6`,
+// `1-7`, `0-7`, `SUN-SAT` — since cron's 7 is Sunday again, folding to the
+// field minimum). Only bare ranges qualify: a step (`0-59/2`) keeps its
+// cadence, so segments carrying a `/` are left untouched.
+function collapseFullSpanRange(segment: string, spec: FieldSpec): string {
+  if (typeof spec.top !== 'number' || includes(segment, '/') ||
+      !includes(segment, '-')) {
+    return segment;
+  }
+
+  const bounds = segment.split('-');
+  const low = toFieldNumber(bounds[0], spec.numbers);
+  const high = toFieldNumber(bounds[1], spec.numbers);
+
+  if (low > high) {
+    return segment;
+  }
+
+  // The full field is min..top; a value above top (weekday 7) folds to min.
+  const top = spec.top as number;
+  const fired: Record<number, boolean> = {};
+
+  for (let value = low; value <= high; value += 1) {
+    fired[value > top ? spec.min : value] = true;
+  }
+
+  for (let value = spec.min; value <= top; value += 1) {
+    if (!fired[value]) {
+      return segment;
+    }
+  }
+
+  return '*';
+}
+
 // 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

@@ -2,6 +2,8 @@
 // German. Anchored to Duden; see notes.md for the decisions.
 
 import {pad} from '../../core/format.js';
+import {weekdayNumbers} from '../../core/specs.js';
+import {toFieldNumber} from '../../core/util.js';
 import type {Cronli5Options} from '../../types.js';
 import type {
   Field, HourTimesPlan, IR, Language, NormalizedOptions, PlanNode, Segment
@@ -61,11 +63,6 @@ const weekdayNames = [
   'freitags', 'samstags'
 ];
 
-// Cron weekday tokens (part of cron syntax), mapped to indices.
-const weekdayTokens: {[token: string]: number} = {
-  SUN: 0, MON: 1, TUE: 2, WED: 3, THU: 4, FRI: 5, SAT: 6
-};
-
 function fieldSegments(ir: IR, field: Field): Segment[] {
   return ir.analyses.segments[field] as Segment[];
 }
@@ -94,14 +91,9 @@ function joinList(items: string[]): string {
   return items.slice(0, -1).join(', ') + ' und ' + items[items.length - 1];
 }
 
-// The adverbial name for a weekday token (cron name or number; 7 = Sunday).
+// The adverbial name for a canonical weekday number (0 = Sunday).
 function weekdayName(token: NameToken): string {
-  if (token === '7' || token === 7) {
-    return weekdayNames[0];
-  }
-
-  return weekdayNames[token as number] ||
-    weekdayNames[weekdayTokens[token as string]];
+  return weekdayNames[+token];
 }
 
 // "montags bis freitags".
@@ -150,12 +142,10 @@ function everyNthHour(segment: StepSegment): string {
   return start === 0 ? base : base + ' ab ' + start + ' Uhr';
 }
 
+// The Quartz weekday stem (`5L`, `MON#2`) is not number-canonicalized in the
+// core, so it may still be a name token; resolve it via the core's index.
 function weekdayNoun(token: string): string {
-  if (token === '7') {
-    return weekdayNouns[0];
-  }
-
-  return weekdayNouns[token in weekdayTokens ? weekdayTokens[token] : +token];
+  return weekdayNouns[toFieldNumber(token, weekdayNumbers)];
 }
 
 // The Quartz weekday phrase: "am letzten Freitag des Monats", "am zweiten
@@ -193,18 +183,12 @@ function quartzDate(field: string): string | null {
   return null;
 }
 
-// Cron month tokens (part of cron syntax), mapped to indices. The month names
-// themselves are dialect-scoped and resolved from `opts.style.months`.
-const monthTokens: {[token: string]: number} = {
-  JAN: 1, FEB: 2, MAR: 3, APR: 4, MAY: 5, JUN: 6,
-  JUL: 7, AUG: 8, SEP: 9, OCT: 10, NOV: 11, DEC: 12
-};
-
 type Months = GermanStyle['months'];
 
+// The month names are dialect-scoped (resolved from `opts.style.months`);
+// the canonical month number indexes them.
 function monthName(token: NameToken, months: Months): string {
-  return (months[token as number] ||
-    months[monthTokens[token as string]]) as string;
+  return months[+token] as string;
 }
 
 // "von Juni bis August".
@@ -511,12 +495,33 @@ function renderSecondsWithinMinute(
     ' jeder Stunde';
 }
 
-// A minute span inside one hour: "jede Minute von 9:00 bis 9:30 Uhr".
+// The whole-hour noun in the genitive: "der Mitternachtsstunde" (0), "der
+// Mittagsstunde" (12), or "der <H>-Uhr-Stunde" for any other hour.
+function wholeHour(hour: number): string {
+  if (hour === 0) {
+    return 'der Mitternachtsstunde';
+  }
+
+  if (hour === 12) {
+    return 'der Mittagsstunde';
+  }
+
+  return 'der ' + hour + '-Uhr-Stunde';
+}
+
+// A minute span inside one hour: "jede Minute von 9:00 bis 9:30 Uhr". A
+// wildcard minute is the whole hour, so it reads as that hour itself ("jede
+// Minute der 9-Uhr-Stunde") rather than a synthesized "von 9:00 bis 9:59"
+// range the source never stated; a plain range is a real window and keeps it.
 function renderMinuteSpanInHour(
   ir: IR,
   plan: Extract<PlanNode, {kind: 'minuteSpanInHour'}>,
   opts: Opts
 ): string {
+  if (ir.pattern.minute === '*') {
+    return 'jede Minute ' + wholeHour(plan.hour);
+  }
+
   const sep = opts.style.sep;
 
   return 'jede Minute von ' + spanTime(plan.hour, plan.span[0], sep) +
@@ -530,9 +535,47 @@ function renderComposeSeconds(
   plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
   opts: Opts
 ): string {
+  // A sub-minute second with the minute pinned to 0 and a specific hour: the
+  // clock-time rest would read "um 9 Uhr", which hides the pinned :00 (and so
+  // the one-minute confinement — 60 fires in :00, not 3,600 across the hour).
+  // Bind the seconds into the explicit clock minute in the genitive ("der
+  // Minute 9:00"); the recurring "täglich"/day frame is added in `describe`.
+  if (composeMinuteZero(ir, plan)) {
+    return secondsLead(ir) + ' ' +
+      clockMinuteGenitive(plan.rest.times, opts.style.sep);
+  }
+
   return secondsLead(ir) + ', ' + render(ir, plan.rest, opts);
 }
 
+// True when a compose-seconds plan is a sub-minute second over a minute-0
+// clock-time rest — the case that reads as the bare hour and so must surface
+// the pinned clock minute.
+function composeMinuteZero(
+  ir: IR,
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>
+): plan is Extract<PlanNode, {kind: 'composeSeconds'}> &
+  {rest: Extract<PlanNode, {kind: 'clockTimes'}>} {
+  return plan.rest.kind === 'clockTimes' &&
+    plan.rest.times.every((time) => +time.minute === 0);
+}
+
+// The pinned clock minute in the genitive: "der Minute 9:00" for one hour,
+// "der Minuten 9:00, 10:00 und 17:00" for several — the explicit ":00" so the
+// minute-0 confinement stays visible.
+function clockMinuteGenitive(
+  times: {hour: number; minute: number}[],
+  sep: string
+): string {
+  const clocks = times.map(function clock(time): string {
+    return time.hour + sep + pad(time.minute);
+  });
+
+  return clocks.length === 1 ?
+    'der Minute ' + clocks[0] :
+    'der Minuten ' + joinList(clocks);
+}
+
 // A minute clause across discrete hours: "in den Minuten 0 bis 30, um 9 und
 // 17 Uhr".
 function renderMinutesAcrossHours(
@@ -741,15 +784,31 @@ function qualifier(ir: IR, months: Months): string {
 }
 
 // Plan kinds whose clause is a clock time: the qualifier leads them ("montags
-// um 9 Uhr"); a frequency clause trails it ("jede Minute montags").
+// um 9 Uhr"); a frequency clause trails it ("jede Minute montags"). The
+// minute-0 compose-seconds clause is anchored on a clock minute too, so the
+// qualifier leads it ("montags jede Sekunde der Minute 9:00").
 const LEADING_PLANS = new Set(['clockTimes']);
 
+// True when the leading qualifier should precede the clause: a clock-time
+// plan, or the minute-0 compose-seconds clause that surfaces a clock minute.
+function leadsQualifier(ir: IR): boolean {
+  return LEADING_PLANS.has(ir.plan.kind) || isComposeMinuteZero(ir);
+}
+
+// Whether the planned clause is the minute-0 compose-seconds confinement
+// (a sub-minute second over a minute-0 clock-time rest).
+function isComposeMinuteZero(ir: IR): boolean {
+  return ir.plan.kind === 'composeSeconds' &&
+    composeMinuteZero(ir, ir.plan);
+}
+
 // True when the clause is a bare daily clock-time list and so needs the
-// "täglich" frame to read as recurring, not a one-off: clockTimes always, and
-// an uneven hour step (rendered as its fire list "um 0, 5, … Uhr", not the
-// cadence "alle N Stunden"). A frequency clause already implies recurrence.
+// "täglich" frame to read as recurring, not a one-off: clockTimes always, the
+// minute-0 compose-seconds clause (a recurring clock minute), and an uneven
+// hour step (rendered as its fire list "um 0, 5, … Uhr", not the cadence "alle
+// N Stunden"). A frequency clause already implies recurrence.
 function needsDailyFrame(ir: IR): boolean {
-  if (ir.plan.kind === 'clockTimes') {
+  if (ir.plan.kind === 'clockTimes' || isComposeMinuteZero(ir)) {
     return true;
   }
 
@@ -804,7 +863,7 @@ function describe(ir: IR, opts: Opts): string {
   let base = core;
 
   if (qual) {
-    base = LEADING_PLANS.has(ir.plan.kind) ?
+    base = leadsQualifier(ir) ?
       qual + ' ' + core :
       core + ' ' + qual;
   }

package/src/lang/en/index.ts

@@ -21,12 +21,15 @@ type StepSegment = Extract<Segment, {kind: 'step'}>;
 
 // 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.
+// string); `plain` suppresses the noon/midnight words. `explicit` forces the
+// minute to show even when zero ("9:00 a.m.", not "9 a.m.") and suppresses
+// the noon/midnight words, so a pinned minute-0 stays visible.
 interface TimeEntry {
   hour: number | string;
   minute: number | string;
   second?: number | string | null;
   plain?: boolean;
+  explicit?: boolean;
 }
 
 // English number names for the integers zero through ten.
@@ -80,22 +83,6 @@ const weekdayNames: [string, string][] = [
   ['Saturday', 'Sat']
 ];
 
-// Month names by abbreviation.
-const monthAbbreviations: Record<string, [string, string] | null> = {
-  JAN: monthNames[1],
-  FEB: monthNames[2],
-  MAR: monthNames[3],
-  APR: monthNames[4],
-  MAY: monthNames[5],
-  JUN: monthNames[6],
-  JUL: monthNames[7],
-  AUG: monthNames[8],
-  SEP: monthNames[9],
-  OCT: monthNames[10],
-  NOV: monthNames[11],
-  DEC: monthNames[12]
-};
-
 // Weekday name by abbreviation.
 const weekdayAbbreviations: Record<string, [string, string]> = {
   SUN: weekdayNames[0],
@@ -192,9 +179,78 @@ function renderSecondsWithinMinute(ir: IR, plan: PlanOf<'secondsWithinMinute'>,
 // pattern follows.
 function renderComposeSeconds(ir: IR, plan: PlanOf<'composeSeconds'>,
   opts: NormalizedOptions): string {
+  // A wildcard or stepped second under a minute pinned to a single value
+  // 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 == "9:00 a.m."), losing the one-minute
+  // confinement. (A second list/range/single leads with a "past the minute"
+  // clause that an "of"/duration frame cannot follow, so it stays generic.)
+  if (plan.rest.kind === 'clockTimes' &&
+      (ir.shapes.second === 'wildcard' || ir.shapes.second === 'step')) {
+    const minute = plan.rest.times[0].minute;
+
+    // Minute 0 is the one-minute window at the top of each named hour: a
+    // duration frame ("for one minute at 9 a.m.") states the confinement
+    // outright, with the hour as its word so it cannot be heard as the hour
+    // itself. A non-zero pinned minute is an unambiguous clock time, so the
+    // compact "of 9:05 a.m." form reads it as the minute, never the hour.
+    if (+minute === 0) {
+      return secondsLeadClause(ir, opts) + ' for one minute at ' +
+        durationHours(ir, plan.rest, opts);
+    }
+
+    return secondsLeadClause(ir, opts) + ' of ' +
+      clockTimesOf(ir, plan.rest, opts);
+  }
+
+  // A wildcard second under a */2 minute step with a wildcard hour binds
+  // idiomatically as "every second of every other minute": "every other" is
+  // 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' &&
+      plan.rest.kind === 'minuteFrequency' &&
+      plan.rest.hours.kind === 'none' &&
+      ir.pattern.minute === '*/2') {
+    return 'every second of every other minute' +
+      trailingQualifier(ir, opts);
+  }
+
   return secondsLeadClause(ir, opts) + ', ' + render(ir, 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'>,
+  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);
+
+  return joinList(hours, opts) + (trail && ', ' + trail);
+}
+
+// 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'>,
+  opts: NormalizedOptions): string {
+  const times = plan.times.map(function clock(time) {
+    return getTime({
+      hour: time.hour,
+      minute: time.minute,
+      second: time.second,
+      explicit: true
+    }, opts);
+  });
+  const trail = dayQualifier(ir, leadingWords, opts);
+
+  return joinList(times, opts) + (trail && ', ' + trail);
+}
+
 // 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".
@@ -289,9 +345,18 @@ function renderMinuteFrequency(ir: IR, plan: PlanOf<'minuteFrequency'>,
 }
 
 // A minute wildcard or plain range under a single specific hour fires
-// every minute within a window inside that hour.
+// every minute within a window inside that hour. A wildcard minute is the
+// 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 === '*') {
+    return 'every minute of the ' +
+      getTime({hour: plan.hour, minute: 0}, opts) + ' hour' +
+      trailingQualifier(ir, 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) +
@@ -1169,7 +1234,7 @@ function stepYears(yearField: string, opts: NormalizedOptions): string {
 // "3.45pm" / "9am" / "midday" for UK (Guardian), or "15:45" / "15.45" in
 // 24-hour mode.
 function getTime(time: TimeEntry, opts: NormalizedOptions): string {
-  const {hour, minute, plain} = time;
+  const {hour, minute, plain, explicit} = time;
   // Seconds are only shown when a specific non-zero value is supplied.
   const second = typeof time.second === 'number' && time.second > 0 ?
     time.second :
@@ -1179,12 +1244,13 @@ function getTime(time: TimeEntry, opts: NormalizedOptions): string {
     // Hour/minute arrive as numbers or raw field tokens (a range bound or
     // single value is a string); `clockDigits` types them as numbers but
     // `pad` stringifies either form to the same digits. Cast to keep the
-    // value byte-identical rather than coercing it.
+    // value byte-identical rather than coercing it. The 24-hour form always
+    // shows the minute, so it is already explicit.
     return clockDigits({hour: hour as number, minute: minute as number,
       second}, {pad: true, sep: opts.style.sep});
   }
 
-  return twelveHourTime({hour, minute, second, plain}, opts);
+  return twelveHourTime({hour, minute, second, plain, explicit}, opts);
 }
 
 // The 12-hour form of a clock time: "9:30 a.m.", "9 a.m." on the hour, or
@@ -1193,13 +1259,13 @@ function getTime(time: TimeEntry, opts: NormalizedOptions): string {
 // stays in one number style.
 function twelveHourTime(
   time: {hour: number | string; minute: number | string; second: number;
-    plain?: boolean},
+    plain?: boolean; explicit?: boolean},
   opts: NormalizedOptions
 ): string {
-  const {hour, minute, second, plain} = time;
+  const {hour, minute, second, plain, explicit} = time;
   const style = opts.style;
 
-  if (!plain && +minute === 0 && !second) {
+  if (!plain && !explicit && +minute === 0 && !second) {
     if (+hour === 0) {
       return style.midnight;
     }
@@ -1211,9 +1277,11 @@ function twelveHourTime(
 
   // `hour`/`minute` may be raw field tokens; the arithmetic below coerces
   // them numerically, matching `clockDigits`. Cast for the modulo/compare.
+  // `explicit` keeps the minute (":00") rather than leaning down to the bare
+  // hour, so a pinned minute-0 stays visible.
   const digits = clockDigits(
     {hour: (hour as number) % 12 || 12, minute: minute as number, second},
-    {lean: true, sep: style.sep});
+    {lean: !explicit, sep: style.sep});
 
   return digits + (style.closeUp ? '' : ' ') +
     ((hour as number) < 12 ? style.am : style.pm);
@@ -1255,11 +1323,10 @@ function getOrdinal(n: number | string): string {
   return n + suffix;
 }
 
-// Get English month names from a number or from an abbreviation.
+// Get English month names from a canonical month number (months are never
+// Quartz, so the field is always number-canonicalized by the core).
 function getMonth(m: number | string, opts: NormalizedOptions): string {
-  // `m` is a month number (indexing `monthNames`) or an abbreviation token
-  // (indexing `monthAbbreviations`); the unmatched table yields undefined.
-  const month = monthNames[m as number] || monthAbbreviations[m];
+  const month = monthNames[+m];
 
   // A valid month always resolves to a name pair, so the guarded lookup is
   // a string; the cast keeps the original null-guard expression intact.
@@ -1287,7 +1354,10 @@ const en: Language = {
   fallback: 'an unrecognizable cron pattern',
   options: normalizeOptions,
   reboot: 'at system startup',
-  sentence: (description) => 'Runs ' + description + '.'
+  // A description ending in an abbreviation already carries its period
+  // ("…9 a.m."), so closing the sentence must not double it.
+  sentence: (description) =>
+    'Runs ' + description + (description.endsWith('.') ? '' : '.')
 };
 
 export default en;