@i18nprune/core 0.1.0

package/dist/config.js

@@ -0,0 +1,2865 @@
+import { z } from 'zod';
+
+// src/config/defaults/app.ts
+var REFERENCE_POLICY_SAFE_DEFAULTS = {
+  treatCommentedCallSitesAsRuntime: false,
+  treatNonSourceFileSitesAsRuntime: false,
+  uncertainKeyPolicy: "protect",
+  stringPresence: "guard",
+  stringPresenceMaxHitsPerKey: 5,
+  respectPreserve: true
+};
+var DEFAULT_CONFIG = {
+  locales: {
+    source: "en",
+    directory: "locales"
+  },
+  src: "src",
+  functions: ["t"],
+  exclude: { useDefaultSkip: true },
+  output: {
+    list: {}
+  },
+  cache: {
+    enabled: true,
+    mode: "readWrite"
+  },
+  policies: {},
+  reference: {
+    defaults: { ...REFERENCE_POLICY_SAFE_DEFAULTS },
+    commands: {
+      cleanup: { ...REFERENCE_POLICY_SAFE_DEFAULTS },
+      sync: { ...REFERENCE_POLICY_SAFE_DEFAULTS },
+      generate: { ...REFERENCE_POLICY_SAFE_DEFAULTS }
+    }
+  },
+  localeLeaves: {
+    mode: "legacy_string",
+    sync: {
+      stripMetadata: false
+    }
+  },
+  missing: {}
+};
+
+// src/shared/constants/translate.ts
+var TRANSLATE_WORKERS_CAP = 64;
+var ENV_TRANSLATE_MAX_WORKERS = "I18NPRUNE_TRANSLATE_MAX_WORKERS";
+
+// src/shared/translator/utils/orchestration.ts
+function clampInt(n, lo, hi) {
+  if (!Number.isFinite(n)) return lo;
+  return Math.min(hi, Math.max(lo, Math.trunc(n)));
+}
+var DEFAULT_PROVIDER_RATE_LIMITS = {
+  // Google can sustain higher throughput; default to safe-high (32) while allowing user/config up to 64.
+  google: { maxConcurrency: 32, rpm: 1920, rps: 32, intervalMs: 32 },
+  mymemory: { maxConcurrency: 2, rpm: 60, rps: 1, intervalMs: 1e3 },
+  libre: { maxConcurrency: 6, rpm: 120, rps: 2, intervalMs: 500 },
+  deepl: { maxConcurrency: 4, rpm: 90, rps: 1.5, intervalMs: 600 },
+  llm: { maxConcurrency: 2, rpm: 30, rps: 0.5, intervalMs: 1500 }
+};
+function parseEnvPositiveInt(raw) {
+  if (raw === void 0 || raw.trim() === "") return void 0;
+  const n = Number.parseInt(raw.trim(), 10);
+  if (!Number.isFinite(n) || n < 1) return void 0;
+  return n;
+}
+function resolveTranslateMaxParallel(input) {
+  let n = input.configMaxWorkers ?? 1;
+  const env = parseEnvPositiveInt(input.envMaxWorkers);
+  if (env !== void 0) n = env;
+  if (input.workersFlag !== void 0) n = input.workersFlag;
+  return clampInt(n, 1, TRANSLATE_WORKERS_CAP);
+}
+
+// src/types/translator/policy.ts
+var TRANSLATE_POLICY_DEFAULTS = Object.freeze({
+  routing: "single",
+  onRateLimit: "backoff",
+  onTransientFailure: "retry",
+  onQuotaExceeded: "fallback",
+  onAuthFailure: "abort",
+  onProviderUnavailable: "fallback",
+  onIdentityOutput: "flag",
+  onIncompleteRun: "confirm",
+  handoff: "auto"
+});
+
+// src/config/schema/translate.ts
+function clampTranslateMaxWorkers(n) {
+  if (!Number.isFinite(n)) return 1;
+  return Math.min(TRANSLATE_WORKERS_CAP, Math.max(1, Math.trunc(n)));
+}
+var translateThrottleSchema = z.object({
+  maxConcurrency: z.number().int().positive().max(TRANSLATE_WORKERS_CAP).optional().describe("Cap parallel translateLeaf calls for this row (core merges with CLI --workers / translate.workers)."),
+  rpm: z.number().int().positive().optional().describe("Vendor-friendly requests/minute ceiling (enforced when orchestration supports it)."),
+  rps: z.number().positive().optional().describe("Optional requests/second ceiling (can be fractional, e.g. 0.5 = 1 request every 2 seconds)."),
+  intervalMs: z.number().int().nonnegative().optional().describe("Minimum spacing between requests originating from this row / merged defaults.")
+}).strict().transform((t) => ({
+  maxConcurrency: t.maxConcurrency,
+  rpm: t.rpm,
+  rps: t.rps,
+  intervalMs: t.intervalMs
+}));
+var translateGoogleRowSchema = z.object({
+  id: z.literal("google"),
+  enabled: z.boolean().optional().describe("When false, row is ignored for merges (rich-init scaffolding)."),
+  rateLimit: translateThrottleSchema.optional()
+}).strict().describe("Google Translate web (gtx) backend.");
+var translateMymemoryRowSchema = z.object({
+  id: z.literal("mymemory"),
+  enabled: z.boolean().optional(),
+  contactEmail: z.string().optional().describe("Fair-use contact email for MyMemory API attribution."),
+  rateLimit: translateThrottleSchema.optional()
+}).strict();
+var translateLibreRowSchema = z.object({
+  id: z.literal("libre"),
+  enabled: z.boolean().optional(),
+  baseUrl: z.string().optional().describe("LibreTranslate base URL when not using the public instance."),
+  rateLimit: translateThrottleSchema.optional()
+}).strict();
+var translateDeeplRowSchema = z.object({
+  id: z.literal("deepl"),
+  enabled: z.boolean().optional(),
+  apiKey: z.string().optional().describe("DeepL API key (or set via env; see docs)."),
+  rateLimit: translateThrottleSchema.optional()
+}).strict();
+var translateLlmRowSchema = z.object({
+  id: z.literal("llm"),
+  enabled: z.boolean().optional(),
+  apiKey: z.string().optional().describe("Bearer / API key for the OpenAI-compatible endpoint."),
+  baseUrl: z.string().optional().describe("Base URL including /v1 when required by the host."),
+  model: z.string().optional().describe("Chat model id for completions."),
+  rateLimit: translateThrottleSchema.optional()
+}).strict();
+var translateProviderRowSchema = z.discriminatedUnion("id", [
+  translateGoogleRowSchema,
+  translateMymemoryRowSchema,
+  translateLibreRowSchema,
+  translateDeeplRowSchema,
+  translateLlmRowSchema
+]);
+var translatePrimaryIdSchema = z.enum(["google", "mymemory", "libre", "deepl", "llm"]);
+var translatePolicySchema = z.object({
+  routing: z.enum(["single", "auto"]).default(TRANSLATE_POLICY_DEFAULTS.routing).describe(
+    "single: one backend per run. auto: ordered fallback chain across enabled providers for retryable backend failures."
+  ),
+  onRateLimit: z.enum(["backoff", "retry", "fallback", "abort"]).default(TRANSLATE_POLICY_DEFAULTS.onRateLimit).describe('Action for HTTP 429 / "too many requests" outcomes.'),
+  onTransientFailure: z.enum(["retry", "fallback", "abort"]).default(TRANSLATE_POLICY_DEFAULTS.onTransientFailure).describe("Action for transient network blips and ECONNRESET-style errors."),
+  onQuotaExceeded: z.enum(["fallback", "prompt", "abort"]).default(TRANSLATE_POLICY_DEFAULTS.onQuotaExceeded).describe("Action when the provider explicitly reports daily/monthly quota exhausted."),
+  onAuthFailure: z.enum(["abort", "prompt"]).default(TRANSLATE_POLICY_DEFAULTS.onAuthFailure).describe("Action for HTTP 401 / 403 \u2014 never silently swap on credential failure."),
+  onProviderUnavailable: z.enum(["fallback", "abort"]).default(TRANSLATE_POLICY_DEFAULTS.onProviderUnavailable).describe("Action for sustained 5xx / DNS unavailable."),
+  onIdentityOutput: z.enum(["flag", "fallback", "abort"]).default(TRANSLATE_POLICY_DEFAULTS.onIdentityOutput).describe("Action when the provider returned the source string unchanged."),
+  onIncompleteRun: z.enum(["confirm", "write", "discard"]).default(TRANSLATE_POLICY_DEFAULTS.onIncompleteRun).describe("Action when a run cannot finish all leaves (cap hit or interrupt)."),
+  maxAttempts: z.number().int().positive().optional().describe(
+    "Cross-provider attempts per leaf. When omitted, defaults to providers.length at parse time."
+  ),
+  handoff: z.enum(["auto", "on", "off"]).default(TRANSLATE_POLICY_DEFAULTS.handoff).describe("Mid-run rescue picker: auto = TTY-only when routing=single; on = always TTY; off = never.")
+}).strict().describe("Translation orchestration: routing + per-outcome actions consumed by the policy resolver.");
+var translateWorkersField = z.number().int().positive().max(TRANSLATE_WORKERS_CAP).describe("Max parallel translateLeaf calls when --workers flag and env omit (1 = serial).");
+var translateInnerSchema = z.object({
+  primary: translatePrimaryIdSchema.describe(
+    "Default backend when CLI --provider and I18NPRUNE_TRANSLATE_PROVIDER omit; must match an enabled providers[] row."
+  ),
+  providers: z.array(translateProviderRowSchema).min(1),
+  policy: translatePolicySchema.default({ ...TRANSLATE_POLICY_DEFAULTS }),
+  workers: translateWorkersField.optional()
+}).strict().transform((t) => ({
+  primary: t.primary,
+  providers: t.providers,
+  /**
+   * `maxAttempts` defaults to `providers.length` (one shot per provider in chain) per
+   * `translate-policy (shipped)` §6. Resolved here because the default
+   * depends on a sibling field — Zod's static `.default()` can't express that.
+   */
+  policy: { ...t.policy, maxAttempts: t.policy.maxAttempts ?? t.providers.length },
+  workers: t.workers ?? 1
+})).superRefine((data, ctx) => {
+  const ids = data.providers.map((p) => p.id);
+  if (new Set(ids).size !== ids.length) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "translate.providers must not contain duplicate id values",
+      path: ["providers"]
+    });
+  }
+  const primaryRow = data.providers.find((p) => p.id === data.primary && p.enabled !== false);
+  if (!primaryRow) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "translate.primary must match at least one translate.providers entry with enabled !== false",
+      path: ["primary"]
+    });
+  }
+}).describe("Translation registry + orchestration policy for generate (including `generate --resume`).");
+var translateSchema = translateInnerSchema.optional().describe(
+  "Optional translate namespace; omit entirely to follow env + built-in default (google) without file-backed rows."
+);
+
+// src/config/schema/define.ts
+function defineConfig(config) {
+  const refDef = DEFAULT_CONFIG.reference?.defaults;
+  const refCmd = DEFAULT_CONFIG.reference?.commands;
+  const merged = {
+    ...DEFAULT_CONFIG,
+    ...config,
+    functions: config.functions?.length ? config.functions : DEFAULT_CONFIG.functions,
+    policies: { ...DEFAULT_CONFIG.policies, ...config.policies },
+    reference: {
+      ...DEFAULT_CONFIG.reference,
+      ...config.reference,
+      defaults: { ...refDef, ...config.reference?.defaults },
+      commands: { ...refCmd, ...config.reference?.commands }
+    },
+    missing: { ...DEFAULT_CONFIG.missing, ...config.missing },
+    locales: { ...DEFAULT_CONFIG.locales, ...config.locales },
+    translate: config.translate !== void 0 ? {
+      ...DEFAULT_CONFIG.translate,
+      ...config.translate,
+      workers: config.translate.workers === void 0 ? 1 : typeof config.translate.workers === "number" ? clampTranslateMaxWorkers(config.translate.workers) : config.translate.workers
+    } : DEFAULT_CONFIG.translate
+  };
+  return merged;
+}
+
+// src/config/schema/localesCompat.ts
+function defaultStructureForMode(mode) {
+  return mode === "flat_file" ? "locale_file" : "locale_per_dir";
+}
+function collectLocalesFilesystemConfigWarnings(locales) {
+  const warnings = [];
+  const mode = locales.mode ?? "flat_file";
+  const structure = locales.structure ?? defaultStructureForMode(mode);
+  if (mode === "flat_file" && structure !== "locale_file") {
+    warnings.push(
+      `locales.structure "${structure}" does not apply when locales.mode is "flat_file"; use "locale_file" or set mode to "locale_directory".`
+    );
+  }
+  if (mode === "locale_directory" && structure === "locale_file") {
+    warnings.push(
+      `locales.structure "locale_file" does not apply when locales.mode is "locale_directory"; use "locale_per_dir" or "feature_bundle".`
+    );
+  }
+  return warnings;
+}
+
+// src/shared/constants/issueCodes.ts
+var ISSUE_PROJECT_LOCALES_SOURCE_NOT_LANGUAGE_CODE = "i18nprune.project.locales_source_not_language_code";
+var ISSUE_PROJECT_LOCALES_SOURCE_NOT_IN_BUNDLE = "i18nprune.project.locales_source_not_in_bundle";
+var ISSUE_LANGUAGES_UNSUPPORTED_LANGUAGE_CODE = "i18nprune.languages.unsupported_language_code";
+var ISSUE_CONFIG_MISSING = "i18nprune.config.missing";
+var ISSUE_CONFIG_INVALID = "i18nprune.config.invalid";
+var ISSUE_CONFIG_LOAD_FAILED = "i18nprune.config.load_failed";
+var ISSUE_TRANSLATE_CONFIG_DEFAULT_APPLIED = "i18nprune.translate.config_default_applied";
+
+// src/shared/languages/catalog/languages.json
+var languages_default = [
+  {
+    code: "ab",
+    english: "Abkhazian",
+    native: "Abkhazian",
+    direction: "ltr"
+  },
+  {
+    code: "ace",
+    english: "Acehnese",
+    native: "Acehnese",
+    direction: "ltr"
+  },
+  {
+    code: "ach",
+    english: "Acoli",
+    native: "Acoli",
+    direction: "ltr"
+  },
+  {
+    code: "af",
+    english: "Afrikaans",
+    native: "Afrikaans",
+    direction: "ltr"
+  },
+  {
+    code: "ak",
+    english: "Akan",
+    native: "Akan",
+    direction: "ltr"
+  },
+  {
+    code: "alz",
+    english: "alz",
+    native: "alz",
+    direction: "ltr"
+  },
+  {
+    code: "am",
+    english: "Amharic",
+    native: "\u12A0\u121B\u122D\u129B",
+    direction: "ltr"
+  },
+  {
+    code: "ar",
+    english: "Arabic",
+    native: "\u0627\u0644\u0639\u0631\u0628\u064A\u0629",
+    direction: "rtl"
+  },
+  {
+    code: "ar-sa",
+    english: "Arabic (Saudi Arabia)",
+    native: "\u0627\u0644\u0639\u0631\u0628\u064A\u0629 (\u0627\u0644\u0645\u0645\u0644\u0643\u0629 \u0627\u0644\u0639\u0631\u0628\u064A\u0629 \u0627\u0644\u0633\u0639\u0648\u062F\u064A\u0629)",
+    direction: "rtl"
+  },
+  {
+    code: "as",
+    english: "Assamese",
+    native: "\u0985\u09B8\u09AE\u09C0\u09AF\u09BC\u09BE",
+    direction: "ltr"
+  },
+  {
+    code: "awa",
+    english: "Awadhi",
+    native: "Awadhi",
+    direction: "ltr"
+  },
+  {
+    code: "ay",
+    english: "Aymara",
+    native: "Aymara",
+    direction: "ltr"
+  },
+  {
+    code: "az",
+    english: "Azerbaijani",
+    native: "az\u0259rbaycan",
+    direction: "ltr"
+  },
+  {
+    code: "ba",
+    english: "Bashkir",
+    native: "Bashkir",
+    direction: "ltr"
+  },
+  {
+    code: "ban",
+    english: "Balinese",
+    native: "Balinese",
+    direction: "ltr"
+  },
+  {
+    code: "bbc",
+    english: "Batak Toba",
+    native: "Batak Toba",
+    direction: "ltr"
+  },
+  {
+    code: "be",
+    english: "Belarusian",
+    native: "\u0431\u0435\u043B\u0430\u0440\u0443\u0441\u043A\u0430\u044F",
+    direction: "ltr"
+  },
+  {
+    code: "bem",
+    english: "Bemba",
+    native: "Ichibemba",
+    direction: "ltr"
+  },
+  {
+    code: "bew",
+    english: "Betawi",
+    native: "Betawi",
+    direction: "ltr"
+  },
+  {
+    code: "bg",
+    english: "Bulgarian",
+    native: "\u0431\u044A\u043B\u0433\u0430\u0440\u0441\u043A\u0438",
+    direction: "ltr"
+  },
+  {
+    code: "bho",
+    english: "Bhojpuri",
+    native: "\u092D\u094B\u091C\u092A\u0941\u0930\u0940",
+    direction: "ltr"
+  },
+  {
+    code: "bik",
+    english: "Bikol",
+    native: "Bikol",
+    direction: "ltr"
+  },
+  {
+    code: "bm",
+    english: "Bambara",
+    native: "bamanakan",
+    direction: "ltr"
+  },
+  {
+    code: "bn",
+    english: "Bangla",
+    native: "\u09AC\u09BE\u0982\u09B2\u09BE",
+    direction: "ltr"
+  },
+  {
+    code: "bn-in",
+    english: "Bangla (India)",
+    native: "\u09AC\u09BE\u0982\u09B2\u09BE (\u09AD\u09BE\u09B0\u09A4)",
+    direction: "ltr"
+  },
+  {
+    code: "br",
+    english: "Breton",
+    native: "brezhoneg",
+    direction: "ltr"
+  },
+  {
+    code: "bs",
+    english: "Bosnian",
+    native: "bosanski",
+    direction: "ltr"
+  },
+  {
+    code: "bs-cyrl",
+    english: "Bosnian (Cyrillic)",
+    native: "\u0431\u043E\u0441\u0430\u043D\u0441\u043A\u0438 (\u045B\u0438\u0440\u0438\u043B\u0438\u0446\u0430)",
+    direction: "ltr"
+  },
+  {
+    code: "bts",
+    english: "bts",
+    native: "bts",
+    direction: "ltr"
+  },
+  {
+    code: "btx",
+    english: "btx",
+    native: "btx",
+    direction: "ltr"
+  },
+  {
+    code: "bua",
+    english: "Buriat",
+    native: "Buriat",
+    direction: "ltr"
+  },
+  {
+    code: "ca",
+    english: "Catalan",
+    native: "catal\xE0",
+    direction: "ltr"
+  },
+  {
+    code: "ceb",
+    english: "Cebuano",
+    native: "Cebuano",
+    direction: "ltr"
+  },
+  {
+    code: "cgg",
+    english: "Chiga",
+    native: "Rukiga",
+    direction: "ltr"
+  },
+  {
+    code: "chm",
+    english: "Mari",
+    native: "Mari",
+    direction: "ltr"
+  },
+  {
+    code: "ckb",
+    english: "Central Kurdish",
+    native: "\u06A9\u0648\u0631\u062F\u06CC\u06CC \u0646\u0627\u0648\u06D5\u0646\u062F\u06CC",
+    direction: "rtl"
+  },
+  {
+    code: "cnh",
+    english: "cnh",
+    native: "cnh",
+    direction: "ltr"
+  },
+  {
+    code: "co",
+    english: "Corsican",
+    native: "Corsican",
+    direction: "ltr"
+  },
+  {
+    code: "crh",
+    english: "Crimean Tatar",
+    native: "Crimean Tatar",
+    direction: "ltr"
+  },
+  {
+    code: "crs",
+    english: "Seselwa Creole French",
+    native: "Seselwa Creole French",
+    direction: "ltr"
+  },
+  {
+    code: "cs",
+    english: "Czech",
+    native: "\u010De\u0161tina",
+    direction: "ltr"
+  },
+  {
+    code: "cv",
+    english: "Chuvash",
+    native: "\u0447\u04D1\u0432\u0430\u0448",
+    direction: "ltr"
+  },
+  {
+    code: "cy",
+    english: "Welsh",
+    native: "Cymraeg",
+    direction: "ltr"
+  },
+  {
+    code: "da",
+    english: "Danish",
+    native: "dansk",
+    direction: "ltr"
+  },
+  {
+    code: "de",
+    english: "German",
+    native: "Deutsch",
+    direction: "ltr"
+  },
+  {
+    code: "din",
+    english: "Dinka",
+    native: "Dinka",
+    direction: "ltr"
+  },
+  {
+    code: "doi",
+    english: "Dogri",
+    native: "\u0921\u094B\u0917\u0930\u0940",
+    direction: "ltr"
+  },
+  {
+    code: "dov",
+    english: "dov",
+    native: "dov",
+    direction: "ltr"
+  },
+  {
+    code: "dv",
+    english: "Divehi",
+    native: "Divehi",
+    direction: "rtl"
+  },
+  {
+    code: "dz",
+    english: "Dzongkha",
+    native: "\u0F62\u0FAB\u0F7C\u0F44\u0F0B\u0F41",
+    direction: "ltr"
+  },
+  {
+    code: "ee",
+    english: "Ewe",
+    native: "E\u028Begbe",
+    direction: "ltr"
+  },
+  {
+    code: "el",
+    english: "Greek",
+    native: "\u0395\u03BB\u03BB\u03B7\u03BD\u03B9\u03BA\u03AC",
+    direction: "ltr"
+  },
+  {
+    code: "en",
+    english: "English",
+    native: "English",
+    direction: "ltr"
+  },
+  {
+    code: "en-au",
+    english: "Australian English",
+    native: "Australian English",
+    direction: "ltr"
+  },
+  {
+    code: "en-ca",
+    english: "Canadian English",
+    native: "Canadian English",
+    direction: "ltr"
+  },
+  {
+    code: "en-gb",
+    english: "British English",
+    native: "British English",
+    direction: "ltr"
+  },
+  {
+    code: "en-nz",
+    english: "English (New Zealand)",
+    native: "English (New Zealand)",
+    direction: "ltr"
+  },
+  {
+    code: "en-ph",
+    english: "English (Philippines)",
+    native: "English (Philippines)",
+    direction: "ltr"
+  },
+  {
+    code: "en-us",
+    english: "American English",
+    native: "American English",
+    direction: "ltr"
+  },
+  {
+    code: "en-za",
+    english: "English (South Africa)",
+    native: "English (South Africa)",
+    direction: "ltr"
+  },
+  {
+    code: "eo",
+    english: "Esperanto",
+    native: "Esperanto",
+    direction: "ltr"
+  },
+  {
+    code: "es",
+    english: "Spanish",
+    native: "espa\xF1ol",
+    direction: "ltr"
+  },
+  {
+    code: "es-419",
+    english: "Latin American Spanish",
+    native: "espa\xF1ol latinoamericano",
+    direction: "ltr"
+  },
+  {
+    code: "es-ar",
+    english: "Spanish (Argentina)",
+    native: "espa\xF1ol (Argentina)",
+    direction: "ltr"
+  },
+  {
+    code: "es-cl",
+    english: "Spanish (Chile)",
+    native: "espa\xF1ol (Chile)",
+    direction: "ltr"
+  },
+  {
+    code: "es-co",
+    english: "Spanish (Colombia)",
+    native: "espa\xF1ol (Colombia)",
+    direction: "ltr"
+  },
+  {
+    code: "es-cr",
+    english: "Spanish (Costa Rica)",
+    native: "espa\xF1ol (Costa Rica)",
+    direction: "ltr"
+  },
+  {
+    code: "es-ec",
+    english: "Spanish (Ecuador)",
+    native: "espa\xF1ol (Ecuador)",
+    direction: "ltr"
+  },
+  {
+    code: "es-es",
+    english: "European Spanish",
+    native: "espa\xF1ol de Espa\xF1a",
+    direction: "ltr"
+  },
+  {
+    code: "es-gt",
+    english: "Spanish (Guatemala)",
+    native: "espa\xF1ol (Guatemala)",
+    direction: "ltr"
+  },
+  {
+    code: "es-hn",
+    english: "Spanish (Honduras)",
+    native: "espa\xF1ol (Honduras)",
+    direction: "ltr"
+  },
+  {
+    code: "es-ht",
+    english: "Spanish (Haiti)",
+    native: "espa\xF1ol (Hait\xED)",
+    direction: "ltr"
+  },
+  {
+    code: "es-mx",
+    english: "Mexican Spanish",
+    native: "espa\xF1ol de M\xE9xico",
+    direction: "ltr"
+  },
+  {
+    code: "es-ni",
+    english: "Spanish (Nicaragua)",
+    native: "espa\xF1ol (Nicaragua)",
+    direction: "ltr"
+  },
+  {
+    code: "es-pa",
+    english: "Spanish (Panama)",
+    native: "espa\xF1ol (Panam\xE1)",
+    direction: "ltr"
+  },
+  {
+    code: "es-pe",
+    english: "Spanish (Peru)",
+    native: "espa\xF1ol (Per\xFA)",
+    direction: "ltr"
+  },
+  {
+    code: "es-pr",
+    english: "Spanish (Puerto Rico)",
+    native: "espa\xF1ol (Puerto Rico)",
+    direction: "ltr"
+  },
+  {
+    code: "es-py",
+    english: "Spanish (Paraguay)",
+    native: "espa\xF1ol (Paraguay)",
+    direction: "ltr"
+  },
+  {
+    code: "es-sv",
+    english: "Spanish (El Salvador)",
+    native: "espa\xF1ol (El Salvador)",
+    direction: "ltr"
+  },
+  {
+    code: "es-us",
+    english: "Spanish (United States)",
+    native: "espa\xF1ol (Estados Unidos)",
+    direction: "ltr"
+  },
+  {
+    code: "es-uy",
+    english: "Spanish (Uruguay)",
+    native: "espa\xF1ol (Uruguay)",
+    direction: "ltr"
+  },
+  {
+    code: "es-ve",
+    english: "Spanish (Venezuela)",
+    native: "espa\xF1ol (Venezuela)",
+    direction: "ltr"
+  },
+  {
+    code: "et",
+    english: "Estonian",
+    native: "eesti",
+    direction: "ltr"
+  },
+  {
+    code: "eu",
+    english: "Basque",
+    native: "euskara",
+    direction: "ltr"
+  },
+  {
+    code: "fa",
+    english: "Persian",
+    native: "\u0641\u0627\u0631\u0633\u06CC",
+    direction: "rtl"
+  },
+  {
+    code: "ff",
+    english: "Fula",
+    native: "Pulaar",
+    direction: "rtl"
+  },
+  {
+    code: "fi",
+    english: "Finnish",
+    native: "suomi",
+    direction: "ltr"
+  },
+  {
+    code: "fil",
+    english: "Filipino",
+    native: "Filipino",
+    direction: "ltr"
+  },
+  {
+    code: "fj",
+    english: "Fijian",
+    native: "Fijian",
+    direction: "ltr"
+  },
+  {
+    code: "fr",
+    english: "French",
+    native: "fran\xE7ais",
+    direction: "ltr"
+  },
+  {
+    code: "fr-ca",
+    english: "Canadian French",
+    native: "fran\xE7ais canadien",
+    direction: "ltr"
+  },
+  {
+    code: "fr-ch",
+    english: "Swiss French",
+    native: "fran\xE7ais suisse",
+    direction: "ltr"
+  },
+  {
+    code: "fr-fr",
+    english: "French (France)",
+    native: "fran\xE7ais (France)",
+    direction: "ltr"
+  },
+  {
+    code: "fy",
+    english: "Western Frisian",
+    native: "Frysk",
+    direction: "ltr"
+  },
+  {
+    code: "ga",
+    english: "Irish",
+    native: "Gaeilge",
+    direction: "ltr"
+  },
+  {
+    code: "gaa",
+    english: "Ga",
+    native: "Ga",
+    direction: "ltr"
+  },
+  {
+    code: "gd",
+    english: "Scottish Gaelic",
+    native: "G\xE0idhlig",
+    direction: "ltr"
+  },
+  {
+    code: "gl",
+    english: "Galician",
+    native: "galego",
+    direction: "ltr"
+  },
+  {
+    code: "gn",
+    english: "Guarani",
+    native: "Guarani",
+    direction: "ltr"
+  },
+  {
+    code: "gom",
+    english: "Goan Konkani",
+    native: "Goan Konkani",
+    direction: "ltr"
+  },
+  {
+    code: "gu",
+    english: "Gujarati",
+    native: "\u0A97\u0AC1\u0A9C\u0AB0\u0ABE\u0AA4\u0AC0",
+    direction: "ltr"
+  },
+  {
+    code: "ha",
+    english: "Hausa",
+    native: "Hausa",
+    direction: "rtl"
+  },
+  {
+    code: "haw",
+    english: "Hawaiian",
+    native: "\u02BB\u014Clelo Hawai\u02BBi",
+    direction: "ltr"
+  },
+  {
+    code: "he",
+    english: "Hebrew",
+    native: "\u05E2\u05D1\u05E8\u05D9\u05EA",
+    direction: "rtl"
+  },
+  {
+    code: "hi",
+    english: "Hindi",
+    native: "\u0939\u093F\u0928\u094D\u0926\u0940",
+    direction: "ltr"
+  },
+  {
+    code: "hil",
+    english: "Hiligaynon",
+    native: "Hiligaynon",
+    direction: "ltr"
+  },
+  {
+    code: "hmn",
+    english: "Hmong",
+    native: "Hmong",
+    direction: "ltr"
+  },
+  {
+    code: "hr",
+    english: "Croatian",
+    native: "hrvatski",
+    direction: "ltr"
+  },
+  {
+    code: "hrx",
+    english: "hrx",
+    native: "hrx",
+    direction: "ltr"
+  },
+  {
+    code: "ht",
+    english: "Haitian Creole",
+    native: "Haitian Creole",
+    direction: "ltr"
+  },
+  {
+    code: "hu",
+    english: "Hungarian",
+    native: "magyar",
+    direction: "ltr"
+  },
+  {
+    code: "hy",
+    english: "Armenian",
+    native: "\u0570\u0561\u0575\u0565\u0580\u0565\u0576",
+    direction: "ltr"
+  },
+  {
+    code: "id",
+    english: "Indonesian",
+    native: "Indonesia",
+    direction: "ltr"
+  },
+  {
+    code: "ig",
+    english: "Igbo",
+    native: "Igbo",
+    direction: "ltr"
+  },
+  {
+    code: "ilo",
+    english: "Iloko",
+    native: "Iloko",
+    direction: "ltr"
+  },
+  {
+    code: "is",
+    english: "Icelandic",
+    native: "\xEDslenska",
+    direction: "ltr"
+  },
+  {
+    code: "it",
+    english: "Italian",
+    native: "italiano",
+    direction: "ltr"
+  },
+  {
+    code: "iw",
+    english: "Hebrew",
+    native: "\u05E2\u05D1\u05E8\u05D9\u05EA",
+    direction: "rtl"
+  },
+  {
+    code: "ja",
+    english: "Japanese",
+    native: "\u65E5\u672C\u8A9E",
+    direction: "ltr"
+  },
+  {
+    code: "jv",
+    english: "Javanese",
+    native: "Jawa",
+    direction: "ltr"
+  },
+  {
+    code: "jw",
+    english: "Javanese",
+    native: "Jawa",
+    direction: "ltr"
+  },
+  {
+    code: "ka",
+    english: "Georgian",
+    native: "\u10E5\u10D0\u10E0\u10D7\u10E3\u10DA\u10D8",
+    direction: "ltr"
+  },
+  {
+    code: "kk",
+    english: "Kazakh",
+    native: "\u049B\u0430\u0437\u0430\u049B \u0442\u0456\u043B\u0456",
+    direction: "ltr"
+  },
+  {
+    code: "km",
+    english: "Khmer",
+    native: "\u1781\u17D2\u1798\u17C2\u179A",
+    direction: "ltr"
+  },
+  {
+    code: "kn",
+    english: "Kannada",
+    native: "\u0C95\u0CA8\u0CCD\u0CA8\u0CA1",
+    direction: "ltr"
+  },
+  {
+    code: "ko",
+    english: "Korean",
+    native: "\uD55C\uAD6D\uC5B4",
+    direction: "ltr"
+  },
+  {
+    code: "kri",
+    english: "Krio",
+    native: "Krio",
+    direction: "ltr"
+  },
+  {
+    code: "ktu",
+    english: "ktu",
+    native: "ktu",
+    direction: "ltr"
+  },
+  {
+    code: "ku",
+    english: "Kurdish",
+    native: "kurd\xEE (kurmanc\xEE)",
+    direction: "ltr"
+  },
+  {
+    code: "ky",
+    english: "Kyrgyz",
+    native: "\u043A\u044B\u0440\u0433\u044B\u0437\u0447\u0430",
+    direction: "ltr"
+  },
+  {
+    code: "la",
+    english: "Latin",
+    native: "Latin",
+    direction: "ltr"
+  },
+  {
+    code: "lb",
+    english: "Luxembourgish",
+    native: "L\xEBtzebuergesch",
+    direction: "ltr"
+  },
+  {
+    code: "lg",
+    english: "Ganda",
+    native: "Luganda",
+    direction: "ltr"
+  },
+  {
+    code: "li",
+    english: "Limburgish",
+    native: "Limburgish",
+    direction: "ltr"
+  },
+  {
+    code: "lij",
+    english: "Ligurian",
+    native: "ligure",
+    direction: "ltr"
+  },
+  {
+    code: "lmo",
+    english: "Lombard",
+    native: "Lombard",
+    direction: "ltr"
+  },
+  {
+    code: "ln",
+    english: "Lingala",
+    native: "ling\xE1la",
+    direction: "ltr"
+  },
+  {
+    code: "lo",
+    english: "Lao",
+    native: "\u0EA5\u0EB2\u0EA7",
+    direction: "ltr"
+  },
+  {
+    code: "lt",
+    english: "Lithuanian",
+    native: "lietuvi\u0173",
+    direction: "ltr"
+  },
+  {
+    code: "ltg",
+    english: "Latgalian",
+    native: "Latgalian",
+    direction: "ltr"
+  },
+  {
+    code: "luo",
+    english: "Luo",
+    native: "Dholuo",
+    direction: "ltr"
+  },
+  {
+    code: "lus",
+    english: "Mizo",
+    native: "Mizo",
+    direction: "ltr"
+  },
+  {
+    code: "lv",
+    english: "Latvian",
+    native: "latvie\u0161u",
+    direction: "ltr"
+  },
+  {
+    code: "mai",
+    english: "Maithili",
+    native: "\u092E\u0948\u0925\u093F\u0932\u0940",
+    direction: "ltr"
+  },
+  {
+    code: "mak",
+    english: "Makasar",
+    native: "Makasar",
+    direction: "ltr"
+  },
+  {
+    code: "mg",
+    english: "Malagasy",
+    native: "Malagasy",
+    direction: "ltr"
+  },
+  {
+    code: "mi",
+    english: "M\u0101ori",
+    native: "M\u0101ori",
+    direction: "ltr"
+  },
+  {
+    code: "min",
+    english: "Minangkabau",
+    native: "Minangkabau",
+    direction: "ltr"
+  },
+  {
+    code: "mk",
+    english: "Macedonian",
+    native: "\u043C\u0430\u043A\u0435\u0434\u043E\u043D\u0441\u043A\u0438",
+    direction: "ltr"
+  },
+  {
+    code: "ml",
+    english: "Malayalam",
+    native: "\u0D2E\u0D32\u0D2F\u0D3E\u0D33\u0D02",
+    direction: "ltr"
+  },
+  {
+    code: "mn",
+    english: "Mongolian",
+    native: "\u043C\u043E\u043D\u0433\u043E\u043B",
+    direction: "ltr"
+  },
+  {
+    code: "mni-mtei",
+    english: "Manipuri (Meitei Mayek)",
+    native: "\u09AE\u09C8\u09A4\u09C8\u09B2\u09CB\u09A8\u09CD (\u09AE\u09C0\u09A4\u09C8 \u09AE\u09AF\u09BC\u09C7\u0995)",
+    direction: "ltr"
+  },
+  {
+    code: "mr",
+    english: "Marathi",
+    native: "\u092E\u0930\u093E\u0920\u0940",
+    direction: "ltr"
+  },
+  {
+    code: "ms",
+    english: "Malay",
+    native: "Melayu",
+    direction: "ltr"
+  },
+  {
+    code: "ms-arab",
+    english: "Malay (Arabic)",
+    native: "Melayu (Arab)",
+    direction: "ltr"
+  },
+  {
+    code: "mt",
+    english: "Maltese",
+    native: "Malti",
+    direction: "ltr"
+  },
+  {
+    code: "my",
+    english: "Burmese",
+    native: "\u1019\u103C\u1014\u103A\u1019\u102C",
+    direction: "ltr"
+  },
+  {
+    code: "nb",
+    english: "Norwegian Bokm\xE5l",
+    native: "norsk bokm\xE5l",
+    direction: "ltr"
+  },
+  {
+    code: "ne",
+    english: "Nepali",
+    native: "\u0928\u0947\u092A\u093E\u0932\u0940",
+    direction: "ltr"
+  },
+  {
+    code: "new",
+    english: "Newari",
+    native: "Newari",
+    direction: "ltr"
+  },
+  {
+    code: "nl",
+    english: "Dutch",
+    native: "Nederlands",
+    direction: "ltr"
+  },
+  {
+    code: "nl-be",
+    english: "Flemish",
+    native: "Vlaams",
+    direction: "ltr"
+  },
+  {
+    code: "no",
+    english: "Norwegian",
+    native: "norsk",
+    direction: "ltr"
+  },
+  {
+    code: "nr",
+    english: "South Ndebele",
+    native: "South Ndebele",
+    direction: "ltr"
+  },
+  {
+    code: "nso",
+    english: "Northern Sotho",
+    native: "Northern Sotho",
+    direction: "ltr"
+  },
+  {
+    code: "nus",
+    english: "Nuer",
+    native: "Thok Nath",
+    direction: "ltr"
+  },
+  {
+    code: "ny",
+    english: "Nyanja",
+    native: "Nyanja",
+    direction: "ltr"
+  },
+  {
+    code: "oc",
+    english: "Occitan",
+    native: "occitan",
+    direction: "ltr"
+  },
+  {
+    code: "om",
+    english: "Oromo",
+    native: "Oromoo",
+    direction: "ltr"
+  },
+  {
+    code: "or",
+    english: "Odia",
+    native: "\u0B13\u0B21\u0B3C\u0B3F\u0B06",
+    direction: "ltr"
+  },
+  {
+    code: "pa",
+    english: "Punjabi",
+    native: "\u0A2A\u0A70\u0A1C\u0A3E\u0A2C\u0A40",
+    direction: "ltr"
+  },
+  {
+    code: "pa-arab",
+    english: "Punjabi (Arabic)",
+    native: "\u067E\u0646\u062C\u0627\u0628\u06CC (\u0639\u0631\u0628\u06CC)",
+    direction: "ltr"
+  },
+  {
+    code: "pa-pk",
+    english: "Punjabi (Pakistan)",
+    native: "\u067E\u0646\u062C\u0627\u0628\u06CC (\u067E\u0627\u06A9\u0633\u062A\u0627\u0646)",
+    direction: "ltr"
+  },
+  {
+    code: "pag",
+    english: "Pangasinan",
+    native: "Pangasinan",
+    direction: "ltr"
+  },
+  {
+    code: "pam",
+    english: "Pampanga",
+    native: "Pampanga",
+    direction: "ltr"
+  },
+  {
+    code: "pap",
+    english: "Papiamento",
+    native: "Papiamento",
+    direction: "ltr"
+  },
+  {
+    code: "pl",
+    english: "Polish",
+    native: "polski",
+    direction: "ltr"
+  },
+  {
+    code: "ps",
+    english: "Pashto",
+    native: "\u067E\u069A\u062A\u0648",
+    direction: "rtl"
+  },
+  {
+    code: "pt",
+    english: "Portuguese",
+    native: "portugu\xEAs",
+    direction: "ltr"
+  },
+  {
+    code: "pt-br",
+    english: "Brazilian Portuguese",
+    native: "portugu\xEAs (Brasil)",
+    direction: "ltr"
+  },
+  {
+    code: "pt-pt",
+    english: "European Portuguese",
+    native: "portugu\xEAs europeu",
+    direction: "ltr"
+  },
+  {
+    code: "qu",
+    english: "Quechua",
+    native: "Runasimi",
+    direction: "ltr"
+  },
+  {
+    code: "rn",
+    english: "Rundi",
+    native: "Ikirundi",
+    direction: "ltr"
+  },
+  {
+    code: "ro",
+    english: "Romanian",
+    native: "rom\xE2n\u0103",
+    direction: "ltr"
+  },
+  {
+    code: "rom",
+    english: "Romany",
+    native: "Romany",
+    direction: "ltr"
+  },
+  {
+    code: "ru",
+    english: "Russian",
+    native: "\u0440\u0443\u0441\u0441\u043A\u0438\u0439",
+    direction: "ltr"
+  },
+  {
+    code: "rw",
+    english: "Kinyarwanda",
+    native: "Kinyarwanda",
+    direction: "ltr"
+  },
+  {
+    code: "sa",
+    english: "Sanskrit",
+    native: "\u0938\u0902\u0938\u094D\u0915\u0943\u0924 \u092D\u093E\u0937\u093E",
+    direction: "ltr"
+  },
+  {
+    code: "scn",
+    english: "Sicilian",
+    native: "Sicilian",
+    direction: "ltr"
+  },
+  {
+    code: "sd",
+    english: "Sindhi",
+    native: "\u0633\u0646\u068C\u064A",
+    direction: "rtl"
+  },
+  {
+    code: "sg",
+    english: "Sango",
+    native: "S\xE4ng\xF6",
+    direction: "ltr"
+  },
+  {
+    code: "shn",
+    english: "Shan",
+    native: "Shan",
+    direction: "ltr"
+  },
+  {
+    code: "si",
+    english: "Sinhala",
+    native: "\u0DC3\u0DD2\u0D82\u0DC4\u0DBD",
+    direction: "ltr"
+  },
+  {
+    code: "sk",
+    english: "Slovak",
+    native: "sloven\u010Dina",
+    direction: "ltr"
+  },
+  {
+    code: "sl",
+    english: "Slovenian",
+    native: "sloven\u0161\u010Dina",
+    direction: "ltr"
+  },
+  {
+    code: "sm",
+    english: "Samoan",
+    native: "Samoan",
+    direction: "ltr"
+  },
+  {
+    code: "sn",
+    english: "Shona",
+    native: "chiShona",
+    direction: "ltr"
+  },
+  {
+    code: "so",
+    english: "Somali",
+    native: "Soomaali",
+    direction: "ltr"
+  },
+  {
+    code: "sq",
+    english: "Albanian",
+    native: "shqip",
+    direction: "ltr"
+  },
+  {
+    code: "sr",
+    english: "Serbian",
+    native: "\u0441\u0440\u043F\u0441\u043A\u0438",
+    direction: "ltr"
+  },
+  {
+    code: "ss",
+    english: "Swati",
+    native: "Swati",
+    direction: "ltr"
+  },
+  {
+    code: "st",
+    english: "Southern Sotho",
+    native: "Southern Sotho",
+    direction: "ltr"
+  },
+  {
+    code: "su",
+    english: "Sundanese",
+    native: "Basa Sunda",
+    direction: "ltr"
+  },
+  {
+    code: "sv",
+    english: "Swedish",
+    native: "svenska",
+    direction: "ltr"
+  },
+  {
+    code: "sw",
+    english: "Swahili",
+    native: "Kiswahili",
+    direction: "ltr"
+  },
+  {
+    code: "szl",
+    english: "Silesian",
+    native: "\u015Bl\u014Dnski",
+    direction: "ltr"
+  },
+  {
+    code: "ta",
+    english: "Tamil",
+    native: "\u0BA4\u0BAE\u0BBF\u0BB4\u0BCD",
+    direction: "ltr"
+  },
+  {
+    code: "te",
+    english: "Telugu",
+    native: "\u0C24\u0C46\u0C32\u0C41\u0C17\u0C41",
+    direction: "ltr"
+  },
+  {
+    code: "tet",
+    english: "Tetum",
+    native: "Tetum",
+    direction: "ltr"
+  },
+  {
+    code: "tg",
+    english: "Tajik",
+    native: "\u0442\u043E\u04B7\u0438\u043A\u04E3",
+    direction: "ltr"
+  },
+  {
+    code: "th",
+    english: "Thai",
+    native: "\u0E44\u0E17\u0E22",
+    direction: "ltr"
+  },
+  {
+    code: "ti",
+    english: "Tigrinya",
+    native: "\u1275\u130D\u122D\u129B",
+    direction: "ltr"
+  },
+  {
+    code: "tk",
+    english: "Turkmen",
+    native: "t\xFCrkmen dili",
+    direction: "ltr"
+  },
+  {
+    code: "tl",
+    english: "Filipino",
+    native: "Filipino",
+    direction: "ltr"
+  },
+  {
+    code: "tn",
+    english: "Tswana",
+    native: "Tswana",
+    direction: "ltr"
+  },
+  {
+    code: "tr",
+    english: "Turkish",
+    native: "T\xFCrk\xE7e",
+    direction: "ltr"
+  },
+  {
+    code: "ts",
+    english: "Tsonga",
+    native: "Tsonga",
+    direction: "ltr"
+  },
+  {
+    code: "tt",
+    english: "Tatar",
+    native: "\u0442\u0430\u0442\u0430\u0440",
+    direction: "ltr"
+  },
+  {
+    code: "ug",
+    english: "Uyghur",
+    native: "\u0626\u06C7\u064A\u063A\u06C7\u0631\u0686\u06D5",
+    direction: "rtl"
+  },
+  {
+    code: "uk",
+    english: "Ukrainian",
+    native: "\u0443\u043A\u0440\u0430\u0457\u043D\u0441\u044C\u043A\u0430",
+    direction: "ltr"
+  },
+  {
+    code: "ur",
+    english: "Urdu",
+    native: "\u0627\u0631\u062F\u0648",
+    direction: "rtl"
+  },
+  {
+    code: "uz",
+    english: "Uzbek",
+    native: "o\u2018zbek",
+    direction: "ltr"
+  },
+  {
+    code: "vi",
+    english: "Vietnamese",
+    native: "Ti\u1EBFng Vi\u1EC7t",
+    direction: "ltr"
+  },
+  {
+    code: "xh",
+    english: "Xhosa",
+    native: "IsiXhosa",
+    direction: "ltr"
+  },
+  {
+    code: "yi",
+    english: "Yiddish",
+    native: "\u05D9\u05D9\u05B4\u05D3\u05D9\u05E9",
+    direction: "rtl"
+  },
+  {
+    code: "yo",
+    english: "Yoruba",
+    native: "\xC8d\xE8 Yor\xF9b\xE1",
+    direction: "ltr"
+  },
+  {
+    code: "yua",
+    english: "yua",
+    native: "yua",
+    direction: "ltr"
+  },
+  {
+    code: "yue",
+    english: "Cantonese",
+    native: "\u7CB5\u8A9E",
+    direction: "ltr"
+  },
+  {
+    code: "zh",
+    english: "Chinese",
+    native: "\u4E2D\u6587",
+    direction: "ltr"
+  },
+  {
+    code: "zh-cn",
+    english: "Chinese (China)",
+    native: "\u4E2D\u6587\uFF08\u4E2D\u56FD\uFF09",
+    direction: "ltr"
+  },
+  {
+    code: "zh-hans",
+    english: "Simplified Chinese",
+    native: "\u7B80\u4F53\u4E2D\u6587",
+    direction: "ltr"
+  },
+  {
+    code: "zh-hant",
+    english: "Traditional Chinese",
+    native: "\u7E41\u9AD4\u4E2D\u6587",
+    direction: "ltr"
+  },
+  {
+    code: "zh-hk",
+    english: "Chinese (Hong Kong SAR China)",
+    native: "\u4E2D\u6587\uFF08\u4E2D\u570B\u9999\u6E2F\u7279\u5225\u884C\u653F\u5340\uFF09",
+    direction: "ltr"
+  },
+  {
+    code: "zh-tw",
+    english: "Chinese (Taiwan)",
+    native: "\u4E2D\u6587\uFF08\u53F0\u7063\uFF09",
+    direction: "ltr"
+  },
+  {
+    code: "zu",
+    english: "Zulu",
+    native: "isiZulu",
+    direction: "ltr"
+  }
+];
+
+// src/shared/languages/normalize.ts
+function normalizeLanguageCode(code) {
+  return code.trim().toLowerCase().replace(/_/g, "-");
+}
+
+// src/shared/languages/catalog/index.ts
+var generatedLanguageCatalog = languages_default;
+function buildLanguageCatalog(raw) {
+  return Object.freeze(raw.map((r) => ({ ...r, code: normalizeLanguageCode(r.code) })));
+}
+function filterLanguageCatalog(catalog2, filter) {
+  const all = [...catalog2];
+  const q = filter?.trim().toLowerCase();
+  if (!q) return all.sort((a, b) => a.code.localeCompare(b.code));
+  return all.filter(
+    (r) => r.code.includes(q) || r.english.toLowerCase().includes(q) || r.native.toLowerCase().includes(q)
+  ).sort((a, b) => a.code.localeCompare(b.code));
+}
+function getLanguageByCodeFromCatalog(catalog2, code) {
+  const n = normalizeLanguageCode(code);
+  return catalog2.find((r) => r.code === n);
+}
+function suggestCatalogCodesForInvalidInputFromCatalog(catalog2, code, maxCodesInCatalogHint = 5) {
+  const n = normalizeLanguageCode(code);
+  const all = [...catalog2].sort((a, b) => a.code.localeCompare(b.code));
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (c) => {
+    if (!seen.has(c)) {
+      seen.add(c);
+      out.push(c);
+    }
+  };
+  for (const r of filterLanguageCatalog(catalog2, n)) {
+    push(r.code);
+    if (out.length >= maxCodesInCatalogHint) return out;
+  }
+  if (n.length >= 2) {
+    const prefix = n.slice(0, 2);
+    for (const r of all) {
+      if (r.code.startsWith(prefix)) push(r.code);
+      if (out.length >= maxCodesInCatalogHint) return out;
+    }
+  }
+  for (const r of all) {
+    push(r.code);
+    if (out.length >= maxCodesInCatalogHint) return out;
+  }
+  return out;
+}
+
+// src/config/locales/sourceValidate.ts
+var MAX_CATALOG_HINT = 5;
+var LANGUAGE_CODE_SHAPE = /^[a-z]{2}(-[a-z0-9]{2,8})*$/i;
+function catalog() {
+  return buildLanguageCatalog(generatedLanguageCatalog);
+}
+function classifyLocalesSourceInput(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return "invalid_shape";
+  if (trimmed.includes("/") || trimmed.includes("\\")) return "path";
+  if (trimmed.toLowerCase().endsWith(".json")) return "json_filename";
+  if (!LANGUAGE_CODE_SHAPE.test(trimmed)) return "invalid_shape";
+  return "language_code";
+}
+function catalogHintLine(code) {
+  const hints = suggestCatalogCodesForInvalidInputFromCatalog(catalog(), code, MAX_CATALOG_HINT);
+  return hints.length > 0 ? hints.join(", ") : null;
+}
+function localesSourceFieldMessage(raw, detail) {
+  return `locales.source is ${JSON.stringify(raw)} in your config \u2014 ${detail}`;
+}
+function unsupportedLanguageCodeFailure(code, raw) {
+  const hint = catalogHintLine(code);
+  if (hint === null) {
+    return {
+      ok: false,
+      issueCode: ISSUE_PROJECT_LOCALES_SOURCE_NOT_LANGUAGE_CODE,
+      message: localesSourceFieldMessage(
+        raw,
+        `"${code}" is not a supported language code. Set a BCP47 tag only (e.g. en, pt-br), not a file path or *.json. Run i18nprune languages for the full catalog.`
+      )
+    };
+  }
+  return {
+    ok: false,
+    issueCode: ISSUE_LANGUAGES_UNSUPPORTED_LANGUAGE_CODE,
+    message: localesSourceFieldMessage(
+      raw,
+      `"${code}" is not a supported language code \u2014 try: ${hint}. Set a BCP47 tag only (not a path or *.json). Run i18nprune languages for the full list.`
+    )
+  };
+}
+function rejectNotLanguageCode(raw, detail) {
+  return {
+    ok: false,
+    issueCode: ISSUE_PROJECT_LOCALES_SOURCE_NOT_LANGUAGE_CODE,
+    message: localesSourceFieldMessage(raw, detail)
+  };
+}
+function validateLocalesSourceConfigValue(raw) {
+  const trimmed = raw.trim();
+  const kind = classifyLocalesSourceInput(trimmed);
+  if (kind === "path") {
+    const tail = trimmed.replace(/\\/g, "/").split("/").pop() ?? trimmed;
+    if (tail.toLowerCase().endsWith(".json")) {
+      const guess = normalizeLanguageCode(tail.replace(/\.json$/i, ""));
+      if (!getLanguageByCodeFromCatalog(catalog(), guess)) {
+        return unsupportedLanguageCodeFailure(guess, trimmed);
+      }
+      return rejectNotLanguageCode(
+        trimmed,
+        `use the language code "${guess}" instead of a file path (paths belong in locales.directory / layout, not locales.source).`
+      );
+    }
+    return rejectNotLanguageCode(
+      trimmed,
+      "must be a BCP47 language code (e.g. en, pt-br), not a file path \u2014 remove directory segments and use only the locale tag."
+    );
+  }
+  if (kind === "json_filename") {
+    const guess = normalizeLanguageCode(trimmed.replace(/\.json$/i, ""));
+    if (getLanguageByCodeFromCatalog(catalog(), guess)) {
+      return rejectNotLanguageCode(
+        trimmed,
+        `use the language code "${guess}" instead of the filename "${trimmed}" (locales.source is the tag only; JSON paths come from locales.directory and layout).`
+      );
+    }
+    const hinted = unsupportedLanguageCodeFailure(guess, trimmed);
+    if (!hinted.ok && hinted.issueCode === ISSUE_LANGUAGES_UNSUPPORTED_LANGUAGE_CODE) {
+      return hinted;
+    }
+    return rejectNotLanguageCode(
+      trimmed,
+      `use a supported language code instead of "${trimmed}". Run i18nprune languages for supported tags.`
+    );
+  }
+  if (kind === "invalid_shape") {
+    const candidate = normalizeLanguageCode(trimmed);
+    const hinted = unsupportedLanguageCodeFailure(candidate, trimmed);
+    if (!hinted.ok && hinted.issueCode === ISSUE_LANGUAGES_UNSUPPORTED_LANGUAGE_CODE) {
+      return hinted;
+    }
+    return rejectNotLanguageCode(
+      trimmed,
+      "is not a valid language code shape. Use a BCP47 tag (e.g. en, pt-br). Run i18nprune languages for supported codes."
+    );
+  }
+  const code = normalizeLanguageCode(trimmed);
+  if (!getLanguageByCodeFromCatalog(catalog(), code)) {
+    return unsupportedLanguageCodeFailure(code, trimmed);
+  }
+  return { ok: true, code };
+}
+function issueLocalesSourceNotInBundle(input) {
+  const present = input.presentCodes.length > 0 ? input.presentCodes.map((c) => normalizeLanguageCode(c)).join(", ") : "(none discovered)";
+  return {
+    issueCode: ISSUE_PROJECT_LOCALES_SOURCE_NOT_IN_BUNDLE,
+    message: `locales.source is "${input.sourceCode}" but no locale JSON segments for that code were found under ${input.directory}. Locales on disk: ${present}.`
+  };
+}
+
+// src/config/schema/root.ts
+var preserveSchema = z.object({
+  copyKeys: z.array(z.string()).optional().describe("Locale key paths that must mirror the source locale verbatim (exact matches)."),
+  copyPrefixes: z.array(z.string()).optional().describe("Key path prefixes treated like copyKeys (prefix match).")
+}).optional().describe("Preserve policy: keys/prefixes that must not be freely translated or drifted.");
+var paritySchema = z.object({
+  excludeKeys: z.array(z.string()).optional().describe("Key paths excluded from source-identical / drift checks (exact)."),
+  excludePrefixes: z.array(z.string()).optional().describe("Key path prefixes excluded from parity checks."),
+  excludeValues: z.array(z.string()).optional().describe("Locale string values excluded from parity checks.")
+}).optional().describe("Parity policy: exclusions for \u201Csame as source\u201D style checks.");
+var policiesSchema = z.object({
+  preserve: preserveSchema,
+  parity: paritySchema
+}).optional().describe("High-level preserve / parity rules used across sync, quality, cleanup, generate, etc.");
+var missingCommandSchema = z.object({
+  placeholder: z.string().optional().describe("String merged at each new key path for missing; omit for built-in sentinel.")
+}).strict().optional().describe("Defaults for the missing command.");
+var outputSchema = z.object({
+  list: z.object({
+    top: z.number().int().positive().max(1e5).optional().describe("Default max rows for bounded human lists when --top is omitted."),
+    full: z.boolean().optional().describe("When true, show all rows where the command supports it."),
+    maxCap: z.number().int().positive().max(1e6).optional().describe("Hard ceiling for list size even when full is used.")
+  }).strict().optional().describe("Human-readable list caps for previews and summaries.")
+}).strict().optional().describe("CLI-wide defaults for human list-style output.");
+var referenceDefaultsSchema = z.object({
+  treatCommentedCallSitesAsRuntime: z.boolean().optional().describe("When false, translation calls inside comments do not count as runtime evidence."),
+  treatNonSourceFileSitesAsRuntime: z.boolean().optional().describe("When false, non-source file call sites are ignored for uncertainty."),
+  uncertainKeyPolicy: z.enum(["protect", "allow", "warn_only"]).optional().describe("How dynamic / uncertain key prefixes are handled (protect is safest)."),
+  stringPresence: z.enum(["guard", "warn", "off"]).optional().describe("Whether ripgrep checks locale strings in src before destructive cleanup."),
+  stringPresenceMaxHitsPerKey: z.number().int().positive().max(1e3).optional().describe("Max rg JSON matches recorded per key (performance cap)."),
+  respectPreserve: z.boolean().optional().describe("When true, `generate --resume` skips paths matching policies.preserve (same as full generate).")
+}).passthrough().describe("Reference / uncertainty policy fields (defaults or per-operation override).");
+var referenceCommandsSchema = z.object({
+  cleanup: referenceDefaultsSchema.optional().describe("Overrides reference.defaults when running i18nprune cleanup."),
+  sync: referenceDefaultsSchema.optional().describe("Overrides reference.defaults when running i18nprune sync."),
+  generate: referenceDefaultsSchema.optional().describe("Overrides reference.defaults when running i18nprune generate (including `generate --resume`).")
+}).passthrough().describe(
+  "Per-operation reference overrides. Supported keys: cleanup, sync, generate. Unknown keys are preserved for forward compatibility."
+).optional();
+var referenceSchema = z.object({
+  defaults: referenceDefaultsSchema.optional().describe("Baseline merged before reference.commands.<operation> for each operation."),
+  commands: referenceCommandsSchema
+}).passthrough().optional().describe("Uncertainty and string-presence policy: defaults plus optional per-operation blocks.");
+var excludeSchema = z.object({
+  preset: z.enum(["production"]).optional().describe("Built-in preset for common production skip sets (when defined)."),
+  dirs: z.array(z.union([z.string(), z.instanceof(RegExp)])).optional().describe("Directory names or regexes to skip while scanning."),
+  files: z.array(z.union([z.string(), z.instanceof(RegExp)])).optional().describe("File paths or regexes to skip."),
+  extensions: z.array(z.union([z.string(), z.instanceof(RegExp)])).optional().describe("File extensions to skip."),
+  patterns: z.array(z.instanceof(RegExp)).optional().describe("Path regexes to skip under src."),
+  useDefaultSkip: z.boolean().optional().describe("When true, apply built-in directory skips (node_modules, dist, etc.).")
+}).strict().optional().describe("Scanner skip rules beyond CLI flags.");
+var scannerSchema = z.object({
+  mode: z.enum(["serial", "concurrent", "auto"]).optional().describe("Scan worker layout: serial, concurrent, or auto-tuned."),
+  concurrency: z.number().int().positive().max(4096).optional().describe("Worker count hint when mode is concurrent or auto."),
+  hardCap: z.number().int().positive().max(4096).optional().describe("Upper bound on concurrent units (core may clamp).")
+}).strict().optional().describe("Optional scan orchestration hints.");
+var cacheSchema = z.object({
+  enabled: z.boolean().optional().describe("Master switch for core-owned project analysis cache."),
+  dir: z.string().optional().describe("Cache root directory. Relative paths resolve from the project root; omit to use the host default."),
+  profile: z.enum(["safe", "balanced", "fast"]).optional().describe(
+    "Named preset for cache rebuild policy. Default 'balanced' when omitted. Explicit rebuild, threshold, or mode below override the profile when set."
+  ),
+  mode: z.enum(["readWrite", "readOnly"]).optional().describe(
+    "readWrite (default): cache may persist hits and misses. readOnly: reuse valid cache on disk but skip all cache writes (meta, files index, snapshots). Overrides cache.profile when set."
+  ),
+  rebuild: z.enum(["partial", "full"]).optional().describe(
+    "How to rebuild analysis.json on cache miss. Overrides cache.profile when set. 'partial': patch from delta when safe. 'full': always run a full project scan."
+  ),
+  fullRescanThresholdPercent: z.number().min(0).max(100).optional().describe(
+    "When rebuild is 'partial', fall back to a full src scan if (added+changed+deleted) src files reach this percent of tracked src files. Overrides cache.profile when set. Ignored when rebuild is 'full'."
+  )
+}).strict().optional().describe("Project cache policy shared by core operations. Hosts provide runtime adapters and the default root.");
+var localeLeavesSchema = z.object({
+  mode: z.enum(["structured", "legacy_string"]).optional().describe("JSON leaf shape: structured objects vs plain strings."),
+  sync: z.object({
+    stripMetadata: z.boolean().optional().describe("When true, sync may strip structured metadata back to plain strings.")
+  }).strict().optional().describe("Options that apply when running sync.")
+}).strict().optional().describe("How sync and generate read/write JSON terminals.");
+var localesFilesystemSchema = z.object({
+  source: z.string().describe("Source locale language code (e.g. en, pt-BR). Not a file path \u2014 layout + directory locate JSON segments."),
+  directory: z.string().describe("Directory containing locale JSON segment files, relative to the config file directory."),
+  mode: z.enum(["flat_file", "locale_directory"]).optional().describe("Filesystem layout: `flat_file` is one JSON file per locale code under `directory`."),
+  structure: z.enum(["locale_file", "locale_per_dir", "feature_bundle"]).optional().describe("How multiple JSON files group into one logical locale.")
+}).strict().describe("Locale files on disk: source document + bundle root, with optional topology hints.");
+var patchingSchema = z.object({
+  enabled: z.boolean().optional().describe("Master switch for loader / generated-file patching."),
+  recipe: z.enum(["loader_generated"]).optional().describe("Which patching recipe to run when enabled."),
+  loaderPath: z.string().optional().describe("Path to generated patching loader output (for example src/i18n/loaders.generated.ts)."),
+  configPath: z.string().optional().describe("Path to JSON consumed by the loader."),
+  localeJsonImportBase: z.string().optional().describe(
+    "Path to the locales directory relative to the folder that contains i18nprune.config.* (often the repo root). Core computes import() URLs inside loaders.generated.ts from this."
+  ),
+  sizeLimitBytes: z.number().int().positive().max(16 * 1024 * 1024).optional().describe("Max bytes to read when patching (safety)."),
+  mode: z.enum(["warn_skip", "strict"]).optional().describe("warn_skip logs and continues on oversize; strict fails the run.")
+}).strict().optional().describe("Auto-patch loader wiring for patch / generate --patch.");
+var configSchema = z.object({
+  locales: localesFilesystemSchema,
+  src: z.string().describe("Root directory scanned for translation helper calls."),
+  functions: z.array(z.string()).min(1).describe("Function names treated as translation entry points (e.g. t)."),
+  exclude: excludeSchema,
+  output: outputSchema,
+  scanner: scannerSchema,
+  cache: cacheSchema,
+  policies: policiesSchema,
+  reference: referenceSchema,
+  localeLeaves: localeLeavesSchema,
+  patching: patchingSchema,
+  missing: missingCommandSchema,
+  translate: translateSchema
+}).describe("i18nprune project configuration (merged with defaults then validated by parseI18nPruneConfig).");
+var ConfigValidationError = class extends Error {
+  constructor(message, zodError, issueCode) {
+    super(message);
+    this.zodError = zodError;
+    this.issueCode = issueCode;
+    this.name = "ConfigValidationError";
+  }
+  zodError;
+  issueCode;
+};
+function isConfigValidationError(err) {
+  if (err instanceof ConfigValidationError) return true;
+  if (typeof err !== "object" || err === null || !(err instanceof Error)) return false;
+  if (err.name !== "ConfigValidationError") return false;
+  const code = err.issueCode;
+  return code === void 0 || typeof code === "string";
+}
+function parseI18nPruneConfig(raw) {
+  const r = configSchema.safeParse(raw);
+  if (!r.success) {
+    throw new ConfigValidationError(
+      `Invalid i18nprune config: ${r.error.message}`,
+      r.error
+    );
+  }
+  const sourceCheck = validateLocalesSourceConfigValue(r.data.locales.source);
+  if (!sourceCheck.ok) {
+    throw new ConfigValidationError(sourceCheck.message, void 0, sourceCheck.issueCode);
+  }
+  const locales = { ...r.data.locales, source: sourceCheck.code };
+  return { ...r.data, locales };
+}
+
+// src/shared/locales/enumerate/parseSegmentLocale.ts
+function localeCodeForSegment(structure, path, segment) {
+  if (structure === "locale_file") {
+    if (segment.relativePath.includes("/")) return null;
+    return path.basename(segment.absolutePath, ".json");
+  }
+  if (structure === "locale_per_dir") {
+    const slash = segment.relativePath.indexOf("/");
+    if (slash < 0) return null;
+    const locale = segment.relativePath.slice(0, slash);
+    return locale.length > 0 ? locale : null;
+  }
+  if (structure === "feature_bundle") {
+    return path.basename(segment.absolutePath, ".json");
+  }
+  return null;
+}
+
+// src/shared/locales/diagnostics/structuralParity.ts
+function localeStructuralSlot(structure, relativePath) {
+  if (structure === "locale_per_dir") {
+    const slash = relativePath.indexOf("/");
+    if (slash < 0) return null;
+    const slot = relativePath.slice(slash + 1);
+    return slot.length > 0 ? slot : null;
+  }
+  if (structure === "feature_bundle") {
+    const slash = relativePath.lastIndexOf("/");
+    if (slash < 0) return null;
+    const slot = relativePath.slice(0, slash);
+    return slot.length > 0 ? slot : null;
+  }
+  return null;
+}
+function slotsByLocale(structure, segments) {
+  const byLocale = /* @__PURE__ */ new Map();
+  for (const segment of segments) {
+    const slot = localeStructuralSlot(structure, segment.relativePath);
+    if (slot === null) continue;
+    let set = byLocale.get(segment.locale);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      byLocale.set(segment.locale, set);
+    }
+    set.add(slot);
+  }
+  return byLocale;
+}
+function pickReferenceLocale(byLocale, preferred) {
+  if (preferred !== void 0 && byLocale.has(preferred)) return preferred;
+  let best = null;
+  let bestSize = -1;
+  for (const [locale, slots] of byLocale) {
+    if (slots.size > bestSize) {
+      best = locale;
+      bestSize = slots.size;
+    }
+  }
+  return best;
+}
+function collectLocaleStructuralParityDiagnostics(input) {
+  const { structure, segments } = input;
+  if (structure !== "locale_per_dir" && structure !== "feature_bundle") {
+    return [];
+  }
+  const byLocale = slotsByLocale(structure, segments);
+  if (byLocale.size < 2) return [];
+  const reference = pickReferenceLocale(byLocale, input.referenceLocale);
+  if (reference === null) return [];
+  const referenceSlots = byLocale.get(reference);
+  if (!referenceSlots || referenceSlots.size === 0) return [];
+  const diagnostics = [];
+  for (const [locale, slots] of byLocale) {
+    if (locale === reference) continue;
+    for (const slot of referenceSlots) {
+      if (!slots.has(slot)) {
+        diagnostics.push({
+          level: "warn",
+          code: "locale_structure_slot_missing",
+          message: `locale ${locale} is missing segment slot ${slot} (present for reference locale ${reference})`
+        });
+      }
+    }
+    for (const slot of slots) {
+      if (!referenceSlots.has(slot)) {
+        diagnostics.push({
+          level: "warn",
+          code: "locale_structure_slot_extra",
+          message: `locale ${locale} has extra segment slot ${slot} (not present for reference locale ${reference})`
+        });
+      }
+    }
+  }
+  diagnostics.sort((a, b) => a.message.localeCompare(b.message));
+  return diagnostics;
+}
+
+// src/shared/errors/internal.ts
+var I18nPruneError = class extends Error {
+  code;
+  issueCode;
+  constructor(message, code, options) {
+    super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.name = "I18nPruneError";
+    this.code = code;
+    this.issueCode = options?.issueCode;
+  }
+};
+
+// src/runtime/helpers/sync/assert.ts
+function isThenable(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function assertSyncPortResult(value, label, at) {
+  if (isThenable(value)) {
+    throw new I18nPruneError(
+      `Synchronous ${label} requires a plain value (got a Promise at ${at})`,
+      "USAGE"
+    );
+  }
+  return value;
+}
+
+// src/runtime/helpers/sync/fs.ts
+function existsRuntimeFsSync(filePath, fs) {
+  return assertSyncPortResult(fs.exists(filePath), "fs.exists", filePath);
+}
+function listRuntimeFsDirSync(dirPath, fs) {
+  return assertSyncPortResult(fs.listDir(dirPath), "fs.listDir", dirPath);
+}
+
+// src/shared/constants/locales.ts
+var MAX_LOCALE_SEGMENT_TREE_DEPTH = 16;
+
+// src/shared/locales/enumerate/walkJsonTree.ts
+function posixRelative(pathApi, root, absolute) {
+  let rel = pathApi.relative(root, absolute);
+  if (rel.startsWith("..") || pathApi.isAbsolute(rel)) {
+    rel = pathApi.basename(absolute);
+  }
+  return rel.replace(/\\/g, "/");
+}
+function walkLocaleJsonSegments(input) {
+  const { fs, path, rootAbsolute, recursive } = input;
+  const maxDepth = input.maxDepth ?? MAX_LOCALE_SEGMENT_TREE_DEPTH;
+  const out = [];
+  function visit(dirAbsolute, depth) {
+    if (!existsRuntimeFsSync(dirAbsolute, fs)) return;
+    const entries = listRuntimeFsDirSync(dirAbsolute, fs);
+    for (const entry of entries) {
+      const childAbsolute = path.join(dirAbsolute, entry.name);
+      if (entry.kind === "file" && entry.name.endsWith(".json")) {
+        out.push({
+          absolutePath: childAbsolute,
+          relativePath: posixRelative(path, rootAbsolute, childAbsolute)
+        });
+      } else if (recursive && entry.kind === "directory" && depth < maxDepth) {
+        visit(childAbsolute, depth + 1);
+      }
+    }
+  }
+  visit(rootAbsolute, 0);
+  return out;
+}
+
+// src/shared/locales/enumerate/listLocaleSegments.ts
+function listLocaleSegments(input) {
+  const diagnostics = [];
+  const { layout, fs, path } = input;
+  const recursive = layout.structure !== "locale_file";
+  const walked = walkLocaleJsonSegments({
+    fs,
+    path,
+    rootAbsolute: layout.directoryAbsolute,
+    recursive
+  });
+  const segments = [];
+  for (const segment of walked) {
+    const locale = localeCodeForSegment(layout.structure, path, segment);
+    if (locale === null) continue;
+    segments.push({
+      locale,
+      relativePath: segment.relativePath,
+      absolutePath: segment.absolutePath
+    });
+  }
+  segments.sort((a, b) => {
+    const byLocale = a.locale.localeCompare(b.locale);
+    if (byLocale !== 0) return byLocale;
+    return a.relativePath.localeCompare(b.relativePath);
+  });
+  diagnostics.push(
+    ...collectLocaleStructuralParityDiagnostics({
+      structure: layout.structure,
+      segments
+    })
+  );
+  return { segments, diagnostics };
+}
+
+// src/shared/locales/layout/requireStructure.ts
+function localesMode(config) {
+  return config.mode ?? "flat_file";
+}
+function isLocalesStructureRequired(config) {
+  return localesMode(config) === "locale_directory" && config.structure === void 0;
+}
+function resolveLocalesStructure(config) {
+  if (config.structure !== void 0) {
+    return config.structure;
+  }
+  if (localesMode(config) === "flat_file") {
+    return "locale_file";
+  }
+  throw new Error("locales.structure is required when locales.mode is locale_directory");
+}
+
+// src/shared/locales/layout/resolveLayout.ts
+function resolveLocalesLayout(config, directoryAbsolute) {
+  const mode = localesMode(config);
+  const structure = resolveLocalesStructure(config);
+  return { mode, structure, directoryAbsolute, config };
+}
+
+// src/config/locales/sourceResolve.ts
+var STRUCTURE_GUESS_ORDER = [
+  "locale_per_dir",
+  "feature_bundle",
+  "locale_file"
+];
+function resolveSourceLocaleAbsoluteBeforeStructureKnown(input) {
+  const { directoryAbsolute, path, fs, sourceCode } = input;
+  if (fs) {
+    const walked = walkLocaleJsonSegments({
+      fs,
+      path,
+      rootAbsolute: directoryAbsolute,
+      recursive: true
+    });
+    const matches = [];
+    for (const segment of walked) {
+      for (const structure of STRUCTURE_GUESS_ORDER) {
+        const locale = localeCodeForSegment(structure, path, segment);
+        if (locale !== null && normalizeLanguageCode(locale) === sourceCode) {
+          matches.push({ relativePath: segment.relativePath, absolutePath: segment.absolutePath });
+          break;
+        }
+      }
+    }
+    if (matches.length > 0) {
+      const sorted = matches.slice().sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+      return sorted[0].absolutePath;
+    }
+  }
+  return path.join(directoryAbsolute, `${sourceCode}.json`);
+}
+function pickPrimarySegmentAbsolute(path, directoryAbsolute, matches) {
+  const sorted = matches.slice().sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+  return path.join(directoryAbsolute, sorted[0].relativePath);
+}
+function resolveSourceLocaleAbsolutePath(input) {
+  const code = normalizeLanguageCode(input.locales.source);
+  if (isLocalesStructureRequired(input.locales)) {
+    return resolveSourceLocaleAbsoluteBeforeStructureKnown({
+      directoryAbsolute: input.directoryAbsolute,
+      path: input.path,
+      fs: input.fs,
+      sourceCode: code
+    });
+  }
+  const layout = resolveLocalesLayout(input.locales, input.directoryAbsolute);
+  if (layout.mode === "flat_file" && layout.structure === "locale_file") {
+    return input.path.join(input.directoryAbsolute, `${code}.json`);
+  }
+  if (input.fs) {
+    const { segments } = listLocaleSegments({ layout, fs: input.fs, path: input.path });
+    const matches = segments.filter((s) => normalizeLanguageCode(s.locale) === code);
+    if (matches.length > 0) {
+      return pickPrimarySegmentAbsolute(input.path, input.directoryAbsolute, matches);
+    }
+  }
+  return input.path.join(input.directoryAbsolute, `${code}.json`);
+}
+function resolveSourceLocaleAbsoluteFromRelPaths(input) {
+  const code = normalizeLanguageCode(input.locales.source);
+  const layout = resolveLocalesLayout(input.locales, input.directoryAbsolute);
+  const dirRel = input.path.relative(input.projectRootAbsolute, input.directoryAbsolute).replace(/\\/g, "/");
+  const prefix = dirRel === "." || dirRel === "" ? "" : `${dirRel}/`;
+  const matches = [];
+  for (const rel of input.relPaths) {
+    const normalized = rel.replace(/\\/g, "/");
+    if (!normalized.endsWith(".json")) continue;
+    if (prefix && !normalized.startsWith(prefix) && normalized !== `${dirRel}/${code}.json`) {
+      continue;
+    }
+    const underDir = prefix && normalized.startsWith(prefix) ? normalized.slice(prefix.length) : normalized;
+    const absolutePath = input.path.join(input.projectRootAbsolute, normalized);
+    const locale = localeCodeForSegment(layout.structure, input.path, {
+      absolutePath,
+      relativePath: underDir
+    });
+    if (locale !== null && normalizeLanguageCode(locale) === code) {
+      matches.push({ relativePath: underDir, absolutePath });
+    }
+  }
+  if (matches.length > 0) {
+    const sorted = matches.slice().sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+    return sorted[0].absolutePath;
+  }
+  return resolveSourceLocaleAbsolutePath({
+    locales: input.locales,
+    directoryAbsolute: input.directoryAbsolute,
+    path: input.path
+  });
+}
+
+// src/config/defaults/core.ts
+var CORE_CONFIG_DEFAULT_INPUT = {};
+
+// src/shared/constants/result.ts
+var RESULT_API_VERSION = "1";
+var DOCS_ISSUES_PAGE_PATH = "/issues";
+
+// src/shared/docs/issueAnchors.ts
+var DOC_ISSUE_PARENT_SEGMENTS = /* @__PURE__ */ new Set([
+  "cli",
+  "cleanup",
+  "config",
+  "context",
+  "doctor",
+  "generate",
+  "io",
+  "languages",
+  "locale",
+  "locales",
+  "missing",
+  "patching",
+  "paths",
+  "project",
+  "quality",
+  "report",
+  "scan",
+  "share",
+  "sync",
+  "translate",
+  "validate"
+]);
+function issueDocHeadingSlug(raw) {
+  return raw.toLowerCase().replace(/[.\s_]+/g, "-").replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function splitIssueCode(code) {
+  return code.trim().split(".");
+}
+function buildIssueCodeDocLinkParts(code) {
+  const trimmed = code.trim();
+  const parts = splitIssueCode(trimmed);
+  let parent = null;
+  if (parts.length >= 3 && parts[0] === "i18nprune") {
+    const p = parts[1];
+    if (DOC_ISSUE_PARENT_SEGMENTS.has(p)) parent = p;
+  }
+  let anchor;
+  if (parent) {
+    anchor = issueDocHeadingSlug(parts.slice(2).join("."));
+  } else {
+    anchor = issueDocHeadingSlug(trimmed.includes(".") ? trimmed.replace(/\./g, "_") : trimmed);
+  }
+  const sitePagePath = parent ? `${DOCS_ISSUES_PAGE_PATH}/${parent}` : DOCS_ISSUES_PAGE_PATH;
+  const repoDocPath = parent ? `issues/${parent}` : "issues";
+  return { parent, anchor, sitePagePath, repoDocPath };
+}
+function issueCodeRepoDocPathForIssueCode(code) {
+  return buildIssueCodeDocLinkParts(code).repoDocPath;
+}
+
+// src/shared/errors/normalize.ts
+function isErrnoCode(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+function normalizeUnknownError(error, input) {
+  if (error instanceof I18nPruneError) return error;
+  const extra = input.issueCode !== void 0 ? { issueCode: input.issueCode } : void 0;
+  if (error instanceof Error) {
+    return new I18nPruneError(`${input.when}: ${error.message}`, input.defaultCode, { cause: error, ...extra });
+  }
+  return new I18nPruneError(`${input.when}: ${String(error)}`, input.defaultCode, { cause: error, ...extra });
+}
+function issueFromI18nPruneError(error, input) {
+  const code = error.issueCode ?? input.codeByErrorCode?.[error.code] ?? input.fallbackCode;
+  const base = {
+    severity: "error",
+    code,
+    message: error.message
+  };
+  const withPath = input.path !== void 0 ? { ...base, path: input.path } : base;
+  if (!code.startsWith("i18nprune.")) return withPath;
+  return { ...withPath, docPath: issueCodeRepoDocPathForIssueCode(code) };
+}
+
+// src/shared/json/parse.ts
+var I18nPruneJsonParseError = class extends I18nPruneError {
+  filePath;
+  line;
+  column;
+  offset;
+  constructor(input) {
+    const options = input.issueCode !== void 0 ? { cause: input.cause, issueCode: input.issueCode } : { cause: input.cause };
+    super(input.message, input.code, options);
+    this.name = "I18nPruneJsonParseError";
+    this.filePath = input.filePath;
+    this.line = input.location.line;
+    this.column = input.location.column;
+    this.offset = input.location.offset;
+  }
+};
+function locationFromOffset(text, offset) {
+  let line = 1;
+  let column = 1;
+  const capped = Math.max(0, Math.min(offset, text.length));
+  for (let i = 0; i < capped; i += 1) {
+    if (text.charCodeAt(i) === 10) {
+      line += 1;
+      column = 1;
+    } else {
+      column += 1;
+    }
+  }
+  return { line, column, offset };
+}
+function getJsonParseLocation(error, text) {
+  const message = error instanceof Error ? error.message : String(error);
+  const positionMatch = /\bposition\s+(\d+)\b/i.exec(message);
+  if (positionMatch?.[1]) {
+    return locationFromOffset(text, Number.parseInt(positionMatch[1], 10));
+  }
+  const lineColumnMatch = /\bline\s+(\d+)\s+column\s+(\d+)\b/i.exec(message);
+  if (lineColumnMatch?.[1] && lineColumnMatch[2]) {
+    return {
+      line: Number.parseInt(lineColumnMatch[1], 10),
+      column: Number.parseInt(lineColumnMatch[2], 10)
+    };
+  }
+  return {};
+}
+function formatJsonParseMessage(filePath, location, cause) {
+  const subject = filePath ? `Invalid JSON in ${filePath}` : "Invalid JSON";
+  const at = location.line !== void 0 && location.column !== void 0 ? ` at line ${String(location.line)}, column ${String(location.column)}` : location.offset !== void 0 ? ` at offset ${String(location.offset)}` : "";
+  const detail = cause instanceof Error ? cause.message : String(cause);
+  return `${subject}${at}: ${detail}`;
+}
+function parseJsonText(text, options = {}) {
+  try {
+    return JSON.parse(text);
+  } catch (cause) {
+    const location = getJsonParseLocation(cause, text);
+    throw new I18nPruneJsonParseError({
+      message: formatJsonParseMessage(options.filePath, location, cause),
+      code: options.code ?? "IO",
+      cause,
+      location,
+      ...options.issueCode !== void 0 ? { issueCode: options.issueCode } : {},
+      ...options.filePath !== void 0 ? { filePath: options.filePath } : {}
+    });
+  }
+}
+
+// src/shared/constants/cache.ts
+var DEFAULT_CACHE_PROFILE_ID = "balanced";
+var CACHE_PROFILE_DEFAULTS = {
+  safe: {
+    rebuild: "full",
+    fullRescanThresholdPercent: 10,
+    mode: "readWrite"
+  },
+  balanced: {
+    rebuild: "partial",
+    fullRescanThresholdPercent: 40,
+    mode: "readWrite"
+  },
+  fast: {
+    rebuild: "partial",
+    fullRescanThresholdPercent: 70,
+    mode: "readWrite"
+  }
+};
+
+// src/cache/resolveConfig.ts
+function clampThresholdPercent(value) {
+  if (value < 0) return 0;
+  if (value > 100) return 100;
+  return value;
+}
+function resolveCacheConfig(cache) {
+  const profileId = cache?.profile ?? DEFAULT_CACHE_PROFILE_ID;
+  const profile = CACHE_PROFILE_DEFAULTS[profileId] ?? CACHE_PROFILE_DEFAULTS[DEFAULT_CACHE_PROFILE_ID];
+  const threshold = cache?.fullRescanThresholdPercent !== void 0 ? clampThresholdPercent(cache.fullRescanThresholdPercent) : profile.fullRescanThresholdPercent;
+  return {
+    enabled: cache?.enabled ?? true,
+    profile: profileId,
+    mode: cache?.mode ?? profile.mode,
+    rebuild: cache?.rebuild ?? profile.rebuild,
+    fullRescanThresholdPercent: threshold,
+    ...cache?.dir !== void 0 ? { dir: cache.dir } : {}
+  };
+}
+
+// src/shared/options/listWindow.ts
+var LIST_WINDOW_DEFAULT_TOP = 200;
+var LIST_WINDOW_HARD_CAP = 1e4;
+function clampPositiveInt(raw, fallback) {
+  if (typeof raw !== "number" || !Number.isFinite(raw) || !Number.isInteger(raw) || raw < 1) {
+    return fallback;
+  }
+  return raw;
+}
+function resolveListWindow(input, options) {
+  const hardCap = clampPositiveInt(options?.hardCap, LIST_WINDOW_HARD_CAP);
+  const defaultTopRaw = clampPositiveInt(options?.defaultTop, LIST_WINDOW_DEFAULT_TOP);
+  const defaultTop = Math.min(defaultTopRaw, hardCap);
+  if (input?.full === true) {
+    return {
+      top: hardCap,
+      full: true,
+      limit: hardCap,
+      hardCap,
+      clamped: false
+    };
+  }
+  const requestedTop = input?.top;
+  const top = clampPositiveInt(requestedTop, defaultTop);
+  const limit = Math.min(top, hardCap);
+  const isRequestedValidNumber = typeof requestedTop === "number" && Number.isFinite(requestedTop) && Number.isInteger(requestedTop);
+  return {
+    top,
+    full: false,
+    limit,
+    hardCap,
+    clamped: isRequestedValidNumber && requestedTop > hardCap
+  };
+}
+
+// src/shared/scanner/config.ts
+var SCANNER_DEFAULT_MODE = "auto";
+var SCANNER_DEFAULT_CONCURRENCY = 16;
+var SCANNER_DEFAULT_HARD_CAP = 32;
+function clampInt2(value, min, max) {
+  if (!Number.isFinite(value)) return min;
+  const n = Math.trunc(value);
+  if (n < min) return min;
+  if (n > max) return max;
+  return n;
+}
+function resolveScannerConfig(input, options) {
+  const hardCap = clampInt2(input?.hardCap ?? options?.defaultHardCap ?? SCANNER_DEFAULT_HARD_CAP, 1, 4096);
+  const mode = input?.mode ?? options?.defaultMode ?? SCANNER_DEFAULT_MODE;
+  const requested = clampInt2(
+    input?.concurrency ?? options?.defaultConcurrency ?? SCANNER_DEFAULT_CONCURRENCY,
+    1,
+    hardCap
+  );
+  const effectiveConcurrency = mode === "serial" ? 1 : requested;
+  return {
+    mode,
+    concurrency: requested,
+    hardCap,
+    effectiveConcurrency
+  };
+}
+
+// src/config/resolve/core.ts
+function mergeCoreConfigInputs(a, b) {
+  return {
+    output: {
+      list: {
+        ...a?.output?.list ?? {},
+        ...b?.output?.list ?? {}
+      }
+    },
+    scanner: {
+      ...a?.scanner ?? {},
+      ...b?.scanner ?? {}
+    },
+    cache: {
+      ...a?.cache ?? {},
+      ...b?.cache ?? {}
+    }
+  };
+}
+function resolveCoreConfig(input, options) {
+  const list = input?.output?.list;
+  return {
+    output: {
+      list: resolveListWindow(
+        list ? { top: list.top, full: list.full } : void 0,
+        {
+          ...options?.listWindow,
+          ...typeof list?.maxCap === "number" ? { hardCap: list.maxCap } : {}
+        }
+      )
+    },
+    scanner: resolveScannerConfig(input?.scanner, options?.scanner),
+    cache: resolveCacheConfig(input?.cache)
+  };
+}
+function resolveCoreConfigLayers(layers, options) {
+  const merged = layers.reduce((acc, layer) => mergeCoreConfigInputs(acc, layer.input), {});
+  return resolveCoreConfig(merged, options);
+}
+
+// src/config/resolve/load.ts
+function normalizeLoadError(configPath, error) {
+  if (isErrnoCode(error, "ENOENT")) {
+    return new I18nPruneError(`Config file not found: ${configPath}`, "CONFIG_MISSING", {
+      cause: error,
+      issueCode: ISSUE_CONFIG_MISSING
+    });
+  }
+  if (error instanceof SyntaxError) {
+    return new I18nPruneError(`Config parse failed at ${configPath}: ${error.message}`, "CONFIG_INVALID", {
+      cause: error,
+      issueCode: ISSUE_CONFIG_INVALID
+    });
+  }
+  return normalizeUnknownError(error, {
+    when: `Config load failed at ${configPath}`,
+    defaultCode: "IO",
+    issueCode: ISSUE_CONFIG_LOAD_FAILED
+  });
+}
+function issueFromI18nError(error, configPath) {
+  return issueFromI18nPruneError(error, {
+    codeByErrorCode: {
+      CONFIG_MISSING: "i18nprune.config.missing",
+      CONFIG_INVALID: "i18nprune.config.invalid"
+    },
+    fallbackCode: "i18nprune.config.load_failed",
+    path: configPath
+  });
+}
+async function loadCoreConfigFromPath(input) {
+  const parseText = input.parseText ?? ((text, configPath) => parseJsonText(text, {
+    filePath: configPath,
+    code: "CONFIG_INVALID",
+    issueCode: ISSUE_CONFIG_INVALID
+  }));
+  const cwd = input.runtime?.system?.cwd();
+  const effectivePath = cwd && input.runtime?.path && !input.runtime.path.isAbsolute(input.configPath) ? input.runtime.path.resolve(cwd, input.configPath) : input.configPath;
+  try {
+    const text = await input.readText(effectivePath);
+    const parsed = await parseText(text, effectivePath);
+    const asInput = typeof parsed === "object" && parsed !== null ? parsed : {};
+    return resolveCoreConfig(asInput, input.resolveOptions);
+  } catch (error) {
+    throw normalizeLoadError(effectivePath, error);
+  }
+}
+async function tryLoadCoreConfigFromPath(input, cwd = input.runtime?.system?.cwd() ?? "") {
+  try {
+    const data = await loadCoreConfigFromPath(input);
+    return {
+      ok: true,
+      kind: "core.config",
+      data,
+      issues: [],
+      meta: { apiVersion: RESULT_API_VERSION, cwd }
+    };
+  } catch (error) {
+    const normalized = error instanceof I18nPruneError ? error : normalizeLoadError(input.configPath, error);
+    return {
+      ok: false,
+      kind: "failed",
+      issues: [issueFromI18nError(normalized, input.configPath)],
+      meta: { apiVersion: RESULT_API_VERSION, cwd }
+    };
+  }
+}
+
+// src/config/resolve/mergePartial.ts
+function mergePartialConfigIntoBase(base, partial) {
+  const out = { ...base ?? {} };
+  for (const [k, v] of Object.entries(partial)) {
+    const existing = out[k];
+    if (v !== null && typeof v === "object" && !Array.isArray(v) && existing !== null && typeof existing === "object" && !Array.isArray(existing)) {
+      out[k] = mergePartialConfigIntoBase(existing, v);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+
+// src/shared/translator/providers/registry.ts
+var GOOGLE_DESCRIPTOR = {
+  id: "google",
+  label: "Google Translate (unofficial gtx endpoint)",
+  kind: "public_http",
+  envVars: []
+};
+var MYMEMORY_DESCRIPTOR = {
+  id: "mymemory",
+  label: "MyMemory Translation API (free tier)",
+  kind: "public_http",
+  envVars: [],
+  configKeys: [
+    {
+      key: "translate.providers row (id=mymemory).contactEmail",
+      description: "Optional MyMemory contact email",
+      optional: true
+    }
+  ]
+};
+var LIBRE_DESCRIPTOR = {
+  id: "libre",
+  label: "LibreTranslate-compatible HTTP API",
+  kind: "public_http",
+  envVars: [
+    {
+      key: "I18NPRUNE_TRANSLATE_LIBRE_URL",
+      description: "LibreTranslate instance origin (https://\u2026), no trailing slash",
+      required: false
+    }
+  ],
+  configKeys: [
+    {
+      key: "translate.providers row (id=libre).baseUrl",
+      description: "Instance origin (`https://\u2026`); superseded when `I18NPRUNE_TRANSLATE_LIBRE_URL` is set",
+      optional: true
+    }
+  ]
+};
+var DEEPL_DESCRIPTOR = {
+  id: "deepl",
+  label: "DeepL API",
+  kind: "api_key",
+  envVars: [
+    {
+      key: "I18NPRUNE_TRANSLATE_DEEPL_API_KEY",
+      description: "DeepL authentication key (preferred when using DeepL)",
+      required: false
+    }
+  ],
+  configKeys: [
+    {
+      key: "translate.providers row (id=deepl).apiKey",
+      description: "DeepL auth key \u2014 superseded by `I18NPRUNE_TRANSLATE_DEEPL_API_KEY` when set",
+      optional: true
+    }
+  ]
+};
+var LLM_DESCRIPTOR = {
+  id: "llm",
+  label: "OpenAI-compatible chat/completions API (LLM)",
+  kind: "llm",
+  envVars: [
+    {
+      key: "I18NPRUNE_TRANSLATE_LLM_API_KEY",
+      description: "Bearer token for the OpenAI-compatible API",
+      required: false
+    },
+    {
+      key: "I18NPRUNE_TRANSLATE_LLM_BASE_URL",
+      description: "API base URL (e.g. https://api.openai.com/v1)",
+      required: false
+    },
+    {
+      key: "I18NPRUNE_TRANSLATE_LLM_MODEL",
+      description: "Model id (e.g. gpt-4o-mini)",
+      required: false
+    }
+  ],
+  configKeys: [
+    {
+      key: "translate.providers row (id=llm): apiKey, baseUrl, model",
+      description: "OpenAI-compatible host; env `I18NPRUNE_TRANSLATE_LLM_*` supersede matching fields",
+      optional: true
+    }
+  ]
+};
+var DESCRIPTORS = [
+  GOOGLE_DESCRIPTOR,
+  MYMEMORY_DESCRIPTOR,
+  LIBRE_DESCRIPTOR,
+  DEEPL_DESCRIPTOR,
+  LLM_DESCRIPTOR
+];
+new Map(
+  DESCRIPTORS.map((d) => [d.id, d])
+);
+function defaultResolvedTranslationOptions() {
+  return { provider: "google" };
+}
+
+// src/config/resolve/translate.ts
+function clampInt3(n, lo, hi) {
+  if (!Number.isFinite(n)) return lo;
+  return Math.min(hi, Math.max(lo, Math.trunc(n)));
+}
+function toWarning(message) {
+  return {
+    severity: "warning",
+    code: ISSUE_TRANSLATE_CONFIG_DEFAULT_APPLIED,
+    message
+  };
+}
+function pickEnabledProviderRow(rows, providerId) {
+  return rows?.find((row) => row.id === providerId && row.enabled !== false);
+}
+function resolveProviderOrder(input) {
+  const head = input.providerIdPin ?? input.config?.primary ?? defaultResolvedTranslationOptions().provider;
+  const order = [head];
+  if (input.config?.policy?.routing !== "auto") return order;
+  for (const row of input.config?.providers ?? []) {
+    if (row.enabled === false) continue;
+    if (!order.includes(row.id)) order.push(row.id);
+  }
+  return order;
+}
+function resolveProviderProfile(config, providerId) {
+  const defaults = DEFAULT_PROVIDER_RATE_LIMITS[providerId];
+  const row = pickEnabledProviderRow(config?.providers, providerId)?.rateLimit;
+  const profile = {
+    maxConcurrency: clampInt3(row?.maxConcurrency ?? defaults.maxConcurrency, 1, TRANSLATE_WORKERS_CAP),
+    rpm: row?.rpm ?? defaults.rpm,
+    rps: row?.rps ?? defaults.rps,
+    intervalMs: row?.intervalMs ?? defaults.intervalMs
+  };
+  const startRateLimit = profile.rpm === void 0 && profile.rps === void 0 && profile.intervalMs === void 0 ? void 0 : { rpm: profile.rpm, rps: profile.rps, intervalMs: profile.intervalMs };
+  return { id: providerId, profile, startRateLimit };
+}
+function resolveTranslateConfig(input) {
+  const warnings = [];
+  const routing = input.config?.policy?.routing === "auto" ? "auto" : "single";
+  if (input.config === void 0) {
+    warnings.push(
+      toWarning(
+        "translate config omitted; using defaults (provider=google, routing=single, workers=1)."
+      )
+    );
+  }
+  if (input.config?.policy?.routing === void 0) {
+    warnings.push(toWarning('translate.policy.routing omitted; defaulting to "single".'));
+  }
+  const providerOrder = resolveProviderOrder({
+    config: input.config,
+    providerIdPin: input.pin?.providerId
+  });
+  const effectiveProviderId = providerOrder[0];
+  if (input.config?.primary === void 0 && input.pin?.providerId === void 0) {
+    warnings.push(toWarning('translate.primary omitted; defaulting to provider "google".'));
+  }
+  if (input.pin?.providerId !== void 0) {
+    warnings.push(toWarning(`provider pin applied; using "${input.pin.providerId}" first.`));
+  }
+  const requestedWorkers = resolveTranslateMaxParallel({
+    configMaxWorkers: input.config?.workers,
+    workersFlag: input.pin?.workers,
+    envMaxWorkers: input.env?.[ENV_TRANSLATE_MAX_WORKERS]
+  });
+  if (input.config?.workers === void 0 && input.pin?.workers === void 0) {
+    warnings.push(toWarning("translate.workers omitted; defaulting to 1 worker."));
+  }
+  const providerRows = {};
+  for (const providerId of Object.keys(DEFAULT_PROVIDER_RATE_LIMITS)) {
+    providerRows[providerId] = resolveProviderProfile(input.config, providerId);
+  }
+  const effectiveWorkers = clampInt3(
+    Math.min(requestedWorkers, providerRows[effectiveProviderId].profile.maxConcurrency),
+    1,
+    TRANSLATE_WORKERS_CAP
+  );
+  if (effectiveWorkers < requestedWorkers) {
+    warnings.push(
+      toWarning(
+        `provider "${effectiveProviderId}" maxConcurrency=${String(providerRows[effectiveProviderId].profile.maxConcurrency)} capped workers from ${String(requestedWorkers)} to ${String(effectiveWorkers)}.`
+      )
+    );
+  }
+  return {
+    resolved: {
+      providerOrder,
+      effectiveProviderId,
+      requestedWorkers,
+      effectiveWorkers,
+      providers: providerRows,
+      routing
+    },
+    warnings
+  };
+}
+
+export { CORE_CONFIG_DEFAULT_INPUT, ConfigValidationError, DEFAULT_CONFIG, REFERENCE_POLICY_SAFE_DEFAULTS, clampTranslateMaxWorkers, classifyLocalesSourceInput, collectLocalesFilesystemConfigWarnings, configSchema, defineConfig, isConfigValidationError, issueLocalesSourceNotInBundle, loadCoreConfigFromPath, localesFilesystemSchema, mergeCoreConfigInputs, mergePartialConfigIntoBase, parseI18nPruneConfig, resolveCoreConfig, resolveCoreConfigLayers, resolveSourceLocaleAbsoluteFromRelPaths, resolveSourceLocaleAbsolutePath, resolveTranslateConfig, tryLoadCoreConfigFromPath, validateLocalesSourceConfigValue };