localewarden 0.1.1 → 0.2.0

package/README.md

@@ -11,7 +11,7 @@ npx localewarden             # translate new and changed strings
 npx localewarden check       # quality check, no API calls (use it in CI)
 ```
 
-Works with i18next, react-intl / FormatJS, vue-i18n, next-intl, ngx-translate and any other setup that keeps strings in JSON files. Uses any OpenAI-compatible API (OpenAI, OpenRouter, a local Ollama, ...).
+Works with i18next, react-intl / FormatJS, vue-i18n, next-intl, ngx-translate and any other setup that keeps strings in JSON files, with Flutter (`.arb` files) and with fastlane's App Store / Play Store metadata (`.txt` files). Uses any OpenAI-compatible API (OpenAI, OpenRouter, a local Ollama, ...).
 
 ## Why
 
@@ -22,15 +22,22 @@ Translating locale files with a language model is easy once. Keeping 20 language
 - **Models are inconsistent across batches.** French screens mix "tu" and "vous", Spanish copies English Title Case ("Configure Su Cuenta"), and Polish or Russian address every user as a man.
 - **Broken output ships silently.** A translated placeholder (`{heures}` instead of `{hours}`) shows raw braces in your app. A dropped `</strong>` breaks the layout. Stray Cyrillic letters end up in a Danish sentence.
 
-localewarden grew out of the translation pipeline of a production app that ships in 38 languages. Every rule and check in it exists because one of these failures happened in real output.
+localewarden grew out of the translation pipeline of a production app that ships in 38 languages. Every rule and check in it exists because one of these failures happened in real output. The checks are tuned against that app's real texts (UI, website, long-form learning content and store listings, about 165 MB) to report problems without flooding you with false alarms. On those texts they still find things that slipped through earlier pipelines: sections cut off after the English grew, stray letters from other alphabets, a trial notice left in English.
+
+## How it compares
+
+- **Translation platforms** (Crowdin, Lokalise, Phrase, Weblate) are hosted services with editors, translator workflows and review for teams. localewarden is a small CLI that runs in your repository and CI, with no account and no server. If you have professional translators, a platform fits better. If a model translates and people only fix the odd string, this is the lighter setup.
+- **"Translate my JSON with GPT" scripts** usually send every string on every run and overwrite whatever is there. localewarden keeps state, so it only sends what changed, keeps human fixes, and checks the output.
+- **Editor extensions** (such as i18n Ally) help you write and look up keys while coding. localewarden is about filling and maintaining 10 to 40 languages afterwards. The two work well together.
 
 ## What it does
 
 - **Translates only what changed.** It remembers a hash of each source string per language. New strings are translated. Changed strings are *revised*: the model gets the existing translation and changes only what the source change requires. Removed strings are deleted from every language.
 - **Protects hand edits.** If someone edited a translation, localewarden detects it, keeps it, and lists it for review. If the source of a hand-edited string changes later, the string is flagged instead of overwritten.
-- **Checks every result before writing it.** Broken placeholders, injected HTML or scripts, foreign alphabets, changed links, broken HTML and echoed source text are rejected (retried once, then left for the next run). Softer problems are retried and reported.
+- **Checks every result before writing it.** Broken placeholders, injected HTML or scripts, foreign alphabets, changed links, broken HTML and echoed source text are rejected (retried once, then left for the next run). Softer problems (too long, content missing, words left in English) are retried and reported.
 - **Consistent style per language.** It enforces formal or informal address per language (`du`/`Sie`, `tu`/`vous`, `ты`/`вы` and 16 more), uses sentence case where the language does, avoids gendered forms for "you", and applies local typography (French spacing, `92 %` in German, CJK quotation marks).
 - **Plural forms per language.** For i18next-style keys (`item_one`, `item_other`) it adds the forms a language needs but English lacks, such as Polish `_few` and `_many` or Arabic `_zero`, `_two`, `_few` and `_many` (CLDR plural rules).
+- **Data files and store listings.** Fields like `id`, `type` or `image` are copied instead of translated (`ignoreKeys`), and so are URLs, email addresses and file paths. Length limits per key (`maxLength`) are passed to the model and checked: App Store names, SEO titles, buttons.
 - **Glossary and protected names.** You choose fixed renderings ("Privacy Policy" -> "Politique de confidentialité") and names that must never be translated. The check accepts grammatical case endings.
 - **Quality check for CI.** `localewarden check` runs all checks without any API calls and exits non-zero on errors.
 - **Targeted repair.** `--fix-flagged` asks the model to fix only what the check flagged. The fix is accepted only if the problem is gone and little else changed.
@@ -79,7 +86,7 @@ es  Mantén vivas tus plantas sin tener que pensar en ello
 ja  何も考えなくても、植物を元気に保てます
 ```
 
-German uses "du" and French "vous", as configured. Spanish and French use sentence case, not the English Title Case. French has its space before "!". The hedge "tend to" survived, and so did the placeholders, the link and the brand name. The full example is in [`examples/basic`](examples/basic).
+German uses "du" and French "vous", as configured. Spanish and French use sentence case, not the English Title Case. French has its space before "!". The hedge "tend to" survived, and so did the placeholders, the link and the brand name. The full example is in [`examples/basic`](examples/basic). There are also examples for [Flutter ARB files](examples/flutter) and [App Store / Play Store texts with fastlane](examples/fastlane).
 
 ## Quick start
 
@@ -135,24 +142,28 @@ The same checks run in two places. Right after each model answer, a failed hard
 | --- | --- | --- |
 | `placeholder` | `{name}`, `{{count}}`, `%s`, `%1$d`, `%{x}`, `${x}`, `<0></0>` renamed, translated, added or dropped. ICU `plural`/`select` arguments are compared, while plural categories may differ per language. | error |
 | `unsafe` | HTML tags, attributes, event handlers or `javascript:`/`data:` URLs that the source does not have. Translations are often rendered as raw HTML, so this would be a script injection. | error |
-| `script` | Letters from an alphabet the language does not use ("刺激" in German), or a word that mixes Latin with Cyrillic/Greek lookalikes ("Вarda") | error |
+| `script` | Letters from an alphabet the language does not use ("刺激" in German), a word that mixes Latin with Cyrillic/Greek lookalikes ("Вarda"), or Simplified characters in Traditional Chinese (`zh-TW`) and the reverse | error |
 | `markup` | Changed link targets, different number of tags, unclosed or misnested tags, dropped list items | warning (broken tags and changed links: never written) |
 | `years` | A year from the source missing or changed (citations, dates) | warning |
 | `formality` | The other form of address than configured, both forms in one string, or masculine-only forms for "you" | warning |
+| `length` | Longer than the `maxLength` configured for the key | warning |
 | `titlecase` | English Title Case copied into a language that uses sentence case | warning |
 | `ampersand` | "&" in languages that write the word | warning |
 | `glossary` | A glossary rendering missing (case endings allowed), or a `doNotTranslate` name translated | warning |
 | `untranslated` | Identical to the source (prose of 3+ words; "OK" and names are fine) | warning |
-| `partial` | Source-language words left inside the translation, an untranslated bold lead-in, or a hedge that became certainty ("tend to" stated as fact) | warning |
+| `partial` | Source-language words left inside the translation, an untranslated bold lead-in, a hedge that became certainty ("tend to" stated as fact), a translation much shorter than its source (content cut off, or the source grew after it was translated), or sibling options that got the same translation although the source differs ("Rarely" and "Occasionally" both "Selten") | warning |
 
 ```bash
 npx localewarden check              # counts per language and check
 npx localewarden check -v           # with examples
 npx localewarden check --strict     # exit 1 on warnings too
 npx localewarden check --json       # for scripts
+npx localewarden check --fix        # repair placeholders with one possible fix, no API calls
 ```
 
-Approved hand edits are skipped, except for errors (placeholder, unsafe, script), which break the app either way.
+`--fix` repairs a translated placeholder when the source has exactly one and the translation renamed it (`{stunden}` back to `{hours}`). The file is edited in place, so its formatting stays as it is. Anything less certain is left for `--fix-flagged` or a person.
+
+Approved strings are skipped, except for errors (placeholder, unsafe, script), which break the app either way. You can approve any string, not only hand edits: `npx localewarden review --approve de:home.title` tells the check that a person looked at it (for example a pun on a brand name that is correct without the name), and runs leave it alone.
 
 ### In CI
 
@@ -240,6 +251,9 @@ npx localewarden review --release de:home.title   # hand it back: next run revis
 | `glossary` | `{}` | `{"fr": {"Terms of Service": "Conditions d'utilisation"}}` |
 | `termNotes` | `{}` | Meanings of ambiguous terms, sent only with strings that contain them: `{"snooze": "postpone a reminder"}` |
 | `instructions` | `{}` | Extra instructions per language, `"*"` for all: `{"es": "Use neutral Latin American Spanish."}` |
+| `ignoreKeys` | `[]` | Keys that are not text, copied from the source: `["id", "type", "**.sources.*"]`. `*` matches within a key segment, `**` across segments; a pattern without a dot matches the last segment anywhere. URLs, emails, file paths and numbers are always copied. |
+| `exclude` | `[]` | Source files to skip: `["locales/{lang}/nav.json"]` |
+| `maxLength` | `{}` | Character limits per key pattern: `{"**.meta.title": 60, "name": 30}`. The model is told the limit; longer results are retried once and reported by the `length` check. |
 | `placeholders` | built-in | Regular expressions (strings) that match your placeholders. Replaces the built-in list. |
 | `model` | `"gpt-5.4-mini"` | Any chat model your endpoint offers |
 | `baseUrl` | `"https://api.openai.com/v1"` | Any OpenAI-compatible endpoint |
@@ -251,6 +265,37 @@ npx localewarden review --release de:home.title   # hand it back: next run revis
 | `batchSize` | `20` | Strings per request (smaller for scripts that need many tokens) |
 | `stateDir` | `".localewarden"` | Where state and the review list live |
 
+### App Store and Play Store listings (fastlane)
+
+```json
+{
+  "sourceLanguage": "en-US",
+  "targetLanguages": ["de-DE", "fr-FR", "ja"],
+  "files": "fastlane/metadata/{lang}/*.txt",
+  "exclude": ["fastlane/metadata/{lang}/*_url.txt"],
+  "maxLength": { "name": 30, "subtitle": 30, "keywords": 100, "promotional_text": 170, "description": 4000 },
+  "termNotes": { "keywords": "a comma-separated keyword list for store search, not a sentence" }
+}
+```
+
+Each `.txt` file is one string, keyed by its file name, so the limits above apply to `name.txt`, `subtitle.txt` and so on.
+
+### Flutter (ARB)
+
+```json
+{ "files": "lib/l10n/app_{lang}.arb", "targetLanguages": ["de", "fr", "pt_BR"] }
+```
+
+Metadata (`@@locale`, `@key` descriptions and placeholders) is copied, not translated, and `@@locale` is set to the target language. ICU plurals and selects keep their structure, and each language gets the plural categories it needs.
+
+### Data files
+
+For content JSON with ids, types and links, list the non-text keys:
+
+```json
+{ "files": "content/**/*.{lang}.json", "ignoreKeys": ["id", "type", "category", "image", "**.sources.*"] }
+```
+
 ### Other providers
 
 ```json
@@ -268,7 +313,7 @@ Small local models make noticeably more mistakes. The checks catch the mechanica
 ```text
 localewarden [translate]  --dry-run --lang de,fr --fix-flagged --retranslate-all
                           --overwrite-manual --max-tokens <n> --verbose
-localewarden check        --lang de,fr --verbose --limit <n> --strict --json
+localewarden check        --lang de,fr --verbose --limit <n> --strict --json --fix
 localewarden review       --all --approve <sel>... --release <sel>...
 localewarden init
 Global: --config <path>  --help  --version
@@ -300,7 +345,7 @@ Translations are treated as untrusted: any markup the source does not have is bl
 
 ## Limitations
 
-- JSON only (nested objects, arrays, flat keys). YAML, PO, XLIFF and ARB are not supported yet.
+- JSON (nested objects, arrays, flat keys), Flutter ARB and plain `.txt` files. YAML, PO and XLIFF are not supported yet.
 - The checks catch mechanical problems, not every wrong meaning. Have a native speaker look at important screens, then approve their edits with `review`.
 - Rules for form of address, gender and typography exist for the languages listed above. Other languages are translated with the general rules.
 - A run that is interrupted keeps everything written so far. Unwritten strings are picked up on the next run.

package/dist/checks.d.ts

@@ -1,4 +1,5 @@
 import type { Config } from './config.js';
+import { Scope } from './scope.js';
 /**
  * Deterministic quality checks. No API calls, so they can run in CI on every commit.
  *
@@ -11,14 +12,16 @@ import type { Config } from './config.js';
  *   years         a year from the source is missing or changed (citations, dates)
  *   formality     the other form of address than configured, or both mixed;
  *                 masculine-only forms for "you" when genderNeutral is on
+ *   length        longer than the maxLength configured for the key
  *   titlecase     English Title Case copied into a sentence-case language
  *   ampersand     "&" in a language that writes the word
  *   glossary      a glossary rendering or a doNotTranslate name is missing
  *   untranslated  identical to the source (prose of 3+ words)
  *   partial       source-language words left inside an otherwise translated string,
- *                 or a dropped hedge ("tend to" stated as certain)
+ *                 a dropped hedge ("tend to" stated as certain), or a translation much
+ *                 shorter than its source (content missing or cut off)
  */
-export type CheckName = 'placeholder' | 'unsafe' | 'script' | 'markup' | 'years' | 'formality' | 'titlecase' | 'ampersand' | 'glossary' | 'untranslated' | 'partial';
+export type CheckName = 'placeholder' | 'unsafe' | 'script' | 'markup' | 'years' | 'formality' | 'length' | 'titlecase' | 'ampersand' | 'glossary' | 'untranslated' | 'partial';
 export declare const CHECKS: CheckName[];
 export declare const ERROR_CHECKS: Set<CheckName>;
 /** Checks a targeted repair (--fix-flagged) may try to fix. */
@@ -30,7 +33,14 @@ export interface Issue {
 export declare class Checker {
     readonly config: Config;
     readonly placeholderRe: RegExp;
+    readonly scope: Scope;
+    /** Words of termNotes and doNotTranslate: terms a translation may keep in the source language. */
+    readonly keptWords: Set<string>;
     constructor(config: Config);
+    /** The text without doNotTranslate names, which stay the same in every language. */
+    withoutNames(text: string): string;
+    /** "62 characters, limit 60", or null. */
+    tooLong(key: string, text: string): string | null;
     get englishSource(): boolean;
     placeholdersMatch(key: string, source: string, text: string): boolean;
     placeholderNote(source: string, text: string): string;
@@ -50,6 +60,8 @@ export declare class Checker {
 }
 /** Non-Latin scripts each language is written in. Latin is always allowed (names, codes). */
 export declare const NATIVE_SCRIPTS: Record<string, string[]>;
+/** Simplified characters in Traditional Chinese text, or the reverse (2+ distinct ones). */
+export declare function wrongChineseScript(lang: string, text: string): string | null;
 /** Why `text` contains letters that cannot belong to `lang`, or null. */
 export declare function foreignScript(lang: string, text: string): string | null;
 /**
@@ -82,3 +94,8 @@ export declare function isUnchangedProse(source: string, text: string, placehold
  * allowed) copied into the translation, or null.
  */
 export declare function sourceRun(source: string, text: string): string | null;
+/**
+ * A translation with a fraction of the source's length lost content: cut off by the model, or
+ * the source grew after it was translated. Markup and placeholders are not counted.
+ */
+export declare function muchShorter(lang: string, source: string, text: string): string | null;

package/dist/checks.js

@@ -1,6 +1,7 @@
 import { placeholderRegExp, placeholderSignature, placeholdersMatch } from './placeholders.js';
 import { GENDERED_FORMS, NO_AMPERSAND_LANGUAGES, SENTENCE_CASE_LANGUAGES, formalityRule, registerFor, withoutQuotedSpeech, } from './style.js';
-import { baseLanguage, escapeRegExp } from './util.js';
+import { Scope } from './scope.js';
+import { baseLanguage, escapeRegExp, isTraditionalChinese } from './util.js';
 export const CHECKS = [
     'placeholder',
     'unsafe',
@@ -8,6 +9,7 @@ export const CHECKS = [
     'markup',
     'years',
     'formality',
+    'length',
     'titlecase',
     'ampersand',
     'glossary',
@@ -21,6 +23,7 @@ export const FIXABLE_CHECKS = new Set([
     'markup',
     'years',
     'formality',
+    'length',
     'titlecase',
     'ampersand',
     'glossary',
@@ -29,9 +32,24 @@ export const FIXABLE_CHECKS = new Set([
 export class Checker {
     config;
     placeholderRe;
+    scope;
+    /** Words of termNotes and doNotTranslate: terms a translation may keep in the source language. */
+    keptWords;
     constructor(config) {
         this.config = config;
         this.placeholderRe = placeholderRegExp(config.placeholders);
+        this.scope = new Scope(config);
+        this.keptWords = new Set([...Object.keys(config.termNotes), ...config.doNotTranslate].flatMap(term => term.toLowerCase().split(/[^\p{L}]+/u)).filter(Boolean));
+    }
+    /** The text without doNotTranslate names, which stay the same in every language. */
+    withoutNames(text) {
+        return this.config.doNotTranslate.reduce((value, name) => value.split(name).join(' '), text);
+    }
+    /** "62 characters, limit 60", or null. */
+    tooLong(key, text) {
+        const max = this.scope.maxLength(key);
+        const length = [...text].length;
+        return max !== undefined && length > max ? `${length} characters, limit ${max}` : null;
     }
     get englishSource() {
         return baseLanguage(this.config.sourceLanguage) === 'en';
@@ -88,16 +106,22 @@ export class Checker {
             this.config.sentenceCase &&
             SENTENCE_CASE_LANGUAGES.has(base) &&
             isEnglishTitleCase(source)) {
-            const capitals = midCapitals(text, source, this.config.doNotTranslate);
+            const capitals = midCapitals(text, source, this.config.doNotTranslate, lang);
             if (capitals.length >= (source.trim().split(/\s+/).length <= 3 ? 1 : 2)) {
                 add('titlecase', `capitalised: ${capitals.join(' ')}`);
             }
         }
+        const long = this.tooLong(key, text);
+        if (long)
+            add('length', long);
         const ampersands = (value) => value.split(' & ').length - 1;
         if (NO_AMPERSAND_LANGUAGES.has(base) && ampersands(text) > ampersands(source))
             add('ampersand');
-        if (isUnchangedProse(source, text, this.placeholderRe))
+        if (isUnchangedProse(this.withoutNames(source), this.withoutNames(text), this.placeholderRe))
             add('untranslated');
+        const short = muchShorter(lang, source, text);
+        if (short)
+            add('partial', short);
         if (this.englishSource && text !== source) {
             const copied = sourceRun(source, text);
             if (copied)
@@ -105,7 +129,7 @@ export class Checker {
             const lead = !copied ? sourceBoldLeadIn(source, text, this.config.doNotTranslate) : null;
             if (lead)
                 add('partial', `bold lead-in still in the source language: "${lead}"`);
-            const mixed = !copied && !lead ? englishInNativeScript(lang, source, text, this.placeholderRe) : null;
+            const mixed = !copied && !lead ? englishInNativeScript(lang, source, text, this.placeholderRe, this.keptWords) : null;
             if (mixed)
                 add('partial', mixed);
             if (droppedHedge(lang, source, text)) {
@@ -127,7 +151,7 @@ export class Checker {
         const placeholders = this.placeholdersMatch(key, source, text) ? null : `placeholder mismatch: ${this.placeholderNote(source, text)}`;
         const foreign = foreignScript(this.config.sourceLanguage, source) ? null : foreignScript(lang, text);
         const links = hrefSignature(source) !== hrefSignature(text) ? `links changed: [${hrefSignature(source)}] -> [${hrefSignature(text)}]` : null;
-        const echoed = isUnchangedProse(source, text, this.placeholderRe) ? 'returned the source text unchanged' : null;
+        const echoed = isUnchangedProse(this.withoutNames(source), this.withoutNames(text), this.placeholderRe) ? 'returned the source text unchanged' : null;
         const broken = brokenMarkup(source) ? null : brokenMarkup(text);
         const boldMarkers = (value) => (value.match(/\*\*/g) ?? []).length % 2;
         const brokenBold = boldMarkers(text) === 1 && boldMarkers(source) === 0 ? 'unbalanced ** markers' : null;
@@ -135,7 +159,7 @@ export class Checker {
         const hard = placeholders ?? unsafeAdditions(source, text) ?? foreign ?? links ?? echoed ?? broken ?? brokenBold ?? droppedBullets(source, text) ?? leaked;
         const tags = tagCount(source) !== tagCount(text) ? `${tagCount(source)} tags in the source, got ${tagCount(text)}` : null;
         const copied = this.englishSource && text !== source ? sourceRun(source, text) : null;
-        return { hard, soft: hard ?? tags ?? yearDifference(source, text) ?? (copied ? `source text left in: "${copied}"` : null) };
+        return { hard, soft: hard ?? this.tooLong(key, text) ?? muchShorter(lang, source, text) ?? tags ?? yearDifference(source, text) ?? (copied ? `source text left in: "${copied}"` : null) };
     }
 }
 // ---------------------------------------------------------------------------------------
@@ -188,8 +212,25 @@ const LATIN_LANGUAGES = new Set([
 ]);
 // Latin glued to a lookalike alphabet inside one word ("Вarda": Cyrillic В + Latin arda).
 const HOMOGLYPH_WORD = /(?=\p{L}*\p{Script=Latin})(?=\p{L}*[\p{Script=Cyrillic}\p{Script=Greek}])\p{L}+/u;
+// Common characters that exist in only one of the two Chinese scripts (pairs at the same index).
+const SIMPLIFIED_ONLY = '们这说时会来对个为发过还让现实动门问间题体关点应开东头书长见认学页电话语读写买卖钱网设计习惯觉机帮爱车钟儿气无边进选择检样经验数据项结种类业务环节';
+const TRADITIONAL_ONLY = '們這說時會來對個為發過還讓現實動門問間題體關點應開東頭書長見認學頁電話語讀寫買賣錢網設計習慣覺機幫愛車鐘兒氣無邊進選擇檢樣經驗數據項結種類業務環節';
+/** Simplified characters in Traditional Chinese text, or the reverse (2+ distinct ones). */
+export function wrongChineseScript(lang, text) {
+    if (baseLanguage(lang) !== 'zh')
+        return null;
+    const traditional = isTraditionalChinese(lang);
+    const wrong = traditional ? SIMPLIFIED_ONLY : TRADITIONAL_ONLY;
+    const found = [...new Set([...text].filter(ch => wrong.includes(ch)))];
+    return found.length >= 2
+        ? `${traditional ? 'Simplified' : 'Traditional'} Chinese characters in ${lang}: ${found.slice(0, 6).join('')}`
+        : null;
+}
 /** Why `text` contains letters that cannot belong to `lang`, or null. */
 export function foreignScript(lang, text) {
+    const chinese = wrongChineseScript(lang, text);
+    if (chinese)
+        return chinese;
     const base = baseLanguage(lang);
     const native = NATIVE_SCRIPTS[base] ?? (LATIN_LANGUAGES.has(base) ? [] : null);
     if (native === null)
@@ -218,13 +259,18 @@ const unescapeEntities = (text) => text
     .replace(/&quot;|&#0*34;|&#x0*22;/gi, '"')
     .replace(/&#0*39;|&#x0*27;|&apos;/gi, "'")
     .replace(/&colon;|&#0*58;|&#x0*3a;/gi, ':');
-/** Tag names, in lower case. Numbered <0> tags (react-i18next) are placeholders, not HTML. */
-const tagNames = (html) => new Set([...html.matchAll(/<\/?([a-z][\w-]*)/gi)].map(m => m[1].toLowerCase()));
+// HTML elements, so text in angle brackets ("<minutes>", "<your name>") is not taken for markup.
+const HTML_ELEMENTS = new Set(('a abbr address area article aside audio b base bdi bdo blockquote body br button canvas caption cite code col colgroup data datalist dd del details dfn dialog div dl dt em embed fieldset figcaption figure footer form frame frameset h1 h2 h3 h4 h5 h6 head header hr html i iframe img input ins kbd label legend li link main map mark math meta meter nav noscript object ol optgroup option output p param picture pre progress q rp rt ruby s samp script section select slot small source span strong style sub summary sup svg table tbody td template textarea tfoot th thead time title tr track u ul var video wbr animate foreignobject use image set').split(' '));
+/** HTML element names, in lower case. Numbered <0> tags (react-i18next) are placeholders. */
+const tagNames = (html) => new Set([...html.matchAll(/<\/?([a-z][\w-]*)/gi)].map(m => m[1].toLowerCase()).filter(tag => HTML_ELEMENTS.has(tag)));
 const TEXT_ATTRIBUTES = new Set(['title', 'alt', 'aria-label', 'aria-description', 'placeholder']);
 /** Every attribute as "name=value" (value without quotes), in lower case. */
 const attributes = (html) => {
     const found = new Set();
-    for (const [, inner] of html.matchAll(/<[a-z][\w-]*\s([^>]*)>?/gi)) {
+    for (const [, tag, inner] of html.matchAll(/<([a-z][\w-]*)\s([^>]*)>?/gi)) {
+        // "<dakika 20)" (sw: under 20 minutes) is text, not a tag.
+        if (!HTML_ELEMENTS.has(tag.toLowerCase()))
+            continue;
         for (const [, name, v1, v2, v3] of inner.matchAll(/([^\s"'=<>\/]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+)))?/g)) {
             const attr = name.toLowerCase();
             // Text attributes are translated along with the visible text; only their presence counts.
@@ -234,7 +280,10 @@ const attributes = (html) => {
     }
     return found;
 };
-const DANGEROUS_URL = /(?:javascript|vbscript|data)\s*:/gi;
+// Script URLs in a link target or Markdown link. Plain "data:" in prose is a word (pt/it "date:").
+const DANGEROUS_URL = /(?:(?:href|src|action|formaction|xlink:href|poster|background)\s*=\s*["']?|\]\()\s*(?:javascript|vbscript|data)\s*:/gi;
+// Formatting a translator may add for emphasis or a title (no attributes): a markup warning, not a risk.
+const HARMLESS_TAGS = new Set(['br', 'i', 'b', 'em', 'strong', 'u', 's', 'sub', 'sup', 'small', 'mark', 'q', 'cite']);
 /**
  * Markup the translation adds that the source does not have: a new tag type, a new or changed
  * attribute, an event handler or a script URL. Translations are often rendered as raw HTML
@@ -244,7 +293,7 @@ const DANGEROUS_URL = /(?:javascript|vbscript|data)\s*:/gi;
 export function unsafeAdditions(source, text) {
     const [src, out] = [unescapeEntities(source), unescapeEntities(text)];
     const srcTags = tagNames(src);
-    const newTags = [...tagNames(out)].filter(tag => !srcTags.has(tag) && tag !== 'br');
+    const newTags = [...tagNames(out)].filter(tag => !srcTags.has(tag) && !HARMLESS_TAGS.has(tag));
     if (newTags.length > 0)
         return `HTML tag not in the source: <${newTags.join('>, <')}>`;
     const srcAttrs = attributes(src);
@@ -312,7 +361,8 @@ const asciiDigits = (text) => text.replace(/\p{Nd}/gu, ch => {
 export function yearDifference(source, text) {
     // Decades ("the 2020s") are written in words or with suffixes in many languages.
     const decades = new Set(asciiDigits(source).match(/(?<!\d)(?:19|20)\d0(?=['’]?s\b)/g) ?? []);
-    const years = (value) => (asciiDigits(value).match(/(?<!\d)(?:19|20)\d\d(?!\d)/g) ?? []).filter(y => !decades.has(y)).sort().join(',');
+    // "1,900", "1.900" and "1 900" are numbers, not years: drop thousands separators first.
+    const years = (value) => (asciiDigits(value).replace(/(\d)[,.\u00a0\u202f ](?=\d{3}(?!\d))/g, '$1').match(/(?<!\d)(?:19|20)\d\d(?!\d)/g) ?? []).filter(y => !decades.has(y)).sort().join(',');
     const [a, b] = [years(source), years(text)];
     return a === b ? null : `source years [${a}], got [${b}]`;
 }
@@ -359,20 +409,25 @@ export function keptNameMissing(name, source, text) {
 // ---------------------------------------------------------------------------------------
 // Title case
 const COMMON_NAMES = new Set(['iOS', 'Android', 'Apple', 'Google', 'iPhone', 'iPad', 'Mac', 'Windows', 'Linux', 'AI', 'API', 'URL', 'PDF', 'FAQ', 'OK']);
-function midCapitals(text, source, names) {
+// Polish capitalises "you" pronouns as a sign of respect ("W Twoim planie"): correct, not Title Case.
+const POLISH_RESPECT = /^(?:Ty|Twój|Twoja|Twoje|Twojego|Twojej|Twoim|Twoją|Twoich|Twoimi|Ciebie|Cię|Tobie|Tobą|Wy|Wasz|Wasza|Wasze|Wam|Was|Wami)$/u;
+function midCapitals(text, source, names, lang = '') {
     const allowed = new Set([...COMMON_NAMES, ...names.flatMap(name => name.split(/\s+/))]);
     const isName = (word) => allowed.has(word) ||
         new RegExp(`(?<!\\p{L})${escapeRegExp(word)}(?!\\p{L})`, 'u').test(source) ||
         [...allowed].some(name => name.length >= 4 && word.startsWith(name));
     return text
-        .split(/[.!?:—–\n•|]+/)
+        // Commas and brackets start segments too: list items ("SMART: Specific, Measurable") and
+        // bracketed words ("Customize (Optional)") are capitalised in many languages.
+        .split(/[.!?:—–\n•|,;()]+/)
         .flatMap(segment => {
         const words = segment.trim().split(/\s+/);
         const first = words.findIndex(word => /\p{L}/u.test(word));
         return first === -1 ? [] : words.slice(first + 1);
     })
         .map(word => word.replace(/^[^\p{L}]+|[^\p{L}]+$/gu, ''))
-        .filter(word => word.length >= 3 && /^\p{Lu}\p{Ll}/u.test(word) && !isName(word));
+        .filter(word => word.length >= 3 && /^\p{Lu}\p{Ll}/u.test(word) && !isName(word))
+        .filter(word => !(baseLanguage(lang) === 'pl' && POLISH_RESPECT.test(word)));
 }
 function isEnglishTitleCase(source) {
     const rest = source
@@ -430,26 +485,34 @@ function sourceBoldLeadIn(source, text, names) {
     for (const lead of bold(source)) {
         if (lead.length <= 15 || !/\p{Ll}{3}/u.test(lead) || names.some(name => lead.includes(name)))
             continue;
+        // Only capitalised words ("Apple App Store:", "Google Play"): a name, kept on purpose.
+        if (lead.split(/\s+/).every(word => !/\p{L}/u.test(word) || /^[^\p{L}]*\p{Lu}/u.test(word)))
+            continue;
         if (translated.has(lead))
             return lead;
     }
     return null;
 }
+const ICU_HEADER = /\{\s*[\w.-]+\s*,\s*(?:plural|select|selectordinal)\s*,/g;
+const ICU_HEADER_TEST = /\{\s*[\w.-]+\s*,\s*(?:plural|select|selectordinal)\s*,/;
 // Loanwords commonly written in Latin script inside non-Latin text.
 const LATIN_LOANWORDS = new Set(['email', 'online', 'offline', 'emoji', 'smartphone', 'podcast', 'podcasts', 'wifi', 'blog', 'login', 'like', 'likes']);
 /** Source-language words left inside a non-Latin-script translation ("Settings → Privacy"). */
-function englishInNativeScript(lang, source, text, placeholderRe) {
+function englishInNativeScript(lang, source, text, placeholderRe, allowed) {
     const base = baseLanguage(lang);
     // Greek writes many anglicisms in Latin script; not checked.
     if (!NATIVE_SCRIPTS[base] || base === 'el' || base === 'sr' || text === source)
         return null;
     const strip = (value) => withoutUrls(value.replace(/[\w.+-]+@[\w.-]+/g, ' ').replace(/<[^>]+>/g, ' '))
+        // ICU syntax ("{count, plural, one {…} other {…}}") is code, not English text.
+        .replace(ICU_HEADER, ' ')
+        .replace(ICU_HEADER_TEST.test(value) ? /(?:^|[\s}])(?:zero|one|two|few|many|other|=\d+|[\w-]+)\s*(?=\{)/g : /$^/g, ' ')
         .replace(placeholderRe, ' ')
         .replace(/[(（][^)）]*[)）]/g, ' ')
         .replace(/["“„«「『‘'][^"”“»」』’']*["”“»」』’']/g, ' ');
     const sourceWords = new Set(strip(source).match(/\b[a-z]{4,}\b/g) ?? []);
     const left = [
-        ...new Set((strip(text).match(/(?<![\p{L}-])[a-z]{4,}(?![\p{L}])/gu) ?? []).filter(word => sourceWords.has(word) && !LATIN_LOANWORDS.has(word))),
+        ...new Set((strip(text).match(/(?<![\p{L}-])[a-z]{4,}(?![\p{L}])/gu) ?? []).filter(word => sourceWords.has(word) && !LATIN_LOANWORDS.has(word) && !allowed.has(word))),
     ];
     const menu = /\b[A-Z][a-z]+ → [A-Z][a-z]+/.exec(text);
     if (menu && source.includes(menu[0]))
@@ -478,9 +541,22 @@ const HEDGE_MARKERS = {
     cs: /tendenc|obvykle|často|zpravidla|většinou|bývá|sklon|snadno|častěji|mív/iu,
     sk: /tendenc|obvykle|často|zvyčajne|väčšinou|býva|sklon|ľahko|častejšie|zvyk|skôr/iu,
     el: /τείν|συχνά|συνήθως|τάση|συνήθ|εύκολα|συχνότερα/iu,
-    fi: /taipu|usein|yleensä|tapaa|tavallisesti|tuppaa|tyypillisesti|taipumus|helposti|useimmiten|herkästi/iu,
+    fi: /taipu|tapana|usein|yleensä|tapaa|tavallisesti|tuppaa|tyypillisesti|taipumus|helposti|useimmiten|herkästi/iu,
     ca: /tendeix|tendència|sol|sovint|generalment|acostum|normalment|fàcilment|freqüent/iu,
 };
+// Chinese, Japanese and Korean need far fewer characters than English; Thai has no spaces.
+const COMPACT_SCRIPTS = new Set(['zh', 'ja', 'ko']);
+/**
+ * A translation with a fraction of the source's length lost content: cut off by the model, or
+ * the source grew after it was translated. Markup and placeholders are not counted.
+ */
+export function muchShorter(lang, source, text) {
+    const visible = (value) => [...value.replace(/<[^>]+>|\{\{?[^{}]*\}?\}/g, '').replace(/\s+/g, ' ').trim()].length;
+    const [a, b] = [visible(source), visible(text)];
+    // Real translations from English rarely drop below 60% (Chinese/Japanese/Korean: 25%).
+    const min = COMPACT_SCRIPTS.has(baseLanguage(lang)) ? 0.2 : 0.5;
+    return a >= 200 && b < a * min ? `translation much shorter than the source (${b} of ${a} characters): content missing?` : null;
+}
 function droppedHedge(lang, source, text) {
     const markers = HEDGE_MARKERS[baseLanguage(lang)];
     return Boolean(markers) && /\btends? to\b/i.test(source) && !markers.test(text);

package/dist/cli.js

@@ -5,7 +5,7 @@ import { ConfigError, CONFIG_FILE, loadConfig } from './config.js';
 import { CHECKS } from './checks.js';
 import { findSourceFiles } from './files.js';
 import { isReasoningModel } from './llm.js';
-import { checkProject, summaryTable } from './project.js';
+import { checkProject, fixPlaceholders, summaryTable } from './project.js';
 import { listReview, updateReview } from './review.js';
 import { run } from './translate.js';
 const HELP = `localewarden - incremental AI translation for JSON locale files
@@ -31,6 +31,7 @@ Check options:
   --limit <n>            findings shown per check with --verbose (default 20)
   --strict               exit 1 on warnings too (default: only placeholder/script errors)
   --json                 print findings as JSON
+  --fix                  repair placeholders with exactly one possible fix ({heures} -> {hours})
 
 Review options:
   --all                  include approved entries
@@ -93,6 +94,8 @@ const LAYOUTS = [
     'src/assets/i18n/{lang}.json',
     'i18n/{lang}.json',
     'lang/{lang}.json',
+    'lib/l10n/app_{lang}.arb',
+    'lib/l10n/intl_{lang}.arb',
 ];
 function init() {
     const file = path.resolve(CONFIG_FILE);
@@ -180,7 +183,15 @@ async function translateCommand(args) {
 function checkCommand(args) {
     const config = loadConfig(args.values.get('--config')?.[0]);
     const languages = languagesArg(args) ?? config.targetLanguages;
-    const findings = checkProject(config, languages);
+    let findings = checkProject(config, languages);
+    if (args.flags.has('--fix')) {
+        const fixed = fixPlaceholders(config, findings);
+        for (const f of fixed)
+            console.log(`fixed [${f.lang}] ${f.file} ${f.key}: ${f.text}`);
+        console.log(`${fixed.length} placeholder(s) repaired.\n`);
+        if (fixed.length > 0)
+            findings = checkProject(config, languages);
+    }
     if (args.flags.has('--json')) {
         console.log(JSON.stringify(findings, null, 2));
     }
@@ -200,7 +211,17 @@ function checkCommand(args) {
                     console.log(`  ... ${items.length - limit} more (--limit <n>)`);
             }
         }
-        const errors = findings.filter(f => f.severity === 'error').length;
+        // Errors fail CI, so show them even without --verbose.
+        const errorItems = findings.filter(f => f.severity === 'error');
+        if (!args.flags.has('--verbose') && errorItems.length > 0) {
+            console.log('\nErrors:');
+            for (const f of errorItems.slice(0, 20)) {
+                console.log(`  [${f.lang}] ${f.file} ${f.key} - ${f.check}${f.note ? `: ${f.note}` : ''}`);
+            }
+            if (errorItems.length > 20)
+                console.log(`  ... ${errorItems.length - 20} more (--verbose)`);
+        }
+        const errors = errorItems.length;
         console.log(`\n${errors} error(s), ${findings.length - errors} warning(s).${findings.length && !args.flags.has('--verbose') ? ' Details: --verbose' : ''}`);
     }
     const errors = findings.some(f => f.severity === 'error');

package/dist/config.d.ts

@@ -24,6 +24,16 @@ export interface Config {
     termNotes: Record<string, string>;
     /** Extra instructions per language; "*" applies to every language. */
     instructions: Record<string, string>;
+    /**
+     * Keys whose values are not text (ids, types, image paths). Copied from the source, never
+     * translated. "*" matches within one key segment, "**" across segments; a pattern without
+     * a dot matches the last segment anywhere ("id" matches "steps.2.id").
+     */
+    ignoreKeys: string[];
+    /** Source files to skip, as path patterns relative to the config ("locales/{lang}/nav.json"). */
+    exclude: string[];
+    /** Maximum characters per key pattern: { "**.meta.title": 60 }. Told to the model and checked. */
+    maxLength: Record<string, number>;
     /** Regular expressions (as strings) that match placeholders. Replaces the built-in list. */
     placeholders?: string[];
     model: string;

package/dist/config.js

@@ -10,6 +10,9 @@ export const DEFAULTS = {
     glossary: {},
     termNotes: {},
     instructions: {},
+    ignoreKeys: [],
+    exclude: [],
+    maxLength: {},
     model: 'gpt-5.4-mini',
     baseUrl: 'https://api.openai.com/v1',
     apiKeyEnv: 'OPENAI_API_KEY',
@@ -65,6 +68,16 @@ export function resolveConfig(raw, root) {
         !Object.values(config.glossary).every(isStringRecord)) {
         fail('"glossary" must map languages to { "source term": "required rendering" } objects.');
     }
+    for (const key of ['ignoreKeys', 'exclude']) {
+        if (!Array.isArray(config[key]) || !config[key].every(p => typeof p === 'string' && p !== '')) {
+            fail(`"${key}" must be a list of patterns.`);
+        }
+    }
+    if (!config.maxLength ||
+        typeof config.maxLength !== 'object' ||
+        !Object.values(config.maxLength).every(n => Number.isInteger(n) && n > 0)) {
+        fail('"maxLength" must map key patterns to positive whole numbers, e.g. { "**.meta.title": 60 }.');
+    }
     if (!isStringRecord(config.termNotes))
         fail('"termNotes" must map terms to explanations.');
     if (!isStringRecord(config.instructions))

package/dist/files.d.ts

@@ -10,6 +10,18 @@ export interface LocaleFile {
  * Supported: {lang} (once or more), * within one path segment, and **\/ for any depth.
  */
 export declare function findSourceFiles(root: string, pattern: string, sourceLanguage: string): LocaleFile[];
+/**
+ * Key pattern -> RegExp. "*" matches within one segment, "**" any number of segments. A
+ * pattern without a dot matches the last segment anywhere ("id" matches "steps.2.id").
+ */
+export declare function keyPattern(pattern: string): RegExp;
+/** Path pattern -> RegExp ("*" within a folder, "**" across folders, {lang} as written). */
+export declare function pathPattern(pattern: string): RegExp;
+/**
+ * Values that are not text and stay as they are in every language: URLs, email addresses,
+ * file paths and plain numbers or codes without spaces.
+ */
+export declare function isLiteralValue(value: string): boolean;
 export type JsonValue = string | number | boolean | null | JsonValue[] | {
     [key: string]: JsonValue;
 };
@@ -48,5 +60,14 @@ export interface JsonFormat {
 /** Indentation and final newline of an existing JSON text (2 spaces by default). */
 export declare function detectFormat(text: string | null): JsonFormat;
 export declare function serialize(value: JsonValue, format: JsonFormat): string;
+/**
+ * Parses a locale file. A .txt file (fastlane metadata: description.txt, keywords.txt) is one
+ * string, keyed by its file name, so maxLength patterns like "keywords" apply to it.
+ */
+export declare function parseDoc(rel: string, text: string): JsonValue;
+/** Flutter ARB metadata ("@@locale", "@title": { description, placeholders }): not text. */
+export declare const isArbMetadata: (rel: string, key: string) => boolean;
+/** Text of a locale file, or null when a .txt file has no value to write. */
+export declare function serializeDoc(rel: string, doc: JsonValue, format: JsonFormat): string | null;
 export declare function readText(file: string): string | null;
 export declare function writeText(file: string, text: string): void;