prosebook 0.3.0 → 0.5.0

package/src/tools/native/apple.ts

@@ -0,0 +1,201 @@
+/**
+ * The catalog as Apple `.strings` tables: `<locale>.lproj/<name>.strings` per locale, each holding
+ * what that locale shows, every fallback resolved. Plain `.strings` and not a String Catalog, which
+ * only Xcode compiles: an app bundled by other tools copies these into its `Resources` as they are.
+ *
+ * The Swift target covers what code shows; these are for what the system reads from a bundle. With
+ * `plist`, the table is `InfoPlist`: the permission prompts and names in that Info.plist, an entry
+ * per key it has, which its own text must match in the source locale.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+
+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 { staticLiteral, TYPE, type MessageFormatElement } from '#src/tools/icu.ts';
+import { checkNames } from './emit.ts';
+import { fileOf, foundIn, LEAVE_OUT, restOf, wordsFor } from './model.ts';
+import { checkPlural, formatString, noteOf, type PluralHolder, type Printf } from './printf.ts';
+
+/** Text inside a `.strings` file's quotes; `%` doubled where the string has arguments. */
+function escape(text: string, formatted: boolean): string {
+  const out = text.replaceAll('\\', '\\\\').replaceAll('"', '\\"').replaceAll('\n', '\\n').replaceAll('\r', '\\r').replaceAll('\t', '\\t');
+  return formatted ? out.replaceAll('%', '%%') : out;
+}
+
+const PRINTF: Printf = {
+  platform: 'Apple',
+  formatter: 'String(format:)',
+  holder: '.strings files',
+  string: '@',
+  count: 'lld',
+  escape,
+  // A plural at the top goes to the .stringsdict; one under a select never gets here, as the select fails first.
+  plural: (name) => `{${name}} is a plural inside another, which a .strings file can't hold: say it without, ${LEAVE_OUT}`,
+};
+
+const xml = (text: string) => text.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+
+const DICT: Printf = {
+  ...PRINTF,
+  holder: '.stringsdict files',
+  escape: (text, formatted) => (formatted ? xml(text).replaceAll('%', '%%') : xml(text)),
+  plural: (name) =>
+    `{${name}} is a plural inside another plural's arm, which a .stringsdict here can't hold: write a key per case and pick one in code, ${LEAVE_OUT}`,
+};
+
+const PLURALS: PluralHolder = { platform: 'Apple', plurals: "a .stringsdict's plurals", exact: '' };
+
+/**
+ * A message holding plurals as a `.stringsdict` entry: its format, with each plural a variable
+ * (`%1$#@count@`) whose arms the system picks by the count's category, from its own CLDR rules.
+ */
+function dictEntry(name: string, ast: MessageFormatElement[], args: string[]): string {
+  const variables: string[] = [];
+  const taken = new Map<string, number>();
+  let format = '';
+  for (const el of ast) {
+    if (el.type !== TYPE.plural) {
+      format += formatString([el], args, DICT);
+      continue;
+    }
+    checkPlural(el, PLURALS);
+    const base = el.value.replace(/\W/g, '_');
+    const seen = (taken.get(base) ?? 0) + 1;
+    taken.set(base, seen);
+    const variable = seen === 1 ? base : `${base}${seen}`;
+    format += `%${args.indexOf(el.value) + 1}$#@${variable}@`;
+    const arms = Object.entries(el.options).map(
+      ([category, option]) =>
+        `            <key>${category}</key>\n            <string>${formatString(option.value, args, DICT, el.value)}</string>\n`,
+    );
+    variables.push(
+      `        <key>${variable}</key>\n        <dict>\n            <key>NSStringFormatSpecTypeKey</key>\n            <string>NSStringPluralRuleType</string>\n            <key>NSStringFormatValueTypeKey</key>\n            <string>${DICT.count}</string>\n${arms.join('')}        </dict>\n`,
+    );
+  }
+  return `    <key>${xml(name)}</key>\n    <dict>\n        <key>NSStringLocalizedFormatKey</key>\n        <string>${format}</string>\n${variables.join('')}    </dict>\n`;
+}
+
+const ENTITIES: Record<string, string> = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'" };
+
+/** An XML plist's string values by key, read as its text is: every `<key>` followed by a `<string>`. */
+function plistStrings(xml: string): Map<string, string> {
+  const strings = new Map<string, string>();
+  for (const [, key, value] of xml.matchAll(/<key>([^<]*)<\/key>\s*(?:<string>([^<]*)<\/string>|<string\/>)/g)) {
+    strings.set(
+      key!,
+      (value ?? '').replace(/&(amp|lt|gt|quot|apos|#x?[0-9a-f]+);/gi, (_, e: string) =>
+        e.startsWith('#')
+          ? String.fromCodePoint(Number.parseInt(e.slice(/x/i.test(e[1]!) ? 2 : 1), /x/i.test(e[1]!) ? 16 : 10))
+          : ENTITIES[e.toLowerCase()]!,
+      ),
+    );
+  }
+  return strings;
+}
+
+/** The files `target` writes, by path, or a problem for every message it can't hold. */
+export function appleStrings(
+  target: NativeTarget & { name: string },
+  root: string,
+  catalog: Catalog,
+  locales: string[],
+  entries: Map<string, Entry[]>,
+  banner: string,
+): { files: Map<string, string>; problems: Problem[] } {
+  const source = locales[0]!;
+  const asts = new Map([...entries].map(([locale, list]) => [locale, new Map(list)]));
+  const problems: Problem[] = [];
+  const error = (m: Message, message: string, file = m.file) =>
+    problems.push({ severity: 'error', file, key: m.key, message: `apple: ${message}` });
+
+  const plist = target.plist;
+  const shown = plist === undefined ? '' : relative(root, plist).replaceAll('\\', '/');
+  if (plist !== undefined && !existsSync(plist)) throw new Error(`apple: ${shown} is missing: name the Info.plist the table translates`);
+  const strings = plist === undefined ? undefined : plistStrings(readFileSync(plist, 'utf8'));
+  const byLower = new Map([...(strings?.keys() ?? [])].map((k) => [k.toLowerCase(), k]));
+
+  // Under `plist`, a key's words spell the plist key, which catalog keys can't hold as written.
+  const taken = catalog.messages.flatMap((m) => {
+    const rest = restOf(target, m.key);
+    if (rest === undefined) return [];
+    if (strings === undefined) return [{ m, name: rest }];
+    const name = byLower.get(wordsFor(target, m.key)!.join('').toLowerCase());
+    if (name === undefined) {
+      error(
+        m,
+        `${m.key} names no string in ${shown}: spell one of its keys, as ns-camera-usage-description is NSCameraUsageDescription, or add it there`,
+      );
+      return [];
+    }
+    return [{ m, name }];
+  });
+  checkNames(
+    'apple',
+    taken.map(({ m, name }) => [m.key, name]),
+    [],
+  );
+
+  for (const { m, name } of taken) {
+    if (strings === undefined) continue;
+    if (m.args.size > 0) {
+      error(m, `${name} is shown as it is written, with nothing filled in: say it without {${[...m.args.keys()].join('}, {')}}`);
+      continue;
+    }
+    // The plist's own text shows where no .lproj matches, so it can't be left to say something else.
+    const text = staticLiteral(asts.get(source)?.get(m.key) ?? []);
+    if (text !== undefined && text !== strings.get(name))
+      error(m, `${shown} says ${JSON.stringify(strings.get(name))} for ${name}: make it ${JSON.stringify(text)}, as the catalog says`);
+  }
+
+  const lines = new Map<string, string[]>(locales.map((l) => [l, []]));
+  const dicts = new Map<string, string[]>(locales.map((l) => [l, []]));
+  const failed = new Set(problems.map((p) => p.key));
+  for (const { m, name } of taken) {
+    if (failed.has(m.key)) continue;
+    const args = [...m.args.keys()];
+    const note = noteOf(m);
+    const head = note === '' ? '' : `/* ${note.replaceAll('*/', '* /')} */\n`;
+    const comment = note === '' ? '' : `    <!-- ${note.replace(/-{2,}/g, '-')} -->\n`;
+    const written = new Map<string, { dict: boolean; entry: string }>();
+    for (const locale of locales) {
+      const found = foundIn(m.key, locale, locales, asts);
+      if (found === undefined) continue;
+      let entry = written.get(found);
+      if (entry === undefined) {
+        const ast = asts.get(found)!.get(m.key)!;
+        const dict = ast.some((el) => el.type === TYPE.plural);
+        try {
+          entry = dict
+            ? { dict, entry: `${comment}${dictEntry(name, ast, args)}` }
+            : { dict, entry: `${head}"${escape(name, false)}" = "${formatString(ast, args, PRINTF)}";\n` };
+        } catch (e) {
+          error(m, (e as Error).message, fileOf(m, found, source));
+          break;
+        }
+        written.set(found, entry);
+      }
+      (entry.dict ? dicts : lines).get(locale)!.push(entry.entry);
+    }
+  }
+
+  const said = banner.replace(/^\/\/ /, '');
+  const files = new Map(
+    locales.map((locale) => [
+      join(target.out, `${locale}.lproj`, `${target.name}.strings`),
+      [`/* ${said} */\n`, ...lines.get(locale)!].join('\n'),
+    ]),
+  );
+  // The system looks a key up in the .stringsdict of the table's name first, so a plural lands there.
+  if ([...dicts.values()].some((d) => d.length > 0)) {
+    for (const locale of locales) {
+      const body = dicts.get(locale)!.join('');
+      files.set(
+        join(target.out, `${locale}.lproj`, `${target.name}.stringsdict`),
+        `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<!-- ${said.replace(/-{2,}/g, '-')} -->\n<plist version="1.0">\n<dict>\n${body}</dict>\n</plist>\n`,
+      );
+    }
+  }
+  return { files, problems };
+}

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/index.ts

@@ -1,10 +1,13 @@
 /**
- * The native files `generate` writes beside the TypeScript, one per target in the config's `native`.
- * A message a target can't render fails the build with the reason, as a translation that drifted does.
+ * The native files `generate` writes beside the TypeScript, one per target in the config's `native`
+ * (Android's and Apple's string resources, a file per locale). A message a target can't render
+ * fails the build with the reason, as a translation that drifted does.
  */
 import { CatalogError, type Catalog, type Problem } from '#src/tools/catalog.ts';
 import type { Entry } from '#src/tools/compile.ts';
 import type { ResolvedConfig } from '#src/tools/config.ts';
+import { androidResources } from './android.ts';
+import { appleStrings } from './apple.ts';
 import { kotlinFile } from './kotlin.ts';
 import { nativeModel } from './model.ts';
 import { rustModule } from './rust.ts';
@@ -22,10 +25,19 @@ export function nativeFiles(
   const files = new Map<string, string>();
   const problems: Problem[] = [];
   for (const target of config.native) {
-    const { model, problems: found } = nativeModel(target, catalog, locales, entries);
-    problems.push(...found);
-    if (found.length > 0) continue;
     try {
+      if (target.language === 'android' || target.language === 'apple') {
+        const { files: written, problems: found } =
+          target.language === 'android'
+            ? androidResources(target, catalog, locales, entries, banner)
+            : appleStrings(target, config.root, catalog, locales, entries, banner);
+        problems.push(...found);
+        for (const [path, content] of written) files.set(path, content);
+        continue;
+      }
+      const { model, problems: found } = nativeModel(target, catalog, locales, entries);
+      problems.push(...found);
+      if (found.length > 0) continue;
       files.set(target.out, WRITERS[target.language](model, target, banner));
     } catch (e) {
       problems.push({ severity: 'error', message: (e as Error).message });

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}