@i18nprune/core 0.1.0

package/dist/shared.js

@@ -0,0 +1,4897 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/shared/json/index.ts
+var json_exports = {};
+__export(json_exports, {
+  I18nPruneJsonParseError: () => I18nPruneJsonParseError,
+  applyPreserveFromSource: () => applyPreserveFromSource,
+  deepClone: () => deepClone,
+  deleteAtPath: () => deleteAtPath,
+  getAtPath: () => getAtPath,
+  getJsonParseLocation: () => getJsonParseLocation,
+  mergeToTemplateShape: () => mergeToTemplateShape,
+  parseJsonText: () => parseJsonText,
+  pruneToTemplateShape: () => pruneToTemplateShape,
+  setAtPath: () => setAtPath,
+  splitPath: () => splitPath,
+  targetLocaleCoversAllSourcePaths: () => targetLocaleCoversAllSourcePaths,
+  tryParseJsonText: () => tryParseJsonText
+});
+
+// src/shared/json/clone.ts
+function deepClone(x) {
+  if (x === null || typeof x !== "object") return x;
+  if (Array.isArray(x)) return x.map((e) => deepClone(e));
+  const o = {};
+  for (const k of Object.keys(x)) {
+    o[k] = deepClone(x[k]);
+  }
+  return o;
+}
+
+// src/shared/json/path.ts
+function splitPath(pathStr) {
+  const parts = [];
+  const re = /[^.[\]]+|\[\d+\]/g;
+  let m;
+  const s = pathStr.trim();
+  while ((m = re.exec(s)) !== null) {
+    const tok = m[0];
+    if (tok.startsWith("[") && tok.endsWith("]")) {
+      parts.push(Number.parseInt(tok.slice(1, -1), 10));
+    } else {
+      parts.push(tok);
+    }
+  }
+  return parts;
+}
+function isPlainObject(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function getAtPath(root, pathStr) {
+  let cur = root;
+  for (const seg of splitPath(pathStr)) {
+    if (cur === null || cur === void 0) return void 0;
+    if (typeof seg === "number") {
+      if (!Array.isArray(cur)) return void 0;
+      cur = cur[seg];
+    } else {
+      if (!isPlainObject(cur)) return void 0;
+      cur = cur[seg];
+    }
+  }
+  return cur;
+}
+function setAtPath(root, pathStr, value) {
+  const segs = splitPath(pathStr);
+  if (segs.length === 0) return root;
+  const clone = deepClone(root);
+  let cur = clone;
+  for (let i = 0; i < segs.length - 1; i += 1) {
+    const seg = segs[i];
+    const next = segs[i + 1];
+    if (typeof seg === "number") {
+      if (!Array.isArray(cur)) return clone;
+      ensureArraySlot(cur, seg, typeof next === "number" ? [] : {});
+      cur = cur[seg];
+    } else {
+      if (!isPlainObject(cur)) return clone;
+      if (!(seg in cur)) {
+        cur[seg] = typeof next === "number" ? [] : {};
+      }
+      cur = cur[seg];
+    }
+  }
+  const last = segs[segs.length - 1];
+  if (typeof last === "number") {
+    if (!Array.isArray(cur)) return clone;
+    ensureArraySlot(cur, last, null);
+    cur[last] = value;
+  } else {
+    if (!isPlainObject(cur)) return clone;
+    cur[last] = value;
+  }
+  return clone;
+}
+function ensureArraySlot(arr, index, fill) {
+  while (arr.length <= index) {
+    arr.push(fill);
+  }
+}
+function deleteAtPath(root, pathStr) {
+  const segs = splitPath(pathStr);
+  if (segs.length === 0) return root;
+  const clone = deepClone(root);
+  let cur = clone;
+  for (let i = 0; i < segs.length - 1; i += 1) {
+    const seg = segs[i];
+    if (typeof seg === "number") {
+      if (!Array.isArray(cur)) return clone;
+      cur = cur[seg];
+    } else {
+      if (!isPlainObject(cur)) return clone;
+      cur = cur[seg];
+    }
+  }
+  const last = segs[segs.length - 1];
+  if (typeof last === "number") {
+    if (Array.isArray(cur)) cur.splice(last, 1);
+  } else if (isPlainObject(cur)) {
+    delete cur[last];
+  }
+  return clone;
+}
+
+// src/shared/errors/index.ts
+var errors_exports = {};
+__export(errors_exports, {
+  I18nPruneError: () => I18nPruneError,
+  isErrnoCode: () => isErrnoCode,
+  issueFromI18nPruneError: () => issueFromI18nPruneError,
+  normalizeUnknownError: () => normalizeUnknownError,
+  rethrowAsI18n: () => rethrowAsI18n
+});
+
+// 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/shared/constants/links.ts
+var GITHUB_OWNER = "zamdevio";
+var GITHUB_REPO = "i18nprune";
+var GITHUB_REPO_URL = `https://github.com/${GITHUB_OWNER}/${GITHUB_REPO}`;
+var LICENSE_URL = `${GITHUB_REPO_URL}/blob/main/LICENSE`;
+var DOCS_SITE_BASE = "https://docs.i18nprune.dev";
+var META_WORKER_URL = "https://meta.i18nprune.dev";
+var DEFAULT_WORKER_API_URL = "https://worker.i18nprune.dev";
+var DEMO_REPORT_URL = "https://report.i18nprune.dev";
+var DEMO_WEB_APP_BASE = "https://web.i18nprune.dev";
+var NPM_PACKAGE_NAME = "i18nprune";
+var NPM_PACKAGE_URL = `https://www.npmjs.com/package/${NPM_PACKAGE_NAME}`;
+
+// src/shared/constants/docs.ts
+var GITHUB_BASE = GITHUB_REPO_URL;
+var GITHUB_DOCS_BASE = `${GITHUB_BASE}/blob/main/docs`;
+var GITHUB_DOCS_TREE_BASE = `${GITHUB_BASE}/tree/main/docs`;
+var DOCS_SITE_ORIGIN = DOCS_SITE_BASE;
+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 resolveIssueCodeDocLink(code) {
+  return buildIssueCodeDocLinkParts(code);
+}
+function issueCodeRepoDocPathForIssueCode(code) {
+  return buildIssueCodeDocLinkParts(code).repoDocPath;
+}
+function issueCodeDocHref(code) {
+  const { sitePagePath, anchor } = buildIssueCodeDocLinkParts(code);
+  return `${DOCS_SITE_BASE}${sitePagePath}#${anchor}`;
+}
+
+// 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/errors/wrap.ts
+function rethrowAsI18n(err, message) {
+  if (err instanceof I18nPruneError) throw err;
+  throw normalizeUnknownError(err, { when: message, defaultCode: "INTERNAL" });
+}
+
+// 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 } : {}
+    });
+  }
+}
+function tryParseJsonText(text, options = {}) {
+  try {
+    return { ok: true, data: parseJsonText(text, options) };
+  } catch (error) {
+    if (error instanceof I18nPruneJsonParseError) return { ok: false, error };
+    throw error;
+  }
+}
+
+// src/shared/locales/leaves/index.ts
+var leaves_exports = {};
+__export(leaves_exports, {
+  applyLocaleLeafMode: () => applyLocaleLeafMode,
+  applyLocaleLeafNormalization: () => applyLocaleLeafNormalization,
+  collectTranslationSurfaceLeaves: () => collectTranslationSurfaceLeaves,
+  isCompleteStructuredLocaleLeafMeta: () => isCompleteStructuredLocaleLeafMeta,
+  isStructuredLocaleLeafNode: () => isStructuredLocaleLeafNode,
+  localeSegmentSourceForFile: () => localeSegmentSourceForFile,
+  metadataModeEnabledFromConfig: () => metadataModeEnabledFromConfig,
+  resolveLocaleLeafMode: () => resolveLocaleLeafMode
+});
+
+// src/shared/json/localeLeafPath.ts
+function isPlainObject2(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function isLiteralDottedObjectKey(key) {
+  return key.includes(".");
+}
+function getLocaleLeafAtPath(root, pathStr) {
+  if (isPlainObject2(root) && Object.prototype.hasOwnProperty.call(root, pathStr)) {
+    return root[pathStr];
+  }
+  return getAtPath(root, pathStr);
+}
+function deleteLocaleLeafAtPath(root, pathStr) {
+  if (isPlainObject2(root) && Object.prototype.hasOwnProperty.call(root, pathStr)) {
+    const clone = deepClone(root);
+    delete clone[pathStr];
+    return clone;
+  }
+  return deleteAtPath(root, pathStr);
+}
+function stripLiteralDottedKeysAtLevel(root) {
+  if (!isPlainObject2(root)) {
+    if (Array.isArray(root)) return root.map((item) => stripLiteralDottedKeysAtLevel(item));
+    return root;
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(root)) {
+    if (isLiteralDottedObjectKey(key)) continue;
+    out[key] = stripLiteralDottedKeysAtLevel(value);
+  }
+  return out;
+}
+function normalizeLocaleDocumentToNestedCanonical(root, knownLeafPaths) {
+  if (Array.isArray(root)) {
+    return root.map((item) => normalizeLocaleDocumentToNestedCanonical(item, knownLeafPaths));
+  }
+  if (!isPlainObject2(root)) return root;
+  const preservedNested = {};
+  const dottedAssignments = [];
+  for (const [key, value] of Object.entries(root)) {
+    if (isLiteralDottedObjectKey(key)) {
+      dottedAssignments.push({ path: key, value });
+    } else {
+      preservedNested[key] = normalizeLocaleDocumentToNestedCanonical(value, knownLeafPaths);
+    }
+  }
+  let result = preservedNested;
+  for (const { path, value } of dottedAssignments) {
+    result = setAtPath(result, path, deepClone(value));
+  }
+  if (knownLeafPaths) {
+    for (const leafPath of knownLeafPaths) {
+      if (isLiteralDottedObjectKey(leafPath) && isPlainObject2(result) && Object.prototype.hasOwnProperty.call(result, leafPath)) {
+        result = deleteLocaleLeafAtPath(result, leafPath);
+      }
+    }
+  }
+  return stripLiteralDottedKeysAtLevel(result);
+}
+
+// src/shared/locales/leaves/mode/applyModeHelpers.ts
+function isPlainObjectForLocaleLeaves(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function bump(m, key) {
+  m[key] = (m[key] ?? 0) + 1;
+}
+function initReasonMap() {
+  return {
+    legacy_string_promoted: 0,
+    non_object_replaced: 0,
+    missing_value: 0,
+    invalid_status: 0,
+    invalid_confidence: 0,
+    invalid_needs_review: 0,
+    invalid_needs_translation_again: 0,
+    invalid_source: 0,
+    canonical_metadata_materialized: 0
+  };
+}
+var MATERIALIZED_STRUCTURED_KEYS = [
+  "value",
+  "status",
+  "confidence",
+  "needsReview",
+  "source",
+  "needsTranslationAgain"
+];
+function shouldMaterializeCanonicalStructuredFields(cur) {
+  for (const k of MATERIALIZED_STRUCTURED_KEYS) {
+    if (!(k in cur)) return true;
+  }
+  return false;
+}
+function classifyLeafRuntimeKind(cur) {
+  if (typeof cur === "undefined") return "missing";
+  if (typeof cur === "string") return "legacy_string";
+  if (!isPlainObjectForLocaleLeaves(cur)) return "other";
+  if (typeof cur.value === "string") {
+    const validStatus = cur.status === void 0 || typeof cur.status === "string" && cur.status.trim().length > 0;
+    const validConfidence = cur.confidence === void 0 || cur.confidence === null || typeof cur.confidence === "number" && Number.isFinite(cur.confidence);
+    const validNeedsReview = cur.needsReview === void 0 || typeof cur.needsReview === "boolean";
+    const validNeedsTranslationAgain = cur.needsTranslationAgain === void 0 || typeof cur.needsTranslationAgain === "boolean";
+    const validSource = cur.source === void 0 || typeof cur.source === "string" && cur.source.trim().length > 0;
+    return validStatus && validConfidence && validNeedsReview && validNeedsTranslationAgain && validSource ? "structured_valid" : "structured_corrupt";
+  }
+  return "structured_corrupt";
+}
+function normalizeStructuredLeaf(cur, sourceValue) {
+  const roundConfidence = (v) => Math.round(Math.max(0, Math.min(1, v)) * 100) / 100;
+  const reasons = [];
+  if (typeof cur === "string") {
+    reasons.push("legacy_string_promoted");
+    return {
+      leaf: {
+        value: cur,
+        status: "translated",
+        confidence: null,
+        needsReview: true,
+        needsTranslationAgain: false,
+        source: "manual"
+      },
+      changed: true,
+      reasons
+    };
+  }
+  if (!isPlainObjectForLocaleLeaves(cur)) {
+    reasons.push("non_object_replaced");
+    return {
+      leaf: {
+        value: sourceValue,
+        status: "pending",
+        confidence: null,
+        needsReview: true,
+        needsTranslationAgain: true,
+        source: "sync"
+      },
+      changed: true,
+      reasons
+    };
+  }
+  let changed = false;
+  const out = { value: sourceValue };
+  if (typeof cur.value === "string") out.value = cur.value;
+  else {
+    changed = true;
+    reasons.push("missing_value");
+  }
+  if (typeof cur.status === "string" && cur.status.trim().length > 0) {
+    out.status = cur.status;
+  } else if (cur.status === void 0) {
+    out.status = "translated";
+  } else {
+    out.status = "translated";
+    changed = true;
+    reasons.push("invalid_status");
+  }
+  if (typeof cur.confidence === "number" && Number.isFinite(cur.confidence)) out.confidence = roundConfidence(cur.confidence);
+  else if (cur.confidence === null || cur.confidence === void 0) out.confidence = null;
+  else {
+    out.confidence = null;
+    changed = true;
+    reasons.push("invalid_confidence");
+  }
+  if (typeof cur.needsReview === "boolean") {
+    out.needsReview = cur.needsReview;
+  } else if (cur.needsReview === void 0) {
+    out.needsReview = false;
+  } else {
+    out.needsReview = false;
+    changed = true;
+    reasons.push("invalid_needs_review");
+  }
+  if (typeof cur.source === "string" && cur.source.trim().length > 0) {
+    out.source = cur.source;
+  } else if (cur.source === void 0) {
+    out.source = "manual";
+  } else {
+    out.source = "manual";
+    changed = true;
+    reasons.push("invalid_source");
+  }
+  if (typeof cur.needsTranslationAgain === "boolean") out.needsTranslationAgain = cur.needsTranslationAgain;
+  else if ("needsTranslationAgain" in cur) {
+    out.needsTranslationAgain = false;
+    changed = true;
+    reasons.push("invalid_needs_translation_again");
+  } else {
+    out.needsTranslationAgain = false;
+  }
+  const materialized = isPlainObjectForLocaleLeaves(cur) && typeof cur.value === "string" && shouldMaterializeCanonicalStructuredFields(cur);
+  if (materialized && !changed) reasons.push("canonical_metadata_materialized");
+  const effectiveChanged = changed || materialized;
+  if (changed) {
+    out.needsReview = true;
+  }
+  return { leaf: out, changed: effectiveChanged, reasons };
+}
+
+// src/shared/locales/leaves/mode/applyLocaleLeafMode.ts
+function applyLocaleLeafMode(input) {
+  const changes = [];
+  const leafDecisions = [];
+  let next = input.localeJson;
+  let unchangedLeaves = 0;
+  let structuredLeavesWritten = 0;
+  let promotedLegacyLeaves = 0;
+  let repairedCorruptLeaves = 0;
+  let strippedStructuredLeaves = 0;
+  let missingPathsHydratedFromSource = 0;
+  const byReason = initReasonMap();
+  const sampleLimit = input.sampleLimit ?? 40;
+  for (const [leafPath, sourceValue] of input.sourceMap.entries()) {
+    const cur = getLocaleLeafAtPath(next, leafPath);
+    const beforeKind = classifyLeafRuntimeKind(cur);
+    const beforeValue = cur;
+    if (input.mode === "legacy_string") {
+      const nextValue = typeof cur === "string" ? cur : isPlainObjectForLocaleLeaves(cur) && typeof cur.value === "string" ? cur.value : sourceValue;
+      let action2 = "unchanged";
+      const reasons = [];
+      if (typeof cur === "undefined") {
+        missingPathsHydratedFromSource += 1;
+        action2 = "hydrated_missing";
+      }
+      if (isPlainObjectForLocaleLeaves(cur) && typeof cur.value === "string") {
+        strippedStructuredLeaves += 1;
+        action2 = "stripped_structured";
+      }
+      if (cur === nextValue) unchangedLeaves += 1;
+      else next = setAtPath(next, leafPath, nextValue);
+      const afterValue2 = getLocaleLeafAtPath(next, leafPath);
+      const afterKind2 = classifyLeafRuntimeKind(afterValue2);
+      leafDecisions.push({
+        path: leafPath,
+        sourceValue,
+        beforeKind,
+        afterKind: afterKind2,
+        action: action2,
+        reasons,
+        beforeValue,
+        afterValue: afterValue2
+      });
+      continue;
+    }
+    const normalized = normalizeStructuredLeaf(cur, sourceValue);
+    let action = "unchanged";
+    if (normalized.changed) {
+      next = setAtPath(next, leafPath, normalized.leaf);
+      structuredLeavesWritten += 1;
+      for (const reason of normalized.reasons) {
+        bump(byReason, reason);
+        if (changes.length < sampleLimit) changes.push({ path: leafPath, reason });
+      }
+      const hasLegacy = normalized.reasons.includes("legacy_string_promoted");
+      const hasCorruptRepair = normalized.reasons.some(
+        (r) => r !== "legacy_string_promoted" && r !== "canonical_metadata_materialized"
+      );
+      if (hasLegacy) {
+        promotedLegacyLeaves += 1;
+        action = "promoted_legacy";
+      }
+      if (hasCorruptRepair) {
+        repairedCorruptLeaves += 1;
+        if (!hasLegacy) action = "repaired_corrupt";
+      }
+    } else {
+      unchangedLeaves += 1;
+    }
+    if (typeof cur === "undefined") missingPathsHydratedFromSource += 1;
+    const afterValue = getLocaleLeafAtPath(next, leafPath);
+    const afterKind = classifyLeafRuntimeKind(afterValue);
+    leafDecisions.push({
+      path: leafPath,
+      sourceValue,
+      beforeKind,
+      afterKind,
+      action,
+      reasons: normalized.reasons,
+      beforeValue,
+      afterValue
+    });
+  }
+  const leafPaths = [...input.sourceMap.keys()];
+  next = normalizeLocaleDocumentToNestedCanonical(next, leafPaths);
+  return {
+    next,
+    report: {
+      mode: input.mode,
+      totalSourceLeafPaths: input.sourceMap.size,
+      unchangedLeaves,
+      structuredLeavesWritten,
+      promotedLegacyLeaves,
+      repairedCorruptLeaves,
+      strippedStructuredLeaves,
+      missingPathsHydratedFromSource,
+      byReason,
+      changedPathsSample: changes,
+      leafDecisions
+    }
+  };
+}
+
+// src/shared/locales/leaves/mode/modeResolve.ts
+function metadataModeEnabledFromConfig(mode) {
+  return mode === "structured";
+}
+function resolveLocaleLeafMode(input) {
+  if (input.stripMetadataFlag === true) {
+    return {
+      mode: "legacy_string",
+      conflict: input.metadataFlag === true,
+      reason: "strip_precedence"
+    };
+  }
+  if (input.metadataFlag === true) return { mode: "structured", conflict: false, reason: "explicit_metadata" };
+  if (metadataModeEnabledFromConfig(input.configMode)) {
+    return { mode: "structured", conflict: false, reason: "config_structured" };
+  }
+  return { mode: "legacy_string", conflict: false, reason: "default_legacy" };
+}
+function applyLocaleLeafNormalization(input) {
+  const modeDecision = resolveLocaleLeafMode(input.resolveInput);
+  const normalized = applyLocaleLeafMode({
+    localeJson: input.localeJson,
+    sourceMap: input.sourceMap,
+    mode: modeDecision.mode
+  });
+  return {
+    next: normalized.next,
+    report: normalized.report,
+    modeDecision
+  };
+}
+
+// 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/leaves/segmentSource/localeSegmentSourceForFile.ts
+function localeSegmentSourceForFile(input) {
+  const { path, absoluteFile, localesDir, structure } = input;
+  let relativePath = path.relative(localesDir, absoluteFile);
+  if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+    relativePath = path.basename(absoluteFile);
+  }
+  relativePath = relativePath.replace(/\\/g, "/");
+  const locale = localeCodeForSegment(structure, path, { absolutePath: absoluteFile, relativePath });
+  if (locale === null) return null;
+  return { file: absoluteFile, locale, relativePath };
+}
+
+// src/shared/locales/leaves/walk/translationSurfaceWalk.ts
+function isPlainObject3(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function isStructuredLocaleLeafNode(x) {
+  return isPlainObject3(x) && typeof x.value === "string";
+}
+function readOptionalStatus(o) {
+  const s = o.status;
+  if (typeof s !== "string" || !s.trim()) return void 0;
+  return s;
+}
+function readOptionalLeafSource(o) {
+  const s = o.source;
+  if (typeof s !== "string" || !s.trim()) return void 0;
+  return s;
+}
+function readConfidence(o) {
+  const c = o.confidence;
+  if (c === null || c === void 0) return null;
+  if (typeof c !== "number" || !Number.isFinite(c)) return null;
+  const clamped = Math.max(0, Math.min(1, c));
+  return Math.round(clamped * 100) / 100;
+}
+function readNeedsReview(o) {
+  if (!("needsReview" in o)) return null;
+  return typeof o.needsReview === "boolean" ? o.needsReview : null;
+}
+function readNeedsTranslationAgain(o) {
+  if (!("needsTranslationAgain" in o)) return null;
+  return typeof o.needsTranslationAgain === "boolean" ? o.needsTranslationAgain : null;
+}
+function isCompleteStructuredLocaleLeafMeta(node) {
+  if (!isStructuredLocaleLeafNode(node)) return false;
+  const o = node;
+  if (typeof o.status !== "string" || !o.status.trim()) return false;
+  if (!(o.confidence === null || typeof o.confidence === "number" && Number.isFinite(o.confidence))) return false;
+  if (typeof o.needsReview !== "boolean") return false;
+  if (typeof o.needsTranslationAgain !== "boolean") return false;
+  if (typeof o.source !== "string" || !o.source.trim()) return false;
+  return true;
+}
+function pushStructuredRow(out, prefix, root, fileOrigin) {
+  out.push({
+    path: prefix,
+    value: root.value,
+    shape: "structured",
+    status: readOptionalStatus(root),
+    confidence: readConfidence(root),
+    needsReview: readNeedsReview(root),
+    needsTranslationAgain: readNeedsTranslationAgain(root),
+    source: readOptionalLeafSource(root),
+    structuredMetaComplete: isCompleteStructuredLocaleLeafMeta(root),
+    ...fileOrigin ? { fileOrigin } : {}
+  });
+}
+function collectTranslationSurfaceLeaves(root, prefix = "", out = [], fileOrigin) {
+  if (typeof root === "string") {
+    if (prefix) {
+      out.push({
+        path: prefix,
+        value: root,
+        shape: "legacy_string",
+        confidence: null,
+        needsReview: null,
+        ...fileOrigin ? { fileOrigin } : {}
+      });
+    }
+    return out;
+  }
+  if (isStructuredLocaleLeafNode(root)) {
+    if (prefix) pushStructuredRow(out, prefix, root, fileOrigin);
+    return out;
+  }
+  if (Array.isArray(root)) {
+    root.forEach((item, i) => {
+      const p = prefix ? `${prefix}[${i}]` : `[${i}]`;
+      collectTranslationSurfaceLeaves(item, p, out, fileOrigin);
+    });
+    return out;
+  }
+  if (isPlainObject3(root)) {
+    for (const k of Object.keys(root)) {
+      const p = prefix ? `${prefix}.${k}` : k;
+      collectTranslationSurfaceLeaves(root[k], p, out, fileOrigin);
+    }
+  }
+  return out;
+}
+
+// src/shared/json/targetCoverage.ts
+function targetLocaleCoversAllSourcePaths(sourceRaw, targetRaw) {
+  const sLeaves = collectTranslationSurfaceLeaves(sourceRaw);
+  return targetLocaleCoversAllSourceLeaves(sLeaves, targetRaw);
+}
+function targetLocaleCoversAllSourceLeaves(sourceLeaves, targetRaw) {
+  const tLeaves = collectTranslationSurfaceLeaves(targetRaw);
+  const targetSet = new Set(tLeaves.map((l) => l.path));
+  return sourceLeaves.every((l) => targetSet.has(l.path));
+}
+
+// src/shared/reference/paths.ts
+var paths_exports = {};
+__export(paths_exports, {
+  pathUnderAnyUncertainPrefix: () => pathUnderAnyUncertainPrefix,
+  pathUnderUncertainPrefix: () => pathUnderUncertainPrefix
+});
+function pathUnderUncertainPrefix(keyPath, prefix) {
+  if (keyPath === prefix) return true;
+  if (keyPath.startsWith(`${prefix}.`)) return true;
+  if (keyPath.startsWith(`${prefix}[`)) return true;
+  return false;
+}
+function pathUnderAnyUncertainPrefix(keyPath, prefixes) {
+  for (const p of prefixes) {
+    if (pathUnderUncertainPrefix(keyPath, p)) return true;
+  }
+  return false;
+}
+
+// src/shared/json/merge.ts
+function isPlainObject4(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+var OMIT = /* @__PURE__ */ Symbol("i18nprune.merge.omit");
+function mergeToTemplateShape(template, target, preserve, options) {
+  return mergeWalk(
+    template,
+    target,
+    preserve,
+    "",
+    options?.uncertainKeepPrefixes,
+    options?.skipFillPaths === void 0 ? void 0 : new Set(options.skipFillPaths),
+    options?.forceFillPaths === void 0 ? void 0 : new Set(options.forceFillPaths)
+  );
+}
+function mergeWalk(template, target, preserve, path, uncertainKeepPrefixes, skipFillPaths, forceFillPaths) {
+  if (typeof template === "string") {
+    if (skipFillPaths?.has(path)) return OMIT;
+    if (forceFillPaths?.has(path)) return template;
+    if (typeof target === "string") return target;
+    if (isPlainObject4(target) && typeof target.value === "string") {
+      return deepClone(target);
+    }
+    return template;
+  }
+  if (Array.isArray(template)) {
+    if (!Array.isArray(target)) target = [];
+    const out = [];
+    const tArr = target;
+    for (let i = 0; i < template.length; i += 1) {
+      const seg = path ? `${path}[${String(i)}]` : `[${String(i)}]`;
+      const next = mergeWalk(template[i], tArr[i], preserve, seg, uncertainKeepPrefixes, skipFillPaths, forceFillPaths);
+      if (next !== OMIT) out.push(next);
+    }
+    return out;
+  }
+  if (isPlainObject4(template)) {
+    const tObj = isPlainObject4(target) ? target : {};
+    const out = {};
+    for (const k of Object.keys(template)) {
+      const p = path ? `${path}.${k}` : k;
+      const next = mergeWalk(template[k], tObj[k], preserve, p, uncertainKeepPrefixes, skipFillPaths, forceFillPaths);
+      if (next !== OMIT) out[k] = next;
+    }
+    if (uncertainKeepPrefixes?.length) {
+      for (const k of Object.keys(tObj)) {
+        if (k in template) continue;
+        const p = path ? `${path}.${k}` : k;
+        if (pathUnderAnyUncertainPrefix(p, uncertainKeepPrefixes)) {
+          out[k] = deepClone(tObj[k]);
+        }
+      }
+    }
+    return out;
+  }
+  return deepClone(template);
+}
+function applyPreserveFromSource(target, source, paths) {
+  let out = deepClone(target);
+  for (const p of paths) {
+    const v = getAtPath(source, p);
+    if (v !== void 0) {
+      out = setAtPath(out, p, deepClone(v));
+    }
+  }
+  return out;
+}
+
+// src/shared/json/prune.ts
+function isPlainObject5(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function pruneToTemplateShape(template, target, options) {
+  return pruneWalk(template, target, "", options?.uncertainKeepPrefixes);
+}
+function pruneWalk(template, target, path, uncertainKeepPrefixes) {
+  if (template === null || typeof template !== "object") {
+    return target;
+  }
+  if (Array.isArray(template)) {
+    if (!Array.isArray(target)) return [];
+    const len = Math.min(template.length, target.length);
+    const out2 = [];
+    for (let i = 0; i < len; i += 1) {
+      const seg = path ? `${path}[${String(i)}]` : `[${String(i)}]`;
+      out2.push(pruneWalk(template[i], target[i], seg, uncertainKeepPrefixes));
+    }
+    return out2;
+  }
+  if (!isPlainObject5(template)) return target;
+  if (!isPlainObject5(target)) return {};
+  const out = {};
+  for (const k of Object.keys(template)) {
+    if (k in target) {
+      const p = path ? `${path}.${k}` : k;
+      out[k] = pruneWalk(template[k], target[k], p, uncertainKeepPrefixes);
+    }
+  }
+  if (uncertainKeepPrefixes?.length) {
+    for (const k of Object.keys(target)) {
+      if (k in template) continue;
+      const p = path ? `${path}.${k}` : k;
+      if (pathUnderAnyUncertainPrefix(p, uncertainKeepPrefixes)) {
+        out[k] = deepClone(target[k]);
+      }
+    }
+  }
+  return out;
+}
+
+// src/shared/scanner/index.ts
+var scanner_exports = {};
+__export(scanner_exports, {
+  scanSources: () => scanSources
+});
+
+// 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 readRuntimeFsTextSync(filePath, fs) {
+  return assertSyncPortResult(fs.readText(filePath), "fs.readText", filePath);
+}
+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/issueCodes.ts
+var ISSUE_CONTEXT_DISCOVERY_WARNING = "i18nprune.context.discovery_warning";
+var ISSUE_CONTEXT_RESOLUTION_FAILED = "i18nprune.context.resolution_failed";
+var ISSUE_VALIDATE_MISSING_LITERAL_KEYS = "i18nprune.validate.missing_literal_keys";
+var ISSUE_VALIDATE_DYNAMIC_KEY_SITES = "i18nprune.validate.dynamic_key_sites";
+var ISSUE_VALIDATE_SOURCE_LOCALE_READ_FAILED = "i18nprune.validate.source_locale_unreadable";
+var ISSUE_PROJECT_CONFIG_FILE_MISSING = "i18nprune.project.config_file_missing";
+var ISSUE_PROJECT_SOURCE_LOCALE_UNAVAILABLE = "i18nprune.project.source_locale_unavailable";
+var ISSUE_PROJECT_LOCALES_DIR_UNAVAILABLE = "i18nprune.project.locales_dir_unavailable";
+var ISSUE_PROJECT_SRC_ROOT_UNAVAILABLE = "i18nprune.project.src_root_unavailable";
+var ISSUE_PROJECT_LOCALES_STRUCTURE_REQUIRED = "i18nprune.project.locales_structure_required";
+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_PROJECT_SOURCE_LOCALE_MISSING_SEGMENTS = "i18nprune.project.source_locale_missing_segments";
+var ISSUE_SCAN_DYNAMIC_KEY_SITES = "i18nprune.scan.dynamic_key_sites";
+var ISSUE_MISSING_PATHS_NOT_IN_SCAN = "i18nprune.missing.paths_not_in_current_scan";
+var ISSUE_SYNC_LOCALE_FILE_NOT_FOUND = "i18nprune.sync.locale_file_not_found";
+var ISSUE_SYNC_METADATA_FLAG_CONFLICT = "i18nprune.sync.metadata_flag_conflict";
+var ISSUE_LOCALE_SOURCE_PLACEHOLDER_LEAVES = "i18nprune.locale.source_placeholder_leaves";
+var ISSUE_LOCALE_TARGET_PLACEHOLDER_LEAVES = "i18nprune.locale.target_placeholder_leaves";
+var ISSUE_CLEANUP_UNCERTAIN_PATHS_EXCLUDED = "i18nprune.cleanup.uncertain_paths_excluded";
+var ISSUE_CLEANUP_RIPGREP_UNAVAILABLE = "i18nprune.cleanup.ripgrep_unavailable";
+var ISSUE_QUALITY_ENGLISH_IDENTICAL_LEAVES = "i18nprune.quality.english_identical_leaves";
+var ISSUE_LANGUAGES_EMPTY_FILTER = "i18nprune.languages.empty_filter";
+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_LOCALES_USAGE = "i18nprune.locales.usage";
+var ISSUE_LOCALE_TARGET_NOT_FOUND = "i18nprune.locale.target_not_found";
+var ISSUE_IO_READ_FAILED = "i18nprune.io.read_failed";
+var ISSUE_TRANSLATE_IDENTITY_STREAK_WARNING = "i18nprune.translate.identity_streak_warning";
+var ISSUE_TRANSLATE_IDENTITY_STREAK_ABORT = "i18nprune.translate.identity_streak_abort";
+var ISSUE_TRANSLATE_UNKNOWN_TRANSLATION_PROVIDER = "i18nprune.translate.unknown_translation_provider";
+var ISSUE_TRANSLATE_PROVIDER_NOT_IMPLEMENTED_YET = "i18nprune.translate.provider_not_implemented_yet";
+var ISSUE_TRANSLATE_MISSING_CREDENTIALS = "i18nprune.translate.missing_credentials";
+var ISSUE_TRANSLATE_CONFIG_DEFAULT_APPLIED = "i18nprune.translate.config_default_applied";
+var ISSUE_TRANSLATE_HANDOFF_NO_ELIGIBLE_PROVIDER = "i18nprune.translate.handoff_no_eligible_provider";
+var ISSUE_GENERATE_USAGE = "i18nprune.generate.usage";
+var ISSUE_GENERATE_SOURCE_EMPTY_STRING_LEAVES = "i18nprune.generate.source_empty_string_leaves";
+var ISSUE_GENERATE_TRANSLATE_RATE_LIMITED = "i18nprune.generate.translate_rate_limited";
+var ISSUE_GENERATE_TRANSLATE_NETWORK_ERROR = "i18nprune.generate.translate_network_error";
+var ISSUE_REPORT_INVALID_FORMAT = "i18nprune.report.invalid_format";
+var ISSUE_CLI_INVALID_JSON_PRETTY = "i18nprune.cli.invalid_json_pretty";
+var ISSUE_SHARE_JSON_REPAIRED = "i18nprune.share.json_repaired";
+var ISSUE_SHARE_CACHE_ENTRY_NOT_FOUND = "i18nprune.share.cache_entry_not_found";
+var ISSUE_SHARE_STALE_CACHE_ROW_REMOVED = "i18nprune.share.stale_cache_row_removed";
+var ISSUE_SHARE_CACHE_EMPTY = "i18nprune.share.cache_empty";
+var ISSUE_SHARE_JSON_WRITE_FAILED = "i18nprune.share.json_write_failed";
+var ISSUE_SHARE_REMOTE_PROJECT_NOT_FOUND = "i18nprune.share.remote_project_not_found";
+var ISSUE_SHARE_REMOTE_REPORT_NOT_FOUND = "i18nprune.share.remote_report_not_found";
+var ISSUE_SHARE_REMOTE_PAYLOAD_TOO_LARGE = "i18nprune.share.remote_payload_too_large";
+var ISSUE_SHARE_REMOTE_REPORT_REJECTED = "i18nprune.share.remote_report_rejected";
+var ISSUE_SHARE_REMOTE_UPLOAD_REJECTED = "i18nprune.share.remote_upload_rejected";
+var ISSUE_SHARE_REMOTE_UNAVAILABLE = "i18nprune.share.remote_unavailable";
+var ISSUE_SHARE_REMOTE_ERROR = "i18nprune.share.remote_error";
+var ISSUE_SHARE_SNAPSHOT_EMPTY = "i18nprune.share.snapshot_empty";
+var ISSUE_SHARE_ZIP_FAILED = "i18nprune.share.zip_failed";
+var ISSUE_PATCHING_CONFIG_SIZE_ANOMALY = "i18nprune.patching.config_size_anomaly";
+var ISSUE_PATCHING_CONFIG_TOO_LARGE = "i18nprune.patching.config_too_large";
+var ISSUE_PATCHING_CONFIG_INVALID_SCHEMA = "i18nprune.patching.config_invalid_schema";
+var ISSUE_PATCHING_CONFIG_PARSE_FAILED = "i18nprune.patching.config_parse_failed";
+var ISSUE_PATCHING_CONFIG_LOCALE_MISSING_FILE = "i18nprune.patching.config_locale_missing_file";
+var ISSUE_PATCHING_FILE_LOCALE_MISSING_CONFIG = "i18nprune.patching.file_locale_missing_config";
+var ISSUE_PATCHING_CATALOG_MISMATCH_ENGLISH = "i18nprune.patching.catalog_mismatch_english_name";
+var ISSUE_PATCHING_CATALOG_MISMATCH_NATIVE = "i18nprune.patching.catalog_mismatch_native_name";
+var ISSUE_PATCHING_CATALOG_MISMATCH_DIRECTION = "i18nprune.patching.catalog_mismatch_direction";
+var ISSUE_PATCHING_CONFIG_SECTION_INCOMPLETE = "i18nprune.patching.config_section_incomplete";
+var ISSUE_DOCTOR_RUNTIME_UNSUPPORTED_NODE = "i18nprune.doctor.runtime_unsupported_node";
+var ISSUE_DOCTOR_TOOLS_RG_NOT_ON_PATH = "i18nprune.doctor.tools_rg_not_on_path";
+var ISSUE_DOCTOR_CONFIG_MISSING_FILE = "i18nprune.doctor.config_missing_file";
+var ISSUE_DOCTOR_PATHS_SOURCE_LOCALE_MISSING = "i18nprune.doctor.paths_source_locale_missing";
+var ISSUE_DOCTOR_PATHS_DIRECTORIES_MISSING = "i18nprune.doctor.paths_directories_missing";
+var ISSUE_PATHS_WINDOWS_RESERVED_NAME = "i18nprune.paths.windows_reserved_name";
+var ISSUE_PATHS_WINDOWS_LONG_PATH = "i18nprune.paths.windows_long_path";
+var ISSUE_PATHS_NETWORK_DRIVE = "i18nprune.paths.network_drive";
+var ISSUE_PROJECT_HOSTED_SNAPSHOT_INVALID = "i18nprune.project.hosted_snapshot_invalid";
+var ISSUE_PROJECT_HOSTED_SNAPSHOT_SCHEMA_VERSION = "i18nprune.project.hosted_snapshot_schema_version";
+var ISSUE_PROJECT_UPLOAD_CONFIG_JSON_INVALID = "i18nprune.project.upload_config_json_invalid";
+var ISSUE_PROJECT_UPLOAD_CONFIG_REQUIRED = "i18nprune.project.upload_config_required";
+var ISSUE_PROJECT_SOURCE_LOCALE_NOT_FOUND = "i18nprune.project.source_locale_not_found";
+var ISSUE_PROJECT_SOURCE_LOCALE_INVALID_JSON = "i18nprune.project.source_locale_invalid_json";
+var ISSUE_PROJECT_SOURCE_LOCALE_INVALID_SHAPE = "i18nprune.project.source_locale_invalid_shape";
+var ISSUE_REPORT_HOSTED_REPORT_INVALID = "i18nprune.report.hosted_report_invalid";
+var ISSUE_SHARE_PREPARE_NOTHING_REQUESTED = "i18nprune.share.prepare_nothing_requested";
+var ISSUE_SHARE_PREPARE_REPORT_HOST_REQUIRED = "i18nprune.share.prepare_report_host_required";
+var ISSUE_SHARE_PREPARE_ANALYSIS_FAILED = "i18nprune.share.prepare_analysis_failed";
+var ISSUE_SHARE_PREPARE_REPORT_FROM_ARCHIVE_FAILED = "i18nprune.share.prepare_report_from_archive_failed";
+
+// src/shared/options/runOptions.ts
+var run = {
+  json: false,
+  jsonPretty: true,
+  quiet: false,
+  silent: false,
+  debugScan: false,
+  debugCache: false,
+  onScanDebug: void 0
+};
+function resetRunOptions() {
+  run = {
+    json: false,
+    jsonPretty: true,
+    quiet: false,
+    silent: false,
+    debugScan: false,
+    debugCache: false,
+    onScanDebug: void 0
+  };
+}
+function setRunOptions(partial) {
+  run = { ...run, ...partial };
+}
+function getRunOptions() {
+  return run;
+}
+
+// src/shared/scanner/presets.ts
+var SCAN_EXCLUDE_PRESETS = {
+  production: {
+    dirs: ["node_modules", "dist", "build", "compiled", "tests", "bench"],
+    files: ["pnpm-lock.yaml", "package-lock.json", "yarn.lock"],
+    extensions: ["test.ts", "test.tsx", "spec.ts", "spec.tsx", "test.js", "test.jsx", "spec.js", "spec.jsx"]
+  }
+};
+function mergeExcludeRules(base, extra) {
+  if (!base && !extra) return void 0;
+  return {
+    useDefaultSkip: base?.useDefaultSkip ?? extra?.useDefaultSkip,
+    dirs: [...extra?.dirs ?? [], ...base?.dirs ?? []],
+    files: [...extra?.files ?? [], ...base?.files ?? []],
+    extensions: [...extra?.extensions ?? [], ...base?.extensions ?? []],
+    patterns: [...extra?.patterns ?? [], ...base?.patterns ?? []]
+  };
+}
+function resolveScanExcludeConfig(exclude) {
+  if (!exclude) return void 0;
+  const fromPreset = exclude.preset ? SCAN_EXCLUDE_PRESETS[exclude.preset] : void 0;
+  return mergeExcludeRules(exclude, fromPreset);
+}
+
+// src/shared/scanner/files.ts
+function resolveScanDebugSink(listOpts) {
+  const g = getRunOptions();
+  if (g.silent) return void 0;
+  return listOpts?.onScanDebug ?? g.onScanDebug;
+}
+function emitScanDebug(sink, event) {
+  if (sink) sink(event);
+}
+var DEFAULT_SCAN_SKIP_DIR_NAMES = [
+  "node_modules",
+  "dist",
+  "build",
+  ".git",
+  "coverage",
+  ".next",
+  "out"
+];
+var DEFAULT_SCAN_SKIP_DIR_SET = new Set(DEFAULT_SCAN_SKIP_DIR_NAMES);
+var SOURCE_FILE_NAME = /\.(tsx?|jsx?|mjs|cjs|vue|svelte)$/i;
+var MAX_SOURCE_TREE_WALK_DEPTH = 48;
+function walkDirectoryKey(dir, pathPort, fs) {
+  if (fs.realpath) {
+    try {
+      return fs.realpath(dir);
+    } catch {
+      return pathPort.resolve(dir);
+    }
+  }
+  return pathPort.resolve(dir);
+}
+function normExtToken(s) {
+  const t = s.trim().toLowerCase();
+  return t.startsWith(".") ? t.slice(1) : t;
+}
+function basenameExtensionSuffixes(fileBase) {
+  const parts = fileBase.split(".");
+  if (parts.length < 2) return [];
+  const out = [];
+  for (let i = 1; i < parts.length; i++) {
+    out.push(parts.slice(i).join(".").toLowerCase());
+  }
+  out.sort((a, b) => b.length - a.length);
+  return out;
+}
+function relPosix(pathPort, rootDir, absPath) {
+  return pathPort.relative(rootDir, absPath).replace(/\\/g, "/");
+}
+function partitionRules(rules) {
+  const strings = /* @__PURE__ */ new Set();
+  const regexes = [];
+  if (!rules) return { strings, regexes };
+  for (const r of rules) {
+    if (typeof r === "string") {
+      const t = r.trim();
+      if (t) strings.add(t);
+    } else {
+      regexes.push(r);
+    }
+  }
+  return { strings, regexes };
+}
+function partitionExtRules(rules) {
+  const strings = /* @__PURE__ */ new Set();
+  const regexes = [];
+  if (!rules) return { strings, regexes };
+  for (const r of rules) {
+    if (typeof r === "string") {
+      const n = normExtToken(r);
+      if (n) strings.add(n);
+    } else {
+      regexes.push(r);
+    }
+  }
+  return { strings, regexes };
+}
+function compileScanExclude(exclude) {
+  const resolved = resolveScanExcludeConfig(exclude);
+  const useDefault = resolved?.useDefaultSkip !== false;
+  const defaultDirs = useDefault ? DEFAULT_SCAN_SKIP_DIR_SET : null;
+  const dirs = partitionRules(resolved?.dirs);
+  const files = partitionRules(resolved?.files);
+  const exts = partitionExtRules(resolved?.extensions);
+  const pathPatterns = resolved?.patterns ?? [];
+  const userRulesEmpty = dirs.strings.size === 0 && dirs.regexes.length === 0 && files.strings.size === 0 && files.regexes.length === 0 && exts.strings.size === 0 && exts.regexes.length === 0 && pathPatterns.length === 0;
+  return {
+    defaultDirs,
+    dirStrings: dirs.strings,
+    dirRegexes: dirs.regexes,
+    fileStrings: files.strings,
+    fileRegexes: files.regexes,
+    extStrings: exts.strings,
+    extRegexes: exts.regexes,
+    pathPatterns,
+    userRulesEmpty
+  };
+}
+function explainDirSkip(name, c) {
+  if (c.defaultDirs?.has(name)) return `built-in directory skip (${name})`;
+  if (c.userRulesEmpty) return null;
+  if (c.dirStrings.has(name)) return `exclude.dirs (${name})`;
+  for (const re of c.dirRegexes) {
+    if (re.test(name)) return `exclude.dirs regex /${re.source}/`;
+  }
+  return null;
+}
+function explainFileSkip(relPosix2, baseName, c) {
+  if (c.userRulesEmpty) return null;
+  if (c.fileStrings.has(baseName)) return `exclude.files (${baseName})`;
+  for (const re of c.fileRegexes) {
+    if (re.test(baseName)) return `exclude.files regex /${re.source}/`;
+  }
+  if (c.extStrings.size > 0 || c.extRegexes.length > 0) {
+    for (const suf of basenameExtensionSuffixes(baseName)) {
+      if (c.extStrings.has(suf)) return `exclude.extensions (${suf})`;
+      for (const re of c.extRegexes) {
+        if (re.test(suf)) return `exclude.extensions regex /${re.source}/`;
+      }
+    }
+  }
+  for (const re of c.pathPatterns) {
+    if (re.test(relPosix2)) return `exclude.patterns /${re.source}/ \u2190 ${relPosix2}`;
+  }
+  return null;
+}
+function listSourceFiles(runtime, rootDir, exclude, listOpts) {
+  const { fs, path } = runtime;
+  const compiled = compileScanExclude(exclude);
+  const out = [];
+  const debugSink = resolveScanDebugSink(listOpts);
+  const visitedDirs = /* @__PURE__ */ new Set();
+  function walk(dir, depth) {
+    if (!existsRuntimeFsSync(dir, fs)) return;
+    const dirKey = walkDirectoryKey(dir, path, fs);
+    if (visitedDirs.has(dirKey)) {
+      emitScanDebug(debugSink, {
+        kind: "skip_directory",
+        relativePath: relPosix(path, rootDir, dir),
+        basename: path.basename(dir),
+        reason: "directory already visited (symlink cycle or duplicate path)"
+      });
+      return;
+    }
+    visitedDirs.add(dirKey);
+    if (depth > MAX_SOURCE_TREE_WALK_DEPTH) {
+      emitScanDebug(debugSink, {
+        kind: "skip_directory",
+        relativePath: relPosix(path, rootDir, dir),
+        basename: path.basename(dir),
+        reason: `scan depth limit (${String(MAX_SOURCE_TREE_WALK_DEPTH)})`
+      });
+      return;
+    }
+    const entries = listRuntimeFsDirSync(dir, fs);
+    for (const e of entries) {
+      const p = path.join(dir, e.name);
+      if (e.kind === "directory") {
+        const why = explainDirSkip(e.name, compiled);
+        if (why) {
+          emitScanDebug(debugSink, {
+            kind: "skip_directory",
+            relativePath: relPosix(path, rootDir, p),
+            basename: e.name,
+            reason: why
+          });
+          continue;
+        }
+        walk(p, depth + 1);
+      } else if (e.kind === "file") {
+        const rel = relPosix(path, rootDir, p);
+        if (!SOURCE_FILE_NAME.test(e.name)) {
+          emitScanDebug(debugSink, {
+            kind: "skip_file",
+            relativePath: rel,
+            basename: e.name,
+            reason: `not a scanned source extension (${e.name})`
+          });
+          continue;
+        }
+        const whyF = explainFileSkip(rel, e.name, compiled);
+        if (whyF) {
+          emitScanDebug(debugSink, {
+            kind: "skip_file",
+            relativePath: rel,
+            basename: e.name,
+            reason: whyF
+          });
+          continue;
+        }
+        out.push(p);
+      } else if (e.kind === "other") {
+        emitScanDebug(debugSink, {
+          kind: "skip_file",
+          relativePath: relPosix(path, rootDir, p),
+          basename: e.name,
+          reason: "not a regular file or directory (symlink or special entry)"
+        });
+      }
+    }
+  }
+  walk(rootDir, 0);
+  return out;
+}
+
+// src/shared/scanner/index.ts
+function scanSources(runtime, srcRoot, exclude, scanOpts) {
+  const files = listSourceFiles(runtime, srcRoot, exclude, scanOpts);
+  const parts = [];
+  for (const f of files) {
+    try {
+      parts.push(readRuntimeFsTextSync(f, runtime.fs));
+    } catch {
+    }
+  }
+  return { files, text: parts.join("\n") };
+}
+
+// src/shared/placeholders/index.ts
+var placeholders_exports = {};
+__export(placeholders_exports, {
+  mask: () => mask,
+  restore: () => restore,
+  validateRestored: () => validateRestored
+});
+var SENTINEL_RE = /__I18NPRUNE_(\d+)__/g;
+function mask(input) {
+  const originals = [];
+  const text = input.replace(/\{\{([^}]+)\}\}/g, (_, inner) => {
+    const i = originals.length;
+    originals.push(inner.trim());
+    return `__I18NPRUNE_${i}__`;
+  });
+  return { text, originals };
+}
+function restore(masked, originals) {
+  return masked.replace(SENTINEL_RE, (_, idx) => {
+    const i = Number.parseInt(idx, 10);
+    const o = originals[i];
+    return o !== void 0 ? `{{${o}}}` : _;
+  });
+}
+function validateRestored(source, restored, originals) {
+  if (/__I18NPRUNE_\d+__/.test(restored)) {
+    throw new Error("Translation output still contains placeholder sentinels");
+  }
+  const srcMatches = [...source.matchAll(/\{\{([^}]+)\}\}/g)].map((m) => m[1].trim());
+  if (srcMatches.length !== originals.length) {
+    throw new Error("Placeholder count mismatch after translation");
+  }
+}
+
+// src/shared/translator/index.ts
+var translator_exports = {};
+__export(translator_exports, {
+  localeJsonValueFromTranslation: () => localeJsonValueFromTranslation,
+  translateLeaf: () => translateLeaf,
+  validateLeafTranslationString: () => validateLeafTranslationString
+});
+
+// src/shared/translator/utils/metadata.ts
+function buildHeuristicLeafMeta(input) {
+  const src = input.sourceText.trim();
+  const tgt = input.translatedText.trim();
+  const tag = `${input.providerId}-heuristic`;
+  if (src.length === 0) {
+    return {
+      status: "translated",
+      confidence: null,
+      needsReview: true,
+      source: tag,
+      needsTranslationAgain: true
+    };
+  }
+  if (src === tgt) {
+    return {
+      status: "translated",
+      confidence: null,
+      needsReview: true,
+      source: tag,
+      needsTranslationAgain: true
+    };
+  }
+  const ratio = tgt.length / src.length;
+  const drift = Math.abs(1 - Math.min(ratio, 2));
+  const confidence = Math.max(0.35, Math.min(0.88, 0.62 + (1 - drift) * 0.25));
+  return {
+    status: "translated",
+    confidence,
+    needsReview: confidence < 0.52,
+    source: tag,
+    needsTranslationAgain: false
+  };
+}
+
+// src/shared/translator/utils/pipeline.ts
+function unpackProviderTranslation(raw) {
+  if (typeof raw === "string") return { text: raw, patch: {} };
+  return { text: raw.text, patch: raw.leafMeta ?? {} };
+}
+function mergeTranslationLeafMeta(heuristic, provider) {
+  return {
+    status: provider.status ?? heuristic.status,
+    confidence: "confidence" in provider ? provider.confidence ?? null : heuristic.confidence,
+    needsReview: "needsReview" in provider ? provider.needsReview : heuristic.needsReview,
+    needsTranslationAgain: "needsTranslationAgain" in provider ? provider.needsTranslationAgain : heuristic.needsTranslationAgain,
+    source: provider.source ?? heuristic.source
+  };
+}
+function finalizeTranslationLeafMeta(patch, decision) {
+  const roundConfidence = (v) => {
+    if (v === null || v === void 0) return null;
+    if (!Number.isFinite(v)) return null;
+    const clamped = Math.max(0, Math.min(1, v));
+    return Math.round(clamped * 100) / 100;
+  };
+  return {
+    status: patch.status ?? "translated",
+    confidence: roundConfidence(patch.confidence),
+    needsReview: decision === "review" ? true : patch.needsReview ?? false,
+    needsTranslationAgain: patch.needsTranslationAgain ?? false,
+    source: patch.source ?? "manual"
+  };
+}
+function localeJsonValueFromTranslation(persistStructuredMetadata, tr) {
+  if (!persistStructuredMetadata) return tr.text;
+  return {
+    value: tr.text,
+    status: tr.leafMeta.status,
+    confidence: tr.leafMeta.confidence,
+    needsReview: tr.leafMeta.needsReview,
+    needsTranslationAgain: tr.leafMeta.needsTranslationAgain,
+    source: tr.leafMeta.source
+  };
+}
+function validateLeafTranslationString(value, context) {
+  if (typeof value !== "string") {
+    throw new I18nPruneError(
+      `Translator returned non-string${context ? ` (${context})` : ""}`,
+      "INTERNAL"
+    );
+  }
+  return value;
+}
+
+// src/translator/policy/classify.ts
+function classifyTranslateFailure(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  if (/\b429\b/.test(msg) || /\btoo many requests\b/i.test(msg)) {
+    if (/MYMEMORY WARNING:\s*YOU USED ALL AVAILABLE FREE TRANSLATIONS FOR TODAY/i.test(msg)) {
+      return "quota_exceeded";
+    }
+    return "rate_limited";
+  }
+  if (/\b401\b/.test(msg) || /\b403\b/.test(msg) || /\bunauthorized\b/i.test(msg) || /\bforbidden\b/i.test(msg)) {
+    return "auth_failure";
+  }
+  if (isErrnoCode(err, "ECONNRESET") || isErrnoCode(err, "ETIMEDOUT") || isErrnoCode(err, "ENOTFOUND") || isErrnoCode(err, "EAI_AGAIN") || isErrnoCode(err, "ECONNREFUSED") || /fetch failed/i.test(msg) || /network/i.test(msg)) {
+    return "transient_network";
+  }
+  if (/\b5\d{2}\b/.test(msg) || /\bservice unavailable\b/i.test(msg)) {
+    return "provider_unavailable";
+  }
+  if (/invalid json/i.test(msg) || /malformed/i.test(msg) || /unexpected token/i.test(msg)) {
+    return "malformed_response";
+  }
+  return "unknown_hard_stop";
+}
+
+// src/shared/constants/translate.ts
+var TRANSLATE_WORKERS_CAP = 64;
+var ENV_TRANSLATE_MAX_WORKERS = "I18NPRUNE_TRANSLATE_MAX_WORKERS";
+var ENV_TRANSLATE_PROVIDER = "I18NPRUNE_TRANSLATE_PROVIDER";
+var ENV_TRANSLATE_DEEPL_API_KEY = "I18NPRUNE_TRANSLATE_DEEPL_API_KEY";
+var ENV_TRANSLATE_LIBRE_URL = "I18NPRUNE_TRANSLATE_LIBRE_URL";
+var ENV_TRANSLATE_LLM_API_KEY = "I18NPRUNE_TRANSLATE_LLM_API_KEY";
+var ENV_TRANSLATE_LLM_BASE_URL = "I18NPRUNE_TRANSLATE_LLM_BASE_URL";
+var ENV_TRANSLATE_LLM_MODEL = "I18NPRUNE_TRANSLATE_LLM_MODEL";
+
+// src/shared/translator/index.ts
+var DEFAULT_DELAYS = [400, 900];
+async function sleep(ms) {
+  await new Promise((r) => setTimeout(r, ms));
+}
+async function translateLeaf(provider, sourceText, sourceLang, targetLang, options) {
+  const { text, originals } = mask(sourceText);
+  const providerId = options?.providerId ?? "google";
+  let lastErr;
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    try {
+      const raw = await provider.translate(text, sourceLang, targetLang);
+      const unpacked = unpackProviderTranslation(raw);
+      const normalized = validateLeafTranslationString(unpacked.text, "translate");
+      const restored = restore(normalized, originals);
+      validateRestored(sourceText, restored, originals);
+      const heuristic = buildHeuristicLeafMeta({
+        sourceText,
+        translatedText: restored,
+        providerId
+      });
+      const merged = mergeTranslationLeafMeta(heuristic, unpacked.patch);
+      const decision = merged.needsReview === true ? "review" : "translated";
+      const leafMeta = finalizeTranslationLeafMeta(merged, decision);
+      await options?.onTranslated?.(sourceText, restored);
+      const attempts = attempt + 1;
+      return {
+        text: restored,
+        leafMeta,
+        decision,
+        runtime: { attempts, retries: Math.max(0, attempts - 1) }
+      };
+    } catch (e) {
+      lastErr = e;
+      if (attempt < 2) await sleep(DEFAULT_DELAYS[attempt] ?? 500);
+    }
+  }
+  const parseMyMemoryQuotaWait = (msg) => {
+    const m = msg.match(/NEXT AVAILABLE IN\s+(\d+)\s+HOURS\s+(\d+)\s+MINUTES\s+(\d+)\s+SECONDS/i);
+    if (!m) return null;
+    const h = Number.parseInt(m[1] ?? "", 10);
+    const min = Number.parseInt(m[2] ?? "", 10);
+    const s = Number.parseInt(m[3] ?? "", 10);
+    if (![h, min, s].every((n) => Number.isFinite(n) && n >= 0)) return null;
+    const parts = [h ? `${String(h)}h` : "", min ? `${String(min)}m` : "", `${String(s)}s`].filter(Boolean);
+    return parts.join(" ");
+  };
+  const outcome = classifyTranslateFailure(lastErr);
+  const issueCode = outcome === "rate_limited" || outcome === "quota_exceeded" ? ISSUE_GENERATE_TRANSLATE_RATE_LIMITED : outcome === "transient_network" || outcome === "provider_unavailable" ? ISSUE_GENERATE_TRANSLATE_NETWORK_ERROR : void 0;
+  const issues = issueCode !== void 0 ? [
+    {
+      severity: "error",
+      code: issueCode,
+      message: issueCode === ISSUE_GENERATE_TRANSLATE_RATE_LIMITED ? (() => {
+        const msg = lastErr instanceof Error ? lastErr.message : String(lastErr);
+        const wait = /MYMEMORY WARNING/i.test(msg) ? parseMyMemoryQuotaWait(msg) : null;
+        const waitHint = wait ? ` Wait time reported by MyMemory: ${wait}.` : "";
+        const limitsHint = /MYMEMORY WARNING/i.test(msg) ? " See MyMemory usage limits: https://mymemory.translated.net/doc/usagelimits.php." : "";
+        return `Translation failed: backend rate limited the request(s) (HTTP 429). Reduce --workers, wait, or switch provider.${waitHint}${limitsHint}`;
+      })() : "Translation failed: network error talking to the translation backend. Check connectivity/DNS/proxy and retry.",
+      docPath: issueCodeRepoDocPathForIssueCode(issueCode)
+    }
+  ] : [];
+  const norm = normalizeUnknownError(lastErr, {
+    when: "Translation failed after retries",
+    defaultCode: "INTERNAL",
+    ...issueCode !== void 0 ? { issueCode } : {}
+  });
+  norm.issues = issues;
+  throw norm;
+}
+
+// src/shared/locales/layout/index.ts
+var layout_exports = {};
+__export(layout_exports, {
+  isLocalesLayoutReadSupported: () => isLocalesLayoutReadSupported,
+  isLocalesLayoutWriteSupported: () => isLocalesLayoutWriteSupported,
+  resolveLocalesLayout: () => resolveLocalesLayout,
+  resolveLocalesLayoutFromContext: () => resolveLocalesLayoutFromContext,
+  sourceLocaleCodeForLayout: () => sourceLocaleCodeForLayout
+});
+
+// src/shared/locales/layout/requireStructure.ts
+function localesMode(config) {
+  return config.mode ?? "flat_file";
+}
+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 };
+}
+function resolveLocalesLayoutFromContext(ctx) {
+  return resolveLocalesLayout(ctx.config.locales, ctx.paths.localesDir);
+}
+function isLocalesLayoutReadSupported(layout) {
+  return layout.mode === "flat_file" && layout.structure === "locale_file" || layout.mode === "locale_directory" && (layout.structure === "locale_per_dir" || layout.structure === "feature_bundle");
+}
+function isLocalesLayoutWriteSupported(layout) {
+  return layout.mode === "flat_file" && layout.structure === "locale_file" || layout.mode === "locale_directory" && (layout.structure === "locale_per_dir" || layout.structure === "feature_bundle");
+}
+
+// src/shared/languages/normalize.ts
+function normalizeLanguageCode(code) {
+  return code.trim().toLowerCase().replace(/_/g, "-");
+}
+
+// src/shared/path/posix.ts
+function toPosixPath(value) {
+  return value.replace(/\\/g, "/");
+}
+
+// src/shared/locales/enumerate/resolveSegmentPath.ts
+function resolveLocaleSegmentAbsolutePath(input) {
+  const { layout, path, locale } = input;
+  const rel = input.segmentRelativePath ?? `${locale}.json`;
+  return toPosixPath(path.join(layout.directoryAbsolute, rel));
+}
+function localeSegmentRefFromAbsolute(input) {
+  const { layout, path, absolutePath } = input;
+  let relativePath = path.relative(layout.directoryAbsolute, absolutePath);
+  if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+    return null;
+  }
+  relativePath = relativePath.replace(/\\/g, "/");
+  if (!relativePath.endsWith(".json")) {
+    return null;
+  }
+  const locale = localeCodeForSegment(layout.structure, path, { absolutePath, relativePath });
+  if (locale === null) return null;
+  return { locale, relativePath, absolutePath: toPosixPath(absolutePath) };
+}
+
+// src/shared/locales/layout/sourceLocaleCode.ts
+function sourceLocaleCodeForLayout(input) {
+  const ref = localeSegmentRefFromAbsolute({
+    layout: input.layout,
+    path: input.path,
+    absolutePath: input.sourceLocaleAbsolute
+  });
+  if (ref !== null) {
+    return normalizeLanguageCode(ref.locale);
+  }
+  return normalizeLanguageCode(input.path.basename(input.sourceLocaleAbsolute, ".json"));
+}
+
+// src/shared/locales/read/index.ts
+var read_exports = {};
+__export(read_exports, {
+  createLocaleReadCache: () => createLocaleReadCache,
+  invalidateLocaleReadCacheForAbsolutePath: () => invalidateLocaleReadCacheForAbsolutePath,
+  invalidateLocaleReadCacheForLocaleCode: () => invalidateLocaleReadCacheForLocaleCode,
+  readFlatLocaleJsonSurface: () => readFlatLocaleJsonSurface,
+  readLocaleBundle: () => readLocaleBundle,
+  readLocaleCodeSurfaceFromContext: () => readLocaleCodeSurfaceFromContext,
+  readLocaleJsonFromContextSync: () => readLocaleJsonFromContextSync,
+  readLocalePerDirLocaleSurface: () => readLocalePerDirLocaleSurface,
+  readLocaleSegmentFromContext: () => readLocaleSegmentFromContext
+});
+
+// src/shared/locales/read/flatFileSurface.ts
+function readFlatLocaleJsonSurface(input) {
+  const diagnostics = [];
+  const emit = (d) => {
+    diagnostics.push(d);
+    input.onDiagnostic?.(d);
+  };
+  try {
+    const text = readRuntimeFsTextSync(input.absoluteFile, input.fs);
+    let json;
+    try {
+      json = parseJsonText(text, {
+        filePath: input.absoluteFile,
+        code: "IO",
+        issueCode: ISSUE_IO_READ_FAILED
+      });
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      emit({ level: "error", code: "locale_json_parse_failed", message, path: input.absoluteFile });
+      return { ok: false, leaves: [], diagnostics };
+    }
+    const fileOrigin = localeSegmentSourceForFile({
+      path: input.path,
+      absoluteFile: input.absoluteFile,
+      localesDir: input.localesDir,
+      structure: input.structure
+    });
+    const leaves = collectTranslationSurfaceLeaves(json, "", [], fileOrigin ?? void 0);
+    return { ok: true, document: json, leaves, text, diagnostics };
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    emit({ level: "error", code: "locale_fs_read_failed", message, path: input.absoluteFile });
+    return { ok: false, leaves: [], diagnostics };
+  }
+}
+
+// src/shared/locales/read/bundle.ts
+function readLocaleBundle(input) {
+  const diagnostics = [];
+  const emit = (d) => {
+    diagnostics.push(d);
+    input.onDiagnostic?.(d);
+  };
+  if (!isLocalesLayoutReadSupported(input.layout)) {
+    emit({
+      level: "error",
+      code: "locale_layout_unsupported",
+      message: `locale read is not implemented for mode=${input.layout.mode} structure=${input.layout.structure}`,
+      path: input.absoluteFile
+    });
+    return { ok: false, leaves: [], diagnostics };
+  }
+  const segmentRef = localeSegmentRefFromAbsolute({
+    layout: input.layout,
+    path: input.path,
+    absolutePath: input.absoluteFile
+  });
+  if (segmentRef === null) {
+    emit({
+      level: "warn",
+      code: "locale_read_path_layout_mismatch",
+      message: `path does not match configured layout mode=${input.layout.mode} structure=${input.layout.structure}`,
+      path: input.absoluteFile
+    });
+    return { ok: false, leaves: [], diagnostics };
+  }
+  return readFlatLocaleJsonSurface({
+    fs: input.fs,
+    path: input.path,
+    absoluteFile: input.absoluteFile,
+    localesDir: input.layout.directoryAbsolute,
+    structure: input.layout.structure,
+    onDiagnostic: input.onDiagnostic
+  });
+}
+
+// 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;
+}
+function collectSourceLocaleMissingSegmentDiagnostics(input) {
+  const { structure, segments, sourceLocale } = input;
+  if (structure !== "locale_per_dir" && structure !== "feature_bundle") {
+    return [];
+  }
+  const byLocale = slotsByLocale(structure, segments);
+  const sourceSlots = byLocale.get(sourceLocale);
+  if (!sourceSlots) return [];
+  const peerSlots = /* @__PURE__ */ new Set();
+  for (const [locale, slots] of byLocale) {
+    if (locale === sourceLocale) continue;
+    for (const slot of slots) {
+      peerSlots.add(slot);
+    }
+  }
+  if (peerSlots.size === 0) return [];
+  const diagnostics = [];
+  for (const slot of peerSlots) {
+    if (!sourceSlots.has(slot)) {
+      diagnostics.push({
+        level: "warn",
+        code: "source_locale_segment_slot_missing",
+        message: `source locale ${sourceLocale} is missing segment ${slot} (present for other locale(s) under locales.directory)`
+      });
+    }
+  }
+  diagnostics.sort((a, b) => a.message.localeCompare(b.message));
+  return diagnostics;
+}
+
+// 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/enumerate/listLocaleCodes.ts
+function listLocaleCodes(input) {
+  const { segments, diagnostics } = listLocaleSegments(input);
+  const codes = [...new Set(segments.map((s) => s.locale))].sort((a, b) => a.localeCompare(b));
+  return { codes, diagnostics };
+}
+
+// src/shared/locales/enumerate/fromContext.ts
+function listLocaleSegmentsFromContext(ctx) {
+  return listLocaleSegments({
+    layout: resolveLocalesLayoutFromContext(ctx),
+    fs: ctx.adapters.fs,
+    path: ctx.adapters.path
+  });
+}
+function listLocaleCodesFromContext(ctx) {
+  return listLocaleCodes({
+    layout: resolveLocalesLayoutFromContext(ctx),
+    fs: ctx.adapters.fs,
+    path: ctx.adapters.path
+  });
+}
+
+// src/shared/locales/targets/context.ts
+function normalizeCode(code) {
+  return normalizeLanguageCode(code);
+}
+function listLocaleSegmentTargets(ctx) {
+  const { segments } = listLocaleSegmentsFromContext(ctx);
+  return segments.map((segment) => ({
+    ...segment,
+    reportKey: segment.relativePath
+  }));
+}
+function sourceLocaleCodeFromContext(ctx) {
+  const layout = resolveLocalesLayoutFromContext(ctx);
+  const ref = localeSegmentRefFromAbsolute({
+    layout,
+    path: ctx.adapters.path,
+    absolutePath: ctx.paths.sourceLocale
+  });
+  if (ref !== null) {
+    return normalizeCode(ref.locale);
+  }
+  return normalizeCode(ctx.adapters.path.basename(ctx.paths.sourceLocale, ".json"));
+}
+function localeCodesFromContext(ctx) {
+  return listLocaleCodesFromContext(ctx).codes.map((c) => normalizeCode(c));
+}
+function targetLocaleCodesFromContext(ctx) {
+  const source = sourceLocaleCodeFromContext(ctx);
+  return localeCodesFromContext(ctx).filter((c) => c !== source);
+}
+function segmentsForLocaleCode(ctx, localeCode) {
+  const want = normalizeCode(localeCode);
+  return listLocaleSegmentTargets(ctx).filter((s) => normalizeCode(s.locale) === want);
+}
+function primarySegmentForLocale(ctx, localeCode) {
+  const segments = segmentsForLocaleCode(ctx, localeCode);
+  if (segments.length === 0) return void 0;
+  const sourceResolved = ctx.adapters.path.resolve(ctx.paths.sourceLocale);
+  const sourceMatch = segments.find((s) => ctx.adapters.path.resolve(s.absolutePath) === sourceResolved);
+  if (sourceMatch) return sourceMatch;
+  return segments.slice().sort((a, b) => a.relativePath.localeCompare(b.relativePath))[0];
+}
+function resolveLocaleSegmentTargets(ctx, input) {
+  const source = sourceLocaleCodeFromContext(ctx);
+  const all = listLocaleSegmentTargets(ctx).filter((s) => normalizeCode(s.locale) !== source);
+  if (input.selection.mode === "all") {
+    return { segments: all, missingLocaleCodes: [] };
+  }
+  const missingLocaleCodes = [];
+  const segments = [];
+  for (const code of input.selection.codes) {
+    const norm = normalizeCode(code);
+    const forCode = all.filter((s) => normalizeCode(s.locale) === norm);
+    if (forCode.length === 0) {
+      missingLocaleCodes.push(norm);
+      continue;
+    }
+    segments.push(...forCode);
+  }
+  segments.sort((a, b) => {
+    const byLocale = a.locale.localeCompare(b.locale);
+    if (byLocale !== 0) return byLocale;
+    return a.relativePath.localeCompare(b.relativePath);
+  });
+  return { segments, missingLocaleCodes };
+}
+
+// src/shared/locales/read/cache.ts
+function createLocaleReadCache() {
+  return {
+    segments: /* @__PURE__ */ new Map(),
+    localeCodes: /* @__PURE__ */ new Map()
+  };
+}
+function invalidateLocaleReadCacheForAbsolutePath(ctx, absolutePath) {
+  ctx.localeRead.segments.delete(absolutePath);
+  const layout = resolveLocalesLayoutFromContext(ctx);
+  const ref = localeSegmentRefFromAbsolute({
+    layout,
+    path: ctx.adapters.path,
+    absolutePath
+  });
+  if (ref !== null) {
+    ctx.localeRead.localeCodes.delete(normalizeLanguageCode(ref.locale));
+  }
+}
+function dropLocaleCodeReadCache(ctx, localeCode) {
+  ctx.localeRead.localeCodes.delete(normalizeLanguageCode(localeCode));
+}
+function invalidateLocaleReadCacheForLocaleCode(ctx, localeCode) {
+  const normalized = normalizeLanguageCode(localeCode);
+  dropLocaleCodeReadCache(ctx, normalized);
+  for (const segment of segmentsForLocaleCode(ctx, normalized)) {
+    ctx.localeRead.segments.delete(segment.absolutePath);
+  }
+}
+
+// src/shared/locales/read/fromContext.ts
+function storeSegmentSnapshot(ctx, absoluteFile, snapshot) {
+  ctx.localeRead.segments.set(absoluteFile, snapshot);
+  if (snapshot.ok) {
+    const layout = resolveLocalesLayoutFromContext(ctx);
+    const ref = localeSegmentRefFromAbsolute({
+      layout,
+      path: ctx.adapters.path,
+      absolutePath: absoluteFile
+    });
+    if (ref !== null) {
+      dropLocaleCodeReadCache(ctx, ref.locale);
+    }
+  }
+}
+function segmentSnapshotToResult(snapshot) {
+  if (snapshot.ok) {
+    return {
+      ok: true,
+      document: snapshot.document,
+      leaves: snapshot.leaves,
+      text: snapshot.text,
+      diagnostics: []
+    };
+  }
+  return { ok: false, leaves: [], diagnostics: snapshot.diagnostics };
+}
+function readLocaleSegmentFromContext(ctx, absoluteFile, onDiagnostic) {
+  const cached = ctx.localeRead.segments.get(absoluteFile);
+  if (cached !== void 0) {
+    return segmentSnapshotToResult(cached);
+  }
+  const result = readLocaleBundle({
+    layout: resolveLocalesLayoutFromContext(ctx),
+    fs: ctx.adapters.fs,
+    path: ctx.adapters.path,
+    absoluteFile,
+    onDiagnostic
+  });
+  if (result.ok) {
+    storeSegmentSnapshot(ctx, absoluteFile, {
+      ok: true,
+      absolutePath: absoluteFile,
+      document: result.document,
+      leaves: result.leaves,
+      text: result.text
+    });
+  } else {
+    storeSegmentSnapshot(ctx, absoluteFile, {
+      ok: false,
+      absolutePath: absoluteFile,
+      diagnostics: result.diagnostics
+    });
+  }
+  return result;
+}
+function storeLocaleCodeSnapshot(ctx, snapshot) {
+  ctx.localeRead.localeCodes.set(normalizeLanguageCode(snapshot.localeCode), snapshot);
+}
+function readLocaleCodeSurfaceFromContext(ctx, localeCode, onDiagnostic) {
+  const normalized = normalizeLanguageCode(localeCode);
+  const cached = ctx.localeRead.localeCodes.get(normalized);
+  if (cached !== void 0) {
+    return {
+      ok: true,
+      document: cached.document,
+      leaves: cached.leaves,
+      text: "",
+      diagnostics: []
+    };
+  }
+  const layout = resolveLocalesLayoutFromContext(ctx);
+  if (layout.mode === "flat_file") {
+    const segment = primarySegmentForLocale(ctx, normalized);
+    const absoluteFile = segment?.absolutePath ?? ctx.paths.sourceLocale;
+    const read = readLocaleSegmentFromContext(ctx, absoluteFile, onDiagnostic);
+    if (!read.ok) return read;
+    storeLocaleCodeSnapshot(ctx, {
+      localeCode: normalized,
+      document: read.document,
+      leaves: read.leaves
+    });
+    return read;
+  }
+  const diagnostics = [];
+  const { segments, diagnostics: listDiagnostics } = listLocaleSegments({
+    layout,
+    fs: ctx.adapters.fs,
+    path: ctx.adapters.path
+  });
+  diagnostics.push(...listDiagnostics);
+  const forLocale = segments.filter((s) => normalizeLanguageCode(s.locale) === normalized);
+  if (forLocale.length === 0) {
+    const empty = { localeCode: normalized, document: {}, leaves: [] };
+    storeLocaleCodeSnapshot(ctx, empty);
+    return { ok: true, document: {}, leaves: [], text: "{}", diagnostics };
+  }
+  const allLeaves = [];
+  const documents = [];
+  let combinedText = "";
+  for (const segment of forLocale) {
+    const read = readLocaleSegmentFromContext(ctx, segment.absolutePath, onDiagnostic);
+    diagnostics.push(...read.diagnostics);
+    if (!read.ok) return { ok: false, leaves: [], diagnostics };
+    allLeaves.push(...read.leaves);
+    documents.push(read.document);
+    combinedText = read.text;
+  }
+  const document = documents.length === 1 ? documents[0] : documents;
+  storeLocaleCodeSnapshot(ctx, {
+    localeCode: normalized,
+    document,
+    leaves: allLeaves
+  });
+  return {
+    ok: true,
+    document,
+    leaves: allLeaves,
+    text: combinedText,
+    diagnostics
+  };
+}
+function readLocaleJsonFromContextSync(ctx, absoluteFile) {
+  const read = readLocaleSegmentFromContext(ctx, absoluteFile);
+  if (!read.ok) {
+    const message = read.diagnostics.map((d) => d.message).join(" \xB7 ") || "failed to read locale JSON";
+    throw new I18nPruneError(message, "IO", { issueCode: ISSUE_IO_READ_FAILED });
+  }
+  return read.document;
+}
+
+// src/shared/locales/read/perDirLocaleSurface.ts
+function readLocalePerDirLocaleSurface(input) {
+  const diagnostics = [];
+  const emit = (d) => {
+    diagnostics.push(d);
+    input.onDiagnostic?.(d);
+  };
+  const { segments, diagnostics: listDiagnostics } = listLocaleSegments({
+    layout: input.layout,
+    fs: input.fs,
+    path: input.path
+  });
+  diagnostics.push(...listDiagnostics);
+  const forLocale = segments.filter((s) => s.locale === input.localeCode);
+  if (forLocale.length === 0) {
+    emit({
+      level: "warn",
+      code: "locale_segment_not_found",
+      message: `no locale segments found for code ${input.localeCode}`
+    });
+    return { ok: true, document: {}, leaves: [], text: "{}", diagnostics };
+  }
+  const allLeaves = [];
+  const documents = [];
+  let combinedText = "";
+  for (const segment of forLocale) {
+    const read = readFlatLocaleJsonSurface({
+      fs: input.fs,
+      path: input.path,
+      absoluteFile: segment.absolutePath,
+      localesDir: input.layout.directoryAbsolute,
+      structure: input.layout.structure,
+      onDiagnostic: input.onDiagnostic
+    });
+    diagnostics.push(...read.diagnostics);
+    if (!read.ok) return { ok: false, leaves: [], diagnostics };
+    allLeaves.push(...read.leaves);
+    documents.push(read.document);
+    combinedText = read.text;
+  }
+  return {
+    ok: true,
+    document: documents.length === 1 ? documents[0] : documents,
+    leaves: allLeaves,
+    text: combinedText,
+    diagnostics
+  };
+}
+
+// src/shared/locales/write/index.ts
+var write_exports = {};
+__export(write_exports, {
+  writeFlatLocaleJsonDocument: () => writeFlatLocaleJsonDocument,
+  writeLocaleBundle: () => writeLocaleBundle,
+  writeLocaleJsonFromContextSync: () => writeLocaleJsonFromContextSync
+});
+
+// src/shared/json/sortKeys.ts
+function isPlainObject6(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function sortJsonObjectKeysAsc(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => sortJsonObjectKeysAsc(item));
+  }
+  if (!isPlainObject6(value)) return value;
+  const sorted = {};
+  for (const key of Object.keys(value).sort()) {
+    sorted[key] = sortJsonObjectKeysAsc(value[key]);
+  }
+  return sorted;
+}
+
+// src/shared/locales/write/flatFileLocaleJson.ts
+function writeFlatLocaleJsonDocument(input) {
+  const diagnostics = [];
+  const emit = (d) => {
+    diagnostics.push(d);
+    input.onDiagnostic?.(d);
+  };
+  const indent = input.indent ?? 2;
+  let body;
+  try {
+    body = `${JSON.stringify(sortJsonObjectKeysAsc(input.data), null, indent)}
+`;
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    emit({ level: "error", code: "locale_json_serialize_failed", message, path: input.absoluteFile });
+    return { ok: false, diagnostics };
+  }
+  try {
+    input.fs.mkdirp(input.path.dirname(input.absoluteFile));
+    input.fs.writeText(input.absoluteFile, body);
+    return { ok: true, diagnostics };
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    emit({ level: "error", code: "locale_fs_write_failed", message, path: input.absoluteFile });
+    return { ok: false, diagnostics };
+  }
+}
+
+// src/shared/locales/write/bundle.ts
+function writeLocaleBundle(input) {
+  const diagnostics = [];
+  const emit = (d) => {
+    diagnostics.push(d);
+    input.onDiagnostic?.(d);
+  };
+  if (!isLocalesLayoutWriteSupported(input.layout)) {
+    emit({
+      level: "error",
+      code: "locale_layout_unsupported",
+      message: `locale write is not implemented for mode=${input.layout.mode} structure=${input.layout.structure}`,
+      path: input.absoluteFile
+    });
+    return { ok: false, diagnostics };
+  }
+  const segmentRef = localeSegmentRefFromAbsolute({
+    layout: input.layout,
+    path: input.path,
+    absolutePath: input.absoluteFile
+  });
+  if (segmentRef === null) {
+    emit({
+      level: "warn",
+      code: "locale_write_path_layout_mismatch",
+      message: `path does not match configured layout mode=${input.layout.mode} structure=${input.layout.structure}`,
+      path: input.absoluteFile
+    });
+    return { ok: false, diagnostics };
+  }
+  return writeFlatLocaleJsonDocument({
+    fs: input.fs,
+    path: input.path,
+    absoluteFile: input.absoluteFile,
+    data: input.data,
+    indent: input.indent,
+    onDiagnostic: input.onDiagnostic
+  });
+}
+function writeLocaleJsonFromContextSync(ctx, absoluteFile, data) {
+  const result = writeLocaleBundle({
+    layout: resolveLocalesLayoutFromContext(ctx),
+    fs: ctx.adapters.fs,
+    path: ctx.adapters.path,
+    absoluteFile,
+    data
+  });
+  if (!result.ok) {
+    const message = result.diagnostics.map((d) => d.message).join(" \xB7 ") || "failed to write locale JSON";
+    throw new I18nPruneError(message, "IO", { issueCode: ISSUE_IO_READ_FAILED });
+  }
+  invalidateLocaleReadCacheForAbsolutePath(ctx, absoluteFile);
+}
+
+// src/shared/projects/index.ts
+var projects_exports = {};
+__export(projects_exports, {
+  translationSurfacePathValueMap: () => translationSurfacePathValueMap
+});
+
+// src/shared/projects/localeSurfaceMap.ts
+function translationSurfacePathValueMap(localeJson) {
+  const m = /* @__PURE__ */ new Map();
+  for (const row of collectTranslationSurfaceLeaves(localeJson)) {
+    m.set(row.path, row.value);
+  }
+  return m;
+}
+
+// src/shared/sourcePlaceholders/index.ts
+var sourcePlaceholders_exports = {};
+__export(sourcePlaceholders_exports, {
+  detectLocalePlaceholderLeaves: () => detectLocalePlaceholderLeaves,
+  detectSourcePlaceholderLeaves: () => detectSourcePlaceholderLeaves,
+  formatSourcePlaceholderMessage: () => formatSourcePlaceholderMessage,
+  formatSyncSourcePlaceholderMessage: () => formatSyncSourcePlaceholderMessage,
+  formatTargetPlaceholderMessage: () => formatTargetPlaceholderMessage,
+  issuesFromSourcePlaceholderLeaves: () => issuesFromSourcePlaceholderLeaves,
+  issuesFromTargetPlaceholderLeaves: () => issuesFromTargetPlaceholderLeaves,
+  sourcePlaceholderValues: () => sourcePlaceholderValues
+});
+
+// src/shared/constants/missing.ts
+var DEFAULT_MISSING_LEAF_PLACEHOLDER = "__I18NPRUNE_MISSING__";
+var MAX_MISSING_TARGET_SUGGESTIONS = 3;
+
+// src/missing/placeholder.ts
+var MISSING_LEAF_PLACEHOLDER_MAX_LEN = 256;
+function resolveMissingLeafPlaceholder(raw) {
+  const warnings = [];
+  const def = DEFAULT_MISSING_LEAF_PLACEHOLDER;
+  if (raw === void 0) return { placeholder: def, warnings };
+  if (typeof raw !== "string") {
+    warnings.push(
+      `missing.placeholder must be a string; got ${typeof raw}. Using default ${JSON.stringify(def)} for reliable detection.`
+    );
+    return { placeholder: def, warnings };
+  }
+  const t = raw.trim();
+  if (t.length === 0) {
+    warnings.push(
+      `missing.placeholder is empty or whitespace-only; using default ${JSON.stringify(def)} so missing tooling can detect scaffolded paths.`
+    );
+    return { placeholder: def, warnings };
+  }
+  if (t.length > MISSING_LEAF_PLACEHOLDER_MAX_LEN) {
+    warnings.push(
+      `missing.placeholder exceeds ${String(MISSING_LEAF_PLACEHOLDER_MAX_LEN)} characters; using default ${JSON.stringify(def)}.`
+    );
+    return { placeholder: def, warnings };
+  }
+  return { placeholder: t, warnings };
+}
+
+// src/shared/sourcePlaceholders/index.ts
+function sourcePlaceholderValues(configuredPlaceholder) {
+  const resolved = resolveMissingLeafPlaceholder(configuredPlaceholder).placeholder;
+  return [...new Set([DEFAULT_MISSING_LEAF_PLACEHOLDER, resolved].filter((value) => value.trim().length > 0))];
+}
+function detectSourcePlaceholderLeaves(leaves, placeholderValues) {
+  const sentinels = new Set(placeholderValues);
+  if (sentinels.size === 0) return [];
+  return leaves.filter((leaf) => sentinels.has(leaf.value)).map((leaf) => ({ path: leaf.path, value: leaf.value }));
+}
+function detectLocalePlaceholderLeaves(input) {
+  return detectSourcePlaceholderLeaves(input.leaves, input.placeholderValues).map((leaf) => ({
+    ...leaf,
+    localeRole: input.localeRole,
+    localeCode: input.localeCode,
+    ...input.localePath !== void 0 ? { localePath: input.localePath } : {}
+  }));
+}
+function formatSourcePlaceholderMessage(input) {
+  const sample = input.samplePaths.join(", ");
+  return `Source locale has ${String(input.count)} missing placeholder value(s). Run \`i18nprune missing --full\` to list placeholder paths. Replace them with real source copy, then run \`i18nprune sync\` and \`i18nprune generate --resume\` for target locales. Sample paths: ${sample}`;
+}
+function formatSyncSourcePlaceholderMessage(input) {
+  const sample = input.samplePaths.join(", ");
+  return `Source locale has ${String(input.count)} missing placeholder value(s); sync skipped those path(s) so placeholders are not copied to target locales. Run \`i18nprune missing --full\` to list placeholder paths. Replace them with real source copy, then run \`i18nprune sync\` and \`i18nprune generate --resume\`. Sample paths: ${sample}`;
+}
+function formatTargetPlaceholderMessage(input) {
+  const sample = input.samplePaths.join(", ");
+  const target = input.targetLabel === void 0 ? "Target locale" : `Target locale ${input.targetLabel}`;
+  const listCommand = input.targetLabel === void 0 ? "i18nprune missing --target all --full" : `i18nprune missing --target ${input.targetLabel} --full`;
+  return `${target} has ${String(input.count)} missing placeholder value(s). Run \`${listCommand}\` to list placeholder paths, then \`i18nprune sync\` and \`i18nprune generate --resume\` to refill translations. Sample paths: ${sample}`;
+}
+function issuesFromSourcePlaceholderLeaves(leaves) {
+  if (leaves.length === 0) return [];
+  return [
+    {
+      severity: "warning",
+      code: ISSUE_LOCALE_SOURCE_PLACEHOLDER_LEAVES,
+      message: formatSourcePlaceholderMessage({
+        count: leaves.length,
+        samplePaths: leaves.slice(0, 5).map((leaf) => leaf.path)
+      }),
+      docPath: issueCodeRepoDocPathForIssueCode(ISSUE_LOCALE_SOURCE_PLACEHOLDER_LEAVES)
+    }
+  ];
+}
+function issuesFromTargetPlaceholderLeaves(leaves) {
+  const targetLeaves = leaves.filter((leaf) => leaf.localeRole === "target");
+  if (targetLeaves.length === 0) return [];
+  return [
+    {
+      severity: "warning",
+      code: ISSUE_LOCALE_TARGET_PLACEHOLDER_LEAVES,
+      message: formatTargetPlaceholderMessage({
+        count: targetLeaves.length,
+        samplePaths: targetLeaves.slice(0, 5).map((leaf) => `${leaf.localeCode}:${leaf.path}`),
+        ...new Set(targetLeaves.map((leaf) => leaf.localeCode)).size === 1 ? { targetLabel: targetLeaves[0].localeCode } : {}
+      }),
+      docPath: issueCodeRepoDocPathForIssueCode(ISSUE_LOCALE_TARGET_PLACEHOLDER_LEAVES)
+    }
+  ];
+}
+
+// src/shared/options/index.ts
+var options_exports = {};
+__export(options_exports, {
+  LIST_WINDOW_DEFAULT_TOP: () => LIST_WINDOW_DEFAULT_TOP,
+  LIST_WINDOW_HARD_CAP: () => LIST_WINDOW_HARD_CAP,
+  applyListWindow: () => applyListWindow,
+  getRunOptions: () => getRunOptions,
+  resetRunOptions: () => resetRunOptions,
+  resolveListWindow: () => resolveListWindow,
+  setRunOptions: () => setRunOptions
+});
+
+// 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
+  };
+}
+function applyListWindow(items, window) {
+  return items.slice(0, window.limit);
+}
+
+// src/shared/run/index.ts
+var run_exports = {};
+__export(run_exports, {
+  emitIssuesAsRunErrors: () => emitIssuesAsRunErrors,
+  emitRunErrorFromUnknown: () => emitRunErrorFromUnknown,
+  emitRunEvent: () => emitRunEvent,
+  emitRunMessage: () => emitRunMessage,
+  isProgressEvent: () => isProgressEvent,
+  noopRunEmitter: () => noopRunEmitter,
+  nowMs: () => nowMs
+});
+var noopRunEmitter = () => {
+};
+function emitRunEvent(emit, event) {
+  if (!emit) return;
+  try {
+    emit(event);
+  } catch {
+  }
+}
+function emitRunMessage(emit, input) {
+  emitRunEvent(emit, {
+    type: "run.message",
+    op: input.op,
+    runId: input.runId,
+    at: input.at ?? nowMs(),
+    level: input.level,
+    ...input.channel !== void 0 ? { channel: input.channel } : {},
+    message: input.message,
+    ...input.target !== void 0 ? { target: input.target } : {},
+    ...input.path !== void 0 ? { path: input.path } : {},
+    ...input.data !== void 0 ? { data: input.data } : {}
+  });
+}
+function nowMs() {
+  return Date.now();
+}
+function isProgressEvent(event) {
+  return event.type.startsWith("run.progress.");
+}
+function emitIssuesAsRunErrors(emit, input) {
+  const at = input.at ?? nowMs();
+  for (const issue of input.issues) {
+    emitRunEvent(emit, {
+      type: "run.error",
+      op: input.op,
+      runId: input.runId,
+      at,
+      issue,
+      recoverable: input.recoverable
+    });
+  }
+}
+function emitRunErrorFromUnknown(emit, input) {
+  const normalized = normalizeUnknownError(input.err, {
+    when: "Run error",
+    defaultCode: "INTERNAL"
+  });
+  emitRunEvent(emit, {
+    type: "run.error",
+    op: input.op,
+    runId: input.runId,
+    at: input.at ?? nowMs(),
+    issue: {
+      severity: "error",
+      code: input.code,
+      message: normalized.message
+    },
+    recoverable: input.recoverable
+  });
+}
+
+// src/shared/result/index.ts
+var result_exports = {};
+__export(result_exports, {
+  DOCS_SITE_ORIGIN: () => DOCS_SITE_ORIGIN,
+  buildCliJsonEnvelope: () => buildCliJsonEnvelope,
+  enrichIssuesWithDocHrefs: () => enrichIssuesWithDocHrefs,
+  issueCodeDocHref: () => issueCodeDocHref,
+  normalizeRepoDocPath: () => normalizeRepoDocPath,
+  resolveIssueCodeDocLink: () => resolveIssueCodeDocLink,
+  stringifyCliCommandJson: () => stringifyCliCommandJson,
+  stringifyEnvelope: () => stringifyEnvelope
+});
+
+// src/shared/constants/result.ts
+var RESULT_API_VERSION = "1";
+
+// src/shared/docs/urls.ts
+function parseDocsLinkInput(input) {
+  const hashIdx = input.indexOf("#");
+  const hash = hashIdx >= 0 ? input.slice(hashIdx) : "";
+  let p = (hashIdx >= 0 ? input.slice(0, hashIdx) : input).trim().replace(/^\/+/, "");
+  p = p.replace(/\/+$/g, "");
+  if (p.endsWith(".md")) p = p.slice(0, -3);
+  if (p.endsWith(".mdx")) p = p.slice(0, -4);
+  if (p === "README" || p.endsWith("/README")) {
+    p = p === "README" ? "" : p.slice(0, -"/README".length);
+  }
+  p = p.replace(/\/+$/g, "");
+  p = p.replace(/\/+/g, "/");
+  return { core: p, hash };
+}
+function docsCommandUrl(command) {
+  const slug = command.trim().toLowerCase();
+  return `${DOCS_SITE_BASE}/commands/${slug}`;
+}
+function getDocsUrl(path = "") {
+  const { core, hash } = parseDocsLinkInput(path);
+  if (!core) {
+    return `${DOCS_SITE_BASE}${hash}`;
+  }
+  return `${DOCS_SITE_BASE}/${core}${hash}`;
+}
+
+// src/shared/docs/repoPaths.ts
+function normalizeRepoDocPath(docPath) {
+  const t = docPath.trim();
+  if (t === "") return t;
+  if (t.startsWith("docs/")) return t;
+  if (/^https?:\/\//i.test(t)) return t;
+  return `docs/${t}`;
+}
+
+// src/shared/result/issueDocLinks.ts
+function enrichIssuesWithDocHrefs(issues) {
+  return issues.map((issue) => {
+    const withPath = issue.docPath !== void 0 ? { ...issue, docPath: normalizeRepoDocPath(issue.docPath) } : issue;
+    if (!withPath.code.startsWith("i18nprune.")) return withPath;
+    if (withPath.docHref !== void 0) return withPath;
+    return { ...withPath, docHref: issueCodeDocHref(withPath.code) };
+  });
+}
+
+// src/shared/result/cliJson.ts
+function dataWithoutRedundantKind(envelopeKind, data) {
+  if (data === null || typeof data !== "object" || Array.isArray(data)) return data;
+  if (!("kind" in data)) return data;
+  const k = data.kind;
+  if (k !== envelopeKind) return data;
+  const { kind: _omit, ...rest } = data;
+  return rest;
+}
+function buildCliJsonEnvelope(kind, data, options) {
+  return {
+    ok: options.ok,
+    kind,
+    data: dataWithoutRedundantKind(kind, data),
+    issues: enrichIssuesWithDocHrefs(options.issues ?? []),
+    meta: {
+      apiVersion: RESULT_API_VERSION,
+      ...options.schemaVersion !== void 0 ? { schemaVersion: options.schemaVersion } : {},
+      ...options.cwd !== void 0 ? { cwd: options.cwd } : {}
+    }
+  };
+}
+function stringifyCliCommandJson(input) {
+  const { kind, data, ok, issues, cwd, pretty } = input;
+  const resolvedPretty = pretty ?? getRunOptions().jsonPretty;
+  const envelope = buildCliJsonEnvelope(kind, data, {
+    ok,
+    issues,
+    ...cwd !== void 0 ? { cwd } : {}
+  });
+  return resolvedPretty ? JSON.stringify(envelope, null, 2) : JSON.stringify(envelope);
+}
+function stringifyEnvelope(envelope, pretty) {
+  const resolvedPretty = pretty ?? getRunOptions().jsonPretty;
+  return resolvedPretty ? JSON.stringify(envelope, null, 2) : JSON.stringify(envelope);
+}
+
+// src/shared/languages/catalog/index.ts
+var catalog_exports = {};
+__export(catalog_exports, {
+  buildLanguageCatalog: () => buildLanguageCatalog,
+  filterLanguageCatalog: () => filterLanguageCatalog,
+  generatedLanguageCatalog: () => generatedLanguageCatalog,
+  getLanguageByCodeFromCatalog: () => getLanguageByCodeFromCatalog,
+  suggestCatalogCodesForInvalidInputFromCatalog: () => suggestCatalogCodesForInvalidInputFromCatalog
+});
+
+// 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/catalog/index.ts
+var generatedLanguageCatalog = languages_default;
+function buildLanguageCatalog(raw) {
+  return Object.freeze(raw.map((r) => ({ ...r, code: normalizeLanguageCode(r.code) })));
+}
+function filterLanguageCatalog(catalog, filter) {
+  const all = [...catalog];
+  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(catalog, code) {
+  const n = normalizeLanguageCode(code);
+  return catalog.find((r) => r.code === n);
+}
+function suggestCatalogCodesForInvalidInputFromCatalog(catalog, code, maxCodesInCatalogHint = 5) {
+  const n = normalizeLanguageCode(code);
+  const all = [...catalog].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(catalog, 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/shared/constants/index.ts
+var constants_exports = {};
+__export(constants_exports, {
+  ANALYSIS_BASENAME: () => ANALYSIS_BASENAME,
+  CACHE_PROFILE_DEFAULTS: () => CACHE_PROFILE_DEFAULTS,
+  CACHE_SCHEMA_VERSION: () => CACHE_SCHEMA_VERSION,
+  DEFAULT_CACHE_PROFILE_ID: () => DEFAULT_CACHE_PROFILE_ID,
+  DEFAULT_HEAL_EVERY_RUNS: () => DEFAULT_HEAL_EVERY_RUNS,
+  DEFAULT_LIST_TOP: () => DEFAULT_LIST_TOP,
+  DEFAULT_MAX_SHARE_JSON_BYTES: () => DEFAULT_MAX_SHARE_JSON_BYTES,
+  DEFAULT_MISSING_LEAF_PLACEHOLDER: () => DEFAULT_MISSING_LEAF_PLACEHOLDER,
+  DEFAULT_WORKER_API_URL: () => DEFAULT_WORKER_API_URL,
+  DEMO_REPORT_URL: () => DEMO_REPORT_URL,
+  DEMO_WEB_APP_BASE: () => DEMO_WEB_APP_BASE,
+  DOCS_ISSUES_PAGE_PATH: () => DOCS_ISSUES_PAGE_PATH,
+  DOCS_SITE_BASE: () => DOCS_SITE_BASE,
+  DOCS_SITE_ORIGIN: () => DOCS_SITE_ORIGIN,
+  ENV_TRANSLATE_DEEPL_API_KEY: () => ENV_TRANSLATE_DEEPL_API_KEY,
+  ENV_TRANSLATE_LIBRE_URL: () => ENV_TRANSLATE_LIBRE_URL,
+  ENV_TRANSLATE_LLM_API_KEY: () => ENV_TRANSLATE_LLM_API_KEY,
+  ENV_TRANSLATE_LLM_BASE_URL: () => ENV_TRANSLATE_LLM_BASE_URL,
+  ENV_TRANSLATE_LLM_MODEL: () => ENV_TRANSLATE_LLM_MODEL,
+  ENV_TRANSLATE_MAX_WORKERS: () => ENV_TRANSLATE_MAX_WORKERS,
+  ENV_TRANSLATE_PROVIDER: () => ENV_TRANSLATE_PROVIDER,
+  GITHUB_BASE: () => GITHUB_BASE,
+  GITHUB_DOCS_BASE: () => GITHUB_DOCS_BASE,
+  GITHUB_DOCS_TREE_BASE: () => GITHUB_DOCS_TREE_BASE,
+  GITHUB_OWNER: () => GITHUB_OWNER,
+  GITHUB_REPO: () => GITHUB_REPO,
+  GITHUB_REPO_URL: () => GITHUB_REPO_URL,
+  HOSTED_PROJECT_SNAPSHOT_SCHEMA_VERSION: () => HOSTED_PROJECT_SNAPSHOT_SCHEMA_VERSION,
+  I18NPRUNE_CONFIG_BASENAME: () => I18NPRUNE_CONFIG_BASENAME,
+  I18NPRUNE_CONFIG_JSON_FILE_NAME: () => I18NPRUNE_CONFIG_JSON_FILE_NAME,
+  I18NPRUNE_CONFIG_SCRIPT_FILE_NAMES: () => I18NPRUNE_CONFIG_SCRIPT_FILE_NAMES,
+  I18NPRUNE_CONFIG_SCRIPT_FILE_NAMES_SET: () => I18NPRUNE_CONFIG_SCRIPT_FILE_NAMES_SET,
+  I18NPRUNE_CONFIG_SNAPSHOT_FILE_NAMES: () => I18NPRUNE_CONFIG_SNAPSHOT_FILE_NAMES,
+  I18NPRUNE_CONFIG_SNAPSHOT_FILE_NAMES_SET: () => I18NPRUNE_CONFIG_SNAPSHOT_FILE_NAMES_SET,
+  ISSUE_CLEANUP_RIPGREP_UNAVAILABLE: () => ISSUE_CLEANUP_RIPGREP_UNAVAILABLE,
+  ISSUE_CLEANUP_UNCERTAIN_PATHS_EXCLUDED: () => ISSUE_CLEANUP_UNCERTAIN_PATHS_EXCLUDED,
+  ISSUE_CLI_INVALID_JSON_PRETTY: () => ISSUE_CLI_INVALID_JSON_PRETTY,
+  ISSUE_CONFIG_INVALID: () => ISSUE_CONFIG_INVALID,
+  ISSUE_CONFIG_LOAD_FAILED: () => ISSUE_CONFIG_LOAD_FAILED,
+  ISSUE_CONFIG_MISSING: () => ISSUE_CONFIG_MISSING,
+  ISSUE_CONTEXT_DISCOVERY_WARNING: () => ISSUE_CONTEXT_DISCOVERY_WARNING,
+  ISSUE_CONTEXT_RESOLUTION_FAILED: () => ISSUE_CONTEXT_RESOLUTION_FAILED,
+  ISSUE_DOCTOR_CONFIG_MISSING_FILE: () => ISSUE_DOCTOR_CONFIG_MISSING_FILE,
+  ISSUE_DOCTOR_PATHS_DIRECTORIES_MISSING: () => ISSUE_DOCTOR_PATHS_DIRECTORIES_MISSING,
+  ISSUE_DOCTOR_PATHS_SOURCE_LOCALE_MISSING: () => ISSUE_DOCTOR_PATHS_SOURCE_LOCALE_MISSING,
+  ISSUE_DOCTOR_RUNTIME_UNSUPPORTED_NODE: () => ISSUE_DOCTOR_RUNTIME_UNSUPPORTED_NODE,
+  ISSUE_DOCTOR_TOOLS_RG_NOT_ON_PATH: () => ISSUE_DOCTOR_TOOLS_RG_NOT_ON_PATH,
+  ISSUE_GENERATE_SOURCE_EMPTY_STRING_LEAVES: () => ISSUE_GENERATE_SOURCE_EMPTY_STRING_LEAVES,
+  ISSUE_GENERATE_TRANSLATE_NETWORK_ERROR: () => ISSUE_GENERATE_TRANSLATE_NETWORK_ERROR,
+  ISSUE_GENERATE_TRANSLATE_RATE_LIMITED: () => ISSUE_GENERATE_TRANSLATE_RATE_LIMITED,
+  ISSUE_GENERATE_USAGE: () => ISSUE_GENERATE_USAGE,
+  ISSUE_IO_READ_FAILED: () => ISSUE_IO_READ_FAILED,
+  ISSUE_LANGUAGES_EMPTY_FILTER: () => ISSUE_LANGUAGES_EMPTY_FILTER,
+  ISSUE_LANGUAGES_UNSUPPORTED_LANGUAGE_CODE: () => ISSUE_LANGUAGES_UNSUPPORTED_LANGUAGE_CODE,
+  ISSUE_LOCALES_USAGE: () => ISSUE_LOCALES_USAGE,
+  ISSUE_LOCALE_SOURCE_PLACEHOLDER_LEAVES: () => ISSUE_LOCALE_SOURCE_PLACEHOLDER_LEAVES,
+  ISSUE_LOCALE_TARGET_NOT_FOUND: () => ISSUE_LOCALE_TARGET_NOT_FOUND,
+  ISSUE_LOCALE_TARGET_PLACEHOLDER_LEAVES: () => ISSUE_LOCALE_TARGET_PLACEHOLDER_LEAVES,
+  ISSUE_MISSING_PATHS_NOT_IN_SCAN: () => ISSUE_MISSING_PATHS_NOT_IN_SCAN,
+  ISSUE_PATCHING_CATALOG_MISMATCH_DIRECTION: () => ISSUE_PATCHING_CATALOG_MISMATCH_DIRECTION,
+  ISSUE_PATCHING_CATALOG_MISMATCH_ENGLISH: () => ISSUE_PATCHING_CATALOG_MISMATCH_ENGLISH,
+  ISSUE_PATCHING_CATALOG_MISMATCH_NATIVE: () => ISSUE_PATCHING_CATALOG_MISMATCH_NATIVE,
+  ISSUE_PATCHING_CONFIG_INVALID_SCHEMA: () => ISSUE_PATCHING_CONFIG_INVALID_SCHEMA,
+  ISSUE_PATCHING_CONFIG_LOCALE_MISSING_FILE: () => ISSUE_PATCHING_CONFIG_LOCALE_MISSING_FILE,
+  ISSUE_PATCHING_CONFIG_PARSE_FAILED: () => ISSUE_PATCHING_CONFIG_PARSE_FAILED,
+  ISSUE_PATCHING_CONFIG_SECTION_INCOMPLETE: () => ISSUE_PATCHING_CONFIG_SECTION_INCOMPLETE,
+  ISSUE_PATCHING_CONFIG_SIZE_ANOMALY: () => ISSUE_PATCHING_CONFIG_SIZE_ANOMALY,
+  ISSUE_PATCHING_CONFIG_TOO_LARGE: () => ISSUE_PATCHING_CONFIG_TOO_LARGE,
+  ISSUE_PATCHING_FILE_LOCALE_MISSING_CONFIG: () => ISSUE_PATCHING_FILE_LOCALE_MISSING_CONFIG,
+  ISSUE_PATHS_NETWORK_DRIVE: () => ISSUE_PATHS_NETWORK_DRIVE,
+  ISSUE_PATHS_WINDOWS_LONG_PATH: () => ISSUE_PATHS_WINDOWS_LONG_PATH,
+  ISSUE_PATHS_WINDOWS_RESERVED_NAME: () => ISSUE_PATHS_WINDOWS_RESERVED_NAME,
+  ISSUE_PROJECT_CONFIG_FILE_MISSING: () => ISSUE_PROJECT_CONFIG_FILE_MISSING,
+  ISSUE_PROJECT_HOSTED_SNAPSHOT_INVALID: () => ISSUE_PROJECT_HOSTED_SNAPSHOT_INVALID,
+  ISSUE_PROJECT_HOSTED_SNAPSHOT_SCHEMA_VERSION: () => ISSUE_PROJECT_HOSTED_SNAPSHOT_SCHEMA_VERSION,
+  ISSUE_PROJECT_LOCALES_DIR_UNAVAILABLE: () => ISSUE_PROJECT_LOCALES_DIR_UNAVAILABLE,
+  ISSUE_PROJECT_LOCALES_SOURCE_NOT_IN_BUNDLE: () => ISSUE_PROJECT_LOCALES_SOURCE_NOT_IN_BUNDLE,
+  ISSUE_PROJECT_LOCALES_SOURCE_NOT_LANGUAGE_CODE: () => ISSUE_PROJECT_LOCALES_SOURCE_NOT_LANGUAGE_CODE,
+  ISSUE_PROJECT_LOCALES_STRUCTURE_REQUIRED: () => ISSUE_PROJECT_LOCALES_STRUCTURE_REQUIRED,
+  ISSUE_PROJECT_SOURCE_LOCALE_INVALID_JSON: () => ISSUE_PROJECT_SOURCE_LOCALE_INVALID_JSON,
+  ISSUE_PROJECT_SOURCE_LOCALE_INVALID_SHAPE: () => ISSUE_PROJECT_SOURCE_LOCALE_INVALID_SHAPE,
+  ISSUE_PROJECT_SOURCE_LOCALE_MISSING_SEGMENTS: () => ISSUE_PROJECT_SOURCE_LOCALE_MISSING_SEGMENTS,
+  ISSUE_PROJECT_SOURCE_LOCALE_NOT_FOUND: () => ISSUE_PROJECT_SOURCE_LOCALE_NOT_FOUND,
+  ISSUE_PROJECT_SOURCE_LOCALE_UNAVAILABLE: () => ISSUE_PROJECT_SOURCE_LOCALE_UNAVAILABLE,
+  ISSUE_PROJECT_SRC_ROOT_UNAVAILABLE: () => ISSUE_PROJECT_SRC_ROOT_UNAVAILABLE,
+  ISSUE_PROJECT_UPLOAD_CONFIG_JSON_INVALID: () => ISSUE_PROJECT_UPLOAD_CONFIG_JSON_INVALID,
+  ISSUE_PROJECT_UPLOAD_CONFIG_REQUIRED: () => ISSUE_PROJECT_UPLOAD_CONFIG_REQUIRED,
+  ISSUE_QUALITY_ENGLISH_IDENTICAL_LEAVES: () => ISSUE_QUALITY_ENGLISH_IDENTICAL_LEAVES,
+  ISSUE_REPORT_HOSTED_REPORT_INVALID: () => ISSUE_REPORT_HOSTED_REPORT_INVALID,
+  ISSUE_REPORT_INVALID_FORMAT: () => ISSUE_REPORT_INVALID_FORMAT,
+  ISSUE_SCAN_DYNAMIC_KEY_SITES: () => ISSUE_SCAN_DYNAMIC_KEY_SITES,
+  ISSUE_SHARE_CACHE_EMPTY: () => ISSUE_SHARE_CACHE_EMPTY,
+  ISSUE_SHARE_CACHE_ENTRY_NOT_FOUND: () => ISSUE_SHARE_CACHE_ENTRY_NOT_FOUND,
+  ISSUE_SHARE_JSON_REPAIRED: () => ISSUE_SHARE_JSON_REPAIRED,
+  ISSUE_SHARE_JSON_WRITE_FAILED: () => ISSUE_SHARE_JSON_WRITE_FAILED,
+  ISSUE_SHARE_PREPARE_ANALYSIS_FAILED: () => ISSUE_SHARE_PREPARE_ANALYSIS_FAILED,
+  ISSUE_SHARE_PREPARE_NOTHING_REQUESTED: () => ISSUE_SHARE_PREPARE_NOTHING_REQUESTED,
+  ISSUE_SHARE_PREPARE_REPORT_FROM_ARCHIVE_FAILED: () => ISSUE_SHARE_PREPARE_REPORT_FROM_ARCHIVE_FAILED,
+  ISSUE_SHARE_PREPARE_REPORT_HOST_REQUIRED: () => ISSUE_SHARE_PREPARE_REPORT_HOST_REQUIRED,
+  ISSUE_SHARE_REMOTE_ERROR: () => ISSUE_SHARE_REMOTE_ERROR,
+  ISSUE_SHARE_REMOTE_PAYLOAD_TOO_LARGE: () => ISSUE_SHARE_REMOTE_PAYLOAD_TOO_LARGE,
+  ISSUE_SHARE_REMOTE_PROJECT_NOT_FOUND: () => ISSUE_SHARE_REMOTE_PROJECT_NOT_FOUND,
+  ISSUE_SHARE_REMOTE_REPORT_NOT_FOUND: () => ISSUE_SHARE_REMOTE_REPORT_NOT_FOUND,
+  ISSUE_SHARE_REMOTE_REPORT_REJECTED: () => ISSUE_SHARE_REMOTE_REPORT_REJECTED,
+  ISSUE_SHARE_REMOTE_UNAVAILABLE: () => ISSUE_SHARE_REMOTE_UNAVAILABLE,
+  ISSUE_SHARE_REMOTE_UPLOAD_REJECTED: () => ISSUE_SHARE_REMOTE_UPLOAD_REJECTED,
+  ISSUE_SHARE_SNAPSHOT_EMPTY: () => ISSUE_SHARE_SNAPSHOT_EMPTY,
+  ISSUE_SHARE_STALE_CACHE_ROW_REMOVED: () => ISSUE_SHARE_STALE_CACHE_ROW_REMOVED,
+  ISSUE_SHARE_ZIP_FAILED: () => ISSUE_SHARE_ZIP_FAILED,
+  ISSUE_SYNC_LOCALE_FILE_NOT_FOUND: () => ISSUE_SYNC_LOCALE_FILE_NOT_FOUND,
+  ISSUE_SYNC_METADATA_FLAG_CONFLICT: () => ISSUE_SYNC_METADATA_FLAG_CONFLICT,
+  ISSUE_TRANSLATE_CONFIG_DEFAULT_APPLIED: () => ISSUE_TRANSLATE_CONFIG_DEFAULT_APPLIED,
+  ISSUE_TRANSLATE_HANDOFF_NO_ELIGIBLE_PROVIDER: () => ISSUE_TRANSLATE_HANDOFF_NO_ELIGIBLE_PROVIDER,
+  ISSUE_TRANSLATE_IDENTITY_STREAK_ABORT: () => ISSUE_TRANSLATE_IDENTITY_STREAK_ABORT,
+  ISSUE_TRANSLATE_IDENTITY_STREAK_WARNING: () => ISSUE_TRANSLATE_IDENTITY_STREAK_WARNING,
+  ISSUE_TRANSLATE_MISSING_CREDENTIALS: () => ISSUE_TRANSLATE_MISSING_CREDENTIALS,
+  ISSUE_TRANSLATE_PROVIDER_NOT_IMPLEMENTED_YET: () => ISSUE_TRANSLATE_PROVIDER_NOT_IMPLEMENTED_YET,
+  ISSUE_TRANSLATE_UNKNOWN_TRANSLATION_PROVIDER: () => ISSUE_TRANSLATE_UNKNOWN_TRANSLATION_PROVIDER,
+  ISSUE_VALIDATE_DYNAMIC_KEY_SITES: () => ISSUE_VALIDATE_DYNAMIC_KEY_SITES,
+  ISSUE_VALIDATE_MISSING_LITERAL_KEYS: () => ISSUE_VALIDATE_MISSING_LITERAL_KEYS,
+  ISSUE_VALIDATE_SOURCE_LOCALE_READ_FAILED: () => ISSUE_VALIDATE_SOURCE_LOCALE_READ_FAILED,
+  LICENSE_URL: () => LICENSE_URL,
+  LIST_MORE_HINT: () => LIST_MORE_HINT,
+  MAX_ANALYSIS_BYTES: () => MAX_ANALYSIS_BYTES,
+  MAX_MISSING_TARGET_SUGGESTIONS: () => MAX_MISSING_TARGET_SUGGESTIONS,
+  MAX_PROJECTS_INDEX_BYTES: () => MAX_PROJECTS_INDEX_BYTES,
+  MAX_PROJECT_FILES_BYTES: () => MAX_PROJECT_FILES_BYTES,
+  MAX_TRANSLATIONS_CACHE_BYTES: () => MAX_TRANSLATIONS_CACHE_BYTES,
+  META_WORKER_URL: () => META_WORKER_URL,
+  NPM_PACKAGE_NAME: () => NPM_PACKAGE_NAME,
+  NPM_PACKAGE_URL: () => NPM_PACKAGE_URL,
+  PROJECT_REPORT_KIND: () => PROJECT_REPORT_KIND,
+  PROJECT_REPORT_SCHEMA_VERSION: () => PROJECT_REPORT_SCHEMA_VERSION,
+  PROJECT_SHARE_PREPARED_MAX_BYTES: () => PROJECT_SHARE_PREPARED_MAX_BYTES,
+  PROJECT_UPLOAD_MAX_FILES: () => PROJECT_UPLOAD_MAX_FILES,
+  PROJECT_UPLOAD_MAX_TEXT_BYTES: () => PROJECT_UPLOAD_MAX_TEXT_BYTES,
+  PROJECT_UPLOAD_MAX_ZIP_BYTES: () => PROJECT_UPLOAD_MAX_ZIP_BYTES,
+  PROJECT_UPLOAD_ZIP_LIMITS: () => PROJECT_UPLOAD_ZIP_LIMITS,
+  REPORT_INLINE_PAYLOAD_PLACEHOLDER: () => REPORT_INLINE_PAYLOAD_PLACEHOLDER,
+  REPORT_SHARE_MAX_BYTES: () => REPORT_SHARE_MAX_BYTES,
+  RESULT_API_VERSION: () => RESULT_API_VERSION,
+  SDK_PACKAGE_NAME: () => SDK_PACKAGE_NAME,
+  SDK_VERSION: () => SDK_VERSION,
+  SHARE_BAK_DIRNAME: () => SHARE_BAK_DIRNAME,
+  SHARE_CACHE_REASON_MESSAGES: () => SHARE_CACHE_REASON_MESSAGES,
+  SHARE_JSON_BASENAME: () => SHARE_JSON_BASENAME,
+  TRANSLATE_WORKERS_CAP: () => TRANSLATE_WORKERS_CAP,
+  TRANSLATIONS_DIR: () => TRANSLATIONS_DIR,
+  WORKER_IDLE_RETENTION_MS: () => WORKER_IDLE_RETENTION_MS,
+  WORKER_INGEST_FORCE_QUERY: () => WORKER_INGEST_FORCE_QUERY,
+  formatListOmittedSuffix: () => formatListOmittedSuffix,
+  formatListShownOmitted: () => formatListShownOmitted
+});
+
+// src/shared/constants/config.ts
+var I18NPRUNE_CONFIG_BASENAME = "i18nprune.config";
+var I18NPRUNE_CONFIG_SCRIPT_FILE_NAMES = [
+  `${I18NPRUNE_CONFIG_BASENAME}.ts`,
+  `${I18NPRUNE_CONFIG_BASENAME}.mts`,
+  `${I18NPRUNE_CONFIG_BASENAME}.cts`,
+  `${I18NPRUNE_CONFIG_BASENAME}.js`,
+  `${I18NPRUNE_CONFIG_BASENAME}.mjs`,
+  `${I18NPRUNE_CONFIG_BASENAME}.cjs`
+];
+var I18NPRUNE_CONFIG_SCRIPT_FILE_NAMES_SET = new Set(I18NPRUNE_CONFIG_SCRIPT_FILE_NAMES);
+var I18NPRUNE_CONFIG_JSON_FILE_NAME = `${I18NPRUNE_CONFIG_BASENAME}.json`;
+var I18NPRUNE_CONFIG_SNAPSHOT_FILE_NAMES = [
+  ...I18NPRUNE_CONFIG_SCRIPT_FILE_NAMES,
+  I18NPRUNE_CONFIG_JSON_FILE_NAME
+];
+var I18NPRUNE_CONFIG_SNAPSHOT_FILE_NAMES_SET = new Set(I18NPRUNE_CONFIG_SNAPSHOT_FILE_NAMES);
+
+// src/shared/constants/listDisplay.ts
+var DEFAULT_LIST_TOP = 3;
+var LIST_MORE_HINT = "(use --full or --top <n>)";
+function formatListOmittedSuffix(omitted) {
+  return `\u2026 ${String(omitted)} more ${LIST_MORE_HINT}`;
+}
+function formatListShownOmitted(prefix, omitted) {
+  if (omitted <= 0) return prefix;
+  return `${prefix} + ${formatListOmittedSuffix(omitted)}`;
+}
+
+// src/shared/constants/sdk.ts
+var SDK_PACKAGE_NAME = "@i18nprune/core";
+var SDK_VERSION = "0.1.0";
+
+// src/shared/constants/cache.ts
+var CACHE_SCHEMA_VERSION = 1;
+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"
+  }
+};
+var ANALYSIS_BASENAME = "analysis.json";
+var TRANSLATIONS_DIR = "translations";
+var MAX_PROJECTS_INDEX_BYTES = 2 * 1024 * 1024;
+var MAX_PROJECT_FILES_BYTES = 32 * 1024 * 1024;
+var MAX_ANALYSIS_BYTES = 16 * 1024 * 1024;
+var MAX_TRANSLATIONS_CACHE_BYTES = 32 * 1024 * 1024;
+var DEFAULT_HEAL_EVERY_RUNS = 20;
+
+// src/shared/constants/project.ts
+var PROJECT_UPLOAD_ZIP_LIMITS = {
+  maxZipBytes: 50 * 1024 * 1024,
+  maxFiles: 15e3,
+  maxTextBytes: 60 * 1024 * 1024
+};
+var PROJECT_UPLOAD_MAX_ZIP_BYTES = PROJECT_UPLOAD_ZIP_LIMITS.maxZipBytes;
+var PROJECT_UPLOAD_MAX_FILES = PROJECT_UPLOAD_ZIP_LIMITS.maxFiles;
+var PROJECT_UPLOAD_MAX_TEXT_BYTES = PROJECT_UPLOAD_ZIP_LIMITS.maxTextBytes;
+var HOSTED_PROJECT_SNAPSHOT_SCHEMA_VERSION = 1;
+
+// src/shared/constants/report.ts
+var PROJECT_REPORT_KIND = "i18nprune.projectReport";
+var PROJECT_REPORT_SCHEMA_VERSION = 1;
+var REPORT_INLINE_PAYLOAD_PLACEHOLDER = "__I18NPRUNE_REPORT__";
+
+// src/shared/constants/share.ts
+var SHARE_JSON_BASENAME = "share.json";
+var SHARE_BAK_DIRNAME = "share.bak";
+var DEFAULT_MAX_SHARE_JSON_BYTES = 512 * 1024;
+var REPORT_SHARE_MAX_BYTES = 8 * 1024 * 1024;
+var PROJECT_SHARE_PREPARED_MAX_BYTES = PROJECT_UPLOAD_MAX_ZIP_BYTES;
+var SHARE_CACHE_REASON_MESSAGES = {
+  cache_hit: "analysis cache hit",
+  no_cache: "project cache is disabled",
+  cache_unavailable: "project cache is unavailable",
+  run_missing: "cached analysis run is missing",
+  files_changed: "tracked files changed since last analysis",
+  files_index_recovered: "cache files index was recovered",
+  run_binding_stale: "cached analysis binding is stale",
+  producer_succeeded: "analysis recomputed and cache updated",
+  run_invalid: "cached analysis run is invalid",
+  archive_ingest_no_project_cache: "archive uploads do not use persistent project cache"
+};
+
+// src/shared/constants/worker.ts
+var WORKER_INGEST_FORCE_QUERY = "force";
+var WORKER_IDLE_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
+
+// src/shared/locales/targets/segmentWritePlan.ts
+function swapLocaleInSegmentRelativePath(input) {
+  const target = normalizeLanguageCode(input.targetLocale);
+  const rel = input.relativePath.replace(/\\/g, "/");
+  if (input.structure === "locale_file") {
+    if (rel.includes("/")) return null;
+    return `${target}.json`;
+  }
+  if (input.structure === "locale_per_dir") {
+    const slash = rel.indexOf("/");
+    if (slash < 0) return null;
+    const rest = rel.slice(slash + 1);
+    if (!rest) return null;
+    return `${target}/${rest}`;
+  }
+  if (input.structure === "feature_bundle") {
+    const slash = rel.lastIndexOf("/");
+    if (slash < 0) return null;
+    const feature = rel.slice(0, slash);
+    if (!feature) return null;
+    return `${feature}/${target}.json`;
+  }
+  return null;
+}
+function segmentTargetFromRef(ref, role) {
+  return {
+    locale: normalizeLanguageCode(ref.locale),
+    relativePath: ref.relativePath,
+    absolutePath: ref.absolutePath,
+    role
+  };
+}
+function deriveTargetSegmentFromSource(ctx, layout, targetLocale) {
+  const sourceRef = localeSegmentRefFromAbsolute({
+    layout,
+    path: ctx.adapters.path,
+    absolutePath: ctx.adapters.path.resolve(ctx.paths.sourceLocale)
+  });
+  if (sourceRef === null) {
+    throw new I18nPruneError(
+      `generate: source locale path does not match layout mode=${layout.mode} structure=${layout.structure}: ${ctx.paths.sourceLocale}`,
+      "USAGE"
+    );
+  }
+  const nextRelative = swapLocaleInSegmentRelativePath({
+    structure: layout.structure,
+    relativePath: sourceRef.relativePath,
+    targetLocale
+  });
+  if (nextRelative === null) {
+    throw new I18nPruneError(
+      `generate: cannot derive target segment from source ${sourceRef.relativePath} for structure=${layout.structure}`,
+      "USAGE"
+    );
+  }
+  const absolutePath = resolveLocaleSegmentAbsolutePath({
+    layout,
+    path: ctx.adapters.path,
+    locale: targetLocale,
+    segmentRelativePath: nextRelative
+  });
+  return {
+    locale: normalizeLanguageCode(targetLocale),
+    relativePath: nextRelative,
+    absolutePath,
+    role: "target"
+  };
+}
+function listSourceLocaleWriteTargets(ctx) {
+  const source = sourceLocaleCodeFromContext(ctx);
+  return segmentsForLocaleCode(ctx, source).map((s) => segmentTargetFromRef(s, "source"));
+}
+function resolveTargetLocaleWritePlan(ctx, targetLocale) {
+  const layout = resolveLocalesLayoutFromContext(ctx);
+  const target = normalizeLanguageCode(targetLocale);
+  const { fs } = ctx.adapters;
+  if (layout.mode === "flat_file") {
+    const existing = segmentsForLocaleCode(ctx, target);
+    if (existing.length > 0) {
+      const primary = primarySegmentForLocale(ctx, target);
+      const segments2 = [segmentTargetFromRef(primary, "existing_target")];
+      return {
+        targetLocale: target,
+        layout,
+        segments: segments2,
+        missingSegments: existsRuntimeFsSync(primary.absolutePath, fs) ? [] : segments2
+      };
+    }
+    const derived = deriveTargetSegmentFromSource(ctx, layout, target);
+    const missingSegments2 = existsRuntimeFsSync(derived.absolutePath, fs) ? [] : [derived];
+    return { targetLocale: target, layout, segments: [derived], missingSegments: missingSegments2 };
+  }
+  const sourceSegments = listSourceLocaleWriteTargets(ctx);
+  const existingByRel = new Map(
+    segmentsForLocaleCode(ctx, target).map((s) => [s.relativePath, s])
+  );
+  const segments = [];
+  for (const src of sourceSegments) {
+    const targetRel = swapLocaleInSegmentRelativePath({
+      structure: layout.structure,
+      relativePath: src.relativePath,
+      targetLocale: target
+    });
+    if (targetRel === null) {
+      throw new I18nPruneError(
+        `generate: cannot derive target segment from source ${src.relativePath} for structure=${layout.structure}`,
+        "USAGE"
+      );
+    }
+    const onDisk = existingByRel.get(targetRel);
+    if (onDisk) {
+      segments.push(segmentTargetFromRef(onDisk, "existing_target"));
+      continue;
+    }
+    const absolutePath = resolveLocaleSegmentAbsolutePath({
+      layout,
+      path: ctx.adapters.path,
+      locale: target,
+      segmentRelativePath: targetRel
+    });
+    segments.push({
+      locale: target,
+      relativePath: targetRel,
+      absolutePath,
+      role: "target"
+    });
+  }
+  segments.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+  const missingSegments = segments.filter((s) => !existsRuntimeFsSync(s.absolutePath, fs));
+  return { targetLocale: target, layout, segments, missingSegments };
+}
+function resolvePrimaryTargetWritePath(ctx, targetLocale) {
+  const plan = resolveTargetLocaleWritePlan(ctx, targetLocale);
+  const primary = plan.segments[0];
+  if (!primary) {
+    throw new I18nPruneError(`generate: no write path for target locale ${targetLocale}`, "USAGE");
+  }
+  return primary.absolutePath;
+}
+
+// src/shared/locales/projection.ts
+function isPlainObject7(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function pushLeaf(out, leaf, winner) {
+  const cur = out.get(leaf.path);
+  if (!cur) {
+    out.set(leaf.path, { leaf, winner });
+    return { conflictsAdded: 0 };
+  }
+  if (cur.winner === "nested") {
+    return { conflictsAdded: winner === "dotted" ? 1 : 0 };
+  }
+  if (winner === "nested") {
+    out.set(leaf.path, { leaf, winner });
+    return { conflictsAdded: 1 };
+  }
+  return { conflictsAdded: 0 };
+}
+function collectLeavesPreferNested(input) {
+  let sawDottedKey = false;
+  let conflicts = 0;
+  const { root, prefix } = input;
+  if (typeof root === "string") {
+    if (prefix) {
+      const { conflictsAdded } = pushLeaf(input.out, {
+        path: prefix,
+        value: root,
+        shape: "legacy_string",
+        confidence: null,
+        needsReview: null
+      }, input.winner);
+      conflicts += conflictsAdded;
+    }
+    return { sawDottedKey, conflicts };
+  }
+  if (isStructuredLocaleLeafNode(root)) {
+    if (prefix) {
+      const { conflictsAdded } = pushLeaf(
+        input.out,
+        {
+          path: prefix,
+          value: root.value,
+          shape: "legacy_string",
+          confidence: null,
+          needsReview: null
+        },
+        input.winner
+      );
+      conflicts += conflictsAdded;
+    }
+    return { sawDottedKey, conflicts };
+  }
+  if (Array.isArray(root)) {
+    root.forEach((item, i) => {
+      const p = prefix ? `${prefix}[${i}]` : `[${i}]`;
+      const r = collectLeavesPreferNested({ root: item, prefix: p, out: input.out, winner: input.winner });
+      if (r.sawDottedKey) sawDottedKey = true;
+      conflicts += r.conflicts;
+    });
+    return { sawDottedKey, conflicts };
+  }
+  if (isPlainObject7(root)) {
+    const keys = Object.keys(root);
+    const nestedKeys = keys.filter((k) => !k.includes("."));
+    const dottedKeys = keys.filter((k) => k.includes("."));
+    for (const k of nestedKeys) {
+      const p = prefix ? `${prefix}.${k}` : k;
+      const r = collectLeavesPreferNested({ root: root[k], prefix: p, out: input.out, winner: input.winner });
+      if (r.sawDottedKey) sawDottedKey = true;
+      conflicts += r.conflicts;
+    }
+    for (const k of dottedKeys) {
+      sawDottedKey = true;
+      const p = prefix ? `${prefix}.${k}` : k;
+      const r = collectLeavesPreferNested({ root: root[k], prefix: p, out: input.out, winner: "dotted" });
+      if (r.sawDottedKey) sawDottedKey = true;
+      conflicts += r.conflicts;
+    }
+  }
+  return { sawDottedKey, conflicts };
+}
+function projectLocaleLeaves(localeJson) {
+  const tmp = /* @__PURE__ */ new Map();
+  const r = collectLeavesPreferNested({ root: localeJson, prefix: "", out: tmp, winner: "nested" });
+  const byPath = /* @__PURE__ */ new Map();
+  for (const [k, v] of tmp) byPath.set(k, v.leaf);
+  return { byPath, sawDottedKey: r.sawDottedKey, conflicts: r.conflicts };
+}
+function getProjectedLeafString(proj, path) {
+  const leaf = proj.byPath.get(path);
+  if (!leaf) return void 0;
+  return leaf.value;
+}
+
+// src/shared/locales/targets/segmentMaterialize.ts
+function localeJsonFromTranslationSurfaceLeaves(leaves) {
+  let out = {};
+  for (const leaf of leaves) {
+    out = setAtPath(out, leaf.path, leaf.value);
+  }
+  return out;
+}
+function pathsForSourceSegment(input) {
+  const fromOrigin = input.sourceLeaves.filter((l) => l.fileOrigin?.relativePath === input.sourceRelativePath);
+  if (fromOrigin.length > 0) {
+    return new Set(fromOrigin.map((l) => l.path));
+  }
+  const absoluteFile = resolveLocaleSegmentAbsolutePath({
+    layout: input.layout,
+    path: input.path,
+    locale: input.sourceLocaleCode,
+    segmentRelativePath: input.sourceRelativePath
+  });
+  const read = readFlatLocaleJsonSurface({
+    fs: input.fs,
+    path: input.path,
+    absoluteFile,
+    localesDir: input.layout.directoryAbsolute,
+    structure: input.layout.structure
+  });
+  if (read.ok) {
+    const filePaths = new Set(read.leaves.map((l) => l.path));
+    const intersected = input.sourceLeaves.filter((l) => filePaths.has(l.path)).map((l) => l.path);
+    if (intersected.length > 0) {
+      return new Set(intersected);
+    }
+  }
+  if (input.singleSegmentFallback) {
+    return new Set(input.sourceLeaves.map((l) => l.path));
+  }
+  return /* @__PURE__ */ new Set();
+}
+function materializeGenerateWorkingBySegment(input) {
+  const sourceLocale = input.sourceLocaleCode;
+  const projected = projectLocaleLeaves(input.working);
+  const singleSegmentFallback = input.segments.length === 1;
+  return input.segments.map((segment) => {
+    const sourceRel = swapLocaleInSegmentRelativePath({
+      structure: input.structure,
+      relativePath: segment.relativePath,
+      targetLocale: sourceLocale
+    }) ?? segment.relativePath;
+    const pathsForSegment = pathsForSourceSegment({
+      layout: input.layout,
+      fs: input.fs,
+      path: input.path,
+      sourceLocaleCode: sourceLocale,
+      sourceRelativePath: sourceRel,
+      sourceLeaves: input.sourceLeaves,
+      singleSegmentFallback
+    });
+    let document = {};
+    for (const leafPath of pathsForSegment) {
+      const workingValue = getLocaleLeafAtPath(input.working, leafPath);
+      let value;
+      if (isStructuredLocaleLeafNode(workingValue)) {
+        value = workingValue;
+      } else {
+        const projectedValue = getProjectedLeafString(projected, leafPath);
+        value = projectedValue !== void 0 ? projectedValue : workingValue;
+      }
+      if (value !== void 0) {
+        document = setAtPath(document, leafPath, value);
+      }
+    }
+    return { segment, document };
+  });
+}
+
+// src/shared/locales/archive/buildLocaleJsonByTag.ts
+function segmentRelUnderLocalesDir(localesDirAbsolute, absolutePath) {
+  const root = localesDirAbsolute.replace(/\\/g, "/").replace(/\/$/, "");
+  const abs = absolutePath.replace(/\\/g, "/");
+  if (abs === root) return "";
+  const prefix = `${root}/`;
+  if (!abs.startsWith(prefix)) return null;
+  return abs.slice(prefix.length);
+}
+function collectArchiveLocaleSegments(input) {
+  const { path, localesDirAbsolute, archiveRelPaths, locales, resolveArchiveAbsolute } = input;
+  const layout = resolveLocalesLayout(locales, localesDirAbsolute);
+  const recursive = layout.structure !== "locale_file";
+  const segments = [];
+  for (const archiveRelPath of archiveRelPaths) {
+    if (!archiveRelPath.endsWith(".json")) continue;
+    const absolutePath = resolveArchiveAbsolute(archiveRelPath);
+    const segmentRel = segmentRelUnderLocalesDir(localesDirAbsolute, absolutePath);
+    if (segmentRel === null) continue;
+    if (!recursive && segmentRel.includes("/")) continue;
+    const locale = localeCodeForSegment(layout.structure, path, { absolutePath, relativePath: segmentRel });
+    if (locale === null) continue;
+    segments.push({ locale, relativePath: segmentRel, absolutePath, archiveRelPath });
+  }
+  segments.sort((a, b) => {
+    const byLocale = a.locale.localeCompare(b.locale);
+    if (byLocale !== 0) return byLocale;
+    return a.relativePath.localeCompare(b.relativePath);
+  });
+  return segments;
+}
+function listLocaleCodesFromArchive(input) {
+  const segments = collectArchiveLocaleSegments(input);
+  return [...new Set(segments.map((s) => s.locale))].sort((a, b) => a.localeCompare(b));
+}
+function buildLocaleJsonByTagFromArchive(input) {
+  const { readText, sourceLocaleAbsolute } = input;
+  const segments = collectArchiveLocaleSegments(input);
+  const byLocale = /* @__PURE__ */ new Map();
+  for (const segment of segments) {
+    const list = byLocale.get(segment.locale) ?? [];
+    list.push(segment);
+    byLocale.set(segment.locale, list);
+  }
+  const out = {};
+  for (const [locale, localeSegments] of byLocale) {
+    let primary = localeSegments[0];
+    if (sourceLocaleAbsolute !== void 0) {
+      const sourceMatch = localeSegments.find((s) => s.absolutePath === sourceLocaleAbsolute);
+      if (sourceMatch) primary = sourceMatch;
+    }
+    const raw = readText(primary.archiveRelPath);
+    if (raw === void 0) continue;
+    try {
+      const parsed = JSON.parse(raw);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) continue;
+      out[locale] = parsed;
+    } catch {
+    }
+  }
+  return out;
+}
+
+// src/shared/locales/surface/localeSurface.ts
+function readLocaleLeavesForCode(ctx, localeCode) {
+  const read = readLocaleCodeSurfaceFromContext(ctx, localeCode);
+  if (!read.ok) return [];
+  return read.leaves;
+}
+function readSourceLocaleLeaves(ctx) {
+  return readLocaleLeavesForCode(ctx, sourceLocaleCodeFromContext(ctx));
+}
+
+// src/shared/locales/surface/readJson.ts
+function readLocaleJsonOrEmpty(ctx, absolutePath) {
+  if (!existsRuntimeFsSync(absolutePath, ctx.adapters.fs)) {
+    return {};
+  }
+  const read = readLocaleSegmentFromContext(ctx, absolutePath);
+  if (!read.ok) return {};
+  return read.document;
+}
+
+// src/shared/locales/surface/segmentPairing.ts
+function pairedSourceSegmentRelativePath(ctx, targetSegmentRelativePath, _targetLocaleCode) {
+  const layout = resolveLocalesLayoutFromContext(ctx);
+  const sourceCode = sourceLocaleCodeFromContext(ctx);
+  return swapLocaleInSegmentRelativePath({
+    structure: layout.structure,
+    relativePath: targetSegmentRelativePath,
+    targetLocale: sourceCode
+  });
+}
+function resolvePairedSourceSegmentAbsolutePath(ctx, targetSegmentRelativePath, targetLocaleCode) {
+  const layout = resolveLocalesLayoutFromContext(ctx);
+  const sourceCode = sourceLocaleCodeFromContext(ctx);
+  const sourceRel = pairedSourceSegmentRelativePath(ctx, targetSegmentRelativePath) ?? targetSegmentRelativePath;
+  return resolveLocaleSegmentAbsolutePath({
+    layout,
+    path: ctx.adapters.path,
+    locale: sourceCode,
+    segmentRelativePath: sourceRel
+  });
+}
+function inferSourceSegmentRelativePath(ctx, key) {
+  const sourceCode = sourceLocaleCodeFromContext(ctx);
+  const segments = segmentsForLocaleCode(ctx, sourceCode);
+  const layout = resolveLocalesLayoutFromContext(ctx);
+  const primary = primarySegmentForLocale(ctx, sourceCode);
+  const fallback = primary?.relativePath ?? segments[0]?.relativePath ?? `${sourceCode}.json`;
+  if (layout.structure !== "feature_bundle" || segments.length <= 1) {
+    return fallback;
+  }
+  const featureDirs = new Set(
+    segments.map((s) => {
+      const slash = s.relativePath.indexOf("/");
+      return slash >= 0 ? s.relativePath.slice(0, slash) : null;
+    }).filter((name) => name !== null && name.length > 0)
+  );
+  const top = key.includes(".") ? key.slice(0, key.indexOf(".")) : key;
+  if (featureDirs.has(top)) {
+    return `${top}/${sourceCode}.json`;
+  }
+  return fallback;
+}
+function sourceSegmentRelativePathForKey(ctx, key, sourceLeaves) {
+  const existing = sourceLeaves.find((leaf) => leaf.path === key);
+  if (existing?.fileOrigin?.relativePath) {
+    return existing.fileOrigin.relativePath;
+  }
+  return inferSourceSegmentRelativePath(ctx, key);
+}
+function targetSegmentRelativePathForKey(ctx, localeCode, key, sourceLeaves) {
+  const layout = resolveLocalesLayoutFromContext(ctx);
+  const sourceCode = sourceLocaleCodeFromContext(ctx);
+  const sourceRel = sourceSegmentRelativePathForKey(ctx, key, sourceLeaves);
+  if (localeCode === sourceCode) {
+    return sourceRel;
+  }
+  const swapped = swapLocaleInSegmentRelativePath({
+    structure: layout.structure,
+    relativePath: sourceRel,
+    targetLocale: localeCode
+  });
+  if (swapped !== null) {
+    return swapped;
+  }
+  const primary = primarySegmentForLocale(ctx, localeCode);
+  return primary?.relativePath ?? `${localeCode}.json`;
+}
+
+// src/shared/locales/surface/syncSegment.ts
+function buildSegmentTemplateFromSource(_sourceRaw, leaves) {
+  let template = {};
+  for (const leaf of leaves) {
+    template = setAtPath(template, leaf.path, leaf.value);
+  }
+  return template;
+}
+function resolveSyncSegmentSourcePlan(ctx, input) {
+  const sourceRelativePath = pairedSourceSegmentRelativePath(ctx, input.targetSegmentRelativePath, input.targetLocaleCode) ?? input.targetSegmentRelativePath;
+  const sourceAbsolutePath = resolvePairedSourceSegmentAbsolutePath(
+    ctx,
+    input.targetSegmentRelativePath,
+    input.targetLocaleCode
+  );
+  let sourceRaw = {};
+  let allSourceLeaves = [];
+  if (existsRuntimeFsSync(sourceAbsolutePath, ctx.adapters.fs)) {
+    const read = readLocaleSegmentFromContext(ctx, sourceAbsolutePath);
+    if (read.ok) {
+      sourceRaw = read.document;
+      allSourceLeaves = read.leaves;
+    }
+  }
+  const effectiveSchemaPaths = input.schemaPaths.size > 0 ? input.schemaPaths : new Set(allSourceLeaves.map((l) => l.path));
+  const effectiveSourceLeaves = allSourceLeaves.filter((l) => effectiveSchemaPaths.has(l.path));
+  const template = buildSegmentTemplateFromSource(sourceRaw, effectiveSourceLeaves);
+  return {
+    sourceRelativePath,
+    sourceAbsolutePath,
+    sourceRaw,
+    effectiveSourceLeaves,
+    template,
+    sourceMap: new Map(effectiveSourceLeaves.map((l) => [l.path, l.value]))
+  };
+}
+function resolveGlobalSyncSchemaPaths(ctx, schemaPaths) {
+  if (schemaPaths.size > 0) return schemaPaths;
+  return new Set(readSourceLocaleLeaves(ctx).map((l) => l.path));
+}
+
+export { ANALYSIS_BASENAME, CACHE_PROFILE_DEFAULTS, CACHE_SCHEMA_VERSION, DEFAULT_CACHE_PROFILE_ID, DEFAULT_HEAL_EVERY_RUNS, DEFAULT_LIST_TOP, DEFAULT_MAX_SHARE_JSON_BYTES, DEFAULT_MISSING_LEAF_PLACEHOLDER, DEFAULT_WORKER_API_URL, DEMO_REPORT_URL, DEMO_WEB_APP_BASE, DOCS_ISSUES_PAGE_PATH, DOCS_SITE_BASE, DOCS_SITE_ORIGIN, ENV_TRANSLATE_DEEPL_API_KEY, ENV_TRANSLATE_LIBRE_URL, ENV_TRANSLATE_LLM_API_KEY, ENV_TRANSLATE_LLM_BASE_URL, ENV_TRANSLATE_LLM_MODEL, ENV_TRANSLATE_MAX_WORKERS, ENV_TRANSLATE_PROVIDER, GITHUB_BASE, GITHUB_DOCS_BASE, GITHUB_DOCS_TREE_BASE, GITHUB_OWNER, GITHUB_REPO, GITHUB_REPO_URL, HOSTED_PROJECT_SNAPSHOT_SCHEMA_VERSION, I18NPRUNE_CONFIG_BASENAME, I18NPRUNE_CONFIG_JSON_FILE_NAME, I18NPRUNE_CONFIG_SCRIPT_FILE_NAMES, I18NPRUNE_CONFIG_SCRIPT_FILE_NAMES_SET, I18NPRUNE_CONFIG_SNAPSHOT_FILE_NAMES, I18NPRUNE_CONFIG_SNAPSHOT_FILE_NAMES_SET, I18nPruneError, I18nPruneJsonParseError, ISSUE_CLEANUP_RIPGREP_UNAVAILABLE, ISSUE_CLEANUP_UNCERTAIN_PATHS_EXCLUDED, ISSUE_CLI_INVALID_JSON_PRETTY, ISSUE_CONFIG_INVALID, ISSUE_CONFIG_LOAD_FAILED, ISSUE_CONFIG_MISSING, ISSUE_CONTEXT_DISCOVERY_WARNING, ISSUE_CONTEXT_RESOLUTION_FAILED, ISSUE_DOCTOR_CONFIG_MISSING_FILE, ISSUE_DOCTOR_PATHS_DIRECTORIES_MISSING, ISSUE_DOCTOR_PATHS_SOURCE_LOCALE_MISSING, ISSUE_DOCTOR_RUNTIME_UNSUPPORTED_NODE, ISSUE_DOCTOR_TOOLS_RG_NOT_ON_PATH, ISSUE_GENERATE_SOURCE_EMPTY_STRING_LEAVES, ISSUE_GENERATE_TRANSLATE_NETWORK_ERROR, ISSUE_GENERATE_TRANSLATE_RATE_LIMITED, ISSUE_GENERATE_USAGE, ISSUE_IO_READ_FAILED, ISSUE_LANGUAGES_EMPTY_FILTER, ISSUE_LANGUAGES_UNSUPPORTED_LANGUAGE_CODE, ISSUE_LOCALES_USAGE, ISSUE_LOCALE_SOURCE_PLACEHOLDER_LEAVES, ISSUE_LOCALE_TARGET_NOT_FOUND, ISSUE_LOCALE_TARGET_PLACEHOLDER_LEAVES, ISSUE_MISSING_PATHS_NOT_IN_SCAN, ISSUE_PATCHING_CATALOG_MISMATCH_DIRECTION, ISSUE_PATCHING_CATALOG_MISMATCH_ENGLISH, ISSUE_PATCHING_CATALOG_MISMATCH_NATIVE, ISSUE_PATCHING_CONFIG_INVALID_SCHEMA, ISSUE_PATCHING_CONFIG_LOCALE_MISSING_FILE, ISSUE_PATCHING_CONFIG_PARSE_FAILED, ISSUE_PATCHING_CONFIG_SECTION_INCOMPLETE, ISSUE_PATCHING_CONFIG_SIZE_ANOMALY, ISSUE_PATCHING_CONFIG_TOO_LARGE, ISSUE_PATCHING_FILE_LOCALE_MISSING_CONFIG, ISSUE_PATHS_NETWORK_DRIVE, ISSUE_PATHS_WINDOWS_LONG_PATH, ISSUE_PATHS_WINDOWS_RESERVED_NAME, ISSUE_PROJECT_CONFIG_FILE_MISSING, ISSUE_PROJECT_HOSTED_SNAPSHOT_INVALID, ISSUE_PROJECT_HOSTED_SNAPSHOT_SCHEMA_VERSION, ISSUE_PROJECT_LOCALES_DIR_UNAVAILABLE, ISSUE_PROJECT_LOCALES_SOURCE_NOT_IN_BUNDLE, ISSUE_PROJECT_LOCALES_SOURCE_NOT_LANGUAGE_CODE, ISSUE_PROJECT_LOCALES_STRUCTURE_REQUIRED, ISSUE_PROJECT_SOURCE_LOCALE_INVALID_JSON, ISSUE_PROJECT_SOURCE_LOCALE_INVALID_SHAPE, ISSUE_PROJECT_SOURCE_LOCALE_MISSING_SEGMENTS, ISSUE_PROJECT_SOURCE_LOCALE_NOT_FOUND, ISSUE_PROJECT_SOURCE_LOCALE_UNAVAILABLE, ISSUE_PROJECT_SRC_ROOT_UNAVAILABLE, ISSUE_PROJECT_UPLOAD_CONFIG_JSON_INVALID, ISSUE_PROJECT_UPLOAD_CONFIG_REQUIRED, ISSUE_QUALITY_ENGLISH_IDENTICAL_LEAVES, ISSUE_REPORT_HOSTED_REPORT_INVALID, ISSUE_REPORT_INVALID_FORMAT, ISSUE_SCAN_DYNAMIC_KEY_SITES, ISSUE_SHARE_CACHE_EMPTY, ISSUE_SHARE_CACHE_ENTRY_NOT_FOUND, ISSUE_SHARE_JSON_REPAIRED, ISSUE_SHARE_JSON_WRITE_FAILED, ISSUE_SHARE_PREPARE_ANALYSIS_FAILED, ISSUE_SHARE_PREPARE_NOTHING_REQUESTED, ISSUE_SHARE_PREPARE_REPORT_FROM_ARCHIVE_FAILED, ISSUE_SHARE_PREPARE_REPORT_HOST_REQUIRED, ISSUE_SHARE_REMOTE_ERROR, ISSUE_SHARE_REMOTE_PAYLOAD_TOO_LARGE, ISSUE_SHARE_REMOTE_PROJECT_NOT_FOUND, ISSUE_SHARE_REMOTE_REPORT_NOT_FOUND, ISSUE_SHARE_REMOTE_REPORT_REJECTED, ISSUE_SHARE_REMOTE_UNAVAILABLE, ISSUE_SHARE_REMOTE_UPLOAD_REJECTED, ISSUE_SHARE_SNAPSHOT_EMPTY, ISSUE_SHARE_STALE_CACHE_ROW_REMOVED, ISSUE_SHARE_ZIP_FAILED, ISSUE_SYNC_LOCALE_FILE_NOT_FOUND, ISSUE_SYNC_METADATA_FLAG_CONFLICT, ISSUE_TRANSLATE_CONFIG_DEFAULT_APPLIED, ISSUE_TRANSLATE_HANDOFF_NO_ELIGIBLE_PROVIDER, ISSUE_TRANSLATE_IDENTITY_STREAK_ABORT, ISSUE_TRANSLATE_IDENTITY_STREAK_WARNING, ISSUE_TRANSLATE_MISSING_CREDENTIALS, ISSUE_TRANSLATE_PROVIDER_NOT_IMPLEMENTED_YET, ISSUE_TRANSLATE_UNKNOWN_TRANSLATION_PROVIDER, ISSUE_VALIDATE_DYNAMIC_KEY_SITES, ISSUE_VALIDATE_MISSING_LITERAL_KEYS, ISSUE_VALIDATE_SOURCE_LOCALE_READ_FAILED, LICENSE_URL, LIST_MORE_HINT, LIST_WINDOW_DEFAULT_TOP, LIST_WINDOW_HARD_CAP, MAX_ANALYSIS_BYTES, MAX_MISSING_TARGET_SUGGESTIONS, MAX_PROJECTS_INDEX_BYTES, MAX_PROJECT_FILES_BYTES, MAX_TRANSLATIONS_CACHE_BYTES, META_WORKER_URL, NPM_PACKAGE_NAME, NPM_PACKAGE_URL, PROJECT_REPORT_KIND, PROJECT_REPORT_SCHEMA_VERSION, PROJECT_SHARE_PREPARED_MAX_BYTES, PROJECT_UPLOAD_MAX_FILES, PROJECT_UPLOAD_MAX_TEXT_BYTES, PROJECT_UPLOAD_MAX_ZIP_BYTES, PROJECT_UPLOAD_ZIP_LIMITS, REPORT_INLINE_PAYLOAD_PLACEHOLDER, REPORT_SHARE_MAX_BYTES, RESULT_API_VERSION, SDK_PACKAGE_NAME, SDK_VERSION, SHARE_BAK_DIRNAME, SHARE_CACHE_REASON_MESSAGES, SHARE_JSON_BASENAME, TRANSLATE_WORKERS_CAP, TRANSLATIONS_DIR, WORKER_IDLE_RETENTION_MS, WORKER_INGEST_FORCE_QUERY, applyListWindow, applyLocaleLeafMode, applyLocaleLeafNormalization, applyPreserveFromSource, buildCliJsonEnvelope, buildLanguageCatalog, buildLocaleJsonByTagFromArchive, buildSegmentTemplateFromSource, collectLocaleStructuralParityDiagnostics, collectSourceLocaleMissingSegmentDiagnostics, collectTranslationSurfaceLeaves, constants_exports as constants, createLocaleReadCache, deepClone, deleteAtPath, detectLocalePlaceholderLeaves, detectSourcePlaceholderLeaves, docsCommandUrl, emitIssuesAsRunErrors, emitRunErrorFromUnknown, emitRunEvent, emitRunMessage, enrichIssuesWithDocHrefs, errors_exports as errors, filterLanguageCatalog, formatListOmittedSuffix, formatListShownOmitted, formatSourcePlaceholderMessage, formatSyncSourcePlaceholderMessage, formatTargetPlaceholderMessage, generatedLanguageCatalog, getAtPath, getDocsUrl, getJsonParseLocation, getLanguageByCodeFromCatalog, getProjectedLeafString, getRunOptions, invalidateLocaleReadCacheForAbsolutePath, invalidateLocaleReadCacheForLocaleCode, isCompleteStructuredLocaleLeafMeta, isErrnoCode, isLocalesLayoutReadSupported, isLocalesLayoutWriteSupported, isProgressEvent, isStructuredLocaleLeafNode, issueCodeDocHref, issueCodeRepoDocPathForIssueCode, issueFromI18nPruneError, issuesFromSourcePlaceholderLeaves, issuesFromTargetPlaceholderLeaves, json_exports as json, catalog_exports as languagesCatalog, listLocaleCodes, listLocaleCodesFromArchive, listLocaleCodesFromContext, listLocaleSegmentTargets, listLocaleSegments, listLocaleSegmentsFromContext, listSourceLocaleWriteTargets, localeCodeForSegment, localeCodesFromContext, localeJsonFromTranslationSurfaceLeaves, localeJsonValueFromTranslation, leaves_exports as localeLeaves, localeSegmentRefFromAbsolute, localeSegmentSourceForFile, localeStructuralSlot, layout_exports as localesLayout, read_exports as localesRead, write_exports as localesWrite, mask, materializeGenerateWorkingBySegment, mergeToTemplateShape, metadataModeEnabledFromConfig, noopRunEmitter, normalizeRepoDocPath, normalizeUnknownError, nowMs, options_exports as options, pairedSourceSegmentRelativePath, parseJsonText, placeholders_exports as placeholders, primarySegmentForLocale, projectLocaleLeaves, projects_exports as projects, pruneToTemplateShape, readFlatLocaleJsonSurface, readLocaleBundle, readLocaleCodeSurfaceFromContext, readLocaleJsonFromContextSync, readLocaleJsonOrEmpty, readLocaleLeavesForCode, readLocalePerDirLocaleSurface, readLocaleSegmentFromContext, readSourceLocaleLeaves, paths_exports as reference, resetRunOptions, resolveGlobalSyncSchemaPaths, resolveIssueCodeDocLink, resolveListWindow, resolveLocaleLeafMode, resolveLocaleSegmentAbsolutePath, resolveLocaleSegmentTargets, resolveLocalesLayout, resolveLocalesLayoutFromContext, resolvePairedSourceSegmentAbsolutePath, resolvePrimaryTargetWritePath, resolveSyncSegmentSourcePlan, resolveTargetLocaleWritePlan, restore, result_exports as result, rethrowAsI18n, run_exports as run, scanSources, scanner_exports as scanner, segmentsForLocaleCode, setAtPath, setRunOptions, sourceLocaleCodeForLayout, sourceLocaleCodeFromContext, sourcePlaceholderValues, sourcePlaceholders_exports as sourcePlaceholders, sourceSegmentRelativePathForKey, splitPath, stringifyCliCommandJson, stringifyEnvelope, suggestCatalogCodesForInvalidInputFromCatalog, swapLocaleInSegmentRelativePath, targetLocaleCodesFromContext, targetLocaleCoversAllSourcePaths, targetSegmentRelativePathForKey, translateLeaf, translationSurfacePathValueMap, translator_exports as translator, tryParseJsonText, validateLeafTranslationString, validateRestored, walkLocaleJsonSegments, writeFlatLocaleJsonDocument, writeLocaleBundle, writeLocaleJsonFromContextSync };