champollion 0.3.3 → 0.4.0

package/lib/redo.js

@@ -0,0 +1,95 @@
+/**
+ * --redo / --fresh: one way to say "translate this again".
+ *
+ * Six flags had grown up around re-translation, each with its own cache
+ * rule (--force, --force-keys, --force-content, --retranslate, --no-tm,
+ * --fresh-on-model-change), and people could not tell which one cost money.
+ * Two words now carry the whole idea:
+ *
+ *   --redo <scope>   queue this again. The cache still serves anything it
+ *                    already holds (gate-checked), so a redo is cheap.
+ *                    all | keys:<k1,k2> | content | files:<glob> | gaps
+ *                    (gaps: every plural message on disk that lacks a form
+ *                    its language uses for ordinary counts — asked from the
+ *                    model, never the cache, which holds the incomplete
+ *                    answer; lib/plural-gap-redo.js)
+ *                    (repeatable: --redo keys:a.b --redo files:docs/**)
+ *   --fresh          do not use the cache: what is queued is paid for again.
+ *
+ * `--redo files:X --fresh` is exactly the old `--retranslate X`. The old
+ * flags still work as written; this module only translates the new words
+ * into them, so sync itself has one set of semantics.
+ * --fresh-on-model-change stays separate: it is a policy for model
+ * switches, not a redo.
+ */
+
+const SCOPES = 'all | keys:<k1,k2> | content | files:<glob> | gaps';
+
+/**
+ * Split a comma-separated key list, honouring `\,` for a comma INSIDE a key.
+ * gettext keys are whole sentences ("Welcome, %(name)s"), so a plain split
+ * made them impossible to name in --force-keys / --redo keys:.
+ * @param {string} list
+ * @returns {string[]}
+ */
+export function splitKeyList(list) {
+  return String(list ?? '')
+    .split(/(?<!\\),/)
+    .map((k) => k.replace(/\\,/g, ',').trim())
+    .filter(Boolean);
+}
+
+/** Inverse of splitKeyList for one key. */
+const escapeKey = (k) => k.replace(/,/g, '\\,');
+
+/**
+ * Rewrite args in place. Returns an error message, or null.
+ * @param {object} args parsed CLI args
+ * @returns {string|null}
+ */
+export function applyRedo(args) {
+  const scopes = [].concat(args.redo || []).map((s) => String(s).trim()).filter(Boolean);
+  if (args.redo !== undefined && scopes.length === 0) {
+    return `--redo needs a scope: ${SCOPES}`;
+  }
+  const fresh = Boolean(args.fresh);
+  let keyScope = false;
+
+  for (const scope of scopes) {
+    const m = /^(all|content|keys|files|gaps)(?::(.*))?$/.exec(scope);
+    if (!m) return `--redo ${scope}: unknown scope. Use ${SCOPES}`;
+    const [, kind, value] = m;
+    if ((kind === 'keys' || kind === 'files') && !value) {
+      return `--redo ${kind}: needs a value, e.g. --redo ${kind === 'keys' ? 'keys:nav.home,nav.about' : 'files:docs/intro.md'}`;
+    }
+    if ((kind === 'all' || kind === 'content' || kind === 'gaps') && value) {
+      return `--redo ${kind} takes no value (got "${scope}")`;
+    }
+    if (kind === 'all') {
+      args.force = true;
+      keyScope = true;
+    } else if (kind === 'keys') {
+      const keys = [...splitKeyList(args['force-keys']), ...splitKeyList(value)];
+      args['force-keys'] = keys.map(escapeKey).join(',');
+      keyScope = true;
+    } else if (kind === 'gaps') {
+      args['redo-gaps'] = true;
+      keyScope = true;
+    } else if (kind === 'content') {
+      args['force-content'] = true;
+      keyScope = true; // content blocks are cache-served too; --fresh bills them
+    } else if (kind === 'files') {
+      if (fresh) {
+        args.retranslate = [...[].concat(args.retranslate || []), value];
+      } else {
+        args.files = [...[].concat(args.files || []), value];
+        args['force-content'] = true;
+      }
+    }
+  }
+
+  // --fresh on its own, or with a key/content scope: bypass the cache for
+  // this run. (A files scope under --fresh is already --retranslate.)
+  if (fresh && (scopes.length === 0 || keyScope)) args['no-tm'] = true;
+  return null;
+}

package/lib/refusal-category.js

@@ -0,0 +1,44 @@
+/**
+ * refusal-category.js — why the pair's own method's answer was not used, in
+ * a few words that can be counted. Shared by the key-value pipeline
+ * (lib/translate-pair.js) and the content lanes (lib/fallback.js); no
+ * imports, so neither gets an import cycle.
+ */
+
+/**
+ * A quality-gate refusal (or a missing answer) in a few words, so refusals
+ * can be counted: "length inflation (3.2x source, max 2.5x)" → "length
+ * inflation". The gate's own wording, without the figures that make each
+ * one unique.
+ *
+ * @param {string|null} reason - The gate's reason (null: no answer for it)
+ * @param {{ sharedOutput?: boolean, memorized?: boolean, heldBefore?: boolean, noAnswer?: boolean }} [flags]
+ * @returns {string}
+ */
+export function refusalCategory(reason, flags = {}) {
+  if (flags.heldBefore) return 'refused on an earlier sync, so not asked again';
+  if (flags.sharedOutput || flags.memorized || /memorized sentence/.test(String(reason || ''))) {
+    return 'a memorized sentence repeated for different source strings';
+  }
+  if (flags.noAnswer || !reason) return 'no answer';
+  const text = String(reason);
+  if (/^source echo|disguised|English in disguise/i.test(text)) return 'a copy of the source text';
+  if (/protected element/i.test(text)) return 'code, links or markup damaged or missing';
+  if (/content was lost|content preservation|orphaned placeholder/i.test(text)) return 'content lost or changed';
+  // The gate's words up to its figures or explanation: "length inflation",
+  // "repetition hallucination", "wrong script", "empty translation", …
+  return text.split(/ \(| — |: |; /)[0].trim() || 'refused by the quality gate';
+}
+
+/**
+ * Count one unit the fallback was asked for, under why the primary's answer
+ * was not used (mutates `report.primaryReasons`).
+ *
+ * @param {object} report - A fallback report (lib/fallback.js newFallbackReport)
+ * @param {string} category - refusalCategory()
+ */
+export function notePrimaryReason(report, category) {
+  if (!report) return;
+  report.primaryReasons = report.primaryReasons || {};
+  report.primaryReasons[category] = (report.primaryReasons[category] || 0) + 1;
+}

package/lib/registers.js

@@ -400,6 +400,19 @@ function _presetFor(code) {
  * live corpus still does, and a card's own values must not be silently
  * replaced by config. Once cutover lands, only the config path is live.
  */
+/**
+ * CLI method name → key in the runtime `methodSupport` map. The service
+ * engines are the ones a card can say yes or no about; LLM methods are
+ * open-ended by construction (see `flat.llm` below) and have no entry.
+ */
+const METHOD_SUPPORT_KEYS = {
+  'google-translate': 'googleTranslate',
+  deepl: 'deepl',
+  'microsoft-translator': 'microsoftTranslator',
+  libretranslate: 'libreTranslate',
+  apertium: 'apertium',
+};
+
 function _withPromptConfig(card) {
   if (!card) return card;
   const preset = _presetFor(card.code);
@@ -438,17 +451,10 @@ function _withPromptConfig(card) {
   // that absence answers that question honestly. This synthesizes the legacy
   // map from them; the evidence stays on the card as methodSupportEvidence.
   if (view.methodSupport && Array.isArray(view.methodSupport.named)) {
-    const LEGACY_KEYS = {
-      'google-translate': 'googleTranslate',
-      deepl: 'deepl',
-      'microsoft-translator': 'microsoftTranslator',
-      libretranslate: 'libreTranslate',
-      apertium: 'apertium',
-    };
     const flat = {};
-    for (const key of Object.values(LEGACY_KEYS)) flat[key] = { supported: false };
+    for (const key of Object.values(METHOD_SUPPORT_KEYS)) flat[key] = { supported: false };
     for (const n of view.methodSupport.named) {
-      const legacy = LEGACY_KEYS[n.variant];
+      const legacy = METHOD_SUPPORT_KEYS[n.variant];
       if (legacy && n.value === 'service') flat[legacy] = { supported: true };
     }
     flat.deepl.formality = flat.deepl.supported && _deeplFormality.has(view.code);
@@ -602,6 +608,29 @@ _loadCards();
 // Dynamic tier (packaged mode) — per-user cache + remote fetch
 // -----------------------------------------------------------------
 
+/**
+ * Locale-shaped codes ('aaa-NG', 'cmn-Hant') that no remote fetch can
+ * ever materialize.
+ *
+ * A locale card is a PROJECTION of its language's card, so the
+ * publication lane never emits one: prod's trading_card_index /
+ * trading_card_detail hold 8,681 rows and ZERO hyphenated codes
+ * (verified 2026-08-28). The bundle ships 840 locale deltas whose
+ * parent is in the core set; the remaining 7,840 manifest locales are
+ * names only — asking prod for one buys a round-trip, a miss, and a
+ * tombstone for a code that will never exist.
+ *
+ * Conlangs ('x-pirate') are hyphenated too, but card-config.json loads
+ * them into _cards in BOTH modes, so every caller of this predicate is
+ * already past a _cards hit by the time it runs.
+ *
+ * @param {string} code
+ * @returns {boolean}
+ */
+function _isUnfetchableLocale(code) {
+  return code.includes('-');
+}
+
 /**
  * Try to materialize a card that isn't bundled: first from the
  * per-user cache (~/.champollion/cards/), then via a synchronous
@@ -638,6 +667,9 @@ function _loadDynamicCard(code) {
  */
 function _tryFetchRemoteSync(code) {
   if (OFFLINE) return null;
+  // Prod publishes no locale codes, so there is nothing to ask for —
+  // and no tombstone worth writing for a code that can never exist.
+  if (_isUnfetchableLocale(code)) return null;
   if (_fetchAttempted.has(code)) return null;
   _fetchAttempted.add(code);
 
@@ -706,6 +738,12 @@ async function prefetchLanguageCards(codes) {
       result.skipped.push(input);
       continue;
     }
+    if (_isUnfetchableLocale(code)) {
+      // Never published as a trading card (see _isUnfetchableLocale) —
+      // reported, not silently dropped, and not fetched.
+      result.missing.push(code);
+      continue;
+    }
     try {
       const remote = await fetchRemoteCard(code, { aliases: _manifest.get(code)?.a });
       if (remote.missing) {
@@ -750,6 +788,11 @@ function getCardSourceInfo() {
  *   - Alias: 'fr' → 'fra', 'no' → 'nob', 'iw' → 'heb'
  *   - Base locale fallback: 'deu-AT' → 'deu' (base)
  *
+ * The base fallback is what packaged mode leans on: repo checkouts hold
+ * a card for every locale, but the npm bundle ships only 840 locale
+ * deltas and prod publishes no locale codes, so the other 7,840 resolve
+ * to their language rather than to nothing.
+ *
  * @param {string} code - Locale code to resolve
  * @returns {string} Resolved primary code (ISO 639-3)
  */
@@ -760,9 +803,24 @@ function resolveCode(code) {
   // Alias match
   if (_aliases.has(code)) return _aliases.get(code);
 
+  // Flutter, gettext and Java write locales with '_' (pt_BR, zh_Hant); BCP 47
+  // and the cards use '-'. A Flutter "pt_BR" target matched no card, so it
+  // was synced as a language literally named "pt_BR" with no register.
+  if (typeof code === 'string' && code.includes('_')) {
+    return resolveCode(code.replace(/_/g, '-'));
+  }
+
   // Manifest match (packaged mode) — the code is a known primary code
-  // even though its card isn't materialized locally yet
-  if (_manifest.has(code)) return code;
+  // even though its card isn't materialized locally yet.
+  //
+  // LOCALE CODES ARE EXCLUDED, and that exclusion is the whole point of
+  // the guard. The manifest lists all 8,680 locales, but only the 840
+  // whose parent is in the core set ship as bundled deltas (caught by
+  // the _cards check above) and prod publishes none of them at all. So
+  // a bare manifest hit used to resolve 'aaa-NG' to itself, hand it to
+  // _loadDynamicCard(), and return null for 7,840 codes the docblock
+  // above promises to fall back on. Fall through to the base instead.
+  if (_manifest.has(code) && !_isUnfetchableLocale(code)) return code;
 
   // Base locale fallback — try stripping region (e.g., 'de-AT' → 'de')
   const baseParts = code.split('-');
@@ -1014,6 +1072,34 @@ function getGenderGuidance(code) {
   return card?.gender?.inclusiveGuidance || null;
 }
 
+/**
+ * The gender guidance a prompt carries, in one line a person can read: its
+ * instruction (the first sentence that says what to do — "prefer écriture
+ * inclusive with the interpunct …"), not the grammar note before it.
+ *
+ * @param {string|null} text - Guidance text (a pair's genderGuidance)
+ * @param {number} [max=150]
+ * @returns {string|null}
+ */
+function summarizeGenderGuidance(text, max = 150) {
+  if (typeof text !== 'string' || !text.trim()) return null;
+  const sentences = text.trim().split(/(?<=[.!?])\s+(?=[A-Z])/);
+  const pick = sentences.find(x => /\b(prefer|use|avoid|write|keep|default)\b/i.test(x)) || sentences[0];
+  return pick.length > max ? `${pick.slice(0, max - 1).trimEnd()}…` : pick;
+}
+
+/**
+ * Is this an ISO 639 private-use code (qaa–qtz) — the range kept for a
+ * variety with no code yet, or one not confirmed (an unconfirmed "Ayta")?
+ * The base subtag decides: "qaa", "qaa-PH", "qab_x" all are.
+ *
+ * @param {string} code
+ * @returns {boolean}
+ */
+function isPrivateUseCode(code) {
+  return /^q[a-t][a-z]$/i.test(String(code || '').split(/[-_]/)[0]);
+}
+
 /**
  * Get all loaded language codes (primary, not aliases).
  *
@@ -1033,6 +1119,140 @@ function getAllLanguageCodes() {
   return Array.from(codes);
 }
 
+// -----------------------------------------------------------------
+// Language NAMES → codes (an agent or a person types "French")
+// -----------------------------------------------------------------
+
+/** "Plains  Créé" → "plains cree": case, accents and spacing never decide a match. */
+function _normalizeName(s) {
+  return String(s ?? '').normalize('NFD').replace(/\p{M}/gu, '').toLowerCase().replace(/\s+/g, ' ').trim();
+}
+
+/** @type {Map<string, Array<{ code: string, name: string, aliases: string[] }>>|null} */
+let _nameIndex = null;
+
+/**
+ * normalized display name → the LANGUAGE cards that carry it. Locale cards
+ * (`fra-CA`, a projection of French for Canada) are not languages and never
+ * answer a name: in repo mode they are told by their `locale` block; in
+ * packaged mode an unmaterialized manifest entry has no block, and a locale
+ * entry is the one with a region/script subtag (the convention
+ * _isUnfetchableLocale already applies to the same manifest).
+ */
+function _buildNameIndex() {
+  const index = new Map();
+  const add = (code, name, aliases) => {
+    if (typeof name !== 'string' || !name.trim()) return;
+    const key = _normalizeName(name);
+    const list = index.get(key) || [];
+    if (!list.some(e => e.code === code)) list.push({ code, name, aliases: Array.isArray(aliases) ? aliases : [] });
+    index.set(key, list);
+  };
+  for (const [code, raw] of _cards) {
+    if (!raw || raw.locale) continue;
+    if (_mode === 'packaged' && _isUnfetchableLocale(code)) continue;
+    const name = typeof raw.name === 'string' ? raw.name : normalizeCard({ name: raw.name }).name;
+    add(code, name, raw.codeAliases ?? raw.aliases);
+  }
+  for (const [code, entry] of _manifest) {
+    if (_cards.has(code) || _isUnfetchableLocale(code)) continue;
+    add(code, entry?.n, entry?.a);
+  }
+  return index;
+}
+
+/**
+ * The language cards whose display name is `name` (case-, accent- and
+ * spacing-insensitive), never locale projections. Usually one; several when
+ * the registries give two languages the same name (the caller must then ask
+ * for a code — it never picks).
+ *
+ * @param {string} name
+ * @returns {Array<{ code: string, name: string, tag: string }>} tag: the code
+ *   to write for it — BCP 47 uses the two-letter ISO 639-1 code where one
+ *   exists ("fr", not "fra"), so that is what a project file would carry
+ */
+function findLanguagesByName(name) {
+  if (!_nameIndex) _nameIndex = _buildNameIndex();
+  return (_nameIndex.get(_normalizeName(name)) || []).map(e => ({
+    code: e.code,
+    name: e.name,
+    tag: e.aliases.find(a => typeof a === 'string' && /^[a-z]{2}$/.test(a)) || e.code,
+  }));
+}
+
+/** Locale spelling that never decides a match: case, and `_` vs `-` (pt_BR). */
+const _sameLocale = (a, b) => String(a).toLowerCase().replace(/_/g, '-') === String(b).toLowerCase().replace(/_/g, '-');
+
+/**
+ * Turn what a caller typed for a language — a code ("fr", "fra", "pt_BR") or
+ * a NAME ("French", "Plains Cree") — into the code to work in. With
+ * `locales` (a project's own locale codes: its input locale and targets) the
+ * answer is the project's spelling: "French" and "fra" both become the
+ * project's "fr", exactly the code sync writes, caches and locks under.
+ *
+ * Never guesses. A name two languages share, or a language that matches two
+ * of the project's locales ("French" in a project with fr and fr-CA), is an
+ * error that lists the choices; so is a word that is neither a code nor a
+ * language name. A code with no card ("x-pirate", "qaa") is returned as
+ * written — the private-use and unlisted codes are legitimate.
+ *
+ * @param {string} input
+ * @param {{ locales?: string[]|null }} [options]
+ * @returns {{ code: string, how: 'locale'|'code'|'name', input: string, name?: string }
+ *   | { error: string, input: string, candidates?: string[] }}
+ *   how: 'locale' = one of `locales` (by its code, another code for the same
+ *   language, or its name — `name` says which name matched); 'code' = a code
+ *   outside `locales`; 'name' = a language name, as its code
+ */
+function resolveLanguageInput(input, { locales = null } = {}) {
+  const raw = String(input ?? '').trim();
+  if (!raw) return { error: 'no language given', input: raw };
+  const own = Array.isArray(locales) ? [...new Set(locales.filter(l => typeof l === 'string' && l))] : null;
+
+  if (own) {
+    const exact = own.find(l => l === raw) || own.find(l => _sameLocale(l, raw));
+    if (exact) return { code: exact, how: 'locale', input: raw };
+  }
+  const projectMatches = (languageCode) => (own ? own.filter(l => resolveCode(l) === languageCode) : []);
+  const ambiguous = (what, list) => ({
+    error: `${what} matches more than one of the project's locales (${list.join(', ')}) — pass the one you mean`,
+    input: raw, candidates: list,
+  });
+
+  // A code: shaped like a BCP 47 tag — a 2-3 letter language subtag, or a
+  // private-use tag ("x-pirate"). "French" also parses as a (5-8 letter,
+  // never registered) language subtag, so length decides, not the grammar.
+  const shaped = raw.replace(/_/g, '-');
+  const m = /^([A-Za-z]{2,3})(?:-[A-Za-z0-9]{1,8})*$/.exec(shaped) || /^[xX](?:-[A-Za-z0-9]{1,8})+$/.exec(shaped);
+  if (m) {
+    const same = projectMatches(resolveCode(raw));
+    if (same.length === 1) return { code: same[0], how: 'locale', input: raw };
+    if (same.length > 1) return ambiguous(`"${raw}"`, same);
+    return { code: raw, how: 'code', input: raw };
+  }
+
+  // A name.
+  const found = findLanguagesByName(raw);
+  if (found.length === 0) {
+    return {
+      error: `"${raw}" is neither a language code nor the name of a language champollion has a card for — pass its code (e.g. "fr", "crk")`,
+      input: raw,
+    };
+  }
+  if (found.length > 1) {
+    return {
+      error: `"${raw}" is the name of ${found.length} languages (${found.map(f => f.code).join(', ')}) — pass the code of the one you mean`,
+      input: raw, candidates: found.map(f => f.code),
+    };
+  }
+  const lang = found[0];
+  const same = projectMatches(lang.code);
+  if (same.length === 1) return { code: same[0], how: 'locale', input: raw, name: lang.name };
+  if (same.length > 1) return ambiguous(`"${raw}" (${lang.code})`, same);
+  return { code: lang.tag, how: 'name', input: raw, name: lang.name };
+}
+
 /**
  * Get method support flags for a locale.
  *
@@ -1044,6 +1264,25 @@ function getMethodSupport(code) {
   return card?.methodSupport || null;
 }
 
+/**
+ * Does the card say this service engine covers this language?
+ *
+ * Takes the CLI method name (`libretranslate`, `google-translate`, …) and
+ * reads the entry's `supported` flag — entries are objects, never bare
+ * booleans, so testing the entry itself against `false` can never fire.
+ *
+ * @param {string} code - Locale code
+ * @param {string} method - CLI method name
+ * @returns {boolean|null} true/false when the card answers; null when there
+ *   is no card, no entry, or the method is not a listed service (LLM lanes)
+ */
+function isMethodSupported(code, method) {
+  const key = METHOD_SUPPORT_KEYS[method];
+  if (!key) return null;
+  const entry = getMethodSupport(code)?.[key];
+  return typeof entry?.supported === 'boolean' ? entry.supported : null;
+}
+
 // -----------------------------------------------------------------
 // Reference tier — REMOVED (v6: unified cards)
 // -----------------------------------------------------------------
@@ -1167,9 +1406,14 @@ export {
   getRegisterPresets,
   getFormality,
   getGenderGuidance,
+  summarizeGenderGuidance,
+  isPrivateUseCode,
   getAllLanguageCodes,
   getMethodSupport,
+  isMethodSupported,
   resolveCode,
+  findLanguagesByName,
+  resolveLanguageInput,
   DEFAULT_REGISTER_FALLBACK,
 
   // Dynamic card tier (packaged installs)

package/lib/repair-script.js

@@ -42,9 +42,8 @@ import { getLanguageCard } from './registers.js';
 import {
   SCRIPT_CONVERTERS, reverseScript, isPrivateUse, converterKeyForLocale, getConverterInfo,
 } from './scripts.js';
-import {
-  readLocaleFile, writeLocaleFile, detectFormatFromDir, detectYAMLStyle, getExtension,
-} from './format.js';
+import { readLocaleFile, writeLocaleFile, detectYAMLStyle, LOCALE_FILE_FORMATS } from './format.js';
+import { discoverLocaleLayout } from './locale-layout.js';
 import { discoverDocusaurusJSONFiles } from './docusaurus-sync.js';
 import { visualize } from './integrity.js';
 import { output } from './output.js';
@@ -107,7 +106,10 @@ function runRepairScript({ cwd = process.cwd(), cliArgs = {} } = {}) {
   const dry = !!cliArgs.dry;
   const localeFilter = cliArgs.locale || null;
 
-  const pairs = resolvePairs(config);
+  const pairs = resolvePairs(config, { cwd });
+  // Key-value projects: every locale's files from the ONE layout module
+  // (flat file, folder of namespace files, or localesPattern).
+  const layout = config.format === 'docusaurus' ? null : discoverLocaleLayout(config, { cwd });
   const report = [];
   const totals = { filesScanned: 0, valuesRepaired: 0, caseLossy: 0, unreversedCodepoints: 0 };
   let hadWriteFailure = false;
@@ -134,16 +136,18 @@ function runRepairScript({ cwd = process.cwd(), cliArgs = {} } = {}) {
       continue;
     }
 
-    // Discover this locale's files. Docusaurus keeps a directory per locale;
-    // everything else is one flat file per locale.
+    // Discover this locale's files: Docusaurus keeps a directory per locale
+    // of {message} JSON; key-value projects ask the layout (one file, or
+    // one per namespace). Each entry carries its own real format.
     const files = [];
-    let flatFormat = null;
     if (config.format === 'docusaurus') {
-      files.push(...discoverDocusaurusJSONFiles(path.join(config.localesDir, locale)));
+      for (const p of discoverDocusaurusJSONFiles(path.join(config.localesDir, locale))) {
+        files.push({ path: p, format: 'json' });
+      }
     } else {
-      flatFormat = config.format !== 'auto' ? config.format : detectFormatFromDir(config.localesDir);
-      const filePath = path.join(config.localesDir, `${locale}${getExtension(flatFormat)}`);
-      if (fs.existsSync(filePath)) files.push(filePath);
+      for (const f of layout.filesFor(locale)) {
+        if (fs.existsSync(f.path)) files.push({ path: f.path, format: f.format });
+      }
     }
 
     const localeReport = {
@@ -152,12 +156,15 @@ function runRepairScript({ cwd = process.cwd(), cliArgs = {} } = {}) {
       files: [],
     };
 
-    for (const filePath of files) {
+    for (const { path: filePath, format: flatFormat } of files) {
       totals.filesScanned++;
       const stats = { repaired: 0, caseLossy: 0, unreversed: new Set(), samples: [] };
 
       try {
-        if (config.format === 'docusaurus' || flatFormat === 'json') {
+        if (!LOCALE_FILE_FORMATS.includes(flatFormat)) {
+          throw new Error(`locale format "${flatFormat}" is not supported by this version of champollion`);
+        }
+        if (flatFormat === 'json') {
           const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
           const repaired = repairNode(parsed, converterKey, stats);
           if (stats.repaired > 0 && !dry) {