prosebook 0.1.0 → 0.3.0

package/src/runtime/helpers.ts

@@ -1,34 +1,61 @@
 import type { Arms, Helpers, Values } from './types.ts';
 
+/** Formatters by options object, then by the options arguments gave, as JSON (`''` for none). */
+type Formatters<F> = Map<object | undefined, Map<string, F>>;
+
 /**
  * The helpers compiled messages call, for one locale. Formatters are built once per options object:
  * the generator hoists each message's options to a module-level constant, so identity is a stable key.
+ * Options an argument gives are built per call, so those are told apart by value.
+ *
+ * A value missing, or one `Intl` refuses, never throws: `n` and `d` give nothing back, and the message
+ * shows the placeholder's fallback through `e`, which hands `report` what went wrong.
  */
-export function createHelpers(locale: string): Helpers {
-  const numbers = new Map<Intl.NumberFormatOptions | undefined, Intl.NumberFormat>();
-  const dates = new Map<Intl.DateTimeFormatOptions | undefined, Intl.DateTimeFormat>();
-  let cardinal: Intl.PluralRules | undefined;
-  let ordinal: Intl.PluralRules | undefined;
+export function createHelpers(locale: string, report?: (error: Error) => void): Helpers {
+  const numbers: Formatters<Intl.NumberFormat> = new Map();
+  const dates: Formatters<Intl.DateTimeFormat> = new Map();
+  const rules: Formatters<Intl.PluralRules>[] = [new Map(), new Map()];
+  let failure: unknown;
+
+  function attempt(value: unknown, format: () => string): string | undefined {
+    failure = undefined;
+    // `value !== value`: NaN, which `Intl` prints as "NaN".
+    if (value === undefined || value === null || value !== value) return undefined;
+    try {
+      return format();
+    } catch (error) {
+      failure = error;
+      return undefined;
+    }
+  }
 
   return {
     locale,
-    n(value, options) {
-      let format = numbers.get(options);
-      if (format === undefined) numbers.set(options, (format = new Intl.NumberFormat(locale, options)));
-      return format.format(value);
+    n(value, options, given) {
+      return attempt(value, () => formatter(numbers, options, given, (o) => new Intl.NumberFormat(locale, o)).format(value));
     },
-    d(value, options) {
-      let format = dates.get(options);
-      if (format === undefined) dates.set(options, (format = new Intl.DateTimeFormat(locale, options)));
-      return format.format(value);
+    d(value, options, given) {
+      return attempt(value, () => formatter(dates, options, given, (o) => new Intl.DateTimeFormat(locale, o)).format(value));
     },
-    p(value, offset, isOrdinal, arms) {
+    e(fallback) {
+      const why = failure instanceof Error ? `could not be formatted: ${failure.message}` : 'has no value';
+      report?.(new Error(`${fallback} ${why}`, { cause: failure }));
+      failure = undefined;
+      return fallback;
+    },
+    p(value, offset, isOrdinal, arms, options, given) {
       const exact = arms[`=${value}`];
       if (exact !== undefined) return exact();
-      const rules = isOrdinal
-        ? (ordinal ??= new Intl.PluralRules(locale, { type: 'ordinal' }))
-        : (cardinal ??= new Intl.PluralRules(locale));
-      return pick(arms, rules.select(value - offset));
+      let category = 'other';
+      try {
+        const type = isOrdinal ? 'ordinal' : 'cardinal';
+        category = formatter(rules[+isOrdinal]!, options, given, (o) => new Intl.PluralRules(locale, { ...o, type })).select(
+          value - offset,
+        );
+      } catch {
+        // Options an argument gave that `Intl` refuses: the catch-all arm, as MF2 falls back to `*`.
+      }
+      return pick(arms, category);
     },
     s(value, arms) {
       return pick(arms, String(value));
@@ -40,6 +67,15 @@ export function createHelpers(locale: string): Helpers {
   };
 }
 
+function formatter<O extends object, F>(cache: Formatters<F>, options: O | undefined, given: O | undefined, make: (o?: O) => F): F {
+  let byGiven = cache.get(options);
+  if (byGiven === undefined) cache.set(options, (byGiven = new Map()));
+  const key = given === undefined ? '' : JSON.stringify(given);
+  let format = byGiven.get(key);
+  if (format === undefined) byGiven.set(key, (format = make(given === undefined ? options : { ...options, ...given })));
+  return format;
+}
+
 function pick(arms: Arms, arm: string): unknown {
   // ICU requires an `other` arm, and the generator refuses a message without one.
   return (Object.hasOwn(arms, arm) ? arms[arm]! : arms['other']!)();

package/src/runtime/locale.ts

@@ -44,6 +44,25 @@ export function preferredLocales(): string[] {
   return resolved ? [resolved] : [];
 }
 
+/**
+ * The locales an `Accept-Language` header asks for, most preferred first: ordered by `q`, ties in
+ * the header's order. `q=0` means "not this one", and `*` asks for nothing `negotiate`'s fallback
+ * doesn't already give, so both are left out, as is a part whose `q` isn't a number.
+ */
+export function acceptedLocales(header: string | null | undefined): string[] {
+  const weighed: { tag: string; q: number }[] = [];
+  for (const part of (header ?? '').split(',')) {
+    const [tag = '', ...params] = part.split(';').map((s) => s.trim());
+    if (tag === '' || tag === '*') continue;
+    const weight = params.find((p) => /^q\s*=/i.test(p));
+    const q = weight === undefined ? 1 : Number(weight.slice(weight.indexOf('=') + 1).trim());
+    if (Number.isNaN(q) || q <= 0) continue;
+    weighed.push({ tag, q });
+  }
+  // Array.prototype.sort is stable, so equal weights keep the header's order.
+  return weighed.sort((a, b) => b.q - a.q).map((w) => w.tag);
+}
+
 function languageOf(tag: string): string {
   return tag.split('-', 1)[0]!.toLowerCase();
 }

package/src/runtime/types.ts

@@ -42,12 +42,27 @@ export type DefaultTags = Register extends { tags: infer T extends string } ? T
  */
 export interface Helpers {
   readonly locale: string;
-  /** `{x, number, …}` and the `#` of a plural. */
-  n(value: number, options?: Intl.NumberFormatOptions): string;
-  /** `{x, date, …}` and `{x, time, …}`. */
-  d(value: Date | number, options?: Intl.DateTimeFormatOptions): string;
-  /** `{x, plural, …}` and `{x, selectordinal, …}`: picks an arm and renders it. */
-  p(value: number, offset: number, ordinal: boolean, arms: Arms): unknown;
+  /**
+   * `{x, number, …}` and the `#` of a plural; `given` holds the options arguments give, in MF2.
+   * Nothing where there is no value or `Intl` refuses it, so the message shows `e`'s fallback.
+   */
+  n(value: number, options?: Intl.NumberFormatOptions, given?: Intl.NumberFormatOptions): string | undefined;
+  /** `{x, date, …}` and `{x, time, …}`, as `n`. */
+  d(value: Date | number, options?: Intl.DateTimeFormatOptions, given?: Intl.DateTimeFormatOptions): string | undefined;
+  /** A placeholder's fallback, `{x}`, where it has no value or `n` or `d` gave nothing: reports why. */
+  e(fallback: string): string;
+  /**
+   * `{x, plural, …}` and `{x, selectordinal, …}`: picks an arm and renders it. MF2 passes the
+   * options its selector formats with, since those decide the category: `1.0` is `other` in English.
+   */
+  p(
+    value: number,
+    offset: number,
+    ordinal: boolean,
+    arms: Arms,
+    options?: Intl.PluralRulesOptions,
+    given?: Intl.PluralRulesOptions,
+  ): unknown;
   /** `{x, select, …}`. */
   s(value: unknown, arms: Arms): unknown;
   /** `<tag>…</tag>`: the tag's function from the values, or the bare children when there is none. */

package/src/tools/bundle.ts

@@ -0,0 +1,131 @@
+/**
+ * What the bundler integrations share: which messages a build ships, the reads that would show a key
+ * once their message is pruned, and the code a dev server appends so an edit swaps messages in place.
+ *
+ * Vite sees every module before it writes a chunk, so it prunes after the fact (`vite.ts`). Next's
+ * loaders and Bun's `onLoad` hand over a locale module before the code that reads it has been seen,
+ * so they read the source under `scan.dirs` first (`scanSources`) and load the locale already pruned.
+ */
+import { existsSync, readFileSync, watch } from 'node:fs';
+import { relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { compileLocale, localeModule, type Entry } from './compile.ts';
+import type { ResolvedConfig } from './config.ts';
+import { isReferenced, keyRefs, READERS, sourceFiles, unseenReads, type KeyRefs, type Reads, type UnseenRead } from './scan.ts';
+
+/** How a build prunes: `strict` also fails on a read whose key it can't see. */
+export type Prune = 'strict' | 'loose' | false;
+
+/** Whether a build keeps a key: some module names it, or `keep` lists it, exactly or as `prefix.*`. */
+export function keeper(refs: KeyRefs, keep: string[] = []): (key: string) => boolean {
+  return (key) => isReferenced(key, refs) || keep.some((k) => (k.endsWith('.*') ? key.startsWith(k.slice(0, -1)) : k === key));
+}
+
+/** The unseen reads that are a copy's: a name only counts once some module binds a reader to it. */
+export function unseenOf(reads: Iterable<Reads>): UnseenRead[] {
+  const all = [...reads];
+  const readers = new Set([...READERS, ...all.flatMap((r) => [...r.aliases])]);
+  return all.flatMap((r) => r.unseen).filter((u) => u.name === 'Text' || readers.has(u.name));
+}
+
+/** The error a strict build fails with, each read at its path from `root`. */
+export function unseenMessage(unseen: UnseenRead[], root: string): string {
+  const at = (file: string) => relative(root, file).replaceAll('\\', '/');
+  return [
+    `${unseen.length} read(s) whose key the build can't see, so their messages would be pruned and the key shown instead:`,
+    ...unseen.map((u) => `  ${at(u.file)}:${u.line}:${u.column}  ${u.code}`),
+    'Write each key at the read, as a literal or `area.${id}`; or, where every key it reads is written elsewhere or listed in `keep`, mark the line `prosebook-ignore`. `prune: "loose"` turns this check off.',
+  ].join('\n');
+}
+
+export interface SourceScan {
+  refs: KeyRefs;
+  unseen: UnseenRead[];
+}
+
+/**
+ * Every key the app's source names and, with `strict`, its unseen reads. The generated modules are
+ * left out, since they name every key.
+ */
+export function scanSources(config: ResolvedConfig, strict: boolean): SourceScan {
+  const refs: KeyRefs = { exact: new Set(), prefixes: new Set() };
+  const reads: Reads[] = [];
+  for (const file of sourceFiles(config.scan.dirs, config.scan.extensions, [config.out])) {
+    const code = readFileSync(file, 'utf8');
+    keyRefs(code, refs);
+    if (strict) reads.push(unseenReads(file, code));
+  }
+  return { refs, unseen: unseenOf(reads) };
+}
+
+/** Calls `change` once a burst of edits to the catalog or its translations settles. Returns the stop. */
+export function watchCatalog(config: ResolvedConfig, change: () => void): () => void {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const watchers = [config.catalog, config.locales]
+    .filter((dir) => existsSync(dir))
+    .map((dir) =>
+      watch(dir, { recursive: true }, (_event, file) => {
+        if (file === null || !file.endsWith('.yaml')) return;
+        clearTimeout(timer);
+        timer = setTimeout(change, 50);
+      }),
+    );
+  return () => {
+    clearTimeout(timer);
+    for (const w of watchers) w.close();
+  };
+}
+
+/** A locale's module holding only the keys `kept`, as JavaScript, for a bundler to load in its place. */
+export function prunedModule(entries: Entry[], kept: (key: string) => boolean): string {
+  return localeModule(compileLocale(entries, kept), '// Pruned by prosebook: only the messages the code names.', false);
+}
+
+/**
+ * Appended to a locale module in dev. Accepts its own update and hands the new messages to every
+ * copy (`HotHook`); a page loaded before the hooks existed reloads instead.
+ */
+export const hotLocale = (locale: string) => `
+if (import.meta.hot) {
+  import.meta.hot.accept((next) => {
+    const hot = globalThis.__PROSEBOOK_HOT__;
+    if (next === undefined || hot === undefined) return import.meta.hot.invalidate();
+    for (const update of hot) update(${JSON.stringify(locale)}, next.default);
+  });
+}
+`;
+
+/** Appended to the index in dev: its doc comments change with every edit; only a new locale reloads. */
+export const HOT_INDEX = `
+if (import.meta.hot) {
+  import.meta.hot.accept((next) => {
+    if (next === undefined || next.catalog.locales.join() !== catalog.locales.join()) import.meta.hot.invalidate();
+  });
+}
+`;
+
+/**
+ * A locale module in dev under a bundler that runs it again when it changes, as Turbopack's Fast
+ * Refresh does, but has no `import.meta.hot`: each run hands its messages to every copy. The first
+ * run finds no copy holding the locale yet, so it changes nothing.
+ */
+export const notifyingLocale = (code: string, locale: string) =>
+  `${code.replace(/^export default /m, 'const messages = ')}
+export default messages;
+globalThis.__PROSEBOOK_HOT__?.forEach((update) => update(${JSON.stringify(locale)}, messages));
+`;
+
+/** Prepended to the index in dev, so the set every copy adds itself to exists before any copy does. */
+export const HOT_SET = 'globalThis.__PROSEBOOK_HOT__ ??= new Set();\n';
+
+/**
+ * A module of prosebook's own beside the one at `url`, which passes its `import.meta.url`: the source
+ * when run from source, the built file in dist.
+ */
+export const beside = (url: string, name: string) =>
+  fileURLToPath(new URL(`./${name}${url.endsWith('.ts') ? '.ts' : '.js'}`, url)).replaceAll('\\', '/');
+
+/** Code that starts the inspector (`inspector.ts`, imported from `path`) on the page, its endpoints under `base`. */
+export const installInspector = (path: string, base: string) =>
+  `import { install as installInspector } from ${JSON.stringify(path)};\ninstallInspector(${JSON.stringify({ base })});\n`;

package/src/tools/catalog.ts

@@ -179,7 +179,7 @@ function readEntry(
 
   let ast: MessageFormatElement[];
   try {
-    ast = readMessage(config.messageFormat, text, config.source);
+    ast = readMessage(config.messageFormat, text, config.source, config.isolate);
   } catch (e) {
     fail(syntaxError(config, text, e));
     return undefined;
@@ -260,7 +260,7 @@ function readLocales(
         }
         let ast: MessageFormatElement[];
         try {
-          ast = readMessage(config.messageFormat, value, locale);
+          ast = readMessage(config.messageFormat, value, locale, config.isolate);
         } catch (e) {
           error(syntaxError(config, value, e), key);
           continue;

package/src/tools/compile.ts

@@ -3,12 +3,26 @@
  *
  * A message with no placeholders becomes its string. Any other becomes `(a, h) => …`, where `a` holds
  * the arguments and `h` the locale's helpers (see `runtime/helpers.ts`): a plural is a call picking an
- * arm, a number is a call to a cached `Intl.NumberFormat`. Formatting options are resolved here and
+ * arm, a number is a call to a cached `Intl.NumberFormat`. A placeholder without a value, or with one
+ * `Intl` refuses, shows as `{name}` and is reported (`h.e`) rather than throwing, so every such
+ * message uses `h`. Formatting options are resolved here and
  * hoisted to module constants, so a skeleton costs nothing at runtime and its formatter is built once.
+ * Options an argument gives (MF2's `currency=$code`) follow them as an object built per call, and the
+ * runtime keeps a formatter per value.
  */
 import { isDateElement, isNumberElement, isTimeElement } from '@formatjs/icu-messageformat-parser';
 
-import { dateOptions, numberOptions, staticLiteral, TYPE, type MessageFormatElement } from './icu.ts';
+import {
+  dateOptions,
+  numberOptions,
+  optionArgsOf,
+  placeholderOf,
+  selectionOf,
+  staticLiteral,
+  TYPE,
+  type MessageFormatElement,
+  type OptionArgs,
+} from './icu.ts';
 
 export type Entry = readonly [key: string, ast: MessageFormatElement[]];
 
@@ -35,34 +49,67 @@ function access(name: string): string {
   return /^[A-Za-z_$][\w$]*$/.test(name) ? `a.${name}` : `a[${JSON.stringify(name)}]`;
 }
 
-function nodes(elements: MessageFormatElement[], hoisted: Hoisted, pound: string | null): string {
+/** The plural a `#` prints the value of. */
+type Pound = { name: string; offset: number } | null;
+
+function nodes(elements: MessageFormatElement[], hoisted: Hoisted, pound: Pound): string {
   if (elements.length === 0) return '""';
   const parts = elements.map((el) => node(el, hoisted, pound));
   return parts.length === 1 ? parts[0]! : `[${parts.join(', ')}]`;
 }
 
-function arms(options: Record<string, { value: MessageFormatElement[] }>, hoisted: Hoisted, pound: string | null): string {
+function arms(options: Record<string, { value: MessageFormatElement[] }>, hoisted: Hoisted, pound: Pound): string {
   const body = Object.entries(options).map(([arm, option]) => `${JSON.stringify(arm)}: () => ${nodes(option.value, hoisted, pound)}`);
   return `{ ${body.join(', ')} }`;
 }
 
-function node(el: MessageFormatElement, hoisted: Hoisted, pound: string | null): string {
-  if (isNumberElement(el)) return `h.n(${access(el.value)}${hoisted.arg(numberOptions(el))})`;
-  if (isDateElement(el) || isTimeElement(el)) return `h.d(${access(el.value)}${hoisted.arg(dateOptions(el))})`;
+/** The hoisted options, then the options arguments give as `{ currency: a.code }`, where there are any. */
+function formatting(options: object | undefined, args: OptionArgs | undefined, hoisted: Hoisted): string {
+  const given = Object.entries(args ?? {});
+  const fixed = hoisted.arg(options);
+  if (given.length === 0) return fixed;
+  return `${fixed || ', undefined'}, { ${given.map(([option, { arg }]) => `${option}: ${access(arg)}`).join(', ')} }`;
+}
+
+/** A string literal, its invisible direction marks escaped so the generated code shows them. */
+function text(value: string): string {
+  return JSON.stringify(value).replace(/[\u2066-\u2069]/g, (c) => `\\u${c.charCodeAt(0).toString(16)}`);
+}
+
+/**
+ * A placeholder's value, or its fallback (`{name}`, reported through `h.e`) where it has none or
+ * `Intl` refuses it, between the marks isolating its direction where it has them.
+ */
+function placed(el: MessageFormatElement, name: string, value: string): string {
+  const { fallback, isolate } = placeholderOf(el, name);
+  const shown = `${value} ?? h.e(${text(fallback)})`;
+  return isolate === undefined ? shown : `[${text(isolate[0])}, ${shown}, ${text(isolate[1])}]`;
+}
+
+function node(el: MessageFormatElement, hoisted: Hoisted, pound: Pound): string {
+  const formatted = (helper: string, name: string, options: object | undefined) =>
+    placed(el, name, `h.${helper}(${access(name)}${formatting(options, optionArgsOf(el), hoisted)})`);
+  if (isNumberElement(el)) return formatted('n', el.value, numberOptions(el));
+  if (isDateElement(el) || isTimeElement(el)) return formatted('d', el.value, dateOptions(el));
   switch (el.type) {
     case TYPE.literal:
       return JSON.stringify(el.value);
     case TYPE.argument:
-      return access(el.value);
+      return placed(el, el.value, access(el.value));
     case TYPE.pound:
-      return pound ?? '"#"';
+      // `#` is its plural's own value less its offset, formatted as a number.
+      if (pound === null) return '"#"';
+      return placed(el, pound.name, `h.n(${access(pound.name)}${pound.offset !== 0 ? ` - ${pound.offset}` : ''})`);
     case TYPE.select:
       return `h.s(${access(el.value)}, ${arms(el.options, hoisted, pound)})`;
     case TYPE.plural: {
-      // `#` is the plural's own value less its offset, formatted as a number.
+      // Read from MF2, a plural selects on the number as formatted, and on what `:integer` and `:percent` make of it.
+      const selection = selectionOf(el);
       const value = access(el.value);
-      const hash = `h.n(${value}${el.offset !== 0 ? ` - ${el.offset}` : ''})`;
-      return `h.p(${value}, ${el.offset}, ${el.pluralType === 'ordinal'}, ${arms(el.options, hoisted, hash)})`;
+      const on = selection?.value === 'round' ? `Math.round(${value})` : selection?.value === 'percent' ? `${value} * 100` : value;
+      const rules = selection === undefined ? '' : formatting(selection.options, selection.args, hoisted);
+      const own = { name: el.value, offset: el.offset };
+      return `h.p(${on}, ${el.offset}, ${el.pluralType === 'ordinal'}, ${arms(el.options, hoisted, own)}${rules})`;
     }
     case TYPE.tag:
       return `h.t(a, ${JSON.stringify(el.value)}, ${nodes(el.children, hoisted, pound)})`;
@@ -73,7 +120,8 @@ function node(el: MessageFormatElement, hoisted: Hoisted, pound: string | null):
 
 function message(ast: MessageFormatElement[], hoisted: Hoisted): string {
   const literal = staticLiteral(ast);
-  return literal === undefined ? `(a, h) => ${nodes(ast, hoisted, null)}` : JSON.stringify(literal);
+  if (literal !== undefined) return JSON.stringify(literal);
+  return `(a, h) => ${nodes(ast, hoisted, null)}`;
 }
 
 export interface CompiledLocale {

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 };
@@ -38,14 +39,39 @@ export interface WordLists {
   concepts?: Record<string, string>;
   /** Words that keep their capital inside a sentence-case string: product names, platforms. */
   properNouns?: string[];
+  /** What a path through menus or settings is written with, spaced: `›` by default, as in Settings › General. */
+  pathSeparator?: string;
 }
 
+type RuleSeverities = Partial<Record<CoreRule, Severity>> & Record<string, Severity>;
+
 export interface LintConfig extends WordLists {
   /** `recommended` (the default) checks shape; `strict` adds the word lists and rules of a house style guide. */
   extends?: 'recommended' | 'strict' | 'none';
   /** Rules of your own, as `<plugin>/<rule>`. Each takes the severity it gives itself under `extends`. */
   plugins?: Plugin[];
-  rules?: Partial<Record<CoreRule, Severity>> & Record<string, Severity>;
+  rules?: RuleSeverities;
+  /** Severities for one area's entries (a key's first segment) over `rules`: `{ native: { 'sentence-case': 'off' } }`. */
+  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.
+ */
+export interface NativeTarget {
+  language: 'rust' | 'swift' | 'kotlin';
+  /** The file written. */
+  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. */
+  name?: string;
+  /** Kotlin's package. */
+  package?: string;
 }
 
 export interface ProsebookConfig {
@@ -64,6 +90,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. */
@@ -81,6 +114,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[];
@@ -98,6 +133,7 @@ export interface ResolvedConfig {
   lock: string;
   source: string;
   messageFormat: 1 | 2;
+  isolate: Isolate;
   bundled: string[];
   pseudo: string | false;
   stale: 'use' | 'fallback';
@@ -106,10 +142,16 @@ export interface ResolvedConfig {
   require: ('context' | 'kind' | 'surface')[];
   kinds: Record<string, KindRule>;
   surfaces: Record<string, string>;
-  lint: { rules: Record<string, { rule: CheckRule; severity: Severity }> } & Required<WordLists>;
+  lint: {
+    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' };
+
 /** Typed config, for `prosebook.config.ts`. */
 export function defineConfig(config: ProsebookConfig): ProsebookConfig {
   return config;
@@ -141,6 +183,11 @@ export function resolveConfig(root: string, config: ProsebookConfig): ResolvedCo
   const lint = config.lint ?? {};
   const base = lint.extends ?? 'recommended';
   const strict = base === 'strict';
+  const rules = lintRules(lint);
+  for (const [area, severities] of Object.entries(lint.areas ?? {})) {
+    for (const name of Object.keys(severities))
+      if (!(name in rules)) throw new Error(`lint.areas.${area}.${name} is not a rule: name one of ${Object.keys(rules).join(', ')}`);
+  }
   return {
     root,
     catalog: at(config.catalog ?? 'copy/catalog'),
@@ -149,6 +196,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',
@@ -158,12 +206,19 @@ export function resolveConfig(root: string, config: ProsebookConfig): ResolvedCo
     kinds: config.kinds ?? DEFAULT_KINDS,
     surfaces: config.surfaces ?? DEFAULT_SURFACES,
     lint: {
-      rules: lintRules(lint),
+      rules,
+      areas: lint.areas ?? {},
       banned: [...(strict ? STRICT_LISTS.banned : []), ...(lint.banned ?? [])],
       spelling: { ...(strict ? STRICT_LISTS.spelling : {}), ...lint.spelling },
       concepts: { ...lint.concepts },
       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(', ')}`);
+      return { ...target, out: at(target.out), name: target.name ?? NATIVE_NAMES[target.language] };
+    }),
     scan: {
       dirs: (config.scan?.dirs ?? ['src']).map(at),
       extensions: config.scan?.extensions ?? ['.ts', '.tsx', '.js', '.jsx', '.mts', '.mjs'],