prosebook 0.4.0 → 0.5.0

package/src/tools/native/date.ts

@@ -0,0 +1,219 @@
+/**
+ * A date format taken apart at build time, as `number.ts` takes numbers apart: the text between the
+ * fields, how each field is written (a number, padded or not, or a name from a table), and the
+ * locale's digits. Read from `Intl.DateTimeFormat` and checked against it on dates that cover every
+ * month, weekday and hour before any code is written, so native code says what the browser says, or
+ * the build says why it can't.
+ *
+ * Native code reads the fields of the date as the clock shows them in its time zone, and only the
+ * Gregorian calendar: a format that names a time zone, or counts in another calendar, is refused.
+ */
+
+/** A part of a formatted date. */
+export type DatePiece =
+  | { type: 'text'; value: string }
+  /** The field as a number, padded with zeros to `pad` digits. `year2` is the year's last two digits. */
+  | { type: 'number'; field: 'year' | 'year2' | 'month' | 'day' | 'minute' | 'second'; pad: number }
+  /** The hour on the locale's clock: 1 to 12 (`h12`), 0 to 11 (`h11`), 0 to 23 (`h23`) or 1 to 24 (`h24`). */
+  | { type: 'hour'; cycle: HourCycle; pad: number }
+  /**
+   * The field as a name from `names`: a month's January first, a weekday's Sunday first, and the day
+   * period's before noon, then after, or one for each hour of the day.
+   */
+  | { type: 'name'; field: 'month' | 'weekday' | 'dayPeriod'; names: string[] };
+
+export type HourCycle = 'h11' | 'h12' | 'h23' | 'h24';
+
+export interface DateSpec {
+  pieces: DatePiece[];
+  /** The numbering system's digits, 0 to 9, where it isn't ASCII's. */
+  digits?: string[];
+}
+
+/** A date as the clock shows it. */
+export interface DateFields {
+  year: number;
+  /** 1 to 12. */
+  month: number;
+  day: number;
+  hour: number;
+  minute: number;
+  second: number;
+  /** 0 is Sunday. */
+  weekday: number;
+}
+
+/** Dates the spec must format as `Intl` does: every month and weekday, midnight, noon and the hours around them, and two-digit years. */
+const SAMPLES: number[] = [
+  Date.UTC(2001, 0, 5, 1, 2, 3),
+  Date.UTC(2001, 10, 25, 13, 42, 53),
+  Date.UTC(1999, 11, 31, 23, 59, 59),
+  Date.UTC(2000, 1, 29, 0, 0, 0),
+  Date.UTC(2024, 6, 4, 12, 0, 0),
+  Date.UTC(2024, 6, 4, 12, 30, 5),
+  Date.UTC(1970, 0, 1, 0, 0, 0),
+  Date.UTC(2099, 8, 9, 9, 9, 9),
+  Date.UTC(2010, 4, 15, 18, 45, 0),
+  Date.UTC(2026, 2, 10, 6, 15, 30),
+  Date.UTC(2005, 9, 31, 21, 7, 41),
+  ...Array.from({ length: 12 }, (_, m) => Date.UTC(2023, m, 1 + m * 2, m * 2, m * 5, m * 4)),
+  ...Array.from({ length: 24 }, (_, h) => Date.UTC(2022, 3, 3 + (h % 7), h, 30, 0)),
+];
+
+/** The fields of a date in UTC, which the spec is checked in. */
+export function fieldsOf(date: number): DateFields {
+  const d = new Date(date);
+  return {
+    year: d.getUTCFullYear(),
+    month: d.getUTCMonth() + 1,
+    day: d.getUTCDate(),
+    hour: d.getUTCHours(),
+    minute: d.getUTCMinutes(),
+    second: d.getUTCSeconds(),
+    weekday: d.getUTCDay(),
+  };
+}
+
+const HOUR_CYCLES = new Set<string>(['h11', 'h12', 'h23', 'h24']);
+
+/**
+ * What a format with `options` takes in `locale`. Throws a sentence saying what a native target
+ * can't reproduce, which the caller puts in front of a fix.
+ */
+export function dateSpec(locale: string, options: Intl.DateTimeFormatOptions = {}): DateSpec {
+  if (options.timeZone !== undefined) throw new Error(`it names the time zone ${options.timeZone}, which native code can't look up`);
+  const format = new Intl.DateTimeFormat(locale, { ...options, timeZone: 'UTC' });
+  const resolved = format.resolvedOptions();
+  if (resolved.calendar !== 'gregory' && resolved.calendar !== 'iso8601') throw new Error(`it counts in the ${resolved.calendar} calendar`);
+
+  const native = new Intl.NumberFormat(locale, { numberingSystem: resolved.numberingSystem, useGrouping: false });
+  const digits = Array.from({ length: 10 }, (_, d) => native.format(d));
+  const ascii = (text: string) => text.replace(/./gu, (c) => (digits.includes(c) ? String(digits.indexOf(c)) : c));
+  /** The text `type` takes at `date`, in ASCII digits. */
+  const partAt = (date: number, type: string) => ascii(format.formatToParts(date).find((p) => p.type === type)?.value ?? '');
+  const isNumber = (text: string) => /^[0-9]+$/.test(text);
+  const padOf = (date: number, type: string) => (partAt(date, type).startsWith('0') ? 2 : 1);
+
+  const pieces: DatePiece[] = [];
+  for (const part of format.formatToParts(SAMPLES[1])) {
+    switch (part.type) {
+      case 'literal':
+        pieces.push({ type: 'text', value: part.value });
+        break;
+      case 'year':
+        pieces.push(ascii(part.value) === '01' ? { type: 'number', field: 'year2', pad: 2 } : { type: 'number', field: 'year', pad: 1 });
+        break;
+      case 'month': {
+        const names = Array.from(
+          { length: 12 },
+          (_, m) => format.formatToParts(Date.UTC(2023, m, 15, 12)).find((p) => p.type === 'month')!.value,
+        );
+        if (names.every((name) => isNumber(ascii(name))))
+          pieces.push({ type: 'number', field: 'month', pad: padOf(Date.UTC(2023, 0, 15, 12), 'month') });
+        else pieces.push({ type: 'name', field: 'month', names });
+        break;
+      }
+      case 'day':
+        pieces.push({ type: 'number', field: 'day', pad: padOf(Date.UTC(2023, 0, 5, 12), 'day') });
+        break;
+      case 'weekday':
+        // 2023-01-01 is a Sunday.
+        pieces.push({
+          type: 'name',
+          field: 'weekday',
+          names: Array.from(
+            { length: 7 },
+            (_, d) => format.formatToParts(Date.UTC(2023, 0, 1 + d, 12)).find((p) => p.type === 'weekday')!.value,
+          ),
+        });
+        break;
+      case 'hour': {
+        const cycle = resolved.hourCycle;
+        if (cycle === undefined || !HOUR_CYCLES.has(cycle)) throw new Error('its hours follow no clock native code knows');
+        pieces.push({ type: 'hour', cycle, pad: padOf(Date.UTC(2023, 0, 5, 1), 'hour') });
+        break;
+      }
+      case 'minute':
+      case 'second':
+        pieces.push({ type: 'number', field: part.type, pad: padOf(Date.UTC(2023, 0, 5, 1, 5, 5), part.type) });
+        break;
+      case 'dayPeriod': {
+        const byHour = Array.from(
+          { length: 24 },
+          (_, hour) => format.formatToParts(Date.UTC(2023, 0, 5, hour, 30)).find((p) => p.type === 'dayPeriod')!.value,
+        );
+        // Before noon and after, or a period by the hour (`zh-TW`'s 晚上, English's "at night").
+        const halves = byHour.every((name, hour) => name === byHour[hour < 12 ? 0 : 12]);
+        pieces.push({ type: 'name', field: 'dayPeriod', names: halves ? [byHour[0]!, byHour[12]!] : byHour });
+        break;
+      }
+      case 'era':
+      case 'fractionalSecond':
+      case 'timeZoneName':
+      case 'unknown':
+      // A calendar's own parts, such as `relatedYear`, which the calendar check has already refused.
+      default:
+        throw new Error(`it writes the ${part.type as string}, which native code can't`);
+    }
+  }
+  const spec: DateSpec = { pieces, ...(digits.join('') !== '0123456789' && { digits }) };
+  for (const sample of SAMPLES) {
+    const expected = format.format(sample);
+    const actual = formatDate(spec, fieldsOf(sample));
+    if (actual !== expected)
+      throw new Error(`it writes ${new Date(sample).toISOString()} as "${expected}", which native code would write as "${actual}"`);
+  }
+  return spec;
+}
+
+/** The hour as a clock with `cycle` shows it. */
+export function hourOn(cycle: HourCycle, hour: number): number {
+  if (cycle === 'h23') return hour;
+  if (cycle === 'h24') return hour === 0 ? 24 : hour;
+  if (cycle === 'h11') return hour % 12;
+  return ((hour + 11) % 12) + 1;
+}
+
+/** A date field as a target reads it, an integer expression. */
+export type FieldAccess = (field: keyof DateFields) => string;
+
+/**
+ * A piece's number, or a name piece's index into its names, as an expression in the integer
+ * arithmetic Rust, Swift and Kotlin share. Keep in step with `formatDate`.
+ */
+export function pieceExpr(piece: Exclude<DatePiece, { type: 'text' }>, at: FieldAccess): string {
+  if (piece.type === 'hour') {
+    const hour = at('hour');
+    if (piece.cycle === 'h23') return hour;
+    if (piece.cycle === 'h24') return `(${hour} + 23) % 24 + 1`;
+    return piece.cycle === 'h11' ? `${hour} % 12` : `(${hour} + 11) % 12 + 1`;
+  }
+  if (piece.type === 'number') return piece.field === 'year2' ? `(${at('year')} % 100 + 100) % 100` : at(piece.field);
+  if (piece.field === 'month') return `${at('month')} - 1`;
+  if (piece.field === 'weekday') return at('weekday');
+  return piece.names.length === 24 ? at('hour') : `${at('hour')} / 12`;
+}
+
+/** Which of a name piece's `count` names `date` takes. */
+function nameIndex(field: 'month' | 'weekday' | 'dayPeriod', count: number, date: DateFields): number {
+  if (field === 'month') return date.month - 1;
+  if (field === 'weekday') return date.weekday;
+  return count === 24 ? date.hour : date.hour < 12 ? 0 : 1;
+}
+
+/** `date` as the spec writes it: the reference for the code each target generates. */
+export function formatDate(spec: DateSpec, date: DateFields): string {
+  const digits = spec.digits;
+  const number = (value: number, pad: number) => {
+    const text = String(value).padStart(pad, '0');
+    return digits === undefined ? text : text.replace(/[0-9]/g, (d) => digits[Number(d)]!);
+  };
+  return spec.pieces
+    .map((piece) => {
+      if (piece.type === 'text') return piece.value;
+      if (piece.type === 'hour') return number(hourOn(piece.cycle, date.hour), piece.pad);
+      if (piece.type === 'number') return number(piece.field === 'year2' ? ((date.year % 100) + 100) % 100 : date[piece.field], piece.pad);
+      return piece.names[nameIndex(piece.field, piece.names.length, date)]!;
+    })
+    .join('');
+}

package/src/tools/native/kotlin.ts

@@ -3,6 +3,7 @@
  * a file-private object holding what formats them. For the JVM and Android.
  */
 import type { NativeTarget } from '#src/tools/config.ts';
+import { pieceExpr, type DateSpec } from './date.ts';
 import { camel, checkNames, conditionCode, float, leading, stringLiteral, upper, wordsOf } from './emit.ts';
 import type { NativeMessage, NativeModel, Part } from './model.ts';
 import type { NumberSpec } from './number.ts';
@@ -36,6 +37,7 @@ function value(part: Exclude<Part, { type: 'text' }>, indent: string, rt: string
     const of = part.offset === 0 ? argName(part.arg) : `${argName(part.arg)} - ${float(part.offset)}`;
     return `${rt}.number(${of}, ${rt}.F${part.format}, ${lit(part.fallback)})`;
   }
+  if (part.type === 'date') return `${rt}.d${part.format}(${argName(part.arg)})`;
   if (part.type === 'select') {
     const arms = part.arms.map((a) => `${inner}${lit(a.key)} -> ${expr(a.parts, inner, rt)}\n`).join('');
     return `when (${argName(part.arg)}) {\n${arms}${inner}else -> ${expr(part.other, inner, rt)}\n${indent}}`;
@@ -59,10 +61,17 @@ function member(m: NativeMessage, name: string, rt: string): string {
   const head = doc(argDocs.length > 0 ? [...m.doc, '', ...argDocs] : m.doc, '    ');
   const body = `when (this) {\n${branches}        }`;
   if (m.args.length === 0) return `${head}    val ${name}: String\n        get() = ${body}\n`;
-  const params = m.args.map((a) => `${argName(a.name)}: ${a.type === 'number' ? 'Number' : 'String'}`).join(', ');
+  const params = m.args
+    .map((a) => `${argName(a.name)}: ${a.type === 'number' ? 'Number' : a.type === 'date' ? 'java.time.Instant' : 'String'}`)
+    .join(', ');
   const numbers = m.args
-    .filter((a) => a.type === 'number')
-    .map((a) => `        val ${argName(a.name)} = ${argName(a.name)}.toDouble()\n`)
+    .map((a) =>
+      a.type === 'number'
+        ? `        val ${argName(a.name)} = ${argName(a.name)}.toDouble()\n`
+        : a.type === 'date'
+          ? `        val ${argName(a.name)} = ${argName(a.name)}.atZone(java.time.ZoneId.systemDefault())\n`
+          : '',
+    )
     .join('');
   return `${head}    fun ${name}(${params}): String {\n${numbers}        return ${body}\n    }\n`;
 }
@@ -90,6 +99,38 @@ function formatConst(spec: NumberSpec, i: number): string {
   return `    val F${i} = Format(\n${fields.map((f) => `        ${f}`).join(',\n')},\n    )\n`;
 }
 
+const FIELDS: Record<string, string> = {
+  year: 't.year',
+  month: 't.monthValue',
+  day: 't.dayOfMonth',
+  hour: 't.hour',
+  minute: 't.minute',
+  second: 't.second',
+  weekday: '(t.dayOfWeek.value % 7)',
+};
+
+/** A date format as a function of the date in the system's time zone. */
+function dateFn(spec: DateSpec, i: number): string {
+  const digits = spec.digits === undefined ? 'null' : `G${i}`;
+  const at = (field: string) => FIELDS[field]!;
+  const lines = spec.pieces.map((piece) => {
+    if (piece.type === 'text') return `append(${lit(piece.value)})`;
+    if (piece.type === 'name') return `append(arrayOf(${piece.names.map(lit).join(', ')})[${pieceExpr(piece, at)}])`;
+    return `append(pad(${pieceExpr(piece, at)}, ${piece.pad}, ${digits}))`;
+  });
+  const table = spec.digits === undefined ? '' : `    private val G${i} = arrayOf(${spec.digits.map(lit).join(', ')})\n`;
+  const body = lines.map((l) => `        ${l}\n`).join('');
+  return `${table}    fun d${i}(t: java.time.ZonedDateTime): String = buildString {\n${body}    }\n`;
+}
+
+const DATE = `
+    /** \`value\` written with at least \`width\` digits, in \`digits\` where the locale has its own. */
+    private fun pad(value: Int, width: Int, digits: Array<String>?): String {
+        val text = value.toString().padStart(width, '0')
+        return if (digits == null) text else text.map { if (it in '0'..'9') digits[it - '0'] else it.toString() }.joinToString("")
+    }
+`;
+
 const NUMBER = `
     /** A number format, taken apart when the file was generated. */
     class Format(
@@ -225,12 +266,12 @@ export function kotlinFile(model: NativeModel, target: NativeTarget & { name: st
     })
     .join('\n');
   const runtime =
-    model.formats.length + model.rules.length === 0
+    model.formats.length + model.rules.length + model.dates.length === 0
       ? ''
       : `
 /** What formats the messages, generated with them. */
-private object ${rt} {${NUMBER}${model.rules.length > 0 ? PLURAL : ''}
-${model.formats.map(formatConst).join('\n')}${rules === '' ? '' : `\n${rules}`}}
+private object ${rt} {${model.formats.length + model.rules.length > 0 ? NUMBER : ''}${model.rules.length > 0 ? PLURAL : ''}${model.dates.length > 0 ? DATE : ''}
+${[...model.formats.map(formatConst), ...model.dates.map(dateFn)].join('\n')}${rules === '' ? '' : `\n${rules}`}}
 `;
 
   return `${banner}

package/src/tools/native/model.ts

@@ -9,7 +9,8 @@ import { chainOf } from '#src/runtime/locale.ts';
 import type { Catalog, Message, Problem } from '#src/tools/catalog.ts';
 import type { Entry } from '#src/tools/compile.ts';
 import type { NativeTarget } from '#src/tools/config.ts';
-import { numberOptions, optionArgsOf, placeholderOf, selectionOf, TYPE, type MessageFormatElement } from '#src/tools/icu.ts';
+import { dateOptions, numberOptions, optionArgsOf, placeholderOf, selectionOf, TYPE, type MessageFormatElement } from '#src/tools/icu.ts';
+import { dateSpec, type DateSpec } from './date.ts';
 import { docText } from './emit.ts';
 import { numberSpec, roundingOf, type NumberSpec, type Rounding } from './number.ts';
 import { pluralRules, type PluralRules } from './plurals.ts';
@@ -19,6 +20,8 @@ export type Part =
   | { type: 'string'; arg: string }
   /** The argument less `offset`, in format `format`; `fallback` where it isn't a number. */
   | { type: 'number'; arg: string; offset: number; format: number; fallback: string }
+  /** The argument, a date, in date format `format`. */
+  | { type: 'date'; arg: string; format: number }
   | { type: 'select'; arg: string; arms: Arm[]; other: Part[] }
   | {
       type: 'plural';
@@ -45,7 +48,7 @@ export interface NativeMessage {
   words: string[];
   /** The source text, its context, and what's asked of it. */
   doc: string[];
-  args: { name: string; type: 'string' | 'number'; doc?: string }[];
+  args: { name: string; type: 'string' | 'number' | 'date'; doc?: string }[];
   /** A tree per locale that renders it its own way; every locale is in one. */
   bodies: { locales: string[]; parts: Part[] }[];
 }
@@ -56,6 +59,7 @@ export interface NativeModel {
   source: string;
   messages: NativeMessage[];
   formats: NumberSpec[];
+  dates: DateSpec[];
   rules: { name: string; rules: PluralRules }[];
 }
 
@@ -106,6 +110,7 @@ export function nativeModel(
   const source = locales[0]!;
   const asts = new Map([...entries].map(([locale, list]) => [locale, new Map(list)]));
   const formats = new Numbered<NumberSpec>();
+  const dates = new Numbered<DateSpec>();
   const rules = new Numbered<{ name: string; rules: PluralRules }>();
   const problems: Problem[] = [];
   const messages: NativeMessage[] = [];
@@ -124,7 +129,7 @@ export function nativeModel(
         continue;
       }
       try {
-        bodies.set(found, { locales: [locale], parts: parts(asts.get(found)!.get(m.key)!, found, formats, rules, null) });
+        bodies.set(found, { locales: [locale], parts: parts(asts.get(found)!.get(m.key)!, found, { formats, dates, rules }, null) });
       } catch (e) {
         failed = true;
         problems.push({
@@ -142,13 +147,13 @@ export function nativeModel(
       doc: docOf(m),
       args: [...m.args].map(([name, type]) => ({
         name,
-        type: type === 'number' ? 'number' : 'string',
+        type: type === 'number' ? 'number' : type === 'Date | number' ? 'date' : 'string',
         doc: m.argDocs.has(name) ? docText(m.argDocs.get(name)!) : undefined,
       })),
       bodies: [...bodies.values()],
     });
   }
-  return { model: { locales, source, messages, formats: formats.list, rules: rules.list }, problems };
+  return { model: { locales, source, messages, formats: formats.list, dates: dates.list, rules: rules.list }, problems };
 }
 
 export function fileOf(m: Message, locale: string, source: string): string {
@@ -168,6 +173,33 @@ export const LEAVE_OUT = "or leave the key out of this target's `keys`";
 /** Specs by locale and options, kept across runs: taking a format apart checks it against `Intl` dozens of times. */
 const SPECS = new Map<string, NumberSpec | Error>();
 
+/** What a file declares, numbered as the messages use it. */
+interface Declared {
+  formats: Numbered<NumberSpec>;
+  dates: Numbered<DateSpec>;
+  rules: Numbered<{ name: string; rules: PluralRules }>;
+}
+
+/** Date specs as `SPECS` keeps number specs. */
+const DATE_SPECS = new Map<string, DateSpec | Error>();
+
+function date(dates: Numbered<DateSpec>, locale: string, options: Intl.DateTimeFormatOptions | undefined): number {
+  const key = JSON.stringify([locale, options ?? {}]);
+  let spec = DATE_SPECS.get(key);
+  if (spec === undefined) {
+    try {
+      spec = dateSpec(locale, options);
+    } catch (e) {
+      spec = new Error(`native code can't format this date in ${locale}: ${(e as Error).message}. Format it another way, ${LEAVE_OUT}`, {
+        cause: e,
+      });
+    }
+    DATE_SPECS.set(key, spec);
+  }
+  if (spec instanceof Error) throw spec;
+  return dates.add(spec);
+}
+
 function format(formats: Numbered<NumberSpec>, locale: string, options: Intl.NumberFormatOptions | undefined): number {
   const key = JSON.stringify([locale, options ?? {}]);
   let spec = SPECS.get(key);
@@ -187,13 +219,8 @@ function format(formats: Numbered<NumberSpec>, locale: string, options: Intl.Num
 
 type Pound = { arg: string; offset: number } | null;
 
-function parts(
-  elements: MessageFormatElement[],
-  locale: string,
-  formats: Numbered<NumberSpec>,
-  rules: Numbered<{ name: string; rules: PluralRules }>,
-  pound: Pound,
-): Part[] {
+function parts(elements: MessageFormatElement[], locale: string, declared: Declared, pound: Pound): Part[] {
+  const { formats, dates, rules } = declared;
   const out: Part[] = [];
   const text = (value: string) => {
     const last = out.at(-1);
@@ -207,7 +234,7 @@ function parts(
     if (isolate !== undefined) text(isolate[1]);
   };
   const arms = (options: Record<string, { value: MessageFormatElement[] }>, own: Pound) =>
-    Object.entries(options).map(([key, option]) => ({ key, parts: parts(option.value, locale, formats, rules, own) }));
+    Object.entries(options).map(([key, option]) => ({ key, parts: parts(option.value, locale, declared, own) }));
 
   for (const el of elements) {
     if (Object.keys(optionArgsOf(el) ?? {}).length > 0) {
@@ -216,9 +243,8 @@ function parts(
       );
     }
     if (isDateElement(el) || isTimeElement(el)) {
-      throw new Error(
-        `{${el.value}} is a date, which native code doesn't format: pass it formatted, as a plain {${el.value}}, ${LEAVE_OUT}`,
-      );
+      placed(el, el.value, { type: 'date', arg: el.value, format: date(dates, locale, dateOptions(el)) });
+      continue;
     }
     if (isNumberElement(el)) {
       const fallback = placeholderOf(el, el.value).fallback;

package/src/tools/native/printf.ts

@@ -1,13 +1,15 @@
 /**
  * Messages as printf-style format strings, for the targets whose platform fills values in itself:
- * Android's resources and Apple's `.strings` files. Text and plain `{name}` placeholders, as `%N$s`
+ * Android's resources and Apple's `.strings` and `.stringsdict` files. Text and plain `{name}` placeholders, as `%N$s`
  * with N the argument's place in the message's arguments, so a translation can put them in another
  * order; anything `Intl` would format fails with the fix.
  */
 import { isDateElement, isNumberElement, isTimeElement } from '@formatjs/icu-messageformat-parser';
 
+import type { PluralElement } from '@formatjs/icu-messageformat-parser';
 import type { Message } from '#src/tools/catalog.ts';
-import { numberOptions, placeholderOf, TYPE, type MessageFormatElement } from '#src/tools/icu.ts';
+
+import { numberOptions, placeholderOf, selectionOf, TYPE, type MessageFormatElement } from '#src/tools/icu.ts';
 import { docText } from './emit.ts';
 import { LEAVE_OUT } from './model.ts';
 
@@ -19,6 +21,8 @@ export interface Printf {
   holder: string;
   /** A string argument's conversion: `s`, or `@` for Apple's objects. */
   string: string;
+  /** A count's conversion: `d`, or `lld` for Apple's 64-bit `Int`. */
+  count: string;
   /** Text as the file holds it; `formatted` when the string has arguments, so `%` must be doubled. */
   escape: (text: string, formatted: boolean) => string;
   /** The problem with a plural the target can't hold where it is. */
@@ -42,7 +46,45 @@ function isCount(el: MessageFormatElement, count: string): boolean {
   return options.length === 0 || (options.length === 1 && options[0]![0] === 'maximumFractionDigits' && options[0]![1] === 0);
 }
 
-/** `elements` as a format string over `args`; inside a plural, its `count` is `%N$d`. */
+/** What a platform's plurals are called in problems, and what they can't hold. */
+export interface PluralHolder {
+  /** `Android`, as in "Android selects on the count as an integer". */
+  platform: string;
+  /** `Android's <plurals>`. */
+  plurals: string;
+  /** Why an `=N` arm has no place, after "have none for one number". */
+  exact: string;
+}
+
+/**
+ * Throws, with the fix, where a plural asks for more than a platform's plurals pick on: one count,
+ * as an integer, by its cardinal category.
+ */
+export function checkPlural(plural: PluralElement, holder: PluralHolder): void {
+  const named = `{${plural.value}}`;
+  if (plural.pluralType === 'ordinal') {
+    throw new Error(
+      `${named} is an ordinal, and ${holder.plurals} are cardinal only: write a key per case and pick one in code, ${LEAVE_OUT}`,
+    );
+  }
+  if (plural.offset !== 0)
+    throw new Error(`${named} has an offset, which ${holder.plurals} don't: count without it, and say the rest in each arm, ${LEAVE_OUT}`);
+
+  const selection = selectionOf(plural);
+  if (selection !== undefined && (selection.fn.name !== 'integer' || Object.keys(selection.fn.options).length > 0)) {
+    throw new Error(
+      `${named} selects with :${selection.fn.name} and its options, and ${holder.platform} selects on the count as an integer: select with a bare :number or :integer, ${LEAVE_OUT}`,
+    );
+  }
+  const exact = Object.keys(plural.options).filter((k) => k.startsWith('='));
+  if (exact.length > 0) {
+    throw new Error(
+      `${named} has the arm ${exact.join(', ')}, and ${holder.plurals} have none for one number${holder.exact}: say it in a category's arm, or write a key for it and pick that in code, ${LEAVE_OUT}`,
+    );
+  }
+}
+
+/** `elements` as a format string over `args`; inside a plural, its `count` is `%N$d` (or `lld`). */
 export function formatString(elements: MessageFormatElement[], args: string[], printf: Printf, count?: string): string {
   const formatted = args.length > 0;
   const place = (el: MessageFormatElement, name: string, conversion: string) => {
@@ -55,7 +97,7 @@ export function formatString(elements: MessageFormatElement[], args: string[], p
   let out = '';
   for (const el of elements) {
     if (count !== undefined && isCount(el, count)) {
-      out += place(el, count, 'd');
+      out += place(el, count, printf.count);
       continue;
     }
     if (isDateElement(el) || isTimeElement(el)) {

package/src/tools/native/rust.ts

@@ -3,6 +3,7 @@
  * a private `rt` module, so no argument a message names can shadow it.
  */
 import type { NativeTarget } from '#src/tools/config.ts';
+import { pieceExpr, type DateSpec } from './date.ts';
 import { checkNames, conditionCode, float, leading, pascal, snake, stringLiteral, wordsOf } from './emit.ts';
 import type { NativeMessage, NativeModel, Part } from './model.ts';
 import type { NumberSpec } from './number.ts';
@@ -50,6 +51,7 @@ function value(part: Exclude<Part, { type: 'text' }>, indent: string): string {
     const of = part.offset === 0 ? argName(part.arg) : `${argName(part.arg)} - ${float(part.offset)}`;
     return `rt::number(${of}, &rt::F${part.format}, ${lit(part.fallback)})`;
   }
+  if (part.type === 'date') return `rt::D${part.format}(&${argName(part.arg)})`;
   if (part.type === 'select') {
     const arms = part.arms.map((a) => `${inner}${lit(a.key)} => ${expr(a.parts, inner)},\n`).join('');
     return `match ${argName(part.arg)} {\n${arms}${inner}_ => ${expr(part.other, inner)},\n${indent}}`;
@@ -74,7 +76,9 @@ function method(m: NativeMessage, name: string, enumName: string): string {
   const isStatic = m.bodies.every((b) => b.parts.every((p) => p.type === 'text'));
   if (isStatic && m.args.length === 0)
     return `${head}    pub fn ${name}(self) -> &'static str {\n        match self {\n${arms((parts) => lit(parts[0]?.type === 'text' ? parts[0].value : ''))}        }\n    }\n`;
-  const params = m.args.map((a) => `, ${argName(a.name)}: ${a.type === 'number' ? 'impl Number' : '&str'}`).join('');
+  const params = m.args
+    .map((a) => `, ${argName(a.name)}: ${a.type === 'number' ? 'impl Number' : a.type === 'date' ? 'DateTime' : '&str'}`)
+    .join('');
   const argDocs = m.args.filter((a) => a.doc !== undefined).map((a) => `* \`${argName(a.name)}\`: ${a.doc}`);
   const docs = argDocs.length > 0 ? `${head}    ///\n${doc(argDocs, '    ')}` : head;
   const numbers = m.args
@@ -107,6 +111,81 @@ function formatConst(spec: NumberSpec, i: number): string {
   return `    pub const F${i}: Format = Format {\n${fields.map((f) => `        ${f},\n`).join('')}    };\n`;
 }
 
+/** A date format as a function of the date. */
+function dateFn(spec: DateSpec, i: number): string {
+  const digits = spec.digits === undefined ? 'None' : `Some(G${i})`;
+  const at = (field: string) => (field === 'weekday' ? 't.weekday() as i64' : `t.${field} as i64`);
+  const lines = spec.pieces.map((piece) => {
+    if (piece.type === 'text') return `s += ${lit(piece.value)};`;
+    if (piece.type === 'name') return `s += [${piece.names.map(lit).join(', ')}][(${pieceExpr(piece, at)}) as usize];`;
+    return `s += &pad(${pieceExpr(piece, at)}, ${piece.pad}, ${digits});`;
+  });
+  const table = spec.digits === undefined ? '' : `    const G${i}: [&str; 10] = [${spec.digits.map(lit).join(', ')}];\n`;
+  const body = lines.map((l) => `        ${l}\n`).join('');
+  return `${table}    pub fn D${i}(t: &super::DateTime) -> String {\n        let mut s = String::new();\n${body}        s\n    }\n`;
+}
+
+const DATE = `
+    /// \`value\` written with at least \`width\` digits, in \`digits\` where the locale has its own.
+    fn pad(value: i64, width: usize, digits: Option<[&'static str; 10]>) -> String {
+        let text = format!("{:0width$}", value, width = width);
+        match digits {
+            Some(digits) => text.bytes().map(|b| if b.is_ascii_digit() { digits[(b - b'0') as usize] } else { "-" }).collect(),
+            None => text,
+        }
+    }
+`;
+
+const DATE_TIME = `
+/// A date and time as a clock shows it, in the time zone it is shown in.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct DateTime {
+    pub year: i32,
+    /// 1 to 12.
+    pub month: u8,
+    pub day: u8,
+    /// 0 to 23.
+    pub hour: u8,
+    pub minute: u8,
+    pub second: u8,
+}
+
+impl DateTime {
+    /// The time \`seconds\` after the Unix epoch, on a clock \`offset\` seconds ahead of UTC: the
+    /// local time's offset where it is shown, which Rust's standard library can't look up.
+    pub fn from_unix(seconds: i64, offset: i32) -> DateTime {
+        let local = seconds + offset as i64;
+        let (days, time) = (local.div_euclid(86_400), local.rem_euclid(86_400));
+        // Howard Hinnant's civil_from_days: the Gregorian date \`days\` after 1970-01-01.
+        let z = days + 719_468;
+        let (era, doe) = (z.div_euclid(146_097), z.rem_euclid(146_097));
+        let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
+        let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+        let mp = (5 * doy + 2) / 153;
+        let month = if mp < 10 { mp + 3 } else { mp - 9 };
+        DateTime {
+            year: (yoe + era * 400 + if month <= 2 { 1 } else { 0 }) as i32,
+            month: month as u8,
+            day: (doy - (153 * mp + 2) / 5 + 1) as u8,
+            hour: (time / 3600) as u8,
+            minute: (time / 60 % 60) as u8,
+            second: (time % 60) as u8,
+        }
+    }
+
+    /// The day of the week, 0 for Sunday.
+    pub fn weekday(self) -> u8 {
+        // days_from_civil, its inverse.
+        let m = self.month as i64;
+        let y = self.year as i64 - if m <= 2 { 1 } else { 0 };
+        let (era, yoe) = (y.div_euclid(400), y.rem_euclid(400));
+        let doy = (153 * (if m > 2 { m - 3 } else { m + 9 }) + 2) / 5 + self.day as i64 - 1;
+        let days = era * 146_097 + yoe * 365 + yoe / 4 - yoe / 100 + doy - 719_468;
+        (days + 4).rem_euclid(7) as u8
+    }
+}
+`;
+
 const NUMBER = `
     /// A number format, taken apart when the file was generated.
     pub struct Format {
@@ -300,6 +379,8 @@ export function rustModule(model: NativeModel, target: NativeTarget & { name: st
   const tags = model.locales.map((l) => `            ${name}::${variant(l)} => ${lit(l)},\n`).join('');
   const methods = model.messages.map((m, i) => method(m, names[i]![1], name)).join('\n');
   const usesNumbers = model.messages.some((m) => m.args.some((a) => a.type === 'number'));
+  const usesDates = model.dates.length > 0;
+  const usesFormats = model.formats.length + model.rules.length > 0;
   const rules = model.rules
     .map(({ name: rule, rules }, i) => {
       const checks = rules.map(
@@ -310,17 +391,17 @@ export function rustModule(model: NativeModel, target: NativeTarget & { name: st
     })
     .join('\n');
   const runtime =
-    model.formats.length + model.rules.length === 0
+    !usesFormats && !usesDates
       ? ''
       : `
 /// What formats the messages, generated with them.
-mod rt {${NUMBER}${model.rules.length > 0 ? PLURAL : ''}
-${model.formats.map(formatConst).join('\n')}${rules === '' ? '' : `\n${rules}`}}
+mod rt {${usesFormats ? NUMBER : ''}${model.rules.length > 0 ? PLURAL : ''}${usesDates ? DATE : ''}
+${[...model.formats.map(formatConst), ...model.dates.map(dateFn)].join('\n')}${rules === '' ? '' : `\n${rules}`}}
 `;
 
   return `${banner}
 #![allow(dead_code, non_snake_case, clippy::all)]
-${usesNumbers ? NUMBER_TRAIT : ''}
+${usesNumbers ? NUMBER_TRAIT : ''}${usesDates ? DATE_TIME : ''}
 /// A locale the catalog is written or translated in, and its messages.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum ${name} {