prosebook 0.2.0 → 0.4.0

package/src/tools/config.ts

@@ -7,6 +7,7 @@ import { isAbsolute, join, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 
 import { compileRule, CORE_RULES, type CheckRule, type CoreRule, type Plugin } from './lint.ts';
+import type { Isolate } from './mf2.ts';
 import { DEFAULT_KINDS, DEFAULT_SURFACES, STRICT_LISTS, type KindRule, type Severity } from './presets.ts';
 
 export type { KindRule, Severity };
@@ -54,6 +55,39 @@ export interface LintConfig extends WordLists {
   areas?: Record<string, RuleSeverities>;
 }
 
+/**
+ * Native code generated from the catalog, for the parts of an app outside the browser: a tray, a
+ * menu bar, a CLI. One file, holding every locale, with a typed function per message; for Android and
+ * Apple, string resources, a file per locale.
+ */
+export interface NativeTarget {
+  language: 'rust' | 'swift' | 'kotlin' | 'android' | 'apple';
+  /**
+   * The file written; for Android, the `res` folder its `values*` folders go in, and for Apple, the
+   * folder its `.lproj` folders go in.
+   */
+  out: string;
+  /**
+   * Key prefixes the file holds: `['native']` takes every `native.*` key, which it names without the
+   * prefix (`native.tray.quit` is `tray_quit`). Every key, named in full, by default.
+   */
+  keys?: string[];
+  /**
+   * The type holding the locales and messages: `Locale` in Rust, `Copy` in Swift and Kotlin. For
+   * Android, the resource file's name: `strings`, for `values/strings.xml`. For Apple, the table's:
+   * `Localizable`, or `InfoPlist` with `plist`.
+   */
+  name?: string;
+  /** Kotlin's package. */
+  package?: string;
+  /**
+   * For Apple, the Info.plist the table translates: each key names one of its strings, spelled in
+   * words (`ns-camera-usage-description` is `NSCameraUsageDescription`), and the source must say
+   * what the plist says.
+   */
+  plist?: string;
+}
+
 export interface ProsebookConfig {
   /** The source-language catalog: one `<area>.yaml` per area. */
   catalog?: string;
@@ -70,6 +104,13 @@ export interface ProsebookConfig {
    * translations alike; `prosebook migrate` rewrites a catalog from one to the other.
    */
   messageFormat?: 1 | 2;
+  /**
+   * In MF2, when a placeholder is wrapped in Unicode isolation marks, so a value written the other
+   * way (a Latin name in Hebrew) can't reorder the text around it. `'rtl'`, the default: in locales
+   * written right to left, and wherever `u:dir` asks. `'always'`: also every string in any locale,
+   * as the spec's default has it. `false`: never.
+   */
+  isolate?: Isolate;
   /** Locales that ship in the main bundle beside the source, rather than loading when first used. */
   bundled?: string[];
   /** A pseudo-locale generated from the source (accented and lengthened) to find layout bugs and hardcoded text. */
@@ -87,6 +128,8 @@ export interface ProsebookConfig {
   /** Where a string may sit, with what each surface means. */
   surfaces?: Record<string, string>;
   lint?: LintConfig;
+  /** Rust, Swift or Kotlin files `generate` writes beside the TypeScript. */
+  native?: NativeTarget[];
   /** Where `prosebook scan` looks for hardcoded text and catalog keys. */
   scan?: {
     dirs?: string[];
@@ -104,6 +147,7 @@ export interface ResolvedConfig {
   lock: string;
   source: string;
   messageFormat: 1 | 2;
+  isolate: Isolate;
   bundled: string[];
   pseudo: string | false;
   stale: 'use' | 'fallback';
@@ -116,9 +160,12 @@ export interface ResolvedConfig {
     rules: Record<string, { rule: CheckRule; severity: Severity }>;
     areas: Record<string, Record<string, Severity>>;
   } & Required<WordLists>;
+  native: (NativeTarget & { name: string })[];
   scan: { dirs: string[]; extensions: string[]; attributes: string[] };
 }
 
+const NATIVE_NAMES = { rust: 'Locale', swift: 'Copy', kotlin: 'Copy', android: 'strings', apple: 'Localizable' };
+
 /** Typed config, for `prosebook.config.ts`. */
 export function defineConfig(config: ProsebookConfig): ProsebookConfig {
   return config;
@@ -163,6 +210,7 @@ export function resolveConfig(root: string, config: ProsebookConfig): ResolvedCo
     lock: at(config.lock ?? 'copy/lock.json'),
     source: config.source ?? 'en',
     messageFormat: config.messageFormat ?? 1,
+    isolate: config.isolate ?? 'rtl',
     bundled: config.bundled ?? [],
     pseudo: config.pseudo ?? false,
     stale: config.stale ?? 'use',
@@ -180,6 +228,15 @@ export function resolveConfig(root: string, config: ProsebookConfig): ResolvedCo
       properNouns: lint.properNouns ?? [],
       pathSeparator: lint.pathSeparator ?? '›',
     },
+    native: (config.native ?? []).map((target, i) => {
+      if (!(target.language in NATIVE_NAMES))
+        throw new Error(`native[${i}].language is "${target.language}": name one of ${Object.keys(NATIVE_NAMES).join(', ')}`);
+      if (target.plist !== undefined && target.language !== 'apple')
+        throw new Error(`native[${i}].plist names an Info.plist, which only the apple target reads: remove it, or set language to 'apple'`);
+      const plist = target.plist === undefined ? {} : { plist: at(target.plist) };
+      const name = target.name ?? (target.plist === undefined ? NATIVE_NAMES[target.language] : 'InfoPlist');
+      return { ...target, out: at(target.out), name, ...plist };
+    }),
     scan: {
       dirs: (config.scan?.dirs ?? ['src']).map(at),
       extensions: config.scan?.extensions ?? ['.ts', '.tsx', '.js', '.jsx', '.mts', '.mjs'],

package/src/tools/endpoints.ts

@@ -0,0 +1,121 @@
+/**
+ * The dev server's half of the inspector (`inspector.ts`, `inspector-dialog.ts`): `__prosebook/open`,
+ * which opens an entry in the editor, and `__prosebook/entry`, which reads and edits one. Written over
+ * `Request` and `Response`, so each integration mounts them its own way: Vite as middleware, Bun as
+ * `Bun.serve` routes, Next behind a rewrite to a server of their own. Each opens the editor its dev
+ * server already launches.
+ */
+import type { IncomingMessage, ServerResponse } from 'node:http';
+
+import { CatalogError, entryLocation, loadCatalog, type EntryLocation } from './catalog.ts';
+import type { ResolvedConfig } from './config.ts';
+import { editEntry, readEntry, type EntryEdit } from './entry.ts';
+
+export interface EndpointOptions {
+  /** The path the endpoints sit under, ending in `/`: `/` by default. */
+  base?: string;
+  /** Opens an entry in the editor: a redirect to the dev server's own launcher, or a reply once it has. */
+  open: (at: EntryLocation) => Response | Promise<Response>;
+}
+
+/** Answers the inspector's requests, and nothing for any other path. */
+export function inspectorEndpoints(
+  config: ResolvedConfig | Promise<ResolvedConfig>,
+  { base = '/', open }: EndpointOptions,
+): (req: Request) => Promise<Response | undefined> {
+  return async (req) => {
+    const url = new URL(req.url);
+    if (url.pathname === `${base}__prosebook/open`) return openEntry(await config, url, open);
+    if (url.pathname === `${base}__prosebook/entry`) return entry(await config, req, url);
+    return undefined;
+  };
+}
+
+/**
+ * `?key=cart.items&locale=de`: the translation's entry, or the catalog's with `catalog` or when the
+ * locale has none. Read from disk, so a key added since the page loaded is found.
+ */
+async function openEntry(config: ResolvedConfig, url: URL, open: EndpointOptions['open']): Promise<Response> {
+  const key = url.searchParams.get('key') ?? '';
+  let message;
+  try {
+    message = loadCatalog(config).messages.find((m) => m.key === key);
+  } catch (e) {
+    return failed(e);
+  }
+  if (message === undefined)
+    return new Response(`no entry for "${key}" in the catalog: has it been renamed since the page loaded?`, { status: 404 });
+  const locale = url.searchParams.has('catalog') ? undefined : (url.searchParams.get('locale') ?? undefined);
+  return open(entryLocation(config, message, locale));
+}
+
+/**
+ * The inspector's dialog: GET `?key=…` reads an entry in every locale, POST `{ key, edit, write }`
+ * applies an edit (`entry.ts`). A POST writes files, so only the page itself may send one: same origin,
+ * and JSON, which a form on another site can't send without asking first.
+ */
+async function entry(config: ResolvedConfig, req: Request, url: URL): Promise<Response> {
+  if (req.method === 'GET') {
+    try {
+      return Response.json(readEntry(config, url.searchParams.get('key') ?? ''));
+    } catch (e) {
+      return failed(e);
+    }
+  }
+  const origin = req.headers.get('origin');
+  const sameOrigin = origin === null || new URL(origin).host === url.host;
+  if (req.method !== 'POST' || !sameOrigin || req.headers.get('content-type')?.startsWith('application/json') !== true)
+    return Response.json({ problems: [{ severity: 'error', message: 'edits come from the page, as JSON' }] }, { status: 403 });
+  try {
+    const { key, edit, write } = (await req.json()) as { key: string; edit: EntryEdit; write?: boolean };
+    const result = editEntry(config, key, edit, write === true);
+    return Response.json(result, { status: result.problems.length > 0 ? 422 : 200 });
+  } catch (e) {
+    return failed(e);
+  }
+}
+
+/** A redirect within the page's origin, to a launcher the dev server answers itself. */
+export const redirect = (path: string) => new Response(null, { status: 307, headers: { Location: path } });
+
+function failed(e: unknown): Response {
+  return Response.json(
+    { problems: e instanceof CatalogError ? e.problems : [{ severity: 'error', message: e instanceof Error ? e.message : String(e) }] },
+    { status: e instanceof CatalogError ? 409 : 400 },
+  );
+}
+
+/**
+ * The endpoints as Node middleware, for Vite's server and Next's. The request's host is the one the
+ * page was served from: a proxy's `x-forwarded-host`, as Next's rewrite sets, before its own.
+ */
+export function nodeMiddleware(
+  handle: (req: Request) => Promise<Response | undefined>,
+): (req: IncomingMessage, res: ServerResponse, next: () => void) => void {
+  return (req, res, next) => {
+    // Before reading the body, which a request for anything else leaves to whoever answers it.
+    if (req.url?.includes('/__prosebook/') !== true) return next();
+    const forwarded = req.headers['x-forwarded-host'];
+    const host = (Array.isArray(forwarded) ? forwarded[0] : forwarded) ?? req.headers.host ?? 'localhost';
+    const headers = new Headers();
+    for (const [name, value] of Object.entries(req.headers))
+      for (const v of Array.isArray(value) ? value : value === undefined ? [] : [value]) headers.append(name, v);
+
+    const chunks: Buffer[] = [];
+    req.on('data', (chunk: Buffer) => chunks.push(chunk));
+    req.on('end', () => {
+      const body = req.method === 'GET' || req.method === 'HEAD' ? undefined : Buffer.concat(chunks);
+      handle(new Request(`http://${host}${req.url}`, { method: req.method, headers, body }))
+        .then(async (response) => {
+          if (response === undefined) return next();
+          res.statusCode = response.status;
+          response.headers.forEach((value, name) => res.setHeader(name, value));
+          res.end(Buffer.from(await response.arrayBuffer()));
+        })
+        .catch((e: unknown) => {
+          res.statusCode = 500;
+          res.end(e instanceof Error ? e.message : String(e));
+        });
+    });
+  };
+}

package/src/tools/entry.ts

@@ -168,6 +168,83 @@ export function applyFixes(config: ResolvedConfig, catalog: Catalog, findings: F
   return { fixed, problems: [] };
 }
 
+export interface Imported {
+  /** Keys whose translation was written. */
+  written: string[];
+  /** Keys given back as they were: each still holds, so a stale one can be accepted. */
+  unchanged: string[];
+  /** What was left out, and why. The rest was written regardless. */
+  problems: Problem[];
+}
+
+/**
+ * Translations into `locale` from `prosebook todo`'s YAML filled in, by a person or a model, each
+ * written to the file its locale and area put it in. Text around a fenced block is left aside, as a
+ * model's reply has it, and an empty value is one left for later. An entry that would break the
+ * catalog is left out with its problem, so a reply with one bad entry still lands the others.
+ */
+export function importTranslations(config: ResolvedConfig, locale: string, reply: string): Imported {
+  const failed = (message: string, key?: string): Problem => ({ severity: 'error', key, message });
+  if (locale === config.source)
+    return { written: [], unchanged: [], problems: [failed(`${locale} is the source: import takes translations`)] };
+  const fenced = [...reply.matchAll(/^```[^\n]*\n([\s\S]*?)^```/gm)].map((m) => m[1]);
+  const doc = parseDocument(fenced.length > 0 ? fenced.join('\n') : reply);
+  if (doc.errors.length > 0 || !(isMap(doc.contents) || doc.contents === null)) {
+    const why = doc.errors[0]?.message.split('\n', 1)[0] ?? 'it is not a mapping';
+    return {
+      written: [],
+      unchanged: [],
+      problems: [failed(`the reply isn't YAML of \`key: translation\` (${why}): fix it, or ask for one YAML block`)],
+    };
+  }
+
+  const catalog = loadCatalog(config);
+  const problems: Problem[] = [];
+  const unchanged: string[] = [];
+  const pending = new Map<string, { file: string; text: string }>();
+  for (const pair of isMap(doc.contents) ? doc.contents.items : []) {
+    const key = isScalar(pair.key) ? String(pair.key.value) : String(pair.key);
+    const message = catalog.messages.find((m) => m.key === key);
+    if (message === undefined) {
+      problems.push(failed('no entry has this key: translate only the keys `prosebook todo` printed', key));
+      continue;
+    }
+    const value = isScalar(pair.value) ? pair.value.value : pair.value;
+    if (value === null || value === '') continue;
+    if (typeof value !== 'string' && typeof value !== 'number') {
+      problems.push(failed('the translation is not text: give the message as one string', key));
+      continue;
+    }
+    const text = String(value);
+    if (text === message.translations.get(locale)?.text) unchanged.push(key);
+    else pending.set(key, { file: translationFile(config, message, locale), text });
+  }
+
+  // An entry whose own file reports it is left out, until what is left loads clean. A problem
+  // anywhere else means the catalog was broken before the reply, so nothing is written.
+  for (;;) {
+    const unsaved = new Map<string, string>();
+    for (const [key, { file, text }] of pending)
+      unsaved.set(resolve(config.root, file), withTranslation(contentOf(config, file, unsaved), key, text));
+    try {
+      loadCatalog(config, unsaved);
+    } catch (e) {
+      if (!(e instanceof CatalogError)) throw e;
+      const errors = e.problems.filter((p) => p.severity === 'error');
+      const own = errors.filter((p) => p.key !== undefined && pending.get(p.key)?.file === p.file);
+      if (own.length === 0) return { written: [], unchanged: [], problems: [...problems, ...errors] };
+      for (const p of own) if (p.key !== undefined) pending.delete(p.key);
+      problems.push(...own);
+      continue;
+    }
+    for (const [path, content] of unsaved) {
+      mkdirSync(dirname(path), { recursive: true });
+      writeFileSync(path, content);
+    }
+    return { written: [...pending.keys()], unchanged, problems };
+  }
+}
+
 /** A file as the edit has it, as it is on disk, or empty when it is still to be made. */
 function contentOf(config: ResolvedConfig, file: string, unsaved: Map<string, string>): string {
   const path = resolve(config.root, file);

package/src/tools/generate.ts

@@ -12,6 +12,7 @@ import { loadCatalog, type Catalog, type Message } from './catalog.ts';
 import { compileLocale, localeModule, type Entry } from './compile.ts';
 import type { ResolvedConfig } from './config.ts';
 import { readLock, reconcile, serializeLock, type Lock, type StaleTranslation } from './lock.ts';
+import { nativeFiles } from './native/index.ts';
 import { pseudoAst } from './pseudo.ts';
 import { SYNTAX_NAME } from './syntax.ts';
 
@@ -229,6 +230,7 @@ export function render(config: ResolvedConfig, accept?: Map<string, Set<string>
     );
   }
 
+  for (const [path, content] of nativeFiles(config, catalog, locales, entries, head)) files.set(path, content);
   files.set(join(config.catalog, 'catalog.schema.json'), `${JSON.stringify(catalogSchema(config), null, 2)}\n`);
   if (Object.keys(lock.translations).length > 0 || existsSync(config.lock)) files.set(config.lock, serializeLock(lock));
   return { catalog, files, lock, stale, entries };

package/src/tools/icu.ts

@@ -65,6 +65,50 @@ function argType(el: MessageFormatElement): string | undefined {
   }
 }
 
+/**
+ * Formatting options read from arguments as the message renders, by `Intl` option: MF2's
+ * `{$price :currency currency=$code}`. MF1 has no way to say this, so only a tree read from MF2 has them.
+ */
+export type OptionArgs = Record<string, { arg: string; type: string }>;
+
+export function optionArgsOf(el: MessageFormatElement): OptionArgs | undefined {
+  if (el.type === TYPE.plural) return selectionOf(el)?.args;
+  if (!isNumberElement(el) && !isDateElement(el) && !isTimeElement(el)) return undefined;
+  const style = el.style;
+  return typeof style === 'object' && style !== null && 'args' in style ? (style as { args: OptionArgs }).args : undefined;
+}
+
+/**
+ * How an MF2 `.match` selects on a number, beyond its plural type: on the number as formatted, so
+ * the selector's digit options (`Intl.PluralRules` takes the same ones, some from arguments) decide
+ * the category, and on the value `:integer` rounds or `:percent` multiplies by 100. Kept with the
+ * selector's function as written, to write it back. MF1 selects on the bare value.
+ */
+export interface Selection {
+  fn: { name: string; options: Record<string, string>; args?: Record<string, string> };
+  options: Intl.PluralRulesOptions;
+  args?: OptionArgs;
+  value?: 'round' | 'percent';
+}
+
+export function selectionOf(el: MessageFormatElement): Selection | undefined {
+  return el.type === TYPE.plural ? (el as { selection?: Selection }).selection : undefined;
+}
+
+/**
+ * How a placeholder renders around its value: the text it shows when it has none, or one `Intl`
+ * can't format, and the marks isolating its direction from the text around it. MF2 sets these
+ * (`{$name}`, and isolation in a right-to-left locale); an MF1 placeholder shows `{name}`.
+ */
+export interface Placeholder {
+  fallback: string;
+  isolate?: readonly [open: string, close: string];
+}
+
+export function placeholderOf(el: MessageFormatElement, name: string): Placeholder {
+  return (el as { placeholder?: Placeholder }).placeholder ?? { fallback: `{${name}}` };
+}
+
 /** Calls `visit` on every element, inside plural and select arms and tags too. */
 export function walk(elements: MessageFormatElement[], visit: (el: MessageFormatElement) => void): void {
   for (const el of elements) {
@@ -76,12 +120,15 @@ export function walk(elements: MessageFormatElement[], visit: (el: MessageFormat
 
 export function argsOf(elements: MessageFormatElement[], clash: (name: string) => void = () => {}): Map<string, string> {
   const args = new Map<string, string>();
+  const add = (name: string, type: string) => {
+    const seen = args.get(name);
+    if (seen !== undefined && seen !== type) clash(name);
+    else args.set(name, type);
+  };
   walk(elements, (el) => {
+    for (const { arg, type } of Object.values(optionArgsOf(el) ?? {})) add(arg, type);
     const type = argType(el);
-    if (type === undefined || !('value' in el) || typeof el.value !== 'string') return;
-    const seen = args.get(el.value);
-    if (seen !== undefined && seen !== type) clash(el.value);
-    else args.set(el.value, type);
+    if (type !== undefined && 'value' in el && typeof el.value === 'string') add(el.value, type);
   });
   return args;
 }
@@ -121,8 +168,12 @@ export function numberOptions(el: NumberElement): Intl.NumberFormatOptions | und
   const unknown = style.tokens.filter((t) => !stemIsKnown(t.stem, t.options)).map((t) => t.stem);
   if (unknown.length > 0) throw new Error(`{${el.value}} has skeleton stems the formatter drops without a word: ${unknown.join(', ')}`);
   const options = style.parsedOptions as Intl.NumberFormatOptions;
+  // An option an argument gives is checked with a stand-in: `Intl` refuses a currency style without
+  // its currency. Whether the argument's value suits it is known only as the message renders.
+  const args = optionArgsOf(el) ?? {};
+  const given = { ...(args.currency && { currency: 'EUR' }), ...(args.unit && { unit: 'meter' }) };
   try {
-    new Intl.NumberFormat('en', options).resolvedOptions();
+    new Intl.NumberFormat('en', { ...options, ...given }).resolvedOptions();
   } catch (e) {
     throw new Error(`{${el.value}} has a skeleton Intl refuses: ${(e as Error).message}`, { cause: e });
   }
@@ -196,8 +247,13 @@ export function formatsOf(ast: MessageFormatElement[]): Map<string, string> {
       said = `${kind} \`${style}\``;
     } else if ('mf2' in style) {
       // Read from MF2: the function as written.
-      const { name, options } = (style as { mf2: { name: string; options: Record<string, string> } }).mf2;
-      said = `\`${[`:${name}`, ...Object.entries(options).map(([k, v]) => `${k}=${v}`)].join(' ')}\``;
+      const {
+        name,
+        options,
+        args = {},
+      } = (style as { mf2: { name: string; options: Record<string, string>; args?: Record<string, string> } }).mf2;
+      const written = [...Object.entries(options), ...Object.entries(args).map(([k, v]) => [k, `$${v}`])];
+      said = `\`${[`:${name}`, ...written.map(([k, v]) => `${k}=${v}`)].join(' ')}\``;
     } else if ('tokens' in style) {
       said = `${kind} \`::${style.tokens.map((t) => [t.stem, ...t.options].join('/')).join(' ')}\``;
     } else {

package/src/tools/index.ts

@@ -30,14 +30,16 @@ export {
 export {
   applyFixes,
   editEntry,
+  importTranslations,
   readEntry,
+  type Imported,
   type EntryEdit,
   type EntryFields,
   type EntryFinding,
   type EntryView,
   type EntryYaml,
 } from './entry.ts';
-export { defineConfig, loadConfig, resolveConfig, type ProsebookConfig, type ResolvedConfig } from './config.ts';
+export { defineConfig, loadConfig, resolveConfig, type NativeTarget, type ProsebookConfig, type ResolvedConfig } from './config.ts';
 export { catalogSchema, generate, localeEntries, localesOf, render, writeFiles, type Generated } from './generate.ts';
 export {
   applyEdits,
@@ -66,14 +68,15 @@ export {
   type SubstitutionRule,
 } from './lint.ts';
 export { formatDiff, wordDiff, type DiffPart } from './diff.ts';
-export { emptyLock, hash, readLock, reconcile, serializeLock, type Lock, type StaleTranslation } from './lock.ts';
+export { changeOf, emptyLock, hash, readLock, reconcile, serializeLock, type Lock, type StaleTranslation } from './lock.ts';
 export { DEFAULT_KINDS, DEFAULT_SURFACES, STRICT_LISTS, type KindRule, type Severity } from './presets.ts';
 export { pseudoAst, pseudoText } from './pseudo.ts';
-export { intlDate, intlNumber, parseMf2, toMf2, type Mf2Function } from './mf2.ts';
+export { intlDate, intlNumber, parseMf2, toMf2, type Isolate, type Mf2Function } from './mf2.ts';
 export { toMf1 } from './mf1.ts';
 export { applyMigrate, planMigrate, type MigratePlan } from './migrate.ts';
 export { readMessage, SYNTAX_NAME, writeMessage, type MessageFormatVersion } from './syntax.ts';
 export { syntaxKind, typescriptOracle, type Span, type TypeOracle, type ValueKind } from './types.ts';
+export { todoOf, type Todo } from './todo.ts';
 export { SarifReport, type SarifResult, type SarifTool } from './sarif.ts';
 export {
   hardcodedText,

package/src/tools/lock.ts

@@ -14,6 +14,7 @@ import { createHash } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 
 import type { Catalog } from './catalog.ts';
+import { formatDiff, wordDiff } from './diff.ts';
 
 export interface Lock {
   version: 2;
@@ -59,6 +60,12 @@ export interface StaleTranslation {
   translation: string;
 }
 
+/** What changed in the source of a stale translation, as a word diff, or why that isn't known. */
+export function changeOf(stale: StaleTranslation): string {
+  if (stale.was === undefined) return "the earlier text isn't recorded (the lock predates prosebook 0.2)";
+  return formatDiff(wordDiff(stale.was, stale.now)).replaceAll('\n', ' ');
+}
+
 export interface Reconciled {
   lock: Lock;
   /** Per locale, per key: the translations made from a source that has changed since. */

package/src/tools/mf1.ts

@@ -7,8 +7,8 @@
 import { isDateElement, isNumberElement, isTimeElement, parse, TYPE } from '@formatjs/icu-messageformat-parser';
 import type { DateElement, DateTimeSkeleton, NumberElement, NumberSkeleton, TimeElement } from '@formatjs/icu-messageformat-parser';
 
-import type { MessageFormatElement } from './icu.ts';
-import type { Mf2DateSkeleton, Mf2NumberSkeleton } from './mf2.ts';
+import { selectionOf, type MessageFormatElement } from './icu.ts';
+import type { Mf2DateSkeleton, Mf2Function, Mf2NumberSkeleton } from './mf2.ts';
 
 type Element = MessageFormatElement;
 
@@ -89,6 +89,10 @@ function native(elements: Element[], plural: { value: string; offset: number } |
     }
     if (isDateElement(el) || isTimeElement(el)) return dateElement(el);
     if (el.type === TYPE.plural) {
+      // Digit options and `:integer`'s rounding change only which arm some values reach, which
+      // `migrate` reports when it renders both; an argument's option MF1 can't say at all.
+      const args = Object.keys(selectionOf(el)?.args ?? {});
+      if (args.length > 0) throw new Error(`{${el.value}} is selected with ${args.join(', ')} from an argument, which MF1 can't say`);
       const inner = { value: el.value, offset: el.offset };
       return { ...el, options: Object.fromEntries(Object.entries(el.options).map(([k, o]) => [k, { value: native(o.value, inner) }])) };
     }
@@ -102,9 +106,9 @@ function native(elements: Element[], plural: { value: string; offset: number } |
 
 function plainNumber(el: NumberElement): boolean {
   const style = el.style;
-  return (
-    style === null || style === undefined || ('mf2' in Object(style) && Object.keys((style as NumberSkeleton).parsedOptions).length === 0)
-  );
+  if (style === null || style === undefined) return true;
+  const mf2 = 'mf2' in Object(style) ? (style as Mf2NumberSkeleton) : undefined;
+  return mf2 !== undefined && mf2.args === undefined && Object.keys(mf2.parsedOptions).length === 0;
 }
 
 function same(a: object, b: object): boolean {
@@ -120,6 +124,7 @@ function same(a: object, b: object): boolean {
 function numberStyle(el: NumberElement): NumberElement['style'] {
   const style = el.style;
   if (style === null || style === undefined || typeof style === 'string' || !('mf2' in style)) return style;
+  refuseArgs(el.value, style as Mf2NumberSkeleton);
   const options = (style as Mf2NumberSkeleton).parsedOptions as Record<string, unknown>;
   if (Object.keys(options).length === 0) return null;
   if (same(options, { maximumFractionDigits: 0 })) return 'integer';
@@ -210,6 +215,7 @@ const NAMED: Record<string, readonly [TYPE.date | TYPE.time, string]> = {
 function dateElement(el: DateElement | TimeElement): Element {
   const style = el.style;
   if (typeof style !== 'object' || style === null || !('mf2' in style)) return el;
+  refuseArgs(el.value, style as Mf2DateSkeleton);
   const fn = (style as Mf2DateSkeleton).mf2;
   const named = NAMED[mf2Text(fn, true).slice(1)];
   if (named !== undefined) return { type: named[0], value: el.value, style: named[1] };
@@ -239,8 +245,16 @@ function dateSkeleton(o: Intl.DateTimeFormatOptions): string | undefined {
   return out === '' ? undefined : out;
 }
 
-function mf2Text(fn: { name: string; options: Record<string, string> }, sortOptions = false): string {
-  const options = Object.entries(fn.options);
+/** A skeleton names every option, so one an argument gives has no MF1 spelling. */
+function refuseArgs(name: string, style: Mf2NumberSkeleton | Mf2DateSkeleton): void {
+  if (style.args === undefined) return;
+  throw new Error(
+    `{${name} ${mf2Text(style.mf2)}} takes an option from an argument, which MF1 can't: write the option's value in the message`,
+  );
+}
+
+function mf2Text(fn: Mf2Function, sortOptions = false): string {
+  const options = [...Object.entries(fn.options), ...Object.entries(fn.args ?? {}).map(([k, v]) => [k, `$${v}`] as const)];
   if (sortOptions) options.sort(([a], [b]) => a.localeCompare(b));
   return [`:${fn.name}`, ...options.map(([k, v]) => `${k}=${v}`)].join(' ');
 }